hlmod.hu :: Családi Megosztás Menedzsment

hlmod.hu https://hlmod.hu/

Családi Megosztás Menedzsment https://hlmod.hu/viewtopic.php?f=101&t=28926	Oldal: 1 / 1

Szerző:

regener [ 2018.04.10. 00:09 ]

Hozzászólás témája:

Családi Megosztás Menedzsment

Plugin Neve:	Családi Megosztás Menedzsment	Plugint készitette:	YamiKaitou
Játék:	Mind	Kategória:	Szerver kezelés
Eredeti link:	Megnézem	Jóváhagyó:	6almasok

Családi Megosztás Menedzsment

.: Leírás :.
A plugin képes naplózni a családi megosztással játszó játékosok nevét, SteamID-jét és a játék eredeti tulajdonosának a SteamID-jét. A napló fájl family-sharing.log néven kerül mentésre az amxmodx/logs alapértelmezett mappába.
Továbbá lehetőség van az említett játékosok kirúgására is, amely egy "A Családi Megosztással nem játszhatsz ezen a szerveren" üzenettel dobja ki a játékosokat.
A pluginon két módosítást végeztem el:
- Már lehet vele erőltetett naplózást is csinálni, amikor nem csak a megosztott játékosokat naplózza, hanem mindenkit.
- Automatikusan megáll a plugin egy Bot vagy NonSteames játékosnál.

.: CVAR-ok :.
sv_apikey "apikey" - A te Steam Web API kulcsod. Ha még nincs akkor bejelentkezést követően innen szerezhetsz: http://steamcommunity.com/dev/apikey
share_log 1 - Naplózza a megosztott játékkal csatlakozókat (1), naplózzon mindenkit (2) vagy senkit (0).
share_kick 0 - Rúgja ki (1) a megosztott játékkal csatlakozókat vagy ne (0).

.: Szükséges modulok :.
HTTP2

.: Telepítés :.
Miután beszerezted a fenti .inc fájlt és elhelyezted az include mappádban, az .sma-t lefordítod majd a kapott amxx-et feltöltöd a plugins mappába.
Ezután hozzáadod a plugins.ini-hez a family-sharing.amxx-et.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * Family Sharing Management - http://labs.projectyami.com/famshare
 *  Plugin
 *
 * Copyright (C) 2014  Ryan "YamiKaitou" LeBlanc
 *
 *
 * Requires HTTP2 Include files, https://forums.alliedmods.net/showthread.php?t=223898
 *
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation; either version 3 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software Foundation,
 *  Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 *  In addition, as a special exception, the author gives permission to
 *  link the code of this program with the Half-Life Game Engine ("HL
 *  Engine") and Modified Game Libraries ("MODs") developed by Valve,
 *  L.L.C ("Valve"). You must obey the GNU General Public License in all
 *  respects for all of the code used other than the HL Engine and MODs
 *  from Valve. If you modify this file, you may extend this exception
 *  to your version of the file, but you are not obligated to do so. If
 *  you do not wish to do so, delete this exception statement from your
 *  version.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#pragma semicolon 1

#define PLUGINNAME "Családi Megosztás Menedzsment"
#define PLUGINAUTHOR "YamiKaitou"
new const PLUGINVERSION[] = "3.1";

#include <amxmodx>
#if defined _http2_included
	#endinput
#endif
#define _http2_included

#include <sockets>
#include <engine>
#include <regex>
#pragma semicolon 1
/*
* HTTP2
* 2.30
* By [ --{-@ ] Black Rose
*
* Based on HTTP v0.4 by Bugsy
*/

#if !defined HTTP2_MAX_DOWNLOAD_SLOTS
	#define HTTP2_MAX_DOWNLOAD_SLOTS	10
#endif

#if !defined HTTP2_BUFFER_SIZE
	#define HTTP2_BUFFER_SIZE			32768
#endif

#if !defined HTTP2_THINK_INTERVAL
	#define HTTP2_THINK_INTERVAL		0.01
#endif

#if !defined HTTP2_QUE_INTERVAL
	#define HTTP2_QUE_INTERVAL			1.0
#endif

#if !defined HTTP2_Version
	#define HTTP2_Version				2.30
#endif

#if !defined HTTP2_VersionNum
	#define HTTP2_VersionNum			230
#endif

#if !defined HTTP2_VersionString
	#define HTTP2_VersionString			"2.30"
#endif

#define _HTTP2_STATUS_ACTIVE			(1<<0)
#define _HTTP2_STATUS_FIRSTRUN			(1<<1)
#define _HTTP2_STATUS_CHUNKED_TRANSFER	(1<<2)

#define _HTTP2_ishex(%0) ( ( '0' <= %0 <= '9' || 'a' <= %0 <= 'f' || 'A' <= %0 <= 'F' ) ? true : false)
#define _HTTP2_isurlsafe(%0) ( ( '0' <= %0 <= '9' || 'a' <= %0 <= 'z' || 'A' <= %0 <= 'Z' || %0 == '-' || %0 == '_' || %0 == '.' || %0 == '~' || %0 == '%' || %0 == ' ' ) ? true : false)
#define _HTTP2_ctod(%0) ( '0' <= %0 <= '9' ? %0 - '0' : 'A' <= %0 <= 'Z' ? %0 -'A' + 10 : 'a' <= %0 <= 'z' ? %0 -'a' + 10 : 0 )
#define _HTTP2_dtoc(%0) ( 0 <= %0 <= 9 ? %0 + '0' : 10 <= %0 <= 35 ? %0 + 'A' - 10 : 0 )

#define REQUEST_GET		0
#define REQUEST_POST	1

new const _HTTP2_RequestTypes[][] = {
	"GET",
	"POST"
};

new const _HTTP2_Base64Table[] =
/*
*0000000000111111111122222222223333333333444444444455555555556666
*0123456789012345678901234567890123456789012345678901234567890123*/
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

enum _HTTP2_ItemDataEnum {
	_FileName[128],
	_BytesReceived,
	_FileSize,
	_hFile,
	_hSocket,
	_hProgressHandler,
	_hCompleteHandler,
	_Port,
	_Status,
	_RequestType,
	_EndOfChunk,
	_PostVars[1024]
}

enum _HTTP2_URLDataEnum {
	_Scheme[10],
	_Host[128],
	_URLPort,
	_User[128],
	_Pass[128],
	_Path[128],
	_Query[256],
	_Fragment[128]
};

enum _HTTP2_QueDataEnum {
	_QueURL[512],
	_QueFilename[128],
	_QueCompleteHandler[33],
	_QueProgressHandler[33],
	_QuePort,
	_QueRequestType,
	_QueUsername[128],
	_QuePassword[128],
	_QuePostVars[1024]
};

new _gHTTP2_Information[HTTP2_MAX_DOWNLOAD_SLOTS][_HTTP2_ItemDataEnum];
new _gHTTP2_URLParsed[HTTP2_MAX_DOWNLOAD_SLOTS][_HTTP2_URLDataEnum];
new _gHTTP2_QueData[_HTTP2_QueDataEnum];
new _gHTTP2_DataBuffer[HTTP2_BUFFER_SIZE];
new _gHTTP2_BufferLen;

new _gHTTP2_ReturnDummy;
new _gHTTP2_DownloadEntity;
new bool:_gHTTP2_Initialized;

new _gHTTP2_PostVars[1024];

new Array:_gHTTP2_Que_hArray;

new _gHTTP2_QueEntity;
new bool:_gHTTP2_QueInitialized;

/*
* HTTP2_getBytesReceived(Index)
*
* Returns total ammount of bytes received.
*/
stock HTTP2_getBytesReceived(Index)
	return _gHTTP2_Information[Index][_BytesReceived];

/*
* HTTP2_getNewBytesReceived()
*
* Returns the ammount of bytes that was received in this chunk.
*/
stock HTTP2_getNewBytesReceived()
	return _gHTTP2_BufferLen;

/*
* HTTP2_getFilesize(Index)
*
* Returns the filesize of Index.
* If unknown it will return -1.
*/
stock HTTP2_getFilesize(Index)
	return _gHTTP2_Information[Index][_FileSize];

/*
* HTTP2_getFilename(Index)
*
* Returns the filename of Index.
*/
stock HTTP2_getFilename(Index, name[], len)
	copy(name, len, _gHTTP2_Information[Index][_FileName]);

/*
* HTTP2_getData(Data[], len, &datalen)
*
* Fills variable Data[] with the last chunk downloaded.
* len decides the maximum size of Data[].
* datalen will return the ammount of bytes that was received in this chunk.
*/
stock HTTP2_getData(Dest[], len, &datalen) {
	
	static _HTTP2_getData_i, _HTTP2_getData_max;
	
	_HTTP2_getData_max = min(len, _gHTTP2_BufferLen);
	
	Dest[len] = 0;
	datalen = _gHTTP2_BufferLen;
	
	for ( _HTTP2_getData_i = 0 ; _HTTP2_getData_i <= _HTTP2_getData_max ; _HTTP2_getData_i++ )
		Dest[_HTTP2_getData_i] = _gHTTP2_DataBuffer[_HTTP2_getData_i];
}

/*
* HTTP2_getDataUnsafe()
*
* This is a direct connection to the data buffer.
* Use this if you know what you're doing.
* This will be faster because you don't need to spend time copying data between 2 buffers just to read it.
* Since the forward is called efter the data has been written you don't need to worry about corrupting it.
*/
#define HTTP2_getDataUnsafe() _gHTTP2_DataBuffer

/*
* HTTP2_UpdatePlugin(const URL[])
*
* Updates current plugin with binary from chosen URL.
*/
stock HTTP2_UpdatePlugin(const URL[]) {
	new tempfile[14];
	do
		formatex(tempfile, charsmax(tempfile), "temp%d.amxx", random_num(1000,9999));
	while ( file_exists(tempfile) )
	HTTP2_Download(URL, tempfile, "_HTTP2_PluginUpdater_Complete");
}

/*
* HTTP2_Abort(Index, bool:DeleteFile = true)
*
* Aborts the transfer of selected download index.
* If DeleteFile is set to true the partially downloaded file will be deleted.
*/
stock HTTP2_Abort(Index, bool:DeleteFile = true) {
	_HTTP2_TransferDone(Index, 0, false);
	
	if ( DeleteFile && _gHTTP2_Information[Index][_FileName] )
		delete_file(_gHTTP2_Information[Index][_FileName]);
}

/*
* HTTP2_AddPostVar(const variable[], const value[])
*
* Adds a POST variable to the header.
* This function is used before HTTP2_Download() or HTTP_AddToQue(), similar to set/show hudmessage.
* It can be used multiple times before each download.
*/
stock HTTP2_AddPostVar(const variable[], const value[]) {
	
	static _HTTP2_var[1024], _HTTP2_val[1024];
	new len = strlen(_gHTTP2_PostVars);
	
	copy(_HTTP2_var, charsmax(_HTTP2_var), variable);
	copy(_HTTP2_val, charsmax(_HTTP2_val), value);
	
	_HTTP2_URLEncode(_HTTP2_var, charsmax(_HTTP2_var));
	_HTTP2_URLEncode(_HTTP2_val, charsmax(_HTTP2_val));
	
	formatex(_gHTTP2_PostVars[len], charsmax(_gHTTP2_PostVars) - len, "%s%s=%s", len ? "&" : "", _HTTP2_var, _HTTP2_val);
}

/*
* HTTP2_Download(const URL[], const Filename[] = "", const CompleteHandler[] = "", const ProgressHandler[] = "", Port = (80<<443), RequestType = REQUEST_GET, const Username[] = "", const Password[] = "", ...)
*
* Begins download of a URL. Read parameters for information.
*
*
* Parameters:
*
*   const URL[]
*      URL that you want to download.
*
*   (Optional) const Filename[]
*      Where should the information be stored? If no filename is entered it will download as a "stream".
*      This means the data will be thrown away after it passes the buffer.
*      You can read the data on progress forward and make use of it there.
*
*   (Optional) const CompleteHandler[] = ""
*      The function you want called when the download is complete.
*
*   (Optional) const ProgressHandler[] = ""
*      The function you want called when the download is in progress.
*      This will be called every downloaded chunk
*
*   (Optional) Port = (80<<443)
*      The port that should be used.
*      If this is left at default it will use 80 for http.
*
*   (Optional) RequestType = REQUEST_GET
*      What type of request should be used.
*      If this is left at default it will use GET.
*      Possible values so far are REQUEST_GET and REQUEST_POST.
*
*   (Optional) const Username[] = ""
*   (Optional) const Password[] = ""
*      These are used to login to sites that require you to.
*      It's only used for Basic authentication, not POST for example.
*
* Returns a index of the download that may be used to abort the download.
*/
stock HTTP2_Download(const URL[], const Filename[] = "", const CompleteHandler[] = "", const ProgressHandler[] = "", Port = (80<<443), RequestType = REQUEST_GET, const Username[] = "", const Password[] = "", ... /* For possible future use */) {
	
	if ( ! Filename[0] && ! ProgressHandler[0] ) {
		log_amx("[HTTP2] Filename or progress handler is missing.");
		return -1;
	}
	
	new i;
	while ( i < HTTP2_MAX_DOWNLOAD_SLOTS && ( _gHTTP2_Information[i][_Status] & _HTTP2_STATUS_ACTIVE ) ) { i++; }
	
	if ( i == HTTP2_MAX_DOWNLOAD_SLOTS ) {
			log_amx("[HTTP2] Out of free download slots.");
			_gHTTP2_PostVars[0] = 0;
			return -1;
	}
	
	_HTTP2_ParseURL(URL,
	_gHTTP2_URLParsed[i][_Scheme], charsmax(_gHTTP2_URLParsed[][_Scheme]),
	_gHTTP2_URLParsed[i][_User], charsmax(_gHTTP2_URLParsed[][_User]),
	_gHTTP2_URLParsed[i][_Pass], charsmax(_gHTTP2_URLParsed[][_Pass]),
	_gHTTP2_URLParsed[i][_Host], charsmax(_gHTTP2_URLParsed[][_Host]),
	_gHTTP2_URLParsed[i][_URLPort],
	_gHTTP2_URLParsed[i][_Path], charsmax(_gHTTP2_URLParsed[][_Path]),
	_gHTTP2_URLParsed[i][_Query], charsmax(_gHTTP2_URLParsed[][_Query]),
	_gHTTP2_URLParsed[i][_Fragment], charsmax(_gHTTP2_URLParsed[][_Fragment]));
	
	_gHTTP2_Information[i][_Port] = _gHTTP2_URLParsed[i][_URLPort] ? _gHTTP2_URLParsed[i][_URLPort] : Port == (80<<443) ? equali(_gHTTP2_URLParsed[i][_Scheme], "https") ? 443 : 80 : Port;
	
	if ( ! _gHTTP2_URLParsed[i][_User] )
		copy(_gHTTP2_URLParsed[i][_User], charsmax(_gHTTP2_URLParsed[][_User]), Username);
	
	if ( ! _gHTTP2_URLParsed[i][_Pass] )
		copy(_gHTTP2_URLParsed[i][_Pass], charsmax(_gHTTP2_URLParsed[][_Pass]), Password);
	
	if ( ! Filename[0] )
		_gHTTP2_Information[i][_hFile] = 0;
	else if ( ! ( _gHTTP2_Information[i][_hFile] = fopen(Filename, "wb") ) ) {
		log_amx("[HTTP2] Error creating local file.");
		_gHTTP2_PostVars[0] = 0;
		return -1;
	}
	
	static _HTTP2_Plugin[64];
	get_plugin(-1 , _HTTP2_Plugin, charsmax(_HTTP2_Plugin), "", 0, "", 0, "", 0, "", 0);
	new ResultNum = find_plugin_byfile(_HTTP2_Plugin, 0);
	
	if ( ProgressHandler[0] )
		_gHTTP2_Information[i][_hProgressHandler] = CreateOneForward(ResultNum, ProgressHandler, FP_CELL);
	if ( CompleteHandler[0] )
		_gHTTP2_Information[i][_hCompleteHandler] = CreateOneForward(ResultNum, CompleteHandler, FP_CELL, FP_CELL);
	
	_gHTTP2_Information[i][_hSocket] = socket_open(_gHTTP2_URLParsed[i][_Host], _gHTTP2_Information[i][_Port], SOCKET_TCP, ResultNum);
	
	if ( ResultNum ) {
		switch ( ResultNum ) {
			case 1: log_amx("[HTTP2] Socket error: Error while creating socket.");
			case 2: log_amx("[HTTP2] Socket error: Couldn't resolve hostname.");
			case 3: log_amx("[HTTP2] Socket error: Couldn't connect to given hostname:port.");
		}
		_gHTTP2_PostVars[0] = 0;
		return -1;
	}
	
	static _HTTP2_Request[2048], _HTTP2_Auth[256], _HTTP2_TempStr[256];
	new RequestLen = formatex(_HTTP2_Request, charsmax(_HTTP2_Request), "%s /%s%s%s%s%s %s/1.1^r^nHost: %s", _HTTP2_RequestTypes[RequestType], _gHTTP2_URLParsed[i][_Path], _gHTTP2_URLParsed[i][_Query] ? "?" : "", _gHTTP2_URLParsed[i][_Query], _gHTTP2_URLParsed[i][_Fragment] ? "#" : "", _gHTTP2_URLParsed[i][_Fragment], _gHTTP2_URLParsed[i][_Scheme], _gHTTP2_URLParsed[i][_Host]);
	
	if ( _gHTTP2_URLParsed[i][_User] || _gHTTP2_URLParsed[i][_Pass] ) {
		formatex(_HTTP2_TempStr, charsmax(_HTTP2_TempStr), "%s:%s", _gHTTP2_URLParsed[i][_User], _gHTTP2_URLParsed[i][_Pass]);
		_HTTP2_Encode64(_HTTP2_TempStr, _HTTP2_Auth, charsmax(_HTTP2_Auth));
	
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^nAuthorization: Basic %s", _HTTP2_Auth);
	}
	
	if ( RequestType == REQUEST_POST && _gHTTP2_PostVars[0] ) {
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^nContent-Length: %d", strlen(_gHTTP2_PostVars));
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^nContent-Type: application/x-www-form-urlencoded");
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^n^r^n%s", _gHTTP2_PostVars);
		copy(_gHTTP2_Information[i][_PostVars], charsmax(_gHTTP2_Information[][_PostVars]), _gHTTP2_PostVars);
		_gHTTP2_PostVars[0] = 0;
	}
	
	formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^n^r^n");
	
	socket_send(_gHTTP2_Information[i][_hSocket], _HTTP2_Request, sizeof _HTTP2_Request);
	
	if ( ! _gHTTP2_DownloadEntity ) {
		_gHTTP2_DownloadEntity = create_entity("info_target");
		
		if ( ! _gHTTP2_DownloadEntity ) {
			log_amx("[HTTP2] Failed to create entity.");
			_gHTTP2_PostVars[0] = 0;
			return -1;
		}
		
		entity_set_string(_gHTTP2_DownloadEntity, EV_SZ_classname, "http2_downloadentity");
		entity_set_float(_gHTTP2_DownloadEntity, EV_FL_nextthink, get_gametime() + HTTP2_THINK_INTERVAL);
	}
	
	if ( ! _gHTTP2_Initialized ) {
		register_think("http2_downloadentity", "_HTTP2_DownloadThread");
		_gHTTP2_Initialized = true;
	}
	
	copy(_gHTTP2_Information[i][_FileName], charsmax(_gHTTP2_Information[][_FileName]), Filename);
	_gHTTP2_Information[i][_Status] = _HTTP2_STATUS_ACTIVE;
	_gHTTP2_Information[i][_Status] |= _HTTP2_STATUS_FIRSTRUN;
	_gHTTP2_Information[i][_RequestType] = RequestType;
	
	return i;
}

/*
* HTTP2_AddToQue(const URL[], const Filename[] = "", const CompleteHandler[] = "", const ProgressHandler[] = "", Port = (80<<443), RequestType = REQUEST_GET, const Username[] = "", const Password[] = "", ...)
*
* Ques up an item to be downloaded. Formatted exactly like HTTP2_Download().
* Use this when you're looping through a lot of downloads to avoid filling up the download slots.
* This function will not generate a direct error. The errors will occur at HTTP2_Download().
*
* Returns position in que.
*/
stock HTTP2_AddToQue(const URL[], const Filename[] = "", const CompleteHandler[] = "", const ProgressHandler[] = "", Port = (80<<443), RequestType = REQUEST_GET, const Username[] = "", const Password[] = "", ... /* For possible future use */) {
	
	if ( ! _gHTTP2_QueInitialized ) {
		_gHTTP2_Que_hArray = ArrayCreate(sizeof _gHTTP2_QueData, 10);
		register_think("http2_queentity", "_HTTP2_QueThread");
		_gHTTP2_QueInitialized = true;
	}
	
	copy(_gHTTP2_QueData[_QueURL], charsmax(_gHTTP2_QueData[_QueURL]), URL);
	copy(_gHTTP2_QueData[_QueFilename], charsmax(_gHTTP2_QueData[_QueFilename]), Filename);
	copy(_gHTTP2_QueData[_QueCompleteHandler], charsmax(_gHTTP2_QueData[_QueCompleteHandler]), CompleteHandler);
	copy(_gHTTP2_QueData[_QueProgressHandler], charsmax(_gHTTP2_QueData[_QueProgressHandler]), ProgressHandler);
	copy(_gHTTP2_QueData[_QueUsername], charsmax(_gHTTP2_QueData[_QueUsername]), Username);
	copy(_gHTTP2_QueData[_QuePassword], charsmax(_gHTTP2_QueData[_QuePassword]), Password);
	
	_gHTTP2_QueData[_QuePort] = Port;
	_gHTTP2_QueData[_QueRequestType] = RequestType;
	
	if ( RequestType == REQUEST_POST && _gHTTP2_PostVars[0] ) {
		copy(_gHTTP2_QueData[_QuePostVars], charsmax(_gHTTP2_QueData[_QuePostVars]), _gHTTP2_PostVars);
		_gHTTP2_PostVars[0] = 0;
	}
	
	ArrayPushArray(_gHTTP2_Que_hArray, _gHTTP2_QueData);
	
	if ( ! _gHTTP2_QueEntity ) {
		_gHTTP2_QueEntity = create_entity("info_target");
		
		if ( ! _gHTTP2_QueEntity ) {
			log_amx("[HTTP2] Failed to create entity.");
			return -1;
		}
		
		entity_set_string(_gHTTP2_QueEntity, EV_SZ_classname, "http2_queentity");
		entity_set_float(_gHTTP2_QueEntity, EV_FL_nextthink, get_gametime() + HTTP2_QUE_INTERVAL);
	}
	
	return ArraySize(_gHTTP2_Que_hArray);
}

public _HTTP2_DownloadThread(ent) {
	
	static _HTTP2_Index;
	
	for ( _HTTP2_Index = 0 ; _HTTP2_Index < HTTP2_MAX_DOWNLOAD_SLOTS ; _HTTP2_Index++ ) {
		
		if ( ! ( _gHTTP2_Information[_HTTP2_Index][_Status] & _HTTP2_STATUS_ACTIVE ) )
			continue;
		
		if ( ! socket_change(_gHTTP2_Information[_HTTP2_Index][_hSocket], 1000) )
			continue;
		
		if ( _gHTTP2_Information[_HTTP2_Index][_Status] & _HTTP2_STATUS_CHUNKED_TRANSFER &&
		_gHTTP2_Information[_HTTP2_Index][_BytesReceived] == _gHTTP2_Information[_HTTP2_Index][_EndOfChunk] ) {
		
			new tempdata[1], strHex[6], i, bool:error;
			
			while ( ! error ) {
				socket_recv(_gHTTP2_Information[_HTTP2_Index][_hSocket], tempdata, 2);
				
				switch ( tempdata[0] ) {
					case '^n' : {
						if ( i )
							break;
					}
					case '^r' : {}
					default : {
						if ( _HTTP2_ishex(tempdata[0]) )
							strHex[i++] = tempdata[0];
						else
							error = true;
					}
				}
			}
			
			if ( error ) {
				_HTTP2_TransferDone(_HTTP2_Index, -2, true);
				continue;
			}
			
			_HTTP2_GetChunkSize(strHex, _gHTTP2_Information[_HTTP2_Index][_EndOfChunk]);
			
			if ( ! _gHTTP2_Information[_HTTP2_Index][_EndOfChunk] ) {
				_HTTP2_TransferDone(_HTTP2_Index, 0, true);
				continue;
			}
			
			_gHTTP2_Information[_HTTP2_Index][_EndOfChunk] += _gHTTP2_Information[_HTTP2_Index][_BytesReceived];
		}
		
		if ( ! (  _gHTTP2_BufferLen = socket_recv(_gHTTP2_Information[_HTTP2_Index][_hSocket], 
		_gHTTP2_DataBuffer, _gHTTP2_Information[_HTTP2_Index][_Status] & _HTTP2_STATUS_FIRSTRUN ?
			2048
		:
			_gHTTP2_Information[_HTTP2_Index][_Status] & _HTTP2_STATUS_CHUNKED_TRANSFER ?
				min(_gHTTP2_Information[_HTTP2_Index][_EndOfChunk] - _gHTTP2_Information[_HTTP2_Index][_BytesReceived] + 1, HTTP2_BUFFER_SIZE)
			:
				min(_gHTTP2_Information[_HTTP2_Index][_FileSize] - _gHTTP2_Information[_HTTP2_Index][_BytesReceived] + 1, HTTP2_BUFFER_SIZE)
		) ) ) {
			_HTTP2_TransferDone(_HTTP2_Index, 0, true);
			continue;
		}
		
		if ( _gHTTP2_Information[_HTTP2_Index][_Status] & _HTTP2_STATUS_FIRSTRUN ) {
			_gHTTP2_Information[_HTTP2_Index][_Status] &= ~_HTTP2_STATUS_FIRSTRUN;
			
			static _HTTP2_ReturnCodeExtended[32], _HTTP2_Location[128];
			new ReturnCode;
			
			_HTTP2_ParseHeader(_gHTTP2_DataBuffer, _gHTTP2_BufferLen, _gHTTP2_Information[_HTTP2_Index][_FileSize], _gHTTP2_Information[_HTTP2_Index][_Status], ReturnCode, _HTTP2_ReturnCodeExtended, _HTTP2_Location);
			
			if ( 300 <= ReturnCode <= 307 ) {
				
				if ( _HTTP2_FollowLocation(_HTTP2_Index, _HTTP2_Location) ) {
					_gHTTP2_Information[_HTTP2_Index][_BytesReceived] = 0;
					continue;
				}
				else {
					_HTTP2_TransferDone(_HTTP2_Index, ReturnCode, true);
					continue;
				}
			}
			else if ( ! ( 200 <= ReturnCode <= 299 ) ) {
				if ( ! ReturnCode )
					ReturnCode = -1;
				
				_HTTP2_TransferDone(_HTTP2_Index, ReturnCode, true);
				continue;
			}
			if ( _gHTTP2_Information[_HTTP2_Index][_Status] & _HTTP2_STATUS_CHUNKED_TRANSFER ) {
				new Shift = _HTTP2_GetChunkSize(_gHTTP2_DataBuffer, _gHTTP2_Information[_HTTP2_Index][_EndOfChunk]);
				_gHTTP2_BufferLen = _HTTP2_ShiftData(_gHTTP2_DataBuffer, Shift, _gHTTP2_BufferLen);
			}
		}
		
		if ( _gHTTP2_Information[_HTTP2_Index][_hFile] )
			_gHTTP2_Information[_HTTP2_Index][_BytesReceived] += fwrite_blocks(_gHTTP2_Information[_HTTP2_Index][_hFile], _gHTTP2_DataBuffer, _gHTTP2_BufferLen, BLOCK_BYTE);
		else
			_gHTTP2_Information[_HTTP2_Index][_BytesReceived] += _gHTTP2_BufferLen;
		
		if ( _gHTTP2_Information[_HTTP2_Index][_hProgressHandler] ) {
			
			ExecuteForward(_gHTTP2_Information[_HTTP2_Index][_hProgressHandler], _gHTTP2_ReturnDummy, _HTTP2_Index);
			
			if ( _gHTTP2_ReturnDummy == PLUGIN_HANDLED ) {
				_HTTP2_TransferDone(_HTTP2_Index, 0, false);
				continue;
			}
		}
		
		if ( _gHTTP2_Information[_HTTP2_Index][_BytesReceived] == _gHTTP2_Information[_HTTP2_Index][_FileSize] ) {
			_HTTP2_TransferDone(_HTTP2_Index, 0, true);
			continue;
		}
		
	}
	
	entity_set_float(_gHTTP2_DownloadEntity, EV_FL_nextthink, get_gametime() + HTTP2_THINK_INTERVAL);
}

public _HTTP2_QueThread() {
	new count;
	
	for ( new i = 0 ; i < HTTP2_MAX_DOWNLOAD_SLOTS ; i++ ) {
		if ( ! ( _gHTTP2_Information[i][_Status] & _HTTP2_STATUS_ACTIVE ) )
			count++;
	}
	
	new Arraysize = ArraySize(_gHTTP2_Que_hArray);
	if ( count > Arraysize )
		count = Arraysize;
	
	while ( count-- ) {
		ArrayGetArray(_gHTTP2_Que_hArray, 0, _gHTTP2_QueData);
		ArrayDeleteItem(_gHTTP2_Que_hArray, 0);
		
		if ( _gHTTP2_QueData[_QueRequestType] == REQUEST_POST )
			copy(_gHTTP2_PostVars, charsmax(_gHTTP2_PostVars), _gHTTP2_QueData[_QuePostVars]);
		
		HTTP2_Download(_gHTTP2_QueData[_QueURL], _gHTTP2_QueData[_QueFilename], _gHTTP2_QueData[_QueCompleteHandler], _gHTTP2_QueData[_QueProgressHandler], _gHTTP2_QueData[_QuePort], _gHTTP2_QueData[_QueRequestType], _gHTTP2_QueData[_QueUsername], _gHTTP2_QueData[_QuePassword]);
	}
	
	if ( ! ArraySize(_gHTTP2_Que_hArray) ) {
		entity_set_int(_gHTTP2_QueEntity, EV_INT_flags, FL_KILLME);
		call_think(_gHTTP2_QueEntity);
	
		_gHTTP2_QueEntity = 0;
		return;
	}
	
	entity_set_float(_gHTTP2_QueEntity, EV_FL_nextthink, get_gametime() + HTTP2_QUE_INTERVAL);
}

_HTTP2_TransferDone(Index, Error, bool:CallHandler) {
	
	if ( _gHTTP2_Information[Index][_hFile] )
		fclose(_gHTTP2_Information[Index][_hFile]);
	
	socket_close(_gHTTP2_Information[Index][_hSocket]);
	
	if ( CallHandler && _gHTTP2_Information[Index][_hCompleteHandler] )
		ExecuteForward(_gHTTP2_Information[Index][_hCompleteHandler], _gHTTP2_ReturnDummy, Index, Error);
	
	DestroyForward(_gHTTP2_Information[Index][_hProgressHandler]);
	DestroyForward(_gHTTP2_Information[Index][_hCompleteHandler]);
	
	_gHTTP2_Information[Index][_BytesReceived] = 0;
	_gHTTP2_Information[Index][_FileSize] = 0;
	_gHTTP2_Information[Index][_EndOfChunk] = 0;
	_gHTTP2_Information[Index][_hProgressHandler] = 0;
	_gHTTP2_Information[Index][_hCompleteHandler] = 0;
	_gHTTP2_Information[Index][_hFile] = 0;
	_gHTTP2_Information[Index][_Status] = 0;
	_gHTTP2_Information[Index][_PostVars] = 0;
	
	for ( new i = 0 ; i < sizeof _gHTTP2_Information ; i++ ) {
		if ( _gHTTP2_Information[i][_Status] & _HTTP2_STATUS_ACTIVE )
			return;
	}
	
	entity_set_int(_gHTTP2_DownloadEntity, EV_INT_flags, FL_KILLME);
	call_think(_gHTTP2_DownloadEntity);
	
	_gHTTP2_DownloadEntity = 0;
}

_HTTP2_FollowLocation(Index, const Location[]) {
	
	socket_close(_gHTTP2_Information[Index][_hSocket]);
	new bool:Relative = true;
	
	static _HTTP2_Follow_TempURLParsed[_HTTP2_URLDataEnum];
	
	arrayset(_HTTP2_Follow_TempURLParsed, 0, sizeof _HTTP2_Follow_TempURLParsed);
	_HTTP2_ParseURL(Location,
	_HTTP2_Follow_TempURLParsed[_Scheme], charsmax(_HTTP2_Follow_TempURLParsed[_Scheme]),
	_HTTP2_Follow_TempURLParsed[_User], charsmax(_HTTP2_Follow_TempURLParsed[_User]),
	_HTTP2_Follow_TempURLParsed[_Pass], charsmax(_HTTP2_Follow_TempURLParsed[_Pass]),
	_HTTP2_Follow_TempURLParsed[_Host], charsmax(_HTTP2_Follow_TempURLParsed[_Host]),
	_HTTP2_Follow_TempURLParsed[_URLPort],
	_HTTP2_Follow_TempURLParsed[_Path], charsmax(_HTTP2_Follow_TempURLParsed[_Path]),
	_HTTP2_Follow_TempURLParsed[_Query], charsmax(_HTTP2_Follow_TempURLParsed[_Query]),
	_HTTP2_Follow_TempURLParsed[_Fragment], charsmax(_HTTP2_Follow_TempURLParsed[_Fragment]));
	
	if ( _HTTP2_Follow_TempURLParsed[_Scheme] )
		copy(_gHTTP2_URLParsed[Index][_Scheme], charsmax(_gHTTP2_URLParsed[][_Scheme]), _HTTP2_Follow_TempURLParsed[_Scheme]);
	if ( _HTTP2_Follow_TempURLParsed[_Host] ) {
		copy(_gHTTP2_URLParsed[Index][_Host], charsmax(_gHTTP2_URLParsed[][_Host]), _HTTP2_Follow_TempURLParsed[_Host]);
		Relative = false;
	}
	if ( _HTTP2_Follow_TempURLParsed[_URLPort] )
		_gHTTP2_Information[Index][_Port] = _HTTP2_Follow_TempURLParsed[_URLPort];
	if ( _HTTP2_Follow_TempURLParsed[_User] )
		copy(_gHTTP2_URLParsed[Index][_User], charsmax(_gHTTP2_URLParsed[][_User]), _HTTP2_Follow_TempURLParsed[_User]);
	if ( _HTTP2_Follow_TempURLParsed[_Pass] )
		copy(_gHTTP2_URLParsed[Index][_Pass], charsmax(_gHTTP2_URLParsed[][_Pass]), _HTTP2_Follow_TempURLParsed[_Pass]);
	if ( _HTTP2_Follow_TempURLParsed[_Path] ) {
		if ( Relative )
			add(_gHTTP2_URLParsed[Index][_Path], charsmax(_gHTTP2_URLParsed[][_Path]), _HTTP2_Follow_TempURLParsed[_Path]);
		else
			copy(_gHTTP2_URLParsed[Index][_Path], charsmax(_gHTTP2_URLParsed[][_Path]), _HTTP2_Follow_TempURLParsed[_Path]);
	}
	if ( _HTTP2_Follow_TempURLParsed[_Query] )
		copy(_gHTTP2_URLParsed[Index][_Query], charsmax(_gHTTP2_URLParsed[][_Query]), _HTTP2_Follow_TempURLParsed[_Query]);
	if ( _HTTP2_Follow_TempURLParsed[_Fragment] )
		copy(_gHTTP2_URLParsed[Index][_Fragment], charsmax(_gHTTP2_URLParsed[][_Fragment]), _HTTP2_Follow_TempURLParsed[_Fragment]);
	
	new ResultNum;
	_gHTTP2_Information[Index][_hSocket] = socket_open(_gHTTP2_URLParsed[Index][_Host], _gHTTP2_Information[Index][_Port], SOCKET_TCP, ResultNum);
	
	if ( ResultNum ) {
		switch ( ResultNum ) {
		case 1: log_amx("[HTTP2] Socket error: Error while creating socket.");
		case 2: log_amx("[HTTP2] Socket error: Couldn't resolve hostname.");
		case 3: log_amx("[HTTP2] Socket error: Couldn't connect to given hostname:port.");
		}
		return 0;
	}
	
	static _HTTP2_Request[4096], _HTTP2_Auth[256], _HTTP2_TempStr[256];
	new RequestLen = formatex(_HTTP2_Request, charsmax(_HTTP2_Request), "%s /%s%s%s%s%s %s/1.1^r^nHost: %s", _HTTP2_RequestTypes[_gHTTP2_Information[Index][_RequestType]], _gHTTP2_URLParsed[Index][_Path], _gHTTP2_URLParsed[Index][_Query] ? "?" : "", _gHTTP2_URLParsed[Index][_Query], _gHTTP2_URLParsed[Index][_Fragment] ? "#" : "", _gHTTP2_URLParsed[Index][_Fragment], _gHTTP2_URLParsed[Index][_Scheme], _gHTTP2_URLParsed[Index][_Host]);
	
	if ( _gHTTP2_URLParsed[Index][_User] || _gHTTP2_URLParsed[Index][_Pass] ) {
		formatex(_HTTP2_TempStr, charsmax(_HTTP2_TempStr), "%s:%s", _gHTTP2_URLParsed[Index][_User], _gHTTP2_URLParsed[Index][_Pass]);
		_HTTP2_Encode64(_HTTP2_TempStr, _HTTP2_Auth, charsmax(_HTTP2_Auth));
	
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^nAuthorization: Basic %s", _HTTP2_Auth);
	}
	
	if ( _gHTTP2_Information[Index][_RequestType] == REQUEST_POST && _gHTTP2_Information[Index][_PostVars] ) {
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^nContent-Length: %d", strlen(_gHTTP2_Information[Index][_PostVars]));
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^nContent-Type: application/x-www-form-urlencoded");
		RequestLen += formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^n^r^n%s", _gHTTP2_Information[Index][_PostVars]);
	}
	
	formatex(_HTTP2_Request[RequestLen], charsmax(_HTTP2_Request) - RequestLen, "^r^n^r^n");
	
	socket_send(_gHTTP2_Information[Index][_hSocket], _HTTP2_Request, sizeof _HTTP2_Request);
	
	_gHTTP2_Information[Index][_Status] = _HTTP2_STATUS_ACTIVE;
	_gHTTP2_Information[Index][_Status] |= _HTTP2_STATUS_FIRSTRUN;
	
	return 1;
}

_HTTP2_ParseHeader(Data[], Len, &Filesize, &Status, &ReturnCode, ReturnCodeExtended[], Location[]) {
	
	static _HTTP2_TempStr[256];
	new HeaderLen, iPos, c;
	
	HeaderLen = containi(Data, "^r^n^r^n") + 1;
	
	if ( HeaderLen ) {
		HeaderLen += 3;
		
		iPos = containi(Data, "HTTP/1.1 ") + 9;
		
		if ( iPos != 8 && iPos < HeaderLen ) {
			while ( Data[iPos + c] != '^r' )
				_HTTP2_TempStr[c] = Data[iPos + c++];
			
			_HTTP2_TempStr[c] = 0;
			ReturnCode = str_to_num(_HTTP2_TempStr);
			
			iPos += c + 1;
			c = 0;
			while ( Data[iPos + c] != '^r' && Data[iPos + c] != '^n' )
				ReturnCodeExtended[c] = Data[iPos + c++];
			ReturnCodeExtended[c] = 0;
		}
		
		iPos = containi(Data, "Transfer-Encoding: ") + 19;
		c = 0;
		
		if ( iPos != 18 && iPos < HeaderLen ) {
			while ( Data[iPos + c] != '^r' )
				_HTTP2_TempStr[c] = Data[iPos + c++];
			
			_HTTP2_TempStr[c] = 0;
			
			if ( equali(_HTTP2_TempStr, "chunked") )
				Status |= _HTTP2_STATUS_CHUNKED_TRANSFER;
		}
		
		if ( 300 <= ReturnCode <= 399 ) {
			iPos = containi(Data, "Location: ") + 10;
			c = 0;
			
			if ( iPos != 9 && iPos < HeaderLen ) {
				while ( Data[iPos + c] != '^r' )
					Location[c] = Data[iPos + c++];
				
				Location[c] = 0;
			}
		}
		
		iPos = containi(Data, "Content-Length: ") + 16;
		c = 0;
		
		if ( iPos != 15 && iPos < HeaderLen ) {
			while ( Data[iPos + c] != '^r' )
				_HTTP2_TempStr[c] = Data[iPos + c++];
			
			_HTTP2_TempStr[c] = 0;
			Filesize = str_to_num(_HTTP2_TempStr);
		}
		else
			Filesize = -1;
		
		_HTTP2_ShiftData(Data, HeaderLen, Len);
	}
	
	Len -= HeaderLen;
}

_HTTP2_ParseURL(const URL[], Scheme[]="", Schemelen=0, User[]="", Userlen=0, Pass[]="", Passlen=0, Host[]="", Hostlen=0, &Port, Path[]="", Pathlen=0, Query[]="", Querylen=0, Fragment[]="", Fragmentlen=0) {
	
	new temp;
	static Regex:_HTTP2_ParseURL_hRegex;
	
	if ( ! _HTTP2_ParseURL_hRegex )
		_HTTP2_ParseURL_hRegex = regex_compile("(?:(\w+):///?)?(?:([\w&\$\+\,/\.;=@\[\]\{\}\|\\\^^\~%?#]+):([\w&\$\+\,/\.;=@\[\]\{\}\|\\\^^\~%?#]+)@)?((?:\w+\.)*\w+\.\w+)?(?::(\d+))?(?:/?([\w&\$\+\,/\.;=@\[\]\{\}\|\\\^^\~%]*))?(?:\?([\w&\$\+\,/\.;=@\[\]\{\}\|\\\^^\~%:]*))?(?:#([\w&\$\+\,/\.;=@\[\]\{\}\|\\\^^\~%:]*))?", temp, "", 0);
	
	new TempPort[8];
	
	regex_match_c(URL, _HTTP2_ParseURL_hRegex, temp);
	
	regex_substr(_HTTP2_ParseURL_hRegex, 1, Scheme, Schemelen);
	regex_substr(_HTTP2_ParseURL_hRegex, 2, User, Userlen);
	regex_substr(_HTTP2_ParseURL_hRegex, 3, Pass, Passlen);
	regex_substr(_HTTP2_ParseURL_hRegex, 4, Host, Hostlen);
	regex_substr(_HTTP2_ParseURL_hRegex, 5, TempPort, charsmax(TempPort));
	Port = str_to_num(TempPort);
	regex_substr(_HTTP2_ParseURL_hRegex, 6, Path, Pathlen);
	regex_substr(_HTTP2_ParseURL_hRegex, 7, Query, Querylen);
	regex_substr(_HTTP2_ParseURL_hRegex, 8, Fragment, Fragmentlen);
}

_HTTP2_GetChunkSize(const Data[], &ChunkSize) {
	
	new i, c, Hex[6];
	
	while ( Data[i] == '^r' || Data[i] == '^n' )
		i++;
	
	while ( _HTTP2_ishex(Data[i]) )
		Hex[c++] = Data[i++];
	
	while ( Data[i] == '^r' || Data[i] == '^n' )
		i++;
	
	ChunkSize = _HTTP2_HexToDec(Hex);
	
	return i;
}

_HTTP2_ShiftData(Data[], Amt, Len) {
	
	static _HTTP2_ShiftData_i;
	
	for ( _HTTP2_ShiftData_i = Amt ; _HTTP2_ShiftData_i < Len ; _HTTP2_ShiftData_i++ )
		Data[_HTTP2_ShiftData_i - Amt] = Data[_HTTP2_ShiftData_i];
	
	for ( _HTTP2_ShiftData_i = Len - Amt ; _HTTP2_ShiftData_i < Len ; _HTTP2_ShiftData_i++ )
		Data[_HTTP2_ShiftData_i] = 0;
	
	return Len - Amt;
}

stock _HTTP2_URLEncode(string[], len) {
	new what[2], with[4] = "^%";
	
	replace_all(string, len, "^%", "^%25");
	
	for ( new i = 0 ; i < len ; i++ ) {
		
		if ( ! string[i] )
			break;
		
		if ( ! _HTTP2_isurlsafe(string[i]) ) {
			what[0] = string[i];
			_HTTP2_DecToHex(what[0], with[1], charsmax(with) - 1);
			replace_all(string, len, what, with);
		}
	}
	replace_all(string, len, " ", "+");
}

stock _HTTP2_URLDecode(string[], len) {
	
	replace_all(string, len, "+", " ");
	
	new what[4] = "^%", with[2];
	
	for ( new i = 0 ; i < len ; i++ ) {
		
		if ( ! string[i] )
			break;
		
		if ( string[i - 2] == '^%' && _HTTP2_ishex(string[i - 1]) && _HTTP2_ishex(string[i]) ) {
			what[1] = string[i - 1];
			what[2] = string[i];
			with[0] = _HTTP2_HexToDec(what);
			if ( ! _HTTP2_isurlsafe(with[0]) )
				replace_all(string, len, what, with);
		}
	}
	replace_all(string, len, "^%25", "^%");
}

public _HTTP2_PluginUpdater_Complete(Index, Error) {
	
	new pluginfile[320], tempfile[14], temp[1], len;
	
	if ( Error ) {
		get_plugin (-1, pluginfile, charsmax(pluginfile), temp, 0, temp, 0, temp, 0, temp, 0);
		log_amx("Error(%d) while autoupdating plugin: %s", pluginfile);
		return;
	}
	
	HTTP2_getFilename(Index, tempfile, charsmax(tempfile));
	
	len = get_localinfo("amxx_pluginsdir", pluginfile, charsmax(pluginfile));
	pluginfile[len++] = '/';
	get_plugin (-1, pluginfile[len], charsmax(pluginfile) - len, temp, 0, temp, 0, temp, 0, temp, 0);
	
	delete_file(pluginfile);
	rename_file(tempfile, pluginfile, 1);
}

_HTTP2_HexToDec(string[]) {
	
	new result, mult = 1;
	
	for ( new i = strlen(string) - 1 ; i >= 0 ; i-- ) {
		result += _HTTP2_ctod(string[i]) * mult;
		mult *= 16;
	}

return result;
}

stock _HTTP2_DecToHex(val, out[], len) {
	
	setc(out, len, 0);
	
	for ( new i = len - 1 ; val && i > -1 ; --i, val /= 16 )
		out[len-i-1] = _HTTP2_dtoc(val % 16);
	
	new len2 = strlen(out);
	out[len2] = 0;
	new temp;
	
	for ( new i = 0 ; i < len2 / 2 ; i++ ) {
		temp = out[i];
		out[i] = out[len2-i-1];
		out[len2-i-1] = temp;
	}
}

/* Encodes a string to Base64 */
stock _HTTP2_Encode64(const InputString[], OutputString[], len) {
	
	new nLength, resPos, nPos, cCode, cFillChar = '=';
	setc(OutputString, len, 0);
	
	for ( nPos = 0, resPos = 0, nLength = strlen(InputString) ; nPos < nLength ; nPos++ ) {
		
		cCode = (InputString[nPos] >> 2) & 0x3f;
		
		resPos += formatex(OutputString[resPos], len, "%c", _HTTP2_Base64Table[cCode]);
		
		cCode = (InputString[nPos] << 4) & 0x3f;
		if ( ++nPos < nLength )
			cCode |= (InputString[nPos] >> 4) & 0x0f;
		resPos += formatex(OutputString[resPos], len, "%c", _HTTP2_Base64Table[cCode]);
		
		if ( nPos < nLength ) {
			cCode = (InputString[nPos] << 2) & 0x3f;
			if ( ++nPos < nLength )
				cCode |= (InputString[nPos] >> 6) & 0x03;
			
			resPos += formatex(OutputString[resPos], len, "%c", _HTTP2_Base64Table[cCode]);
		}
		else {
			nPos++;
			resPos += formatex(OutputString[resPos], len, "%c", cFillChar);
		}
		
		if(nPos < nLength) {
			cCode = InputString[nPos] & 0x3f;
			resPos += formatex(OutputString[resPos], len, "%c", _HTTP2_Base64Table[cCode]);
		}
		else
			resPos += formatex(OutputString[resPos], len, "%c", cFillChar);
	}
}

new szAppID[7];
new szLogFile[129];
new hCvarApiKey;
new hCvarKick;
new hCvarLog;
new Trie:hDownloads;
new trash;
#if AMXX_VERSION_NUM < 183
new iMaxPlayers;
#endif

public plugin_init()
{
	register_plugin(PLUGINNAME, PLUGINVERSION, PLUGINAUTHOR);
	set_pcvar_string(register_cvar("family_sharing", PLUGINVERSION, FCVAR_SERVER|FCVAR_EXTDLL|FCVAR_UNLOGGED|FCVAR_SPONLY), PLUGINVERSION);

hCvarApiKey = register_cvar("sv_apikey", "YourAPIKey", FCVAR_PROTECTED|FCVAR_SPONLY);
	hCvarKick = register_cvar("share_kick", "0");
	hCvarLog = register_cvar("share_log", "1"); // 1 - Log Shared game, 2 - Log anyway

read_file("steam_appid.txt", 0, szAppID, charsmax(szAppID), trash);

get_localinfo("amxx_logs", szLogFile, charsmax(szLogFile));
	add(szLogFile, charsmax(szLogFile), "/family_sharing.log");

hDownloads = TrieCreate();

#if AMXX_VERSION_NUM < 183
	iMaxPlayers = get_maxplayers();
#endif
}

public client_authorized(id)
{
	if(is_user_bot(id) || !is_user_steam(id))
		return;

new szURL[251];
	new szApiKey[35];
	new szAuthID[38];
	new szFriendID[18];
	new szFile[23];

get_user_authid(id, szAuthID, charsmax(szAuthID));
	getSteam64(szAuthID, szFriendID);
	formatex(szFile, charsmax(szFile), "%s.vdf", szFriendID);
	TrieSetCell(hDownloads, szFile, get_user_userid(id));
	get_pcvar_string(hCvarApiKey, szApiKey, charsmax(szApiKey));
	formatex(szURL, charsmax(szURL), "http://api.steampowered.com/IPlayerService/IsPlayingSharedGame/v0001/?&format=vdf&steamid=%s&appid_playing=%s&key=%s", szFriendID, szAppID, szApiKey);
	HTTP2_Download(szURL, szFile, "DownloadComplete");
}

public DownloadComplete(iDownload, iError)
{
	new szFile[23];
	new iUserID;
	new szLine[101];
	new szKey[21];
	new szValue[21];

HTTP2_getFilename(iDownload, szFile, charsmax(szFile));
	TrieGetCell(hDownloads, szFile, iUserID);

if (iError == 0)
	{
		read_file(szFile, 2, szLine, charsmax(szLine), trash);
		parse(szLine, szKey, charsmax(szKey), szValue, charsmax(szValue));

if (!equal(szValue, "0"))
		{
			if (get_pcvar_num(hCvarLog) > 0)
			{
				new id = findUser(iUserID);
				new szAuthID[40];
				new szSharedID[40];
				new szName[32];

get_user_name(id, szName, charsmax(szName));
				get_user_authid(id, szAuthID, charsmax(szAuthID));
				getSteam2(szValue, szSharedID, charsmax(szSharedID));

log_to_file(szLogFile, "%s<%s> játékos %s által megosztott játékot használ.", szName, szAuthID, szSharedID);
			}

if (get_pcvar_num(hCvarKick))
			{
				server_cmd("kick #%d ^"A Családi Megosztással nem játszhatsz ezen a szerveren^"", iUserID);
			}
		}
		else
		{
			if(get_pcvar_num(hCvarLog) == 2)
			{
				new id = findUser(iUserID);
				new szAuthID[40];
				new szName[32];

get_user_name(id, szName, charsmax(szName));
				get_user_authid(id, szAuthID, charsmax(szAuthID));

log_to_file(szLogFile, "%s<%s> játékos nem használ megosztott játékot.", szName, szAuthID);
			}
		}
	}
	else
	{
		log_amx("Hiba: %d - %s", iError, szFile);
	}

delete_file(szFile);
}

stock findUser(iUserID)
{
#if AMXX_VERSION_NUM < 183
	for (new k = 0; k < iMaxPlayers; k++)
#else
	for (new k = 0; k < MaxClients; k++)
#endif
	{
		if (get_user_userid(k) == iUserID)
		{
			return k;
		}
	}

return 0;
}

new const szBase[] = "76561197960265728";

stock getSteam2(const szSteam64[], szSteam2[], iLen)
{
	new iBorrow = 0;
	new szSteam[18];
	new szAccount[18];
	new iY = 0;
	new iZ = 0;
	new iTemp = 0;

arrayset(szAccount, '0', charsmax(szAccount));
	copy(szSteam, charsmax(szSteam), szSteam64);

if (intval(szSteam[16]) % 2 == 1)
	{
		iY = 1;
		szSteam[16] = strval(intval(szSteam[16]) - 1);
	}

for (new k = 16; k >= 0; k--)
	{
		if (iBorrow > 0)
		{
			iTemp = intval(szSteam[k]) - 1;

if (iTemp >= intval(szBase[k]))
			{
				iBorrow = 0;
				szAccount[k] = strval(iTemp - intval(szBase[k]));
			}
			else
			{
				iBorrow = 1;
				szAccount[k] = strval((iTemp + 10) - intval(szBase[k]));
			}
		}
		else
		{
			if (intval(szSteam[k]) >= intval(szBase[k]))
			{
				iBorrow = 0;
				szAccount[k] = strval(intval(szSteam[k]) - intval(szBase[k]));
			}
			else
			{
				iBorrow = 1;
				szAccount[k] = strval((intval(szSteam[k]) + 10) - intval(szBase[k]));
			}
		}
	}

iZ = str_to_num(szAccount);
	iZ /= 2;

formatex(szSteam2, iLen, "STEAM_0:%d:%d", iY, iZ);
}

stock getSteam64(const szSteam2[], szSteam64[18])
{
	new iCarry = 0;
	new szAccount[18];
	new iTemp = 0;

copy(szSteam64, charsmax(szSteam64), szBase);
	formatex(szAccount, charsmax(szAccount), "%s", szSteam2[10]);
	formatex(szAccount, charsmax(szAccount), "%017d", str_to_num(szAccount));

szSteam64[16] = strval(intval(szSteam64[16]) + intval(szSteam2[8]));

for (new j = 0; j < 2; j++)
	{
		for (new k = 16; k >= 0; k--)
		{
			if (iCarry > 0)
			{
				iTemp = intval(szSteam64[k-iCarry+1]) + 1;

if (iTemp > 9)
				{
					iTemp -= 10;
					szSteam64[k-iCarry+1] = strval(iTemp);
					iCarry += 1;
				}
				else
				{
					szSteam64[k-iCarry+1] = strval(iTemp);
					iCarry = 0;
				}

k++;
			}
			else
			{
				iTemp = intval(szSteam64[k]) + intval(szAccount[k]);

if (iTemp > 9)
				{
					iCarry = 1;
					iTemp -= 10;
				}

szSteam64[k] = strval(iTemp);
			}
		}
	}
}

stock is_user_steam(id)
{
	static dp_pointer;
	if(dp_pointer || (dp_pointer = get_cvar_pointer("dp_r_id_provider")))
	{
		server_cmd("dp_clientinfo %d", id);
		server_exec();
		return (get_pcvar_num(dp_pointer) == 2) ? true : false;
	}
	return false;
}

strval(const iNum)
{
	switch (iNum)
	{
		case 0:		return '0';
		case 1:		return '1';
		case 2:		return '2';
		case 3:		return '3';
		case 4:		return '4';
		case 5:		return '5';
		case 6:		return '6';
		case 7:		return '7';
		case 8:		return '8';
		case 9:		return '9';
	}

return '0';
}

intval(cNum)
{
	switch (cNum)
	{
		case '0':		return 0;
		case '1':		return 1;
		case '2':		return 2;
		case '3':		return 3;
		case '4':		return 4;
		case '5':		return 5;
		case '6':		return 6;
		case '7':		return 7;
		case '8':		return 8;
		case '9':		return 9;
	}

return 0;
}

SMA	Letöltés \| Megtekintés
AMXX	Átalakítás AMXX-re*
*A fordítás a aghl.ru oldalon történik.

Szerző:	Anonymous1337 [ 2018.06.14. 06:37 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
A játék nem mind, mert amxmodx include szükséges, és az csak hl1-el működik.

Szerző:	JohanCorn [ 2018.06.14. 11:16 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
Anonymous1337 írta: A játék nem mind, mert amxmodx include szükséges, és az csak hl1-el működik. Azért is csak az Amx Mod X Pluginokhoz töltötte fel. Úgy értve van minden játékhoz. HL1-en belül.

Szerző:	norbee.16 [ 2018.06.14. 11:26 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
Ahogy én tudom, de lehet teljesen téves az információm régről. De csak az kapcsolódik fix játékhoz ami tartalmazza a hozzá kirendelt inc-t. Jelen esetben kellene tartalmazni a cstrike inc-t és akkor csak cs1.6hoz lehetne használni.

Szerző:	Anonymous1337 [ 2018.06.14. 12:39 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
Ez így ahogy van, nem fog futni egy Half-Life szerveren. Se egy Ricochet szerveren, se egy Vampire Slayer, egy Opposing Force, HL rally szervereken. Ezért nem mind, hanem csak counter-strike. De javítsatok ki ha tévedek.

Szerző:	norbee.16 [ 2018.06.14. 13:17 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
Ha alliedmoddersen 'All'-nál van akkor te tévedsz. Kétlem, hogy ott úgy jóváhagyták volna. https://www.amxmodx.org/compiler.php?mod=1&cat=0&plugin=Family+Sharing+Management&author=&go=search

Szerző:	Anonymous1337 [ 2018.06.14. 13:20 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
norbee.16 írta: Ha alliedmoddersen 'All'-nál van akkor te tévedsz. Kétlem, hogy ott úgy jóváhagyták volna. https://www.amxmodx.org/compiler.php?mod=1&cat=0&plugin=Family+Sharing+Management&author=&go=search Hát pedig ez biztos nem megy Ricochet en, se HL rallyn. Pont a(z) amxmodx.inc miatt.

Szerző:	norbee.16 [ 2018.06.14. 13:26 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
Tessék egy Ricochet plugin, amxmodx.incel. https://forums.alliedmods.net/showthread.php?p=432490 HL Rally plugin, dettó. https://forums.alliedmods.net/showthread.php?p=17619 Hl motor, akkor mért ne menne. Amxmodxen alapszik mindegyik.

Szerző:	regener [ 2018.06.15. 17:19 ]
Hozzászólás témája:	Re: Családi Megosztás Menedzsment
Semmi cstrike specifikus dolog nincs benne, Steamid-vel már akkor rendelkezel mikor létrehozod a Steam fiókod és ezen kívül a Steam saját apijára alapozva működik. A játékmotor fix alattuk, a szóban forgó játékok lényegében csak HL módok. Ha inkompabilitás van is akkor az adott mód felelős érte, de szerintem mindennel mennie kell amit az AMXX támogat.

Oldal: 1 / 1	Minden időpont UTC+02:00 időzóna szerinti
Powered by phpBB® Forum Software © phpBB Limited https://www.phpbb.com/