├── README.md
├── plugins
    └── websocket.smx
└── scripting
    ├── include
        └── websocket.inc
    └── websocket.sp


/README.md:
--------------------------------------------------------------------------------
1 | sm-websocket
2 | ============
3 | 
4 | A WebSocket protocol implementation to create a direct connection between webbrowsers and gameservers.


--------------------------------------------------------------------------------
/plugins/websocket.smx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/peace-maker/sm-websocket/d17be587b5faae08fa63af7a282b4253641ff561/plugins/websocket.smx


--------------------------------------------------------------------------------
/scripting/include/websocket.inc:
--------------------------------------------------------------------------------
  1 | #if defined _websocket_included
  2 |   #endinput
  3 | #endif
  4 | #define _websocket_included
  5 | 
  6 | enum WebsocketReadyState {
  7 | 	State_Connecting = 0,
  8 | 	State_Open,
  9 | 	State_Closing,
 10 | 	State_Closed // Kinda unused
 11 | }
 12 | 
 13 | enum WebsocketHandle {
 14 | 	INVALID_WEBSOCKET_HANDLE = 0
 15 | }
 16 | 
 17 | enum WebsocketSendType {
 18 | 	SendType_Text = 0,
 19 | 	SendType_Binary
 20 | }
 21 | 
 22 | /**
 23 |  * called if an unrecoverable error occured on the master socket
 24 |  *
 25 |  * @param WebsocketHandle	websocket	The websocket handle pointing to the calling websocket
 26 |  * @param cell_t			errorType	The error type, see defines in socket.inc
 27 |  * @param cell_t			errorNum	The errno, see errno.h for details
 28 |  * @noreturn
 29 |  */
 30 | typedef WebsocketErrorCB = function void(WebsocketHandle websocket, const int errorType, const int errorNum);
 31 | 
 32 | /**
 33 |  * called if a master websocket is closed
 34 |  *
 35 |  * @param WebsocketHandle	websocket	The websocket handle pointing to the calling websocket
 36 |  * @noreturn
 37 |  */
 38 | typedef WebsocketCloseCB = function void(WebsocketHandle websocket);
 39 | 
 40 | /**
 41 |  * triggered when a client connected to our websocket
 42 |  *
 43 |  * @param Handle	websocket		The websocket handle pointing to the calling listen-socket
 44 |  * @param Handle	newWebsocket	The websocket handle to the newly spawned child socket
 45 |  * @param String	remoteIP		The remote IP
 46 |  * @param cell_t	remotePort	The remote port
 47 |  * @param String	protocols 	The subprotocols the client supports seperated by commas. You have to choose one of the list, so "protocols" is only that one protocol.
 48 |  * @param String	getPath 		The GET path transmitted upon connection by the client.
 49 |  * @return
 50 |  */
 51 | typeset WebsocketIncomingCB {
 52 | 	function Action(WebsocketHandle websocket, WebsocketHandle newWebsocket, const char[] remoteIP, int remotePort, char protocols[256]);
 53 | 	function Action(WebsocketHandle websocket, WebsocketHandle newWebsocket, const char[] remoteIP, int remotePort, char protocols[256], char getPath[2000]);
 54 | };
 55 | 
 56 | /**
 57 |  * triggered if a websocket receives data
 58 |  *
 59 |  * @note This is binary safe if you always use dataSize for operations on receiveData[]
 60 |  * @note packets may be split up into multiple chunks -> multiple calls to the receive callback
 61 |  * @note if not set otherwise by SocketSetOption(..., ConcatenateCallbacks, ...) receiveData will
 62 |  *       never be longer than 4096 characters including \0 terminator
 63 |  *
 64 |  * @param Handle	websocket		The socket handle pointing to the calling socket
 65 |  * @param String	receiveData	The data which arrived, 0-terminated at receiveData[dataSize]
 66 |  * @param cell_t	dataSize	The length of the arrived data excluding the 0-termination
 67 |  * @noreturn
 68 |  */
 69 | typedef WebsocketReceiveCB = function void(WebsocketHandle websocket, WebsocketSendType iType, const char[] receiveData, const int dataSize);
 70 | 
 71 | /**
 72 |  * called if a socket has been properly disconnected by the remote side
 73 |  *
 74 |  * @param Handle	websocket		The socket handle pointing to the calling socket
 75 |  * @noreturn
 76 |  */
 77 | typedef WebsocketDisconnectCB = function void(WebsocketHandle websocket);
 78 | 
 79 | /**
 80 |  * called if the readystate of a childsocket changes.
 81 |  * Only fires for ReadyState_Open and ReadyState_Closing.
 82 |  *
 83 |  * @param Handle	websocket		The socket handle pointing to the calling socket
 84 |  * @param WebsocketReadyState	readystate	The new readystate of the childsocket.
 85 |  * @noreturn
 86 |  */
 87 | typedef WebsocketReadyStateChangedCB = function void(WebsocketHandle websocket, WebsocketReadyState readystate);
 88 | 
 89 | /**
 90 |  * Creates a websocket server which listens on the supplied ip:port combination.
 91 |  *
 92 |  * @param sHostName    	The IP to bind to.
 93 |  * @param iPort    		The port to listen on
 94 |  * @param inc    		The incoming child connection callback
 95 |  * @param we    		The error callback
 96 |  * @return        		A WebsocketHandle or INVALID_WEBSOCKET_HANDLE on error.
 97 |  */
 98 | native WebsocketHandle Websocket_Open(const char[] sHostName, int iPort, WebsocketIncomingCB inc, WebsocketErrorCB we, WebsocketCloseCB clo);
 99 | 
100 | /**
101 |  * Hooks child socket's events
102 |  *
103 |  * @param childwebsocket    The child websocket to hook.
104 |  * @param recv    			Data receive callback
105 |  * @param disc    			The disconnect callback
106 |  * @param we    			The error callback
107 |  * @return        			True if child socket was hooked, false otherwise
108 |  */
109 | native bool Websocket_HookChild(WebsocketHandle childwebsocket, WebsocketReceiveCB recv, WebsocketDisconnectCB disc, WebsocketErrorCB we);
110 | 
111 | /**
112 |  * Hooks child socket's readystate changes
113 |  *
114 |  * @param childwebsocket    The child websocket to hook.
115 |  * @param readystate   			ReadyState change callback
116 |  * @return        			True if child socket was hooked, false otherwise
117 |  */
118 | native bool Websocket_HookReadyStateChange(WebsocketHandle childwebsocket, WebsocketReadyStateChangedCB readystate);
119 | 
120 | 
121 | /**
122 |  * Sends text or binary data through the websocket
123 |  *
124 |  * @param childwebsocket    The child websocket to send to
125 |  * @param type    			The datatype SendType_Text or SendType_Binary
126 |  * @param sPayLoad 			The data to send
127 |  * @param dataSize			If set, it's used as maxlength. Useful for binary data where \0 might be used before the end of the data.
128 |  * @return        			True if child socket was hooked, false otherwise
129 |  */
130 | native bool Websocket_Send(WebsocketHandle childwebsocket, WebsocketSendType type, const char[] sPayload, const int dataSize =- 1);
131 | 
132 | /**
133 |  * Gets a child websocket's readyState.
134 |  *
135 |  * @param childwebsocket    The child websocket
136 |  * @return        			The readyState
137 |  */
138 | native WebsocketReadyState Websocket_GetReadyState(WebsocketHandle childwebsocket);
139 | 
140 | /**
141 |  * Unhooks a child socket's events: If there's no plugin listening anymore, the socket is closed.
142 |  *
143 |  * @param childwebsocket    The child websocket
144 |  * @noreturn
145 |  */
146 | native void Websocket_UnhookChild(WebsocketHandle childwebsocket);
147 | 
148 | /**
149 |  * Closes a listening master socket, created with Websocket_Open.
150 |  * Note: The socket will still be open, if there are more plugins using it.
151 |  * 
152 |  * Call this in OnPluginEnd()!
153 |  *
154 |  * @param websocket    The master websocket
155 |  * @noreturn
156 |  */
157 | native void Websocket_Close(WebsocketHandle websocket);
158 | 
159 | public SharedPlugin __pl_websocket = 
160 | {
161 | 	name = "websocket",
162 | 	file = "websocket.smx",
163 | #if defined REQUIRE_PLUGIN
164 | 	required = 1,
165 | #else
166 | 	required = 0,
167 | #endif
168 | };
169 | 
170 | #if !defined REQUIRE_PLUGIN
171 | public void __pl_websocket_SetNTVOptional()
172 | {
173 | 	MarkNativeAsOptional("Websocket_Open");
174 | 	MarkNativeAsOptional("Websocket_HookReadyStateChange");
175 | 	MarkNativeAsOptional("Websocket_HookChild");
176 | 	MarkNativeAsOptional("Websocket_Send");
177 | 	MarkNativeAsOptional("Websocket_GetReadyState");
178 | 	MarkNativeAsOptional("Websocket_UnhookChild");
179 | 	MarkNativeAsOptional("Websocket_Close");
180 | }
181 | #endif
182 | 


--------------------------------------------------------------------------------
/scripting/websocket.sp:
--------------------------------------------------------------------------------
   1 | #pragma semicolon 1
   2 | #pragma dynamic 65536
   3 | #include <sourcemod>
   4 | #include <regex>
   5 | #include <socket>
   6 | #include <websocket>
   7 | #include <base64>
   8 | #include <sha1>
   9 | 
  10 | #define PLUGIN_VERSION "1.2"
  11 | 
  12 | #define DEBUG 0
  13 | #if DEBUG > 0
  14 | new String:g_sLog[PLATFORM_MAX_PATH];
  15 | #endif
  16 | 
  17 | /**
  18 |  * This implementation follows the draft version 17 of the websocket protocol specifications
  19 |  * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
  20 |  */
  21 | 
  22 | // Used in the g_hMasterSocketPlugins child arrays
  23 | enum MasterPluginCallbacks {
  24 | 	Handle:MPC_PluginHandle,
  25 | 	Function:MPC_ErrorCallback,
  26 | 	Function:MPC_IncomingCallback,
  27 | 	Function:MPC_CloseCallback
  28 | }
  29 | 
  30 | enum ChildPluginCallbacks {
  31 | 	Handle:CPC_PluginHandle,
  32 | 	Function:CPC_ReceiveCallback,
  33 | 	Function:CPC_DisconnectCallback,
  34 | 	Function:CPC_ErrorCallback,
  35 | 	Function:CPC_ReadystateCallback
  36 | }
  37 | 
  38 | #define FRAGMENT_MAX_LENGTH 32768
  39 | #define URL_MAX_LENGTH 2000
  40 | 
  41 | // Handshake header parsing
  42 | new Handle:g_hRegExKey;
  43 | new Handle:g_hRegExPath;
  44 | new Handle:g_hRegExProtocol;
  45 | 
  46 | // Array of all master sockets we're listening on
  47 | new Handle:g_hMasterSockets;
  48 | new Handle:g_hMasterSocketHostPort;
  49 | new Handle:g_hMasterSocketIndexes;
  50 | // Array of arrays containing plugin handles which use this socket
  51 | new Handle:g_hMasterSocketPlugins;
  52 | new Handle:g_hMasterErrorForwards;
  53 | new Handle:g_hMasterCloseForwards;
  54 | new Handle:g_hMasterIncomingForwards;
  55 | // Array connecting g_hChildSockets with g_hMasterSockets
  56 | new Handle:g_hChildsMasterSockets;
  57 | // Array of child sockets spawned by a master socket. Child indexes are mapped to master sockets via g_hMasterChildSockets {child => master,...}
  58 | new Handle:g_hChildSockets;
  59 | // Array of arrays containing plugin handles which use this child socket
  60 | new Handle:g_hChildSocketPlugins;
  61 | new Handle:g_hChildSocketIndexes;
  62 | new Handle:g_hChildSocketHost;
  63 | new Handle:g_hChildSocketPort;
  64 | new Handle:g_hChildSocketReadyState;
  65 | new Handle:g_hChildSocketFragmentedPayload;
  66 | new Handle:g_hChildErrorForwards;
  67 | new Handle:g_hChildReceiveForwards;
  68 | new Handle:g_hChildDisconnectForwards;
  69 | new Handle:g_hChildReadyStateChangeForwards;
  70 | //new Handle:g_hChildRandomParameter;
  71 | 
  72 | // This is passed as "handle" to plugins
  73 | new g_iLastSocketIndex = 0;
  74 | 
  75 | 
  76 | enum WebsocketFrameType {
  77 | 	FrameType_Continuation = 0,
  78 | 	FrameType_Text = 1,
  79 | 	FrameType_Binary = 2,
  80 | 	FrameType_Close = 8,
  81 | 	FrameType_Ping = 9,
  82 | 	FrameType_Pong = 10
  83 | }
  84 | 
  85 | enum WebsocketFrame
  86 | {
  87 | 	FIN,
  88 | 	RSV1,
  89 | 	RSV2,
  90 | 	RSV3,
  91 | 	WebsocketFrameType:OPCODE,
  92 | 	MASK,
  93 | 	PAYLOAD_LEN,
  94 | 	String:MASKINGKEY[5],
  95 | 	CLOSE_REASON
  96 | }
  97 | 
  98 | public Plugin:myinfo = 
  99 | {
 100 | 	name = "Websocket",
 101 | 	author = "Jannik \"Peace-Maker\" Hartung",
 102 | 	description = "Websocket protocol implementation",
 103 | 	version = PLUGIN_VERSION,
 104 | 	url = "http://www.wcfan.de/"
 105 | }
 106 | 
 107 | public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
 108 | {
 109 | 	RegPluginLibrary("websocket");
 110 | 	CreateNative("Websocket_Open", Native_Websocket_Open);
 111 | 	CreateNative("Websocket_HookChild", Native_Websocket_HookChild);
 112 | 	CreateNative("Websocket_HookReadyStateChange", Native_Websocket_HookReadyStateChange);
 113 | 	CreateNative("Websocket_GetReadyState", Native_Websocket_GetReadyState);
 114 | 	CreateNative("Websocket_Send", Native_Websocket_Send);
 115 | 	CreateNative("Websocket_UnhookChild", Native_Websocket_UnhookChild);
 116 | 	CreateNative("Websocket_Close", Native_Websocket_Close);
 117 | 	return APLRes_Success;
 118 | }
 119 | 
 120 | public OnPluginStart()
 121 | {
 122 | 	new Handle:hVersion = CreateConVar("sm_websocket_version", PLUGIN_VERSION, "", FCVAR_NOTIFY|FCVAR_REPLICATED|FCVAR_DONTRECORD);
 123 | 	if(hVersion != INVALID_HANDLE)
 124 | 		SetConVarString(hVersion, PLUGIN_VERSION);
 125 | 	
 126 | 	// Setup handshake http header parsing regexes
 127 | 	new RegexError:iRegExError, String:sError[64];
 128 | 	g_hRegExKey = CompileRegex("Sec-WebSocket-Key: (.*)\r\n", 0, sError, sizeof(sError), iRegExError);
 129 | 	if(g_hRegExKey == INVALID_HANDLE)
 130 | 	{
 131 | 		SetFailState("Can't compile Sec-WebSocket-Key regex: %s (%d)", sError, _:iRegExError);
 132 | 	}
 133 | 	g_hRegExPath = CompileRegex("GET (.*)( HTTP/1.\\d)\r\n", 0, sError, sizeof(sError), iRegExError);
 134 | 	if(g_hRegExPath == INVALID_HANDLE)
 135 | 	{
 136 | 		SetFailState("Can't compile GET-Path regex: %s (%d)", sError, _:iRegExError);
 137 | 	}
 138 | 	g_hRegExProtocol = CompileRegex("Sec-WebSocket-Protocol: (.*)\r\n", 0, sError, sizeof(sError), iRegExError);
 139 | 	if(g_hRegExProtocol == INVALID_HANDLE)
 140 | 	{
 141 | 		SetFailState("Can't compile Sec-WebSocket-Protocol regex: %s (%d)", sError, _:iRegExError);
 142 | 	}
 143 | 	
 144 | 	g_hMasterSockets = CreateArray();
 145 | 	g_hMasterSocketHostPort = CreateArray(ByteCountToCells(128));
 146 | 	g_hMasterSocketIndexes = CreateArray();
 147 | 	g_hMasterSocketPlugins = CreateArray();
 148 | 	g_hChildsMasterSockets = CreateArray();
 149 | 	g_hChildSockets = CreateArray();
 150 | 	g_hChildSocketIndexes = CreateArray();
 151 | 	g_hChildSocketPlugins = CreateArray();
 152 | 	g_hChildSocketHost = CreateArray(ByteCountToCells(64));
 153 | 	g_hChildSocketPort = CreateArray();
 154 | 	g_hChildSocketReadyState = CreateArray();
 155 | 	g_hChildSocketFragmentedPayload = CreateArray();
 156 | 	
 157 | 	g_hMasterErrorForwards = CreateArray();
 158 | 	g_hMasterCloseForwards = CreateArray();
 159 | 	g_hMasterIncomingForwards = CreateArray();
 160 | 	g_hChildErrorForwards = CreateArray();
 161 | 	g_hChildReceiveForwards = CreateArray();
 162 | 	g_hChildDisconnectForwards = CreateArray();
 163 | 	g_hChildReadyStateChangeForwards = CreateArray();
 164 | 	
 165 | #if DEBUG > 0
 166 | 	BuildPath(Path_SM, g_sLog, sizeof(g_sLog), "logs/websocket_debug.log");
 167 | #endif
 168 | }
 169 | 
 170 | public OnPluginEnd()
 171 | {
 172 | 	while(GetArraySize(g_hMasterSockets))
 173 | 		CloseMasterSocket(0);
 174 | }
 175 | 
 176 | public Native_Websocket_Open(Handle:plugin, numParams)
 177 | {
 178 | 	new iSize = GetArraySize(g_hMasterSocketPlugins);
 179 | 	new Handle:hMasterSocketPlugins, aPluginInfo[MasterPluginCallbacks];
 180 | 	
 181 | 	// Currently only one websocket per plugin is supported.
 182 | 	new iPluginCount;
 183 | 	for(new i=0;i<iSize;i++)
 184 | 	{
 185 | 		hMasterSocketPlugins = GetArrayCell(g_hMasterSocketPlugins, i);
 186 | 		iPluginCount = GetArraySize(hMasterSocketPlugins);
 187 | 		for(new p=0;p<iPluginCount;p++)
 188 | 		{
 189 | 			GetArrayArray(hMasterSocketPlugins, p, aPluginInfo[0], _:MasterPluginCallbacks);
 190 | 			if(aPluginInfo[MPC_PluginHandle] == plugin)
 191 | 			{
 192 | 				ThrowNativeError(SP_ERROR_NATIVE, "Only one websocket per plugin allowed. You already got one open.");
 193 | 				return _:INVALID_WEBSOCKET_HANDLE;
 194 | 			}
 195 | 		}
 196 | 	}
 197 | 	
 198 | 	new iHostNameLength;
 199 | 	GetNativeStringLength(1, iHostNameLength);
 200 | 	if(iHostNameLength <= 0)
 201 | 	{
 202 | 		return _:INVALID_WEBSOCKET_HANDLE;
 203 | 	}
 204 | 	
 205 | 	new String:sHostName[iHostNameLength+1];
 206 | 	GetNativeString(1, sHostName, iHostNameLength+1);
 207 | 	
 208 | 	new iPort = GetNativeCell(2);
 209 | 	
 210 | 	new iIndex = -1;
 211 | 	
 212 | 	// Is there already a socket open on that hostname:port?
 213 | 	decl String:sHostPort[128], String:sHostPortStored[128];
 214 | 	Format(sHostPort, sizeof(sHostPort), "%s:%d", sHostName, iPort);
 215 | 	iSize = GetArraySize(g_hMasterSocketHostPort);
 216 | 	for(new i=0;i<iSize;i++)
 217 | 	{
 218 | 		GetArrayString(g_hMasterSocketHostPort, i, sHostPortStored, sizeof(sHostPortStored));
 219 | 		// Yes there is. Just add this plugin to the listeners
 220 | 		if(StrEqual(sHostPort, sHostPortStored, false))
 221 | 		{
 222 | 			iIndex = i;
 223 | 			break;
 224 | 		}
 225 | 	}
 226 | 	
 227 | 	// Only create the socket, if it's not there already!
 228 | 	new Handle:hErrorForward, Handle:hCloseForward, Handle:hIncomingForward, iPseudoHandle;
 229 | 	if(iIndex == -1)
 230 | 	{
 231 | 		new Handle:hMasterSocket = SocketCreate(SOCKET_TCP, OnSocketError);
 232 | 		
 233 | 		if(SocketSetOption(hMasterSocket, SocketReuseAddr, 1) != 1)
 234 | 		{
 235 | 			ThrowNativeError(SP_ERROR_NATIVE, "Can't set SO_REUSEADDR option.");
 236 | 			return _:INVALID_WEBSOCKET_HANDLE;
 237 | 		}
 238 | 		
 239 | 		if(!SocketBind(hMasterSocket, sHostName, iPort))
 240 | 		{
 241 | 			ThrowNativeError(SP_ERROR_NATIVE, "Unable to bind socket to %s:%d", sHostName, iPort);
 242 | 			return _:INVALID_WEBSOCKET_HANDLE;
 243 | 		}
 244 | 		
 245 | 		if(!SocketListen(hMasterSocket, OnSocketIncoming))
 246 | 		{
 247 | 			ThrowNativeError(SP_ERROR_NATIVE, "Unable to listen on socket to %s:%d", sHostName, iPort);
 248 | 			return _:INVALID_WEBSOCKET_HANDLE;
 249 | 		}
 250 | 		
 251 | 		// Save the socket!
 252 | 		iIndex = PushArrayCell(g_hMasterSockets, hMasterSocket);
 253 | 		Debug(1, "Created socket on %s:%d #%d", sHostName, iPort, iIndex);
 254 | 		// this should always be in sync with g_hMasterSockets
 255 | 		iPseudoHandle = ++g_iLastSocketIndex;
 256 | 		PushArrayCell(g_hMasterSocketIndexes, iPseudoHandle);
 257 | 		// Create private forwards for this socket
 258 | 		hIncomingForward = CreateForward(ET_Event, Param_Cell, Param_Cell, Param_String, Param_Cell, Param_String, Param_String);
 259 | 		PushArrayCell(g_hMasterIncomingForwards, hIncomingForward);
 260 | 		hErrorForward = CreateForward(ET_Ignore, Param_Cell, Param_Cell, Param_Cell);
 261 | 		PushArrayCell(g_hMasterErrorForwards, hErrorForward);
 262 | 		hCloseForward = CreateForward(ET_Ignore, Param_Cell);
 263 | 		PushArrayCell(g_hMasterCloseForwards, hCloseForward);
 264 | 		
 265 | 		SocketSetArg(hMasterSocket, iPseudoHandle);
 266 | 		
 267 | 		// Save the hostname:port combi to check, if there's already a socket open.
 268 | 		// We just pass the handle to the plugin calling instead of creating a new socket.
 269 | 		PushArrayString(g_hMasterSocketHostPort, sHostPort);
 270 | 	}
 271 | 	// There's already a connection open. Get the details
 272 | 	else
 273 | 	{
 274 | 		iPseudoHandle = GetArrayCell(g_hMasterSocketIndexes, iIndex);
 275 | 		hIncomingForward = Handle:GetArrayCell(g_hMasterIncomingForwards, iIndex);
 276 | 		hErrorForward = Handle:GetArrayCell(g_hMasterErrorForwards, iIndex);
 277 | 		hCloseForward = Handle:GetArrayCell(g_hMasterCloseForwards, iIndex);
 278 | 		Debug(1, "Using old socket on %s:%d #%d", sHostName, iPort, iIndex);
 279 | 	}
 280 | 	
 281 | 	// Add him to our private incoming connections forward for this socket
 282 | 	new Function:fIncomingCallback = GetNativeFunction(3);
 283 | 	if(!AddToForward(hIncomingForward, plugin, fIncomingCallback))
 284 | 		LogError("Unable to add plugin to incoming callback");
 285 | 	
 286 | 	// Add him to our private error forward for this socket
 287 | 	new Function:fErrorCallback = GetNativeFunction(4);
 288 | 	if(!AddToForward(hErrorForward, plugin, fErrorCallback))
 289 | 		LogError("Unable to add plugin to error callback");
 290 | 	
 291 | 	// Add him to our private close forward for this socket
 292 | 	new Function:fCloseCallback = GetNativeFunction(5);
 293 | 	if(!AddToForward(hCloseForward, plugin, fCloseCallback))
 294 | 		LogError("Unable to add plugin to close callback");
 295 | 	
 296 | 	// Remember, that this plugin is using this socket. Required to determine, if we can close the socket, if no plugins are using it anymore.
 297 | 	if(iIndex >= iSize)
 298 | 	{
 299 | 		hMasterSocketPlugins = CreateArray(_:MasterPluginCallbacks);
 300 | 		PushArrayCell(g_hMasterSocketPlugins, hMasterSocketPlugins);
 301 | 	}
 302 | 	else
 303 | 		hMasterSocketPlugins = GetArrayCell(g_hMasterSocketPlugins, iIndex);
 304 | 	
 305 | 	aPluginInfo[MPC_PluginHandle] = plugin;
 306 | 	aPluginInfo[MPC_ErrorCallback] = fErrorCallback;
 307 | 	aPluginInfo[MPC_IncomingCallback] = fIncomingCallback;
 308 | 	aPluginInfo[MPC_CloseCallback] = fCloseCallback;
 309 | 	PushArrayArray(hMasterSocketPlugins, aPluginInfo[0], _:MasterPluginCallbacks);
 310 | 	
 311 | 	return _:iPseudoHandle;
 312 | }
 313 | 
 314 | public Native_Websocket_Send(Handle:plugin, numParams)
 315 | {
 316 | 	new WebsocketHandle:iPseudoChildHandle = WebsocketHandle:GetNativeCell(1);
 317 | 	new iChildIndex;
 318 | 	if(iPseudoChildHandle == INVALID_WEBSOCKET_HANDLE
 319 | 	|| (iChildIndex = FindValueInArray(g_hChildSocketIndexes, _:iPseudoChildHandle)) == -1)
 320 | 	{
 321 | 		ThrowNativeError(SP_ERROR_NATIVE, "Invalid child websocket handle.");
 322 | 		return false;
 323 | 	}
 324 | 	
 325 | 	new vFrame[WebsocketFrame];
 326 | 	vFrame[OPCODE] = WebsocketSendType:GetNativeCell(2)==SendType_Text?FrameType_Text:FrameType_Binary;
 327 | 	
 328 | 	vFrame[PAYLOAD_LEN] = GetNativeCell(4);
 329 | 	if(vFrame[PAYLOAD_LEN] == -1)
 330 | 		GetNativeStringLength(3, vFrame[PAYLOAD_LEN]);
 331 | 	
 332 | 	new String:sPayLoad[vFrame[PAYLOAD_LEN]+1];
 333 | 	
 334 | 	GetNativeString(3, sPayLoad, vFrame[PAYLOAD_LEN]+1);
 335 | 	
 336 | 	vFrame[FIN] = 1;
 337 | 	vFrame[CLOSE_REASON] = -1;
 338 | 	SendWebsocketFrame(iChildIndex, sPayLoad, vFrame);
 339 | 	return true;
 340 | }
 341 | 
 342 | public Native_Websocket_HookChild(Handle:plugin, numParams)
 343 | {
 344 | 	new WebsocketHandle:iPseudoChildHandle = WebsocketHandle:GetNativeCell(1);
 345 | 	new iChildIndex;
 346 | 	if(iPseudoChildHandle == INVALID_WEBSOCKET_HANDLE
 347 | 	|| (iChildIndex = FindValueInArray(g_hChildSocketIndexes, _:iPseudoChildHandle)) == -1)
 348 | 	{
 349 | 		ThrowNativeError(SP_ERROR_NATIVE, "Invalid child websocket handle.");
 350 | 		return false;
 351 | 	}
 352 | 	
 353 | 	new Handle:hReceiveForward = Handle:GetArrayCell(g_hChildReceiveForwards, iChildIndex);
 354 | 	new Handle:hErrorForward = Handle:GetArrayCell(g_hChildErrorForwards, iChildIndex);
 355 | 	new Handle:hDisconnectForward = Handle:GetArrayCell(g_hChildDisconnectForwards, iChildIndex);
 356 | 	
 357 | 	// Did this plugin already hook the child socket? Replace callbacks!
 358 | 	new Handle:hChildSocketPlugin = Handle:GetArrayCell(g_hChildSocketPlugins, iChildIndex);
 359 | 	new iPluginCount = GetArraySize(hChildSocketPlugin);
 360 | 	new aPluginInfo[ChildPluginCallbacks];
 361 | 	new iPluginInfoIndex = -1;
 362 | 	for(new p=0;p<iPluginCount;p++)
 363 | 	{
 364 | 		GetArrayArray(hChildSocketPlugin, p, aPluginInfo[0], _:ChildPluginCallbacks);
 365 | 		if(plugin == aPluginInfo[CPC_PluginHandle])
 366 | 		{
 367 | 			iPluginInfoIndex = p;
 368 | 			// Only remove, if there are already callbacks set. This could happen, if ReadyStateChange was called before HookChild.
 369 | 			if(aPluginInfo[CPC_ReceiveCallback] != INVALID_FUNCTION)
 370 | 			{
 371 | 				RemoveFromForward(hReceiveForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReceiveCallback]);
 372 | 				RemoveFromForward(hDisconnectForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_DisconnectCallback]);
 373 | 				RemoveFromForward(hErrorForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ErrorCallback]);
 374 | 				break;
 375 | 			}
 376 | 		}
 377 | 	}
 378 | 	
 379 | 	aPluginInfo[CPC_ReceiveCallback] = GetNativeFunction(2);
 380 | 	aPluginInfo[CPC_DisconnectCallback] = GetNativeFunction(3);
 381 | 	aPluginInfo[CPC_ErrorCallback] = GetNativeFunction(4);
 382 | 	
 383 | 	// This is the first call to a hooking function on this socket for this plugin.
 384 | 	if(iPluginInfoIndex == -1)
 385 | 	{
 386 | 		// Store this plugin's callbacks to be able to remove them from the forward by the time the child socket disconnects
 387 | 		aPluginInfo[CPC_PluginHandle] = plugin;
 388 | 		aPluginInfo[CPC_ReadystateCallback] = INVALID_FUNCTION;
 389 | 		
 390 | 		PushArrayArray(hChildSocketPlugin, aPluginInfo[0], _:ChildPluginCallbacks);
 391 | 	// This plugin is already known.
 392 | 	} else {
 393 | 		SetArrayArray(hChildSocketPlugin, iPluginInfoIndex, aPluginInfo[0], _:ChildPluginCallbacks);
 394 | 	}
 395 | 	
 396 | 	// Add his callbacks to the private forwards
 397 | 	if(!AddToForward(hReceiveForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReceiveCallback]))
 398 | 		LogError("Unable to add plugin to recv callback");
 399 | 	if(!AddToForward(hDisconnectForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_DisconnectCallback]))
 400 | 		LogError("Unable to add plugin to disc callback");
 401 | 	if(!AddToForward(hErrorForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ErrorCallback]))
 402 | 		LogError("Unable to add plugin to err callback");
 403 | 	
 404 | 	return true;
 405 | }
 406 | 
 407 | // Return the ready state of a child socket
 408 | public Native_Websocket_HookReadyStateChange(Handle:plugin, numParams)
 409 | {
 410 | 	new WebsocketHandle:iPseudoChildHandle = WebsocketHandle:GetNativeCell(1);
 411 | 	new iChildIndex;
 412 | 	if(iPseudoChildHandle == INVALID_WEBSOCKET_HANDLE
 413 | 	|| (iChildIndex = FindValueInArray(g_hChildSocketIndexes, _:iPseudoChildHandle)) == -1)
 414 | 	{
 415 | 		ThrowNativeError(SP_ERROR_NATIVE, "Invalid child websocket handle.");
 416 | 		return false;
 417 | 	}
 418 | 	
 419 | 	new Handle:hReadyStateChangeForward = Handle:GetArrayCell(g_hChildReadyStateChangeForwards, iChildIndex);
 420 | 	
 421 | 	// Check, if this plugin already hooked this socket.
 422 | 	new Handle:hChildSocketPlugin = Handle:GetArrayCell(g_hChildSocketPlugins, iChildIndex);
 423 | 	new iPluginCount = GetArraySize(hChildSocketPlugin);
 424 | 	new aPluginInfo[ChildPluginCallbacks];
 425 | 	new iPluginInfoIndex = -1;
 426 | 	for(new p=0;p<iPluginCount;p++)
 427 | 	{
 428 | 		GetArrayArray(hChildSocketPlugin, p, aPluginInfo[0], _:ChildPluginCallbacks);
 429 | 		if(plugin == aPluginInfo[CPC_PluginHandle])
 430 | 		{
 431 | 			iPluginInfoIndex = p;
 432 | 			// Replace the callback, if we already stored one.
 433 | 			if(aPluginInfo[CPC_ReadystateCallback] != INVALID_FUNCTION)
 434 | 			{
 435 | 				RemoveFromForward(hReadyStateChangeForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReadystateCallback]);
 436 | 				break;
 437 | 			}
 438 | 		}
 439 | 	}
 440 | 	
 441 | 	// Save the function to call.
 442 | 	aPluginInfo[CPC_ReadystateCallback] = GetNativeFunction(2);
 443 | 	
 444 | 	// This is the first call for a plugin to call a hooking function.
 445 | 	if(iPluginInfoIndex == -1)
 446 | 	{
 447 | 		aPluginInfo[CPC_PluginHandle] = plugin;
 448 | 		aPluginInfo[CPC_ReceiveCallback] = INVALID_FUNCTION;
 449 | 		aPluginInfo[CPC_ErrorCallback] = INVALID_FUNCTION;
 450 | 		aPluginInfo[CPC_DisconnectCallback] = INVALID_FUNCTION;
 451 | 		
 452 | 		PushArrayArray(hChildSocketPlugin, aPluginInfo[0], _:ChildPluginCallbacks);
 453 | 	}
 454 | 	else
 455 | 	{
 456 | 		SetArrayArray(hChildSocketPlugin, iPluginInfoIndex, aPluginInfo[0], _:ChildPluginCallbacks);
 457 | 	}
 458 | 	
 459 | 	if(!AddToForward(hReadyStateChangeForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReadystateCallback]))
 460 | 		LogError("Unable to add plugin to readystate change callback");
 461 | 	
 462 | 	return true;
 463 | }
 464 | 
 465 | // Return the ready state of a child socket
 466 | public Native_Websocket_GetReadyState(Handle:plugin, numParams)
 467 | {
 468 | 	new WebsocketHandle:iPseudoChildHandle = WebsocketHandle:GetNativeCell(1);
 469 | 	new iChildIndex;
 470 | 	if(iPseudoChildHandle == INVALID_WEBSOCKET_HANDLE
 471 | 	|| (iChildIndex = FindValueInArray(g_hChildSocketIndexes, _:iPseudoChildHandle)) == -1)
 472 | 	{
 473 | 		ThrowNativeError(SP_ERROR_NATIVE, "Invalid child websocket handle.");
 474 | 		return false;
 475 | 	}
 476 | 	
 477 | 	return GetArrayCell(g_hChildSocketReadyState, iChildIndex);
 478 | }
 479 | 
 480 | public Native_Websocket_UnhookChild(Handle:plugin, numParams)
 481 | {
 482 | 	new WebsocketHandle:iPseudoChildHandle = WebsocketHandle:GetNativeCell(1);
 483 | 	new iChildIndex;
 484 | 	if(iPseudoChildHandle == INVALID_WEBSOCKET_HANDLE
 485 | 	|| (iChildIndex = FindValueInArray(g_hChildSocketIndexes, _:iPseudoChildHandle)) == -1)
 486 | 	{
 487 | 		ThrowNativeError(SP_ERROR_NATIVE, "Invalid child websocket handle.");
 488 | 		return;
 489 | 	}
 490 | 	
 491 | 	new Handle:hReceiveForward = Handle:GetArrayCell(g_hChildReceiveForwards, iChildIndex);
 492 | 	new Handle:hDisconnectForward = Handle:GetArrayCell(g_hChildDisconnectForwards, iChildIndex);
 493 | 	new Handle:hErrorForward = Handle:GetArrayCell(g_hChildErrorForwards, iChildIndex);
 494 | 	new Handle:hReadyStateChangeForward = Handle:GetArrayCell(g_hChildReadyStateChangeForwards, iChildIndex);
 495 | 	
 496 | 	new Handle:hChildSocketPlugin = GetArrayCell(g_hChildSocketPlugins, iChildIndex);
 497 | 	new iPluginCount = GetArraySize(hChildSocketPlugin);
 498 | 	new aPluginInfo[ChildPluginCallbacks];
 499 | 	for(new p=0;p<iPluginCount;p++)
 500 | 	{
 501 | 		GetArrayArray(hChildSocketPlugin, p, aPluginInfo[0], _:ChildPluginCallbacks);
 502 | 		if(aPluginInfo[CPC_PluginHandle] == plugin)
 503 | 		{
 504 | 			// Remove the caller from all forwards
 505 | 			if(aPluginInfo[CPC_ReceiveCallback] != INVALID_FUNCTION)
 506 | 			{
 507 | 				RemoveFromForward(hReceiveForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReceiveCallback]);
 508 | 				RemoveFromForward(hDisconnectForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_DisconnectCallback]);
 509 | 				RemoveFromForward(hErrorForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ErrorCallback]);
 510 | 			}
 511 | 			// Did this plugin call Websocket_HookReadyStateChange?
 512 | 			if(aPluginInfo[CPC_ReadystateCallback] != INVALID_FUNCTION)
 513 | 				RemoveFromForward(hReadyStateChangeForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReadystateCallback]);
 514 | 			RemoveFromArray(hChildSocketPlugin, p);
 515 | 			break;
 516 | 		}
 517 | 	}
 518 | 	
 519 | 	// No plugin is using this anymore. Close the connection.
 520 | 	if(GetArraySize(hChildSocketPlugin) == 0)
 521 | 		CloseConnection(iChildIndex, 1000, "");
 522 | }
 523 | 
 524 | public Native_Websocket_Close(Handle:plugin, numParams)
 525 | {
 526 | 	new WebsocketHandle:iPseudoHandle = WebsocketHandle:GetNativeCell(1);
 527 | 	new iIndex;
 528 | 	if(iPseudoHandle == INVALID_WEBSOCKET_HANDLE
 529 | 	|| (iIndex = FindValueInArray(g_hMasterSocketIndexes, iPseudoHandle)) == -1)
 530 | 	{
 531 | 		ThrowNativeError(SP_ERROR_NATIVE, "Invalid websocket handle.");
 532 | 		return;
 533 | 	}
 534 | 	
 535 | 	CloseMasterSocket(iIndex);
 536 | }
 537 | 
 538 | public OnSocketError(Handle:socket, const errorType, const errorNum, any:arg)
 539 | {
 540 | 	new iIndex = FindValueInArray(g_hMasterSocketIndexes, arg);
 541 | 	// That should never happen :/
 542 | 	if(iIndex != -1)
 543 | 	{
 544 | 		CloseMasterSocket(iIndex, true, errorType, errorNum);
 545 | 	}
 546 | 	else
 547 | 		CloseHandle(socket);
 548 | }
 549 | 
 550 | CloseMasterSocket(iIndex, bool:bError = false, errorType=-1, errorNum=-1)
 551 | {
 552 | 	new iPseudoHandle = GetArrayCell(g_hMasterSocketIndexes, iIndex);
 553 | 	new Handle:hErrorForward = GetArrayCell(g_hMasterErrorForwards, iIndex);
 554 | 	new Handle:hIncomingForward = GetArrayCell(g_hMasterIncomingForwards, iIndex);
 555 | 	new Handle:hCloseForward = GetArrayCell(g_hMasterCloseForwards, iIndex);
 556 | 	
 557 | 	// Close all child sockets first.
 558 | 	new iChildSockets = GetArraySize(g_hChildsMasterSockets);
 559 | 	for(new i=0;i<iChildSockets;i++)
 560 | 	{
 561 | 		if(GetArrayCell(g_hChildsMasterSockets, i) == iIndex)
 562 | 			CloseConnection(i, 1001, "");
 563 | 	}
 564 | 	
 565 | 	// Only bother notifying other plugins, if there are still any listening at all.
 566 | 	if(GetForwardFunctionCount(hIncomingForward) > 0)
 567 | 	{
 568 | 		// There's been an error.
 569 | 		if(bError)
 570 | 		{
 571 | 			// Inform plugins there's been an error
 572 | 			Call_StartForward(hErrorForward);
 573 | 			Call_PushCell(WebsocketHandle:iPseudoHandle);
 574 | 			Call_PushCell(errorType);
 575 | 			Call_PushCell(errorNum);
 576 | 			Call_PushCell(0); // Dummy value as the master socket doesn't use the any:data paramter.
 577 | 			Call_Finish();
 578 | 		}
 579 | 		else
 580 | 		{
 581 | 			Call_StartForward(hCloseForward);
 582 | 			Call_PushCell(WebsocketHandle:iPseudoHandle);
 583 | 			Call_Finish();
 584 | 		}
 585 | 		
 586 | 		// Loop through all plugins using this socket
 587 | 		new Handle:hPlugins = GetArrayCell(g_hMasterSocketPlugins, iIndex);
 588 | 		new iPluginCount = GetArraySize(hPlugins);
 589 | 		new aPluginInfo[MasterPluginCallbacks];
 590 | 		// This master socket is gone, remove forward
 591 | 		for(new p=0;p<iPluginCount;p++)
 592 | 		{
 593 | 			GetArrayArray(hPlugins, p, aPluginInfo[0], _:MasterPluginCallbacks);
 594 | 			
 595 | 			if(!IsPluginStillLoaded(aPluginInfo[MPC_PluginHandle]))
 596 | 				continue;
 597 | 			
 598 | 			// Remove it from forwards.
 599 | 			RemoveFromForward(hErrorForward, aPluginInfo[MPC_PluginHandle], aPluginInfo[MPC_ErrorCallback]);
 600 | 			RemoveFromForward(hIncomingForward, aPluginInfo[MPC_PluginHandle], aPluginInfo[MPC_IncomingCallback]);
 601 | 			RemoveFromForward(hCloseForward, aPluginInfo[MPC_PluginHandle], aPluginInfo[MPC_CloseCallback]);
 602 | 		}
 603 | 		CloseHandle(hPlugins);
 604 | 	}
 605 | 	
 606 | 	RemoveFromArray(g_hMasterSocketPlugins, iIndex);
 607 | 	CloseHandle(hErrorForward);
 608 | 	CloseHandle(hIncomingForward);
 609 | 	CloseHandle(hCloseForward);
 610 | 	RemoveFromArray(g_hMasterErrorForwards, iIndex);
 611 | 	RemoveFromArray(g_hMasterIncomingForwards, iIndex);
 612 | 	RemoveFromArray(g_hMasterCloseForwards, iIndex);
 613 | 	RemoveFromArray(g_hMasterSocketHostPort, iIndex);
 614 | 	
 615 | 	// Close the actual master socket
 616 | 	CloseHandle(Handle:GetArrayCell(g_hMasterSockets, iIndex));
 617 | 	
 618 | 	RemoveFromArray(g_hMasterSockets, iIndex);
 619 | 	RemoveFromArray(g_hMasterSocketIndexes, iIndex);
 620 | }
 621 | 
 622 | public OnSocketIncoming(Handle:socket, Handle:newSocket, const String:remoteIP[], remotePort, any:arg)
 623 | {
 624 | 	new iIndex = FindValueInArray(g_hMasterSocketIndexes, arg);
 625 | 	// This isn't handled by anything?! GO AWAY!!1
 626 | 	if(iIndex == -1)
 627 | 	{
 628 | 		CloseHandle(newSocket);
 629 | 		return;
 630 | 	}
 631 | 	
 632 | 	// Hook this child socket. Let the magic begin!
 633 | 	SocketSetReceiveCallback(newSocket, OnChildSocketReceive);
 634 | 	SocketSetDisconnectCallback(newSocket, OnChildSocketDisconnect);
 635 | 	SocketSetErrorCallback(newSocket, OnChildSocketError);
 636 | 	
 637 | 	new iPseudoChildHandle = ++g_iLastSocketIndex;
 638 | 	new Handle:hIncomingForward = GetArrayCell(g_hMasterIncomingForwards, iIndex);
 639 | 	
 640 | 	// There are no plugins listening anymore?! They didn't call WebSocket_Close in OnPluginEnd.
 641 | 	if(!GetForwardFunctionCount(hIncomingForward))
 642 | 	{
 643 | 		CloseHandle(newSocket);
 644 | 		CloseMasterSocket(iIndex);
 645 | 		return;
 646 | 	}
 647 | 	
 648 | 	SocketSetArg(newSocket, iPseudoChildHandle);
 649 | 	
 650 | 	// Save this connection in our arrays
 651 | 	PushArrayCell(g_hChildSockets, newSocket);
 652 | 	// Make sure we remember the master socket!
 653 | 	PushArrayCell(g_hChildsMasterSockets, iIndex);
 654 | 	PushArrayCell(g_hChildSocketIndexes, iPseudoChildHandle);
 655 | 	PushArrayString(g_hChildSocketHost, remoteIP);
 656 | 	PushArrayCell(g_hChildSocketPort, remotePort);
 657 | 	PushArrayCell(g_hChildSocketPlugins, CreateArray(_:ChildPluginCallbacks));
 658 | 	PushArrayCell(g_hChildSocketReadyState, State_Connecting);
 659 | 	new Handle:hFragmentedPayload = CreateArray(ByteCountToCells(FRAGMENT_MAX_LENGTH));
 660 | 	PushArrayCell(g_hChildSocketFragmentedPayload, hFragmentedPayload);
 661 | 	PushArrayCell(hFragmentedPayload, 0); // The first element will always be the payload length.
 662 | 	PushArrayCell(hFragmentedPayload, 0); // The second element is the payload type. (Even though we don't handle text and binary differently..)
 663 | 	
 664 | 	// Create the private forwards for this socket
 665 | 	new Handle:hReceiveForward = CreateForward(ET_Ignore, Param_Cell, Param_Cell, Param_String, Param_Cell, Param_Any);
 666 | 	PushArrayCell(g_hChildReceiveForwards, hReceiveForward);
 667 | 	new Handle:hErrorForward = CreateForward(ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Any);
 668 | 	PushArrayCell(g_hChildErrorForwards, hErrorForward);
 669 | 	new Handle:hDisconnectForward = CreateForward(ET_Ignore, Param_Cell, Param_Any);
 670 | 	PushArrayCell(g_hChildDisconnectForwards, hDisconnectForward);
 671 | 	new Handle:hReadyStateChangeForward = CreateForward(ET_Ignore, Param_Cell, Param_Cell, Param_Any);
 672 | 	PushArrayCell(g_hChildReadyStateChangeForwards, hReadyStateChangeForward);
 673 | 	
 674 | 	// TODO start a timouttimer which closes the connection, if no valid http upgrade request is received in time.
 675 | }
 676 | 
 677 | public OnChildSocketError(Handle:socket, const errorType, const errorNum, any:arg)
 678 | {
 679 | 	new iIndex = FindValueInArray(g_hChildSocketIndexes, arg);
 680 | 	// This isn't handled by anything?! GO AWAY!!1
 681 | 	if(iIndex == -1)
 682 | 	{
 683 | 		CloseHandle(socket);
 684 | 		return;
 685 | 	}
 686 | 	
 687 | 	new Handle:hErrorForward = Handle:GetArrayCell(g_hChildErrorForwards, iIndex);
 688 | 	
 689 | 	Call_StartForward(hErrorForward);
 690 | 	Call_PushCell(GetArrayCell(g_hChildSocketIndexes, iIndex));
 691 | 	Call_PushCell(errorType);
 692 | 	Call_PushCell(errorNum);
 693 | 	Call_Finish();
 694 | 	
 695 | 	CloseChildSocket(iIndex, false);
 696 | }
 697 | 
 698 | public OnChildSocketDisconnect(Handle:socket, any:arg)
 699 | {
 700 | 	Debug(1, "Child socket disconnected");
 701 | 	new iIndex = FindValueInArray(g_hChildSocketIndexes, arg);
 702 | 	// This isn't handled by anything?! GO AWAY!!1
 703 | 	if(iIndex == -1)
 704 | 	{
 705 | 		CloseHandle(socket);
 706 | 		return;
 707 | 	}
 708 | 	CloseChildSocket(iIndex);
 709 | }
 710 | 
 711 | public OnChildSocketReceive(Handle:socket, const String:receiveData[], const dataSize, any:arg)
 712 | {
 713 | 	Debug(2, "Child socket receives data: %s", receiveData);
 714 | 	
 715 | 	new iIndex = FindValueInArray(g_hChildSocketIndexes, arg);
 716 | 	// This isn't handled by anything?! GO AWAY!!1
 717 | 	if(iIndex == -1)
 718 | 	{
 719 | 		CloseHandle(socket);
 720 | 		return;
 721 | 	}
 722 | 	
 723 | 	new WebsocketReadyState:iReadyState = GetArrayCell(g_hChildSocketReadyState, iIndex);
 724 | 	switch(iReadyState)
 725 | 	{
 726 | 		// We received the http upgrade request
 727 | 		// Send the correct response to complete the handshake!
 728 | 		case State_Connecting:
 729 | 		{
 730 | 			new RegexError:iRegexError;
 731 | 			// Get the key
 732 | 			new iSubStrings = MatchRegex(g_hRegExKey, receiveData, iRegexError);
 733 | 			if(iSubStrings <= 0)
 734 | 			{
 735 | 				LogError("Can't find the Key in the http protocol upgrade request.");
 736 | 				CloseChildSocket(iIndex);
 737 | 				return;
 738 | 			}
 739 | 			decl String:sKey[256];
 740 | 			if(!GetRegexSubString(g_hRegExKey, 1, sKey, sizeof(sKey)))
 741 | 			{
 742 | 				LogError("Failed to extract security key.");
 743 | 				CloseChildSocket(iIndex);
 744 | 				return;
 745 | 			}
 746 | 			
 747 | 			Debug(2, "Key: %s", sKey);
 748 | 			
 749 | 			new String:sSHA1Hash[21], String:sResponseKey[41];
 750 | 			Format(sKey, sizeof(sKey), "%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11", sKey);
 751 | 			SHA1String(sKey, sSHA1Hash, false);
 752 | 			EncodeBase64(sResponseKey, sizeof(sResponseKey), sSHA1Hash, 20);
 753 | 			
 754 | 			Debug(2, "ResponseKey: %s", sResponseKey);
 755 | 			
 756 | 			iSubStrings = MatchRegex(g_hRegExProtocol, receiveData, iRegexError);
 757 | 			decl String:sProtocol[256];
 758 | 			if(iSubStrings > 0)
 759 | 			{
 760 | 				if(!GetRegexSubString(g_hRegExProtocol, 1, sProtocol, sizeof(sProtocol)))
 761 | 				{
 762 | 					Format(sProtocol, sizeof(sProtocol), "");
 763 | 					// It's not required to specify a subprotocol!
 764 | 					/*LogError("Failed to extract sub protocols.");
 765 | 					CloseChildSocket(iIndex);
 766 | 					return;*/
 767 | 				}
 768 | 			}
 769 | 			
 770 | 			decl String:sPath[URL_MAX_LENGTH];
 771 | 			
 772 | 			// Get the path
 773 | 			iSubStrings = MatchRegex(g_hRegExPath, receiveData, iRegexError);
 774 | 			if(iSubStrings <= 0 || !GetRegexSubString(g_hRegExPath, 1, sPath, sizeof(sPath)))
 775 | 				sPath = "";
 776 | 			
 777 | 			// Inform plugins, there's an incoming request 
 778 | 			new iMasterIndex = GetArrayCell(g_hChildsMasterSockets, iIndex);
 779 | 			
 780 | 			new Handle:hIncomingForward = GetArrayCell(g_hMasterIncomingForwards, iMasterIndex);
 781 | 			Call_StartForward(hIncomingForward);
 782 | 			Call_PushCell(WebsocketHandle:GetArrayCell(g_hMasterSocketIndexes, iMasterIndex));
 783 | 			Call_PushCell(WebsocketHandle:GetArrayCell(g_hChildSocketIndexes, iIndex));
 784 | 			decl String:remoteIP[65];
 785 | 			GetArrayString(g_hChildSocketHost, iIndex, remoteIP, sizeof(remoteIP));
 786 | 			Call_PushString(remoteIP);
 787 | 			Call_PushCell(GetArrayCell(g_hChildSocketPort, iIndex));
 788 | 			// TODO SM_PARAM_STRING_UTF8 might be wrong here? SM_PARAM_STRING_COPY?
 789 | 			new String:sProtocolReturn[256];
 790 | 			strcopy(sProtocolReturn, sizeof(sProtocolReturn), sProtocol);
 791 | 			Call_PushStringEx(sProtocolReturn, sizeof(sProtocolReturn), SM_PARAM_STRING_UTF8, SM_PARAM_COPYBACK);
 792 | 			Call_PushString(sPath);
 793 | 			
 794 | 			new Action:iResult;
 795 | 			Call_Finish(iResult);
 796 | 			
 797 | 			// TODO be more friendly in refusing connections by sending a proper http header.
 798 | 			// Someone doesn't like this connection..
 799 | 			if(iResult >= Plugin_Handled)
 800 | 			{
 801 | 				Debug(1, "IncomingForward is >= Plugin_Handled. Closing child socket.");
 802 | 				// Uhm.. Just because of that one? plugin denying the connection, we need to revert any Websocket_HookChild call..
 803 | 				CloseChildSocket(iIndex);
 804 | 				
 805 | 				return;
 806 | 			}
 807 | 			
 808 | 			// Check if any plugin called Websocket_HookChild and close the socket, if not.
 809 | 			new Handle:hChildSocketPlugins = GetArrayCell(g_hChildSocketPlugins, iIndex);
 810 | 			if(GetArraySize(hChildSocketPlugins) == 0)
 811 | 			{
 812 | 				Debug(1, "No plugin hooked the new child socket. Closing child socket.");
 813 | 				CloseChildSocket(iIndex);
 814 | 				
 815 | 				return;
 816 | 			}
 817 | 			
 818 | 			// Make sure the server offered this protocol the plugin chose.
 819 | 			// Should probably error out here?
 820 | 			if(StrContains(sProtocol, sProtocolReturn) == -1)
 821 | 			{
 822 | 				Debug(1, "Plugin chose non-existant subprotocol. Offered: \"%s\" - Chosen: \"%s\"", sProtocol, sProtocolReturn);
 823 | 				Format(sProtocolReturn, sizeof(sProtocolReturn), "");
 824 | 			}
 825 | 			else if(strlen(sProtocol) > 0)
 826 | 				Format(sProtocolReturn, sizeof(sProtocolReturn), "\r\nSec-Websocket-Protocol: %s", sProtocol);
 827 | 			
 828 | 			// Prepare HTTP request
 829 | 			decl String:sHTTPRequest[512];
 830 | 			Format(sHTTPRequest, sizeof(sHTTPRequest), "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s%s\r\n\r\n", sResponseKey, sProtocolReturn);
 831 | 			SocketSend(socket, sHTTPRequest);
 832 | 			
 833 | 			Debug(2, "Responding: %s", sHTTPRequest);
 834 | 			
 835 | 			SetArrayCell(g_hChildSocketReadyState, iIndex, State_Open);
 836 | 			
 837 | 			// Inform the other plugins of the change.
 838 | 			new Handle:hReadyStateChangeForward = GetArrayCell(g_hChildReadyStateChangeForwards, iIndex);
 839 | 			
 840 | 			Call_StartForward(hReadyStateChangeForward);
 841 | 			Call_PushCell(WebsocketHandle:GetArrayCell(g_hChildSocketIndexes, iIndex));
 842 | 			Call_PushCell(GetArrayCell(g_hChildSocketReadyState, iIndex));
 843 | 			Call_Finish();
 844 | 		}
 845 | 		// We're open to receive info! Parse the input.
 846 | 		case State_Open:
 847 | 		{
 848 | 			new vFrame[WebsocketFrame], String:sPayLoad[dataSize-1];
 849 | 			ParseFrame(vFrame, receiveData, dataSize, sPayLoad);
 850 | 			if(!PreprocessFrame(iIndex, vFrame, sPayLoad))
 851 | 			{
 852 | 				// Call forward
 853 | 				//SendWebsocketFrame(iIndex, sPayLoad, vFrame);
 854 | 				new Handle:hReceiveForward = Handle:GetArrayCell(g_hChildReceiveForwards, iIndex);
 855 | 				Call_StartForward(hReceiveForward);
 856 | 				Call_PushCell(arg);
 857 | 				
 858 | 				// This is a fragmented message.
 859 | 				if(vFrame[OPCODE] == FrameType_Continuation)
 860 | 				{
 861 | 					new Handle:hFragmentedPayload = Handle:GetArrayCell(g_hChildSocketFragmentedPayload, iIndex);
 862 | 					new iPayloadLength = GetArrayCell(hFragmentedPayload, 0);
 863 | 					
 864 | 					new String:sConcatPayload[iPayloadLength];
 865 | 					new String:sPayloadPart[FRAGMENT_MAX_LENGTH];
 866 | 					new iSize = GetArraySize(hFragmentedPayload);
 867 | 					// Concat all the payload parts
 868 | 					// TODO: Make this binary safe? GetArrayArray vs. GetArrayString?
 869 | 					for(new i=2;i<iSize;i++)
 870 | 					{
 871 | 						GetArrayString(hFragmentedPayload, i, sPayloadPart, sizeof(sPayloadPart));
 872 | 						Format(sConcatPayload, iPayloadLength, "%s%s", sConcatPayload, sPayloadPart);
 873 | 					}
 874 | 					
 875 | 					new WebsocketSendType:iType;
 876 | 					if(WebsocketFrameType:GetArrayCell(hFragmentedPayload, 1) == FrameType_Text)
 877 | 						iType = SendType_Text;
 878 | 					else
 879 | 						iType = SendType_Binary;
 880 | 					Call_PushCell(iType);
 881 | 					
 882 | 					Call_PushString(sConcatPayload);
 883 | 					Call_PushCell(iPayloadLength);
 884 | 					
 885 | 					// Clear the fragment buffer
 886 | 					ClearArray(hFragmentedPayload);
 887 | 					PushArrayCell(hFragmentedPayload, 0); // length
 888 | 					PushArrayCell(hFragmentedPayload, 0); // opcode
 889 | 				}
 890 | 				// This is an unfragmented message.
 891 | 				else
 892 | 				{
 893 | 					new WebsocketSendType:iType;
 894 | 					if(vFrame[OPCODE] == FrameType_Text)
 895 | 						iType = SendType_Text;
 896 | 					else
 897 | 						iType = SendType_Binary;
 898 | 					Call_PushCell(iType);
 899 | 					Call_PushString(sPayLoad);
 900 | 					Call_PushCell(vFrame[PAYLOAD_LEN]);
 901 | 				}
 902 | 				
 903 | 				Call_Finish();
 904 | 			}
 905 | 		}
 906 | 	}
 907 | }
 908 | 
 909 | // Closes a child socket and cleans up the arrays
 910 | CloseChildSocket(iChildIndex, bool:bFireForward=true)
 911 | {
 912 | 	Debug(1, "Closing child socket #%d", iChildIndex);
 913 | 	new Handle:hReceiveForward = Handle:GetArrayCell(g_hChildReceiveForwards, iChildIndex);
 914 | 	new Handle:hDisconnectForward = Handle:GetArrayCell(g_hChildDisconnectForwards, iChildIndex);
 915 | 	new Handle:hErrorForward = Handle:GetArrayCell(g_hChildErrorForwards, iChildIndex);
 916 | 	new Handle:hReadyStateChangeForward = Handle:GetArrayCell(g_hChildReadyStateChangeForwards, iChildIndex);
 917 | 	
 918 | 	if(bFireForward)
 919 | 	{
 920 | 		Call_StartForward(hDisconnectForward);
 921 | 		Call_PushCell(GetArrayCell(g_hChildSocketIndexes, iChildIndex));
 922 | 		Call_Finish();
 923 | 	}
 924 | 	
 925 | 	new Handle:hChildSocket = Handle:GetArrayCell(g_hChildSockets, iChildIndex);
 926 | 	
 927 | 	RemoveFromArray(g_hChildSockets, iChildIndex);
 928 | 	RemoveFromArray(g_hChildsMasterSockets, iChildIndex);
 929 | 	RemoveFromArray(g_hChildSocketHost, iChildIndex);
 930 | 	RemoveFromArray(g_hChildSocketPort, iChildIndex);
 931 | 	RemoveFromArray(g_hChildSocketReadyState, iChildIndex);
 932 | 	new Handle:hChildSocketPlugin = GetArrayCell(g_hChildSocketPlugins, iChildIndex);
 933 | 	new iPluginCount = GetArraySize(hChildSocketPlugin);
 934 | 	new aPluginInfo[ChildPluginCallbacks];
 935 | 	for(new p=0;p<iPluginCount;p++)
 936 | 	{
 937 | 		GetArrayArray(hChildSocketPlugin, p, aPluginInfo[0], _:ChildPluginCallbacks);
 938 | 		if(!IsPluginStillLoaded(aPluginInfo[CPC_PluginHandle]))
 939 | 			continue;
 940 | 		if(aPluginInfo[CPC_ReceiveCallback] != INVALID_FUNCTION)
 941 | 		{
 942 | 			RemoveFromForward(hReceiveForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReceiveCallback]);
 943 | 			RemoveFromForward(hDisconnectForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_DisconnectCallback]);
 944 | 			RemoveFromForward(hErrorForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ErrorCallback]);
 945 | 		}
 946 | 		if(aPluginInfo[CPC_ReadystateCallback] != INVALID_FUNCTION)
 947 | 		{
 948 | 			RemoveFromForward(hReadyStateChangeForward, aPluginInfo[CPC_PluginHandle], aPluginInfo[CPC_ReadystateCallback]);
 949 | 		}
 950 | 	}
 951 | 	CloseHandle(hChildSocketPlugin);
 952 | 	RemoveFromArray(g_hChildSocketPlugins, iChildIndex);
 953 | 	RemoveFromArray(g_hChildSocketIndexes, iChildIndex);
 954 | 	CloseHandle(GetArrayCell(g_hChildSocketFragmentedPayload, iChildIndex));
 955 | 	RemoveFromArray(g_hChildSocketFragmentedPayload, iChildIndex);
 956 | 	
 957 | 	CloseHandle(hReceiveForward);
 958 | 	CloseHandle(hDisconnectForward);
 959 | 	CloseHandle(hErrorForward);
 960 | 	CloseHandle(hReadyStateChangeForward);
 961 | 	
 962 | 	RemoveFromArray(g_hChildReceiveForwards, iChildIndex);
 963 | 	RemoveFromArray(g_hChildErrorForwards, iChildIndex);
 964 | 	RemoveFromArray(g_hChildDisconnectForwards, iChildIndex);
 965 | 	RemoveFromArray(g_hChildReadyStateChangeForwards, iChildIndex);
 966 | 	
 967 | 	CloseHandle(hChildSocket);
 968 | }
 969 | 
 970 | ParseFrame(vFrame[WebsocketFrame], const String:receiveDataLong[], const dataSize, String:sPayLoad[])
 971 | {
 972 | 	// We're only interested in the first 8 bits.. what's that rest?!
 973 | 	new receiveData[dataSize];
 974 | 	for(new i=0;i<dataSize;i++)
 975 | 	{
 976 | 		receiveData[i] = receiveDataLong[i]&0xff;
 977 | 		Debug(3, "%d (%c): %08b", i, (receiveData[i]<32?' ':receiveData[i]), receiveData[i]);
 978 | 	}
 979 | 	
 980 | 	decl String:sByte[9];
 981 | 	Format(sByte, sizeof(sByte), "%08b", receiveData[0]);
 982 | 	Debug(3, "First byte: %s", sByte);
 983 | 	vFrame[FIN] = sByte[0]=='1'?1:0;
 984 | 	vFrame[RSV1] = sByte[1]=='1'?1:0;
 985 | 	vFrame[RSV2] = sByte[2]=='1'?1:0;
 986 | 	vFrame[RSV3] = sByte[3]=='1'?1:0;
 987 | 	vFrame[OPCODE] = WebsocketFrameType:bindec(sByte[4]);
 988 | 	
 989 | 	Format(sByte, sizeof(sByte), "%08b", receiveData[1]);
 990 | 	Debug(3, "Second byte: %s", sByte);
 991 | 	vFrame[MASK] = sByte[0]=='1'?1:0;
 992 | 	vFrame[PAYLOAD_LEN] = bindec(sByte[1]);
 993 | 	
 994 | 	new iOffset = 2;
 995 | 	
 996 | 	vFrame[MASKINGKEY][0] = '\0';
 997 | 	if(vFrame[PAYLOAD_LEN] > 126)
 998 | 	{
 999 | 		new String:sLoongLength[49];
1000 | 		for(new i=2;i<8;i++)
1001 | 			Format(sLoongLength, sizeof(sLoongLength), "%s%08b", sLoongLength, receiveData[i]);
1002 | 		
1003 | 		vFrame[PAYLOAD_LEN] = bindec(sLoongLength);
1004 | 		iOffset += 6;
1005 | 	}
1006 | 	else if(vFrame[PAYLOAD_LEN] > 125)
1007 | 	{
1008 | 		new String:sLongLength[17];
1009 | 		for(new i=2;i<4;i++)
1010 | 			Format(sLongLength, sizeof(sLongLength), "%s%08b", sLongLength, receiveData[i]);
1011 | 		
1012 | 		vFrame[PAYLOAD_LEN] = bindec(sLongLength);
1013 | 		iOffset += 2;
1014 | 	}
1015 | 	if(vFrame[MASK])
1016 | 	{
1017 | 		for(new i=iOffset,j=0;j<4;i++,j++)
1018 | 			vFrame[MASKINGKEY][j] = receiveData[i];
1019 | 		vFrame[MASKINGKEY][4] = '\0';
1020 | 		iOffset += 4;
1021 | 	}
1022 | 	
1023 | 	new iPayLoad[vFrame[PAYLOAD_LEN]];
1024 | 	for(new i=iOffset,j=0;j<vFrame[PAYLOAD_LEN];i++,j++)
1025 | 		iPayLoad[j] = receiveData[i];
1026 | 	
1027 | 	Debug(2, "dataSize: %d", dataSize);
1028 | 	Debug(2, "FIN: %d", vFrame[FIN]);
1029 | 	Debug(2, "RSV1: %d", vFrame[RSV1]);
1030 | 	Debug(2, "RSV2: %d", vFrame[RSV2]);
1031 | 	Debug(2, "RSV3: %d", vFrame[RSV3]);
1032 | 	Debug(2, "OPCODE: %d", _:vFrame[OPCODE]);
1033 | 	Debug(2, "MASK: %d", vFrame[MASK]);
1034 | 	Debug(2, "PAYLOAD_LEN: %d", vFrame[PAYLOAD_LEN]);
1035 | 	
1036 | 	// Unmask
1037 | 	if(vFrame[MASK])
1038 | 	{
1039 | 		for(new i=0;i<vFrame[PAYLOAD_LEN];i++)
1040 | 		{
1041 | 			Format(sPayLoad, vFrame[PAYLOAD_LEN]+1, "%s%c", sPayLoad, iPayLoad[i]^vFrame[MASKINGKEY][i%4]);
1042 | 		}
1043 | 	}
1044 | 	
1045 | 	// Client requested connection close
1046 | 	if(vFrame[OPCODE] == FrameType_Close)
1047 | 	{
1048 | 		// first 2 bytes are close reason
1049 | 		new String:sCloseReason[65];
1050 | 		for(new i=0;i<2;i++)
1051 | 			Format(sCloseReason, sizeof(sCloseReason), "%s%08b", sCloseReason, sPayLoad[i]&0xff);
1052 | 		
1053 | 		vFrame[CLOSE_REASON] = bindec(sCloseReason);
1054 | 		
1055 | 		strcopy(sPayLoad, dataSize-1, sPayLoad[2]);
1056 | 		vFrame[PAYLOAD_LEN] -= 2;
1057 | 		
1058 | 		Debug(2, "CLOSE_REASON: %d", vFrame[CLOSE_REASON]);
1059 | 	}
1060 | 	else
1061 | 	{
1062 | 		vFrame[CLOSE_REASON] = -1;
1063 | 	}
1064 | 	
1065 | 	Debug(2, "PAYLOAD: %s", sPayLoad);
1066 | 	
1067 | 	// TODO: utf8_decode
1068 | }
1069 | 
1070 | bool:PreprocessFrame(iIndex, vFrame[WebsocketFrame], String:sPayLoad[])
1071 | {
1072 | 	// This is a fragmented frame
1073 | 	if(vFrame[FIN] == 0)
1074 | 	{
1075 | 		// This is a control frame. Those cannot be fragmented!
1076 | 		if(vFrame[OPCODE] >= FrameType_Close)
1077 | 		{
1078 | 			LogError("Received fragmented control frame. %d", vFrame[OPCODE]);
1079 | 			CloseConnection(iIndex, 1002, "Received fragmented control frame.");
1080 | 			return true;
1081 | 		}
1082 | 		
1083 | 		new Handle:hFragmentedPayload = Handle:GetArrayCell(g_hChildSocketFragmentedPayload, iIndex);
1084 | 		new iPayloadLength = GetArrayCell(hFragmentedPayload, 0);
1085 | 		
1086 | 		// This is the first frame of a serie of fragmented ones.
1087 | 		if(iPayloadLength == 0)
1088 | 		{
1089 | 			if(vFrame[OPCODE] == FrameType_Continuation)
1090 | 			{
1091 | 				LogError("Received first fragmented frame with opcode 0. The first fragment MUST have a different opcode set.");
1092 | 				CloseConnection(iIndex, 1002, "Received first fragmented frame with opcode 0. The first fragment MUST have a different opcode set.");
1093 | 				return true;
1094 | 			}
1095 | 			
1096 | 			// Remember which type of message this fragmented one is.
1097 | 			SetArrayCell(hFragmentedPayload, 1, vFrame[OPCODE]);
1098 | 		}
1099 | 		else
1100 | 		{
1101 | 			if(vFrame[OPCODE] != FrameType_Continuation)
1102 | 			{
1103 | 				LogError("Received second or later frame of fragmented message with opcode %d. opcode must be 0.", vFrame[OPCODE]);
1104 | 				CloseConnection(iIndex, 1002, "Received second or later frame of fragmented message with opcode other than 0. opcode must be 0.");
1105 | 				return true;
1106 | 			}
1107 | 		}
1108 | 		
1109 | 		// Keep track of the overall payload length of the fragmented message.
1110 | 		// This is used to create the buffer of the right size when passing it to the listening plugin.
1111 | 		iPayloadLength += vFrame[PAYLOAD_LEN];
1112 | 		SetArrayCell(hFragmentedPayload, 0, iPayloadLength);
1113 | 		
1114 | 		// This doesn't fit inside one array cell? Split it up.
1115 | 		if(vFrame[PAYLOAD_LEN] > FRAGMENT_MAX_LENGTH)
1116 | 		{
1117 | 			for(new i=0;i<vFrame[PAYLOAD_LEN];i+=FRAGMENT_MAX_LENGTH)
1118 | 			{
1119 | 				PushArrayString(hFragmentedPayload, sPayLoad[i]);
1120 | 			}
1121 | 		}
1122 | 		else
1123 | 		{
1124 | 			PushArrayString(hFragmentedPayload, sPayLoad);
1125 | 		}
1126 | 		
1127 | 		return true;
1128 | 	}
1129 | 	
1130 | 	/*if(vFrame[RSV1] != 0 || vFrame[RSV2] != 0 || vFrame[RSV3] != 0)
1131 | 	{
1132 | 		LogError("One of the reservation bits is set. We don't support any extensions! (rsv1: %d rsv2: %d rsv3: %d)", vFrame[RSV1], vFrame[RSV2], vFrame[RSV3]);
1133 | 		CloseConnection(iIndex, 1003, "One of the reservation bits is set.");
1134 | 		return false;
1135 | 	}*/
1136 | 	
1137 | 	// The FIN bit is set if we reach here.
1138 | 	switch(vFrame[OPCODE])
1139 | 	{
1140 | 		case FrameType_Continuation:
1141 | 		{
1142 | 			new Handle:hFragmentedPayload = Handle:GetArrayCell(g_hChildSocketFragmentedPayload, iIndex);
1143 | 			new iPayloadLength = GetArrayCell(hFragmentedPayload, 0);
1144 | 			new WebsocketFrameType:iOpcode = WebsocketFrameType:GetArrayCell(hFragmentedPayload, 1);
1145 | 			// We don't know what type of data that is.
1146 | 			if(iOpcode == FrameType_Continuation)
1147 | 			{
1148 | 				LogError("Received last frame of a series of fragmented ones without any fragments with payload first.");
1149 | 				CloseConnection(iIndex, 1002, "Received last frame of fragmented message without any fragments beforehand.");
1150 | 				return true;
1151 | 			}
1152 | 			
1153 | 			// Add the payload of the last frame to the buffer too.
1154 | 			
1155 | 			// Keep track of the overall payload length of the fragmented message.
1156 | 			// This is used to create the buffer of the right size when passing it to the listening plugin.
1157 | 			iPayloadLength += vFrame[PAYLOAD_LEN];
1158 | 			SetArrayCell(hFragmentedPayload, 0, iPayloadLength);
1159 | 			
1160 | 			// This doesn't fit inside one array cell? Split it up.
1161 | 			if(vFrame[PAYLOAD_LEN] > FRAGMENT_MAX_LENGTH)
1162 | 			{
1163 | 				for(new i=0;i<vFrame[PAYLOAD_LEN];i+=FRAGMENT_MAX_LENGTH)
1164 | 				{
1165 | 					PushArrayString(hFragmentedPayload, sPayLoad[i]);
1166 | 				}
1167 | 			}
1168 | 			else
1169 | 			{
1170 | 				PushArrayString(hFragmentedPayload, sPayLoad);
1171 | 			}
1172 | 			
1173 | 			return false;
1174 | 		}
1175 | 		case FrameType_Text:
1176 | 		{
1177 | 			return false;
1178 | 		}
1179 | 		case FrameType_Binary:
1180 | 		{
1181 | 			return false;
1182 | 		}
1183 | 		case FrameType_Close:
1184 | 		{
1185 | 			// We're done here.
1186 | 			if(GetArrayCell(g_hChildSocketReadyState, iIndex) == State_Closing)
1187 | 			{
1188 | 				CloseChildSocket(iIndex);
1189 | 				return true;
1190 | 			}
1191 | 			
1192 | 			// Just mirror it back
1193 | 			SendWebsocketFrame(iIndex, sPayLoad, vFrame);
1194 | 			SetArrayCell(g_hChildSocketReadyState, iIndex, State_Closing);
1195 | 			
1196 | 			new Handle:hReadyStateChangeForward = GetArrayCell(g_hChildReadyStateChangeForwards, iIndex);
1197 | 			
1198 | 			// Inform the other plugins of the change.
1199 | 			Call_StartForward(hReadyStateChangeForward);
1200 | 			Call_PushCell(WebsocketHandle:GetArrayCell(g_hChildSocketIndexes, iIndex));
1201 | 			Call_PushCell(GetArrayCell(g_hChildSocketReadyState, iIndex));
1202 | 			Call_Finish();
1203 | 			
1204 | 			CloseChildSocket(iIndex);
1205 | 			return true;
1206 | 		}
1207 | 		case FrameType_Ping:
1208 | 		{
1209 | 			vFrame[OPCODE] = FrameType_Pong;
1210 | 			SendWebsocketFrame(iIndex, sPayLoad, vFrame);
1211 | 			return true;
1212 | 		}
1213 | 		case FrameType_Pong:
1214 | 		{
1215 | 			return true;
1216 | 		}
1217 | 	}
1218 | 	
1219 | 	// This is an unknown OPCODE?! OMG
1220 | 	LogError("Received invalid opcode = %d", _:vFrame[OPCODE]);
1221 | 	CloseConnection(iIndex, 1002, "Invalid opcode");
1222 | 	return true;
1223 | }
1224 | 
1225 | bool:SendWebsocketFrame(iIndex, String:sPayLoad[], vFrame[WebsocketFrame])
1226 | {
1227 | 	new WebsocketReadyState:iReadyState = GetArrayCell(g_hChildSocketReadyState, iIndex);
1228 | 	if(iReadyState != State_Open)
1229 | 	{
1230 | 		return false;
1231 | 	}
1232 | 	
1233 | 	new length = vFrame[PAYLOAD_LEN];
1234 | 	
1235 | 	Debug(1, "Preparing to send payload %s (%d)", sPayLoad, length);
1236 | 	
1237 | 	// Force RSV bits to 0
1238 | 	vFrame[RSV1] = 0;
1239 | 	vFrame[RSV2] = 0;
1240 | 	vFrame[RSV3] = 0;
1241 | 	
1242 | 	decl String:sFrame[length+14];
1243 | 	if(PackFrame(sPayLoad, sFrame, vFrame))
1244 | 	{
1245 | 		if(length > 65535)
1246 | 			length += 10;
1247 | 		else if(length > 125)
1248 | 			length += 4;
1249 | 		else
1250 | 			length += 2;
1251 | 		if(vFrame[CLOSE_REASON] != -1)
1252 | 			length += 2;
1253 | 		Debug(1, "Sending: \"%s\"", sFrame);
1254 | 		Debug(2, "FIN: %d", vFrame[FIN]);
1255 | 		Debug(2, "RSV1: %d", vFrame[RSV1]);
1256 | 		Debug(2, "RSV2: %d", vFrame[RSV2]);
1257 | 		Debug(2, "RSV3: %d", vFrame[RSV3]);
1258 | 		Debug(2, "OPCODE: %d", _:vFrame[OPCODE]);
1259 | 		Debug(2, "MASK: %d", vFrame[MASK]);
1260 | 		Debug(2, "PAYLOAD_LEN: %d", vFrame[PAYLOAD_LEN]);
1261 | 		Debug(2, "PAYLOAD: %s", sPayLoad);
1262 | 		Debug(2, "CLOSE_REASON: %d", vFrame[CLOSE_REASON]);
1263 | 		Debug(2, "Frame: %s", sFrame);
1264 | 		SocketSend(GetArrayCell(g_hChildSockets, iIndex), sFrame, length);
1265 | 		return true;
1266 | 	}
1267 | 	
1268 | 	return false;
1269 | }
1270 | 
1271 | bool:PackFrame(String:sPayLoad[], String:sFrame[], vFrame[WebsocketFrame])
1272 | {
1273 | 	new length = vFrame[PAYLOAD_LEN];
1274 | 	
1275 | 	// We don't split frames (yet), so FIN is always 1.
1276 | 	switch(vFrame[OPCODE])
1277 | 	{
1278 | 		case FrameType_Text:
1279 | 		{
1280 | 			sFrame[0] = 129; // (1<<0)|(1<<7) - Text-Frame (10000001):
1281 | 		}
1282 | 		case FrameType_Close:
1283 | 		{
1284 | 			sFrame[0] = 136; // (1<<3)|(1<<7) -  Close-Frame (10001000):
1285 | 			length += 2; // Remember the 2byte close reason
1286 | 		}
1287 | 		case FrameType_Ping:
1288 | 		{
1289 | 			sFrame[0] = 137; // (1<<0)|(1<<3)|(1<<7) -  Ping-Frame (10001001):
1290 | 		}
1291 | 		case FrameType_Pong:
1292 | 		{
1293 | 			sFrame[0] = 138; // (1<<1)|(1<<3)|(1<<7) -  Pong-Frame (10001010):
1294 | 		}
1295 | 		default:
1296 | 		{
1297 | 			LogError("Trying to send frame with unknown opcode = %d", _:vFrame[OPCODE]);
1298 | 			return false;
1299 | 		}
1300 | 	}
1301 | 	
1302 | 	new iOffset;
1303 | 	
1304 | 	// Add the length "byte" (7bit). We're only sending unmasked messages
1305 | 	if(length > 65535)
1306 | 	{
1307 | 		sFrame[1] = 127;
1308 | 		decl String:sLengthBin[65], String:sByte[9];
1309 | 		Format(sLengthBin, 65, "%064b", length);
1310 | 		for(new i=0,j=2;j<=10;i++)
1311 | 		{
1312 | 			if(i && !(i%8))
1313 | 			{
1314 | 				sFrame[j] = bindec(sByte);
1315 | 				Format(sByte, 9, "");
1316 | 				j++;
1317 | 			}
1318 | 			Format(sByte, 9, "%s%s", sByte, sLengthBin[i]);
1319 | 		}
1320 | 		
1321 | 		// the most significant bit MUST be 0
1322 | 		if(sFrame[2] > 127)
1323 | 		{
1324 | 			LogError("Can't send frame. Too much data.");
1325 | 			return false;
1326 | 		}
1327 | 		iOffset = 9;
1328 | 	}
1329 | 	else if(length > 125)
1330 | 	{
1331 | 		sFrame[1] = 126;
1332 | 		if(length < 256)
1333 | 		{
1334 | 			sFrame[2] = 0;
1335 | 			sFrame[3] = length;
1336 | 		}
1337 | 		else
1338 | 		{
1339 | 			new String:sLengthBin[17], String:sByte[9];
1340 | 			Format(sLengthBin, 17, "%016b", length);
1341 | 			for(new i=0,j=2;i<=16;i++)
1342 | 			{
1343 | 				if(i && !(i%8))
1344 | 				{
1345 | 					sFrame[j] = bindec(sByte);
1346 | 					Format(sByte, 9, "");
1347 | 					j++;
1348 | 				}
1349 | 				Format(sByte, 9, "%s%s", sByte, sLengthBin[i]);
1350 | 			}
1351 | 		}
1352 | 		iOffset = 4;
1353 | 	}
1354 | 	else
1355 | 	{
1356 | 		sFrame[1] = length;
1357 | 		iOffset = 2;
1358 | 	}
1359 | 	
1360 | 	// Make sure we didn't set the MASK bit by accident..
1361 | 	sFrame[1] &= ~(1<<7);
1362 | 	vFrame[MASK] = 0;
1363 | 	
1364 | 	// We got a closing reason. Add it right in front of the payload.
1365 | 	if(vFrame[OPCODE] == FrameType_Close && vFrame[CLOSE_REASON] != -1)
1366 | 	{
1367 | 		new String:sCloseReasonBin[17], String:sByte[9];
1368 | 		Format(sCloseReasonBin, 17, "%016b", vFrame[CLOSE_REASON]);
1369 | 		for(new i=0,j=iOffset;i<=16;i++)
1370 | 		{
1371 | 			if(i && !(i%8))
1372 | 			{
1373 | 				sFrame[j] = bindec(sByte);
1374 | 				Format(sByte, 9, "");
1375 | 				j++;
1376 | 			}
1377 | 			Format(sByte, 9, "%s%s", sByte, sCloseReasonBin[i]);
1378 | 		}
1379 | 		iOffset += 2;
1380 | 	}
1381 | 	
1382 | 	// Add the payload at the end.
1383 | 	strcopy(sFrame[iOffset], length+iOffset, sPayLoad);
1384 | 	
1385 | 	return true;
1386 | }
1387 | 
1388 | // Close the connection by initiating the connection close handshake with the CLOSE opcode
1389 | CloseConnection(iIndex, iCloseReason, String:sPayLoad[])
1390 | {
1391 | 	new vFrame[WebsocketFrame];
1392 | 	vFrame[OPCODE] = FrameType_Close;
1393 | 	vFrame[CLOSE_REASON] = iCloseReason;
1394 | 	vFrame[PAYLOAD_LEN] = strlen(sPayLoad);
1395 | 	SendWebsocketFrame(iIndex, sPayLoad, vFrame);
1396 | 	SetArrayCell(g_hChildSocketReadyState, iIndex, State_Closing);
1397 | 	
1398 | 	new Handle:hReadyStateChangeForward = GetArrayCell(g_hChildReadyStateChangeForwards, iIndex);
1399 | 	
1400 | 	// Inform the other plugins of the change.
1401 | 	Call_StartForward(hReadyStateChangeForward);
1402 | 	Call_PushCell(WebsocketHandle:GetArrayCell(g_hChildSocketIndexes, iIndex));
1403 | 	Call_PushCell(GetArrayCell(g_hChildSocketReadyState, iIndex));
1404 | 	Call_Finish();
1405 | }
1406 | 
1407 | stock Debug(iDebugLevel, String:fmt[], any:...)
1408 | {
1409 | #if DEBUG > 0
1410 | 	if(iDebugLevel > DEBUG)
1411 | 		return;
1412 | 	decl String:sBuffer[512];
1413 | 	VFormat(sBuffer, sizeof(sBuffer), fmt, 3);
1414 | 	LogToFile(g_sLog, sBuffer);
1415 | #endif
1416 | }
1417 | 
1418 | stock GetIndexOfMasterSocket(Handle:socket)
1419 | {
1420 | 	new iSize = GetArraySize(g_hMasterSockets);
1421 | 	for(new i=0;i<iSize;i++)
1422 | 	{
1423 | 		if(GetArrayCell(g_hMasterSockets, i) == socket)
1424 | 			return i;
1425 | 	}
1426 | 	return -1;
1427 | }
1428 | 
1429 | stock GetIndexOfChildSocket(Handle:socket)
1430 | {
1431 | 	new iSize = GetArraySize(g_hChildSockets);
1432 | 	for(new i=0;i<iSize;i++)
1433 | 	{
1434 | 		if(GetArrayCell(g_hChildSockets, i) == socket)
1435 | 			return i;
1436 | 	}
1437 | 	return -1;
1438 | }
1439 | 
1440 | stock bindec(const String:sBinary[])
1441 | {
1442 | 	new ret, len = strlen(sBinary);
1443 | 	for(new i=0;i<len;i++)
1444 | 	{
1445 | 		ret = ret<<1;
1446 | 		if(sBinary[i] == '1')
1447 | 			ret |= 1;
1448 | 	}
1449 | 	return ret;
1450 | }
1451 | 
1452 | stock bool:IsPluginStillLoaded(Handle:plugin)
1453 | {
1454 | 	new Handle:hIt = GetPluginIterator();
1455 | 	new Handle:hPlugin;
1456 | 	new bool:bPluginLoaded = false;
1457 | 	while(MorePlugins(hIt))
1458 | 	{
1459 | 		hPlugin = ReadPlugin(hIt);
1460 | 		if(hPlugin == plugin && GetPluginStatus(hPlugin) == Plugin_Running)
1461 | 		{
1462 | 			bPluginLoaded = true;
1463 | 			break;
1464 | 		}
1465 | 	}
1466 | 	CloseHandle(hIt);
1467 | 	return bPluginLoaded;
1468 | }


--------------------------------------------------------------------------------