Initial commit

.gitignore

@@ -0,0 +1,14 @@
+*.kdevses
+*.kdevelop.pcs
+*.tag
+Doxyfile
+a.out
+*.o
+*.oc
+*.ox
+*.a
+*.so
+*~
+Release/
+Debug/
+

Callback.cpp

@@ -0,0 +1,204 @@
+#include "Callback.h"
+
+#include <assert.h>
+#include <string>
+#include <boost/asio.hpp>
+
+#include "Define.h"
+#include "Extension.h"
+#include "Socket.h"
+#include "SocketHandler.h"
+
+using namespace boost::asio::ip;
+
+Callback::Callback(CallbackEvent callbackEvent,
+				   const void* socket) : callbackEvent(callbackEvent) {
+	assert(callbackEvent == CallbackEvent_Connect || callbackEvent == CallbackEvent_Disconnect || callbackEvent == CallbackEvent_SendQueueEmpty);
+
+	socketWrapper = socketHandler.GetSocketWrapper(socket);
+}
+
+Callback::Callback(CallbackEvent callbackEvent,
+				   const void* socket,
+				   const char* data,
+				   size_t dataLength) : callbackEvent(callbackEvent) {
+	assert(callbackEvent == CallbackEvent_Receive);
+
+	socketWrapper = socketHandler.GetSocketWrapper(socket);
+	additionalData[0] = new std::string(data, dataLength);
+}
+
+Callback::Callback(CallbackEvent callbackEvent,
+				   const void* socket,
+				   const void* newSocket,
+	   			   const tcp::endpoint& remoteEndPoint) : callbackEvent(callbackEvent) {
+	assert(callbackEvent == CallbackEvent_Incoming);
+
+	socketWrapper = socketHandler.GetSocketWrapper(socket);
+	additionalData[0] = socketHandler.GetSocketWrapper(newSocket);
+	additionalData[1] = new tcp::endpoint(remoteEndPoint);
+}
+
+Callback::Callback(CallbackEvent callbackEvent,
+				   const void* socket,
+				   SM_ErrorType errorType,
+				   int errorNumber) : callbackEvent(callbackEvent) {
+	assert(callbackEvent == CallbackEvent_Error);
+
+	socketWrapper = socketHandler.GetSocketWrapper(socket);
+	additionalData[0] = new SM_ErrorType(errorType);
+	additionalData[1] = new int(errorNumber);
+}
+
+Callback::~Callback() {
+	if (callbackEvent == CallbackEvent_Receive) {
+		delete (std::string*) additionalData[0];
+	} else if (callbackEvent == CallbackEvent_Incoming) {
+		delete (tcp::endpoint*) additionalData[1];
+	} else if (callbackEvent == CallbackEvent_Error) {
+		delete (SM_ErrorType*) additionalData[0];
+		delete (int*) additionalData[1];
+	}
+}
+
+bool Callback::IsExecutable() {
+	if (!socketWrapper) return false;
+
+	switch (socketWrapper->socketType) {
+		case SM_SocketType_Tcp: {
+			Socket<tcp>* socket = (Socket<tcp>*) socketWrapper->socket;
+
+			switch (callbackEvent) {
+				case CallbackEvent_Connect:
+					return (socket->connectCallback != NULL);
+				case CallbackEvent_Disconnect:
+					return (socket->disconnectCallback != NULL);
+				case CallbackEvent_Incoming:
+					return (socket->incomingCallback != NULL);
+				case CallbackEvent_Receive:
+					return (socket->receiveCallback != NULL);
+				case CallbackEvent_SendQueueEmpty:
+					return (socket->sendqueueEmptyCallback != NULL);
+				case CallbackEvent_Error:
+					return (socket->errorCallback != NULL);
+			}
+			break;
+		}
+		case SM_SocketType_Udp: {
+			Socket<udp>* socket = (Socket<udp>*) socketWrapper->socket;
+
+			switch (callbackEvent) {
+				case CallbackEvent_Connect:
+					return (socket->connectCallback != NULL);
+				case CallbackEvent_Disconnect:
+					return (socket->disconnectCallback != NULL);
+				case CallbackEvent_Incoming:
+					return (socket->incomingCallback != NULL);
+				case CallbackEvent_Receive:
+					return (socket->receiveCallback != NULL);
+				case CallbackEvent_SendQueueEmpty:
+					return (socket->sendqueueEmptyCallback != NULL);
+				case CallbackEvent_Error:
+					return (socket->errorCallback != NULL);
+			}
+			break;
+		}
+	}
+
+	return false;
+}
+
+bool Callback::IsValid() {
+	if (!socketWrapper) return false;
+	if (callbackEvent == CallbackEvent_Incoming && (!additionalData[0] || !additionalData[1])) return false;
+
+	return true;
+}
+
+void Callback::Execute() {
+	switch (socketWrapper->socketType) {
+		case SM_SocketType_Tcp: {
+			ExecuteHelper<tcp>();
+			break;
+		}
+		case SM_SocketType_Udp: {
+			ExecuteHelper<udp>();
+			break;
+		}
+	}
+}
+
+template<class SocketType>
+void Callback::ExecuteHelper() {
+	if (!IsValid()) return;
+
+	Socket<SocketType>* socket = (Socket<SocketType>*) socketWrapper->socket;
+
+	switch (callbackEvent) {
+		case CallbackEvent_Connect:
+			if (!socket->connectCallback) return;
+
+			socket->connectCallback->PushCell(socket->smHandle);
+			socket->connectCallback->PushCell(socket->smCallbackArg);
+			socket->connectCallback->Execute(NULL);
+
+			return;
+		case CallbackEvent_Disconnect:
+			if (!socket->disconnectCallback) return;
+
+			socket->disconnectCallback->PushCell(socket->smHandle);
+			socket->disconnectCallback->PushCell(socket->smCallbackArg);
+			socket->disconnectCallback->Execute(NULL);
+
+			return;
+		case CallbackEvent_Incoming: {
+			if (!socket->incomingCallback) return;
+
+			Socket<SocketType>* socket2 = (Socket<SocketType>*) ((SocketWrapper*)additionalData[0])->socket;
+			socket2->smHandle = handlesys->CreateHandle(extension.socketHandleType, socketHandler.GetSocketWrapper(socket2), socket->incomingCallback->GetParentContext()->GetIdentity(), myself->GetIdentity(), NULL);
+
+			socket->incomingCallback->PushCell(socket->smHandle);
+			socket->incomingCallback->PushCell(socket2->smHandle);
+			socket->incomingCallback->PushString(((typename SocketType::endpoint*)additionalData[1])->address().to_string().c_str());
+			socket->incomingCallback->PushCell(((typename SocketType::endpoint*)additionalData[1])->port());
+			socket->incomingCallback->PushCell(socket->smCallbackArg);
+			socket->incomingCallback->Execute(NULL);
+
+			return;
+		}
+		case CallbackEvent_Receive: {
+			if (!socket->receiveCallback) return;
+
+			size_t strLen = ((std::string*) additionalData[0])->length();
+			char* tmp = new char[strLen+1];
+			memcpy(tmp, ((std::string*) additionalData[0])->c_str(), strLen+1);
+
+			socket->receiveCallback->PushCell(socket->smHandle);
+			socket->receiveCallback->PushStringEx(tmp, strLen+1, SM_PARAM_STRING_COPY|SM_PARAM_STRING_BINARY, 0);
+			socket->receiveCallback->PushCell(strLen);
+			socket->receiveCallback->PushCell(socket->smCallbackArg);
+			socket->receiveCallback->Execute(NULL);
+
+			delete[] tmp;
+			return;
+		}
+		case CallbackEvent_SendQueueEmpty:
+			if (!socket->sendqueueEmptyCallback) return;
+
+			socket->sendqueueEmptyCallback->PushCell(socket->smHandle);
+			socket->sendqueueEmptyCallback->PushCell(socket->smCallbackArg);
+			socket->sendqueueEmptyCallback->Execute(NULL);
+
+			return;
+		case CallbackEvent_Error:
+			if (!socket->errorCallback) return;
+
+			socket->errorCallback->PushCell(socket->smHandle);
+			socket->errorCallback->PushCell(*(SM_ErrorType*) additionalData[0]);
+			socket->errorCallback->PushCell(*(int*) additionalData[1]);
+			socket->errorCallback->PushCell(socket->smCallbackArg);
+			socket->errorCallback->Execute(NULL);
+
+			return;
+	}
+}

Callback.h

@@ -0,0 +1,53 @@
+#ifndef INC_SEXT_CALLBACK_H
+#define INC_SEXT_CALLBACK_H
+
+#include <string>
+#include <boost/asio.hpp>
+
+#include "Define.h"
+
+struct SocketWrapper;
+
+class Callback {
+public:
+	/**
+	 * construct a connect, disconnect or sendqueueempty callback
+	 */
+	Callback(CallbackEvent callbackEvent, const void* socket);
+
+	/**
+	 * construct a receive callback
+	 */
+	Callback(CallbackEvent callbackEvent, const void* socket, const char* data, size_t dataLength);
+
+	/**
+	 * construct an incoming callback
+	 */
+	Callback(CallbackEvent callbackEvent, const void* socket, const void* newSocket, const boost::asio::ip::tcp::endpoint& remoteEndPoint);
+
+	/**
+	 * construct an error callback
+	 */
+	Callback(CallbackEvent callbackEvent, const void* socket, SM_ErrorType errorType, int errorNumber);
+
+	~Callback();
+
+	bool IsExecutable();
+	bool IsValid();
+
+	void Execute();
+
+	friend class CallbackHandler;
+
+private:
+	template<class SocketType> void ExecuteHelper();
+
+	const CallbackEvent callbackEvent;
+	SocketWrapper* socketWrapper;
+	const void* additionalData[2];
+	
+//	volatile bool isExecuting;
+};
+
+#endif
+

CallbackHandler.cpp

@@ -0,0 +1,61 @@
+#include "CallbackHandler.h"
+
+#include <iostream>
+
+#include "Callback.h"
+
+void CallbackHandler::AddCallback(Callback* callback) {
+	boost::mutex::scoped_lock l(callbackQueueMutex);
+
+	if (!callback->IsValid()) {
+		std::cout << "[SERR] invalid callback (event=" << callback->callbackEvent << ")" << std::endl;
+		delete callback;
+	} else {
+		callbackQueue.push_back(callback);
+	}
+}
+
+void CallbackHandler::RemoveCallbacks(SocketWrapper* sw) {
+	boost::mutex::scoped_lock l(callbackQueueMutex);
+
+	for (std::deque<Callback*>::iterator it=callbackQueue.begin(); it!=callbackQueue.end(); ) {
+		if ((*it)->socketWrapper == sw) {
+			/*if (!(*it)->isExecuting)*/ delete *it;
+			it = callbackQueue.erase(it);
+		} else {
+			it++;
+		}
+	}
+}
+
+void CallbackHandler::ExecuteQueuedCallbacks() {
+	Callback* cb = FetchFirstCallback();
+	if (!cb) return;
+
+//	cb->isExecuting = true;
+	cb->Execute();
+	delete cb;
+}
+
+Callback* CallbackHandler::FetchFirstCallback() {
+	boost::mutex::scoped_lock l(callbackQueueMutex);
+
+	if (!callbackQueue.empty()) {
+		for (std::deque<Callback*>::iterator it=callbackQueue.begin(); it!=callbackQueue.end(); it++) {
+			Callback* ret = callbackQueue.front();
+
+			if (!ret->IsExecutable()) {
+				std::cout << "[SERR] callback not executable (event=" << ret->callbackEvent << ")" << std::endl;
+				continue;
+			}
+
+			callbackQueue.erase(it);
+			return ret;
+		}
+	}
+
+	return NULL;
+}
+
+CallbackHandler callbackHandler;
+

CallbackHandler.h

@@ -0,0 +1,31 @@
+#ifndef INC_SEXT_CALLBACKHANDLER_H
+#define INC_SEXT_CALLBACKHANDLER_H
+
+#include <deque>
+#include <boost/thread.hpp>
+
+class Callback;
+struct SocketWrapper;
+
+/**
+ * manages the callbacks for asynchronous operations.
+ *
+ * @note No destructor, objects will be freed by ~SocketHandler -> ~SocketWrapper -> CallbackHandler::RemoveCallbacks
+ */
+class CallbackHandler {
+public:
+	void AddCallback(Callback* callback);
+	void RemoveCallbacks(SocketWrapper* sw);
+	void ExecuteQueuedCallbacks();
+
+private:
+	Callback* FetchFirstCallback();
+
+	std::deque<Callback*> callbackQueue;
+	boost::mutex callbackQueueMutex;
+};
+
+extern CallbackHandler callbackHandler;
+
+#endif
+

Define.h

@@ -0,0 +1,58 @@
+#ifndef INC_SEXT_DEFINE_H
+#define INC_SEXT_DEFINE_H
+
+enum SM_ErrorType {
+	SM_ErrorType_EMPTY_HOST = 1,
+	SM_ErrorType_NO_HOST,
+	SM_ErrorType_CONNECT_ERROR,
+	SM_ErrorType_SEND_ERROR,
+	SM_ErrorType_BIND_ERROR,
+	SM_ErrorType_RECV_ERROR,
+	SM_ErrorType_LISTEN_ERROR,
+};
+
+enum SM_SocketType {
+	SM_SocketType_Tcp = 1,
+	SM_SocketType_Udp,
+	//SM_SocketType_Icmp,
+};
+
+enum SM_SocketOption {
+	// SourceMod level options
+	SM_SO_ConcatenateCallbacks = 1,
+	SM_SO_ForceFrameLock,
+	SM_SO_CallbacksPerFrame,
+	// Socket level options,
+	SM_SO_SocketBroadcast,
+	SM_SO_SocketReuseAddr,
+	SM_SO_SocketKeepAlive,
+	SM_SO_SocketLinger,
+	SM_SO_SocketOOBInline,
+	SM_SO_SocketSendBuffer,
+	SM_SO_SocketReceiveBuffer,
+	SM_SO_SocketDontRoute,
+	SM_SO_SocketReceiveLowWatermark,
+	SM_SO_SocketReceiveTimeout,
+	SM_SO_SocketSendLowWatermark,
+	SM_SO_SocketSendTimeout,
+	// ext options
+	SM_SO_DebugMode
+};
+
+struct SocketOption {
+	SocketOption(SM_SocketOption so, int value) : option(so), value(value) {}
+	SM_SocketOption option;
+	int value;
+};
+
+enum CallbackEvent {
+	CallbackEvent_Connect = 0,
+	CallbackEvent_Disconnect,
+	CallbackEvent_Incoming,
+	CallbackEvent_Receive,
+	CallbackEvent_SendQueueEmpty,
+	CallbackEvent_Error,
+};
+
+#endif
+

Extension.cpp

@@ -0,0 +1,463 @@
+#include "Extension.h"
+
+#include <string>
+#include <boost/asio.hpp>
+
+#include "CallbackHandler.h"
+#include "Callback.h"
+#include "Socket.h"
+
+using namespace boost::asio::ip;
+
+Extension extension;
+SMEXT_LINK(&extension);
+
+void GameFrame(bool simulating) {
+	callbackHandler.ExecuteQueuedCallbacks();
+}
+
+extern const sp_nativeinfo_t smsock_natives[];
+
+bool Extension::SDK_OnLoad(char *error, size_t err_max, bool late) {
+	smutils->AddGameFrameHook(&GameFrame);
+
+	sharesys->AddNatives(myself, smsock_natives);
+	socketHandleType = handlesys->CreateType("Socket", this, 0, NULL, NULL, myself->GetIdentity(), NULL);
+
+	//if (_debug) smutils->LogError(myself, "[Debug] Extension loaded");
+	socketHandler.StartProcessing();
+
+	return true;
+}
+
+void Extension::SDK_OnUnload() {
+	smutils->RemoveGameFrameHook(&GameFrame);
+	handlesys->RemoveType(socketHandleType, NULL);
+
+	socketHandler.Shutdown();
+}
+
+void Extension::OnHandleDestroy(HandleType_t type, void *object) {
+	if (type == socketHandleType && object != NULL) {
+		socketHandler.DestroySocket((SocketWrapper*) object);
+	}
+}
+
+SocketWrapper* Extension::GetSocketWrapperByHandle(Handle_t handle) {
+	HandleSecurity sec;
+	sec.pOwner = NULL;
+	sec.pIdentity = myself->GetIdentity();
+	SocketWrapper* sw;
+
+	if (handlesys->ReadHandle(handle, socketHandleType, &sec, (void**)&sw) != HandleError_None) return NULL;
+
+	return sw;
+}
+
+
+// native bool:SocketIsConnected(Handle:socket);
+cell_t SocketIsConnected(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp:
+			return ((Socket<tcp>*) sw->socket)->IsOpen();
+		case SM_SocketType_Udp:
+			return ((Socket<udp>*) sw->socket)->IsOpen();
+		default:
+			return false;
+	}
+}
+
+
+// native Handle:SocketCreate(SocketType:protocol=SOCKET_TCP, SocketErrorCB:efunc);
+cell_t SocketCreate(IPluginContext *pContext, const cell_t *params) {
+	if (params[1] != SM_SocketType_Tcp && params[1] != SM_SocketType_Udp) return pContext->ThrowNativeError("Invalid protocol specified");
+	if (!pContext->GetFunctionById(params[2])) return pContext->ThrowNativeError("Invalid error callback specified");
+
+	cell_t handle = -1;
+
+	switch (params[1]) {
+		case SM_SocketType_Tcp: {
+			Socket<tcp>* socket = socketHandler.CreateSocket<tcp>(SM_SocketType_Tcp);
+			SocketWrapper* sw = socketHandler.GetSocketWrapper(socket);
+
+			handle = handlesys->CreateHandle(extension.socketHandleType, sw, pContext->GetIdentity(), myself->GetIdentity(), NULL);
+
+			socket->smHandle = handle;
+			socket->errorCallback = pContext->GetFunctionById(params[2]);
+
+			break;
+		}
+		case SM_SocketType_Udp: {
+			Socket<udp>* socket = socketHandler.CreateSocket<udp>(SM_SocketType_Udp);
+			SocketWrapper* sw = socketHandler.GetSocketWrapper(socket);
+
+			handle = handlesys->CreateHandle(extension.socketHandleType, sw, pContext->GetIdentity(), myself->GetIdentity(), NULL);
+
+			socket->smHandle = handle;
+			socket->errorCallback = pContext->GetFunctionById(params[2]);
+
+			break;
+		}
+	}
+
+	return handle;
+}
+
+// native SocketBind(Handle:socket, String:hostname[], port);
+cell_t SocketBind(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+	if (params[3] < 0 || params[3] > 65535) return pContext->ThrowNativeError("Invalid port specified");
+
+	char *hostname = NULL;
+	pContext->LocalToString(params[2], &hostname);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp:
+			return ((Socket<tcp>*) sw->socket)->Bind(hostname, params[3], false);
+		case SM_SocketType_Udp:
+			return ((Socket<udp>*) sw->socket)->Bind(hostname, params[3], false);
+		default:
+			return false;
+	}
+}
+
+// native SocketConnect(Handle:socket, SocketConnectCB:cfunc, SocketReceiveCB:rfunc, SocketDisconnectCB:dfunc, String:hostname[], port);
+cell_t SocketConnect(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+	//if (socket->shouldListen()) return pContext->ThrowNativeError("You can't connect a listening socket");
+	if (!pContext->GetFunctionById(params[2])) return pContext->ThrowNativeError("Invalid connect callback specified");
+	if (!pContext->GetFunctionById(params[3])) return pContext->ThrowNativeError("Invalid receive callback specified");
+	if (!pContext->GetFunctionById(params[4])) return pContext->ThrowNativeError("Invalid disconnect callback specified");
+	if (params[6] < 0 || params[6] > 65535) return pContext->ThrowNativeError("Invalid port specified");
+
+	char *hostname = NULL;
+	pContext->LocalToString(params[5], &hostname);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp: {
+			Socket<tcp>* socket = (Socket<tcp>*) sw->socket;
+			if (socket->IsOpen()) return pContext->ThrowNativeError("Socket is already connected");
+
+			socket->connectCallback = pContext->GetFunctionById(params[2]);
+			socket->receiveCallback = pContext->GetFunctionById(params[3]);
+			socket->disconnectCallback = pContext->GetFunctionById(params[4]);
+
+			return socket->Connect(hostname, params[6]);
+		}
+		case SM_SocketType_Udp: {
+			Socket<udp>* socket = (Socket<udp>*) sw->socket;
+			if (socket->IsOpen()) return pContext->ThrowNativeError("Socket is already connected");
+
+			socket->connectCallback = pContext->GetFunctionById(params[2]);
+			socket->receiveCallback = pContext->GetFunctionById(params[3]);
+			socket->disconnectCallback = pContext->GetFunctionById(params[4]);
+
+			return socket->Connect(hostname, params[6]);
+		}
+		default:
+			return false;
+	}
+}
+
+// native SocketDisconnect(Handle:socket);
+cell_t SocketDisconnect(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp: {
+			Socket<tcp>* socket = (Socket<tcp>*) sw->socket;
+			if (!socket->IsOpen()) return pContext->ThrowNativeError("Socket is not connected/listening");
+			return socket->Disconnect();
+		}
+		case SM_SocketType_Udp: {
+			Socket<udp>* socket = (Socket<udp>*) sw->socket;
+			if (!socket->IsOpen()) return pContext->ThrowNativeError("Socket is not connected/listening");
+			return socket->Disconnect();
+		}
+		default:
+			return false;
+	}
+}
+
+// native SocketListen(Handle:socket, SocketIncomingCB:ifunc);
+cell_t SocketListen(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+	if (sw->socketType != SM_SocketType_Tcp) return pContext->ThrowNativeError("The socket must use the TCP/SOCK_STREAM protocol");
+	if (!pContext->GetFunctionById(params[2])) return pContext->ThrowNativeError("Invalid incoming callback specified");
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp: {
+			Socket<tcp>* socket = (Socket<tcp>*) sw->socket;
+			if (socket->IsOpen()) return pContext->ThrowNativeError("Socket is already open");
+			socket->incomingCallback = pContext->GetFunctionById(params[2]);
+			return socket->Listen();
+		}
+		case SM_SocketType_Udp: {
+			Socket<udp>* socket = (Socket<udp>*) sw->socket;
+			if (socket->IsOpen()) return pContext->ThrowNativeError("Socket is already open");
+			socket->incomingCallback = pContext->GetFunctionById(params[2]);
+			return socket->Listen();
+		}
+		default:
+			return false;
+	}
+}
+
+// native SocketSend(Handle:socket, String:command[], size);
+cell_t SocketSend(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	char* dataTmp = NULL;
+	pContext->LocalToString(params[2], &dataTmp);
+
+	std::string data;
+
+	if (params[3] == -1) {
+		data.assign(dataTmp);
+	} else {
+		data.assign(dataTmp, params[3]);
+	}
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp: {
+			Socket<tcp>* socket = (Socket<tcp>*) sw->socket;
+			if (!socket->IsOpen()) return pContext->ThrowNativeError("Can't send, socket is not connected");
+			return socket->Send(data);
+		}
+		case SM_SocketType_Udp: {
+			Socket<udp>* socket = (Socket<udp>*) sw->socket;
+			if (!socket->IsOpen()) return pContext->ThrowNativeError("Can't send, socket is not connected");
+			socket->incomingCallback = pContext->GetFunctionById(params[2]);
+			return socket->Send(data);
+		}
+		default:
+			return false;
+	}
+}
+
+// native SocketSendTo(Handle:socket, const String:data[], size=-1, const String:hostname[], port);
+cell_t SocketSendTo(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+	if (sw->socketType == SM_SocketType_Tcp) return pContext->ThrowNativeError("This native doesn't support connection orientated protocols");
+
+	char* dataTmp = NULL;
+	pContext->LocalToString(params[2], &dataTmp);
+
+	std::string data;
+
+	if (params[3] == -1) {
+		data.assign(dataTmp);
+	} else {
+		data.assign(dataTmp, params[3]);
+	}
+
+	char* hostname = NULL;
+	pContext->LocalToString(params[4], &hostname);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Udp: {
+			Socket<udp>* socket = (Socket<udp>*) sw->socket;
+			//if (!socket->IsOpen()) return pContext->ThrowNativeError("Can't send, socket is not connected");
+			socket->incomingCallback = pContext->GetFunctionById(params[2]);
+			return socket->SendTo(data, hostname, params[5]);
+		}
+		default:
+			return false;
+	}
+}
+
+// native SocketSetOption(Handle:socket, SocketOption:option, value)
+cell_t SocketSetOption(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (params[2] != SM_SO_ConcatenateCallbacks &&
+		params[2] != SM_SO_ForceFrameLock &&
+		params[2] != SM_SO_CallbacksPerFrame &&
+		params[2] != SM_SO_DebugMode) {
+		if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+		switch (sw->socketType) {
+			case SM_SocketType_Tcp: {
+				return ((Socket<tcp>*) sw->socket)->SetOption((SM_SocketOption) params[2], params[3]);
+			}
+			case SM_SocketType_Udp: {
+				return ((Socket<udp>*) sw->socket)->SetOption((SM_SocketOption) params[2], params[3]);
+			}
+			default:
+				return false;
+		}
+	} else {
+		return false;
+	}
+
+	/*
+	switch (params[2]) {
+		case ConcatenateCallbacks:
+			socket->setOption(ConcatenateCallbacks, value);
+			return 1;
+		case ForceFrameLock:
+			callbacks->setOption(ForceFrameLock, value);
+			return 1;
+		case CallbacksPerFrame:
+			if (value > 0) {
+				callbacks->setOption(CallbacksPerFrame, value);
+				return 1;
+			} else {
+				return 0;
+			}
+		case DebugMode:
+			sockets._debug = value != 0;
+			return 1;
+...
+	}*/
+}
+
+
+// native SocketSetReceiveCallback(Handle:socket, SocketReceiveCB:rfunc);
+cell_t SocketSetReceiveCallback(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp:
+			((Socket<tcp>*) sw->socket)->receiveCallback = pContext->GetFunctionById((params[2]));
+			break;
+		case SM_SocketType_Udp:
+			((Socket<udp>*) sw->socket)->receiveCallback = pContext->GetFunctionById((params[2]));
+		default:
+			return false;
+	}
+
+	return true;
+}
+
+// native SocketSetSendqueueEmptyCallback(Handle:socket, SocketSendqueueEmptyCB:sfunc);
+cell_t SocketSetSendqueueEmptyCallback(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	bool forceSendqueueEmptyCallback = false;
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp:
+			((Socket<tcp>*) sw->socket)->sendqueueEmptyCallback = pContext->GetFunctionById((params[2]));
+			if (!((Socket<tcp>*) sw->socket)->sendQueueLength) forceSendqueueEmptyCallback = true;
+			break;
+		case SM_SocketType_Udp:
+			((Socket<udp>*) sw->socket)->sendqueueEmptyCallback = pContext->GetFunctionById((params[2]));
+			if (!((Socket<tcp>*) sw->socket)->sendQueueLength) forceSendqueueEmptyCallback = true;
+		default:
+			return false;
+	}
+
+	if (forceSendqueueEmptyCallback) {
+		callbackHandler.AddCallback(new Callback(CallbackEvent_SendQueueEmpty, sw->socket));
+	}
+
+	return true;
+}
+
+// native SocketSetDisconnectCallback(Handle:socket, SocketDisconnectCB:dfunc);
+cell_t SocketSetDisconnectCallback(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp:
+			((Socket<tcp>*) sw->socket)->disconnectCallback = pContext->GetFunctionById((params[2]));
+			break;
+		case SM_SocketType_Udp:
+			((Socket<udp>*) sw->socket)->disconnectCallback = pContext->GetFunctionById((params[2]));
+		default:
+			return false;
+	}
+
+	return true;
+}
+
+// native SocketSetErrorCallback(Handle:socket, SocketErrorCB:efunc);
+cell_t SocketSetErrorCallback(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp:
+			((Socket<tcp>*) sw->socket)->errorCallback = pContext->GetFunctionById((params[2]));
+			break;
+		case SM_SocketType_Udp:
+			((Socket<udp>*) sw->socket)->errorCallback = pContext->GetFunctionById((params[2]));
+		default:
+			return false;
+	}
+
+	return true;
+}
+
+
+// native SocketSetArg(Handle:socket, any:arg);
+cell_t SocketSetArg(IPluginContext *pContext, const cell_t *params) {
+	SocketWrapper* sw = extension.GetSocketWrapperByHandle(static_cast<Handle_t>(params[1]));
+	if (sw == NULL) return pContext->ThrowNativeError("Invalid handle: %i", params[1]);
+
+	switch (sw->socketType) {
+		case SM_SocketType_Tcp:
+			((Socket<tcp>*) sw->socket)->smCallbackArg = params[2];
+			break;
+		case SM_SocketType_Udp:
+			((Socket<udp>*) sw->socket)->smCallbackArg = params[2];
+		default:
+			return false;
+	}
+
+	return true;
+}
+
+// native SocketGetHostName(String:dest[], destLen);
+cell_t SocketGetHostName(IPluginContext *pContext, const cell_t *params) {
+	char* dest = NULL;
+	pContext->LocalToString(params[1], &dest);
+	
+	boost::system::error_code errorCode;
+	std::string hostName = host_name(errorCode);
+	
+	if (!errorCode) {
+		size_t len = hostName.copy(dest, params[2]-1);
+		dest[len] = '\0';
+		return true;
+	} else {
+		dest[0] = '\0';
+		return false;
+	}
+}
+
+const sp_nativeinfo_t smsock_natives[] = {
+	{"SocketIsConnected",		SocketIsConnected},
+
+	{"SocketCreate",			SocketCreate},
+	{"SocketBind",				SocketBind},
+	{"SocketConnect",			SocketConnect},
+	{"SocketDisconnect",		SocketDisconnect},
+	{"SocketListen",			SocketListen},
+	{"SocketSend",				SocketSend},
+	{"SocketSendTo",			SocketSendTo},
+	{"SocketSetOption",			SocketSetOption},
+
+	{"SocketSetReceiveCallback",		SocketSetReceiveCallback},
+	{"SocketSetSendqueueEmptyCallback",	SocketSetSendqueueEmptyCallback},
+	{"SocketSetDisconnectCallback",		SocketSetDisconnectCallback},
+	{"SocketSetErrorCallback",			SocketSetErrorCallback},
+
+	{"SocketSetArg",			SocketSetArg},
+	
+	{"SocketGetHostName",		SocketGetHostName},
+
+	{NULL,						NULL},
+};

Extension.h

@@ -0,0 +1,21 @@
+#ifndef INC_SEXT_EXTENSION_H
+#define INC_SEXT_EXTENSION_H
+
+#include "sdk/smsdk_ext.h"
+#include "SocketHandler.h"
+
+class Extension : public SDKExtension, public IHandleTypeDispatch {
+public:
+	virtual bool SDK_OnLoad(char *error, size_t err_max, bool late);
+	virtual void SDK_OnUnload(void);
+	void OnHandleDestroy(HandleType_t type, void *object);
+
+	SocketWrapper* GetSocketWrapperByHandle(Handle_t);
+
+	HandleType_t socketHandleType;
+};
+
+extern Extension extension;
+
+#endif
+

Makefile

@@ -0,0 +1,78 @@
+# makefile
+
+SMSDK = /home/m/build/sourcemod-1-0
+SOURCEMM = /home/m/build/mmsource-1-4
+
+PROJECT = socket
+
+OBJECTS = Socket.cpp SocketHandler.cpp Callback.cpp CallbackHandler.cpp
+OBJECTS_C =
+OBJECTS_EXTENSION = Extension.cpp sdk/smsdk_ext.cpp
+OBJECTS_TEST = test.cpp
+
+##############################################
+### CONFIGURE ANY OTHER FLAGS/OPTIONS HERE ###
+##############################################
+
+# symstore.exe add /r /l /f *.* /s c:\symbols /t sm-ext-socket /v version
+C_OPT_FLAGS = -O3 -funroll-loops -s -pipe -fno-strict-aliasing
+C_DEBUG_FLAGS = -g -ggdb3
+CPP = gcc
+
+LINK = -lpthread -Wl,-Bstatic -static-libgcc -lboost_thread -lboost_system -lstdc++ -Wl,-Bdynamic
+INCLUDE = -I. -I$(SOURCEMM) -I$(SOURCEMM)/sourcehook -I$(SOURCEMM)/sourcemm \
+	-I$(SMSDK)/public -I$(SMSDK)/public/sourcepawn -I$(SMSDK)/public/extensions
+
+CFLAGS = -D_LINUX -DSOURCEMOD_BUILD -Wall -fPIC -m32
+CPPFLAGS =
+
+################################################
+### DO NOT EDIT BELOW HERE FOR MOST PROJECTS ###
+################################################
+
+ifeq "$(DEBUG)" "true"
+	BIN_DIR = Debug
+	CFLAGS += $(C_DEBUG_FLAGS)
+else
+	BIN_DIR = Release
+	CFLAGS += $(C_OPT_FLAGS)
+endif
+
+
+GCC_VERSION := $(shell $(CPP) -dumpversion >&1 | cut -b1)
+ifeq "$(GCC_VERSION)" "4"
+	CPPFLAGS += $(CPP_GCC4_FLAGS)
+endif
+
+BINARY = $(PROJECT)
+
+OBJ_LINUX := $(OBJECTS:%.cpp=$(BIN_DIR)/%.ox)
+OBJ_LINUX_C := $(OBJECTS_C:%.c=$(BIN_DIR)/%.oc)
+OBJ_LINUX_EXTENSION := $(OBJECTS_EXTENSION:%.cpp=$(BIN_DIR)/%.ox)
+OBJ_LINUX_TEST := $(OBJECTS_TEST:%.cpp=$(BIN_DIR)/%.ox)
+
+$(BIN_DIR)/%.ox: %.cpp
+	$(CPP) $(INCLUDE) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<
+
+$(BIN_DIR)/%.oc: %.c
+	$(CPP) $(INCLUDE) $(CFLAGS) -o $@ -c $<
+
+all:
+	mkdir -p $(BIN_DIR)/sdk
+	$(MAKE) extension
+#	$(MAKE) test
+
+extension: $(OBJ_LINUX) $(OBJ_LINUX_C) $(OBJ_LINUX_EXTENSION)
+	$(CPP) $(OBJ_LINUX) $(OBJ_LINUX_C) $(OBJ_LINUX_EXTENSION) $(LINK) -shared -m32 -o$(BIN_DIR)/$(BINARY).ext.so
+
+debug:
+	$(MAKE) all DEBUG=true
+
+test: $(OBJ_LINUX) $(OBJ_LINUX_C) $(OBJ_LINUX_TEST)
+	$(CPP) $(OBJ_LINUX) $(OBJ_LINUX_C) $(OBJ_LINUX_TEST) $(LINK) -o$(BIN_DIR)/$(BINARY)
+
+default: all
+
+clean:
+	rm -rf Release
+	rm -rf Debug

Socket.cpp

@@ -0,0 +1,767 @@
+#include "Socket.h"
+
+#include <assert.h>
+#include <cstdio>
+#include <exception>
+#include <boost/bind.hpp>
+
+#include "Callback.h"
+#include "CallbackHandler.h"
+#include "SocketHandler.h"
+
+using namespace boost::asio::ip;
+
+template <class SocketType>
+Socket<SocketType>::Socket(SM_SocketType st,
+						   typename SocketType::socket* asioSocket) : connectCallback(NULL),
+																	  incomingCallback(NULL),
+																	  receiveCallback(NULL),
+																	  sendqueueEmptyCallback(NULL),
+																	  disconnectCallback(NULL),
+																	  errorCallback(NULL),
+																	  smCallbackArg(0),
+																	  sendQueueLength(0),
+																	  sm_sockettype(st),
+																	  socket(NULL),
+																	  localEndpoint(NULL),
+																	  localEndpointMutex(NULL),
+																	  tcpAcceptor(NULL),
+																	  tcpAcceptorMutex(NULL) {
+	if (asioSocket != NULL) {
+		socket = asioSocket;
+	}
+}
+
+template <class SocketType>
+Socket<SocketType>::~Socket() {
+	if (socket) {
+		boost::mutex::scoped_lock l(socketMutex);
+		socket->close();
+		
+		delete socket;
+		socket = NULL;
+	}
+
+	if (tcpAcceptor) {
+		boost::mutex::scoped_lock l(*tcpAcceptorMutex);
+		tcpAcceptor->close();
+		
+		delete tcpAcceptor;
+		tcpAcceptor = NULL;
+	}
+	
+	if (localEndpoint) {
+		boost::mutex::scoped_lock l(*localEndpointMutex);
+		
+		delete localEndpoint;
+		localEndpoint = NULL;
+	}
+
+	// wait for all callbacks to terminate
+	//boost::unique_lock<boost::shared_mutex> l(handlerMutex);
+	handlerMutex.lock();
+
+	boost::mutex::scoped_lock socketLock(socketMutex);
+
+	if (tcpAcceptorMutex) delete tcpAcceptorMutex;
+	if (localEndpointMutex) delete localEndpointMutex;
+
+	while (!socketOptionQueue.empty()) {
+		delete socketOptionQueue.front();
+		socketOptionQueue.pop();
+	}
+}
+
+template <class SocketType>
+void Socket<SocketType>::ReceiveHandler(char* buf, size_t bufferSize, size_t bytesTransferred, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	if (!errorCode) {
+		boost::mutex::scoped_lock l(socketMutex);
+
+		if (socket) {
+			if (bytesTransferred) callbackHandler.AddCallback(new Callback(CallbackEvent_Receive, this, buf, bytesTransferred));
+
+			socket->async_receive(boost::asio::buffer(buf, bufferSize),
+								boost::bind(&Socket<SocketType>::ReceiveHandler,
+											this,
+											buf,
+											bufferSize,
+											boost::asio::placeholders::bytes_transferred,
+											boost::asio::placeholders::error,
+											handlerLock));
+			return;
+		}
+	}
+	
+	if (errorCode) {
+		if (errorCode == boost::asio::error::eof ||
+			errorCode == boost::asio::error::connection_reset ||
+			errorCode == boost::asio::error::connection_aborted) {
+			// asio indicates disconnect
+
+			boost::mutex::scoped_lock l(socketMutex);
+			
+			if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_Disconnect, this));
+
+		} else if (errorCode != boost::asio::error::operation_aborted) {
+			// error
+
+			boost::mutex::scoped_lock l(socketMutex);
+			
+			if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_RECV_ERROR, errorCode.value()));
+			
+		}
+	}
+	
+	delete[] buf;
+	delete handlerLock;
+}
+
+template <class SocketType>
+bool Socket<SocketType>::IsOpen() {
+	boost::mutex::scoped_lock l(socketMutex);
+
+	return (socket && socket->is_open());
+}
+
+template <class SocketType>
+bool Socket<SocketType>::Bind(const char* hostname, uint16_t port, bool async) {
+	typename SocketType::resolver* resolver = NULL;
+	boost::shared_lock<boost::shared_mutex>* handlerLock = NULL;
+
+	try {
+		if (localEndpoint) {
+			// TODO: make sure endpoint is not in use
+			//localEndpointInitialized = false;
+			//delete localEndpoint;
+			return false;
+		}
+
+		char sPort[6];
+		snprintf(sPort, sizeof(sPort), "%hu", port);
+
+		if (async) {
+			resolver = new typename SocketType::resolver(*socketHandler.ioService);
+			handlerLock = new boost::shared_lock<boost::shared_mutex>(handlerMutex);
+
+			resolver->async_resolve(typename SocketType::resolver::query(SocketType::v4(), hostname, sPort),
+									boost::bind(&Socket<SocketType>::BindPostResolveHandler,
+												this,
+												resolver,
+												boost::asio::placeholders::iterator,
+												boost::asio::placeholders::error,
+												handlerLock));
+		} else {
+			typename SocketType::resolver syncResolver(*socketHandler.ioService);
+
+			typename SocketType::resolver::iterator endpointIterator = syncResolver.resolve(typename SocketType::resolver::query(SocketType::v4(), hostname, sPort));
+
+			if (!localEndpoint) {
+				localEndpointMutex = new boost::mutex();
+				boost::mutex::scoped_lock l(*localEndpointMutex);
+				localEndpoint = new typename SocketType::endpoint(endpointIterator->endpoint());
+			}
+		}
+
+		return true;
+	} catch (std::exception& e) {
+		if (resolver) delete resolver;
+		if (handlerLock) delete handlerLock;
+	}
+
+	return false;
+}
+
+template <class SocketType>
+void Socket<SocketType>::BindPostResolveHandler(typename SocketType::resolver* resolver, typename SocketType::resolver::iterator endpointIterator, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	if (!errorCode) {
+		if (!localEndpoint) {
+			localEndpointMutex = new boost::mutex();
+			boost::mutex::scoped_lock l(*localEndpointMutex);
+			localEndpoint = new typename SocketType::endpoint(*endpointIterator);
+		}
+	} else if (errorCode != boost::asio::error::operation_aborted) {
+		callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_BIND_ERROR, errorCode.value()));
+	}
+
+	delete resolver;
+	delete handlerLock;
+}
+
+template <class SocketType>
+bool Socket<SocketType>::Connect(const char* hostname, uint16_t port, bool async) {
+	typename SocketType::resolver* resolver = NULL;
+	boost::shared_lock<boost::shared_mutex>* handlerLock = NULL;
+
+	try {
+		char sPort[6];
+		snprintf(sPort, sizeof(sPort), "%hu", port);
+
+		if (!socket) InitializeSocket();
+
+		if (async) {
+			resolver = new typename SocketType::resolver(*socketHandler.ioService);
+			handlerLock = new boost::shared_lock<boost::shared_mutex>(handlerMutex);
+
+			resolver->async_resolve(typename SocketType::resolver::query(SocketType::v4(), hostname, sPort),
+									boost::bind(&Socket<SocketType>::ConnectPostResolveHandler,
+												this,
+												resolver,
+												boost::asio::placeholders::iterator,
+												boost::asio::placeholders::error,
+												handlerLock));
+		} else {
+			typename SocketType::resolver syncResolver(*socketHandler.ioService);
+
+			typename SocketType::resolver::iterator endpointIterator = syncResolver.resolve(typename SocketType::resolver::query(SocketType::v4(), hostname, sPort));
+
+			boost::system::error_code error = boost::asio::error::host_not_found;
+			typename SocketType::resolver::iterator end;
+
+			while (error && endpointIterator != end) {
+				boost::mutex::scoped_lock l(socketMutex);
+
+				if (socket) {
+					socket->connect(*endpointIterator++, error);
+					if (error) socket->close();
+				} else {
+					throw std::logic_error("Operation cancelled.");
+				}
+			}
+
+			if (error) throw boost::system::system_error(error);
+
+			ReceiveHandler(new char[16384], 16384, 0, boost::system::posix_error::make_error_code(boost::system::posix_error::success), new boost::shared_lock<boost::shared_mutex>(handlerMutex));
+		}
+
+		return true;
+	} catch (std::exception& e) {
+		if (resolver) delete resolver;
+		if (handlerLock) delete handlerLock;
+	}
+
+	return false;
+}
+
+template <class SocketType>
+void Socket<SocketType>::ConnectPostResolveHandler(typename SocketType::resolver* resolver, typename SocketType::resolver::iterator endpointIterator, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	if (!errorCode) {
+		typename SocketType::endpoint endpoint = *endpointIterator;
+		
+		boost::mutex::scoped_lock l(socketMutex);
+
+		if (socket) {
+			socket->async_connect(endpoint,
+								boost::bind(&Socket<SocketType>::ConnectPostConnectHandler,
+											this,
+											resolver,
+											++endpointIterator,
+											boost::asio::placeholders::error,
+											handlerLock));
+			return;
+		}
+	}
+	
+	if (errorCode && errorCode != boost::asio::error::operation_aborted) {
+		boost::mutex::scoped_lock l(socketMutex);
+
+		if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_CONNECT_ERROR, errorCode.value()));
+	}
+
+	delete resolver;
+	delete handlerLock;
+}
+
+template <class SocketType>
+void Socket<SocketType>::ConnectPostConnectHandler(typename SocketType::resolver* resolver, typename SocketType::resolver::iterator endpointIterator, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	if (!errorCode) {
+		{ // lock
+			boost::mutex::scoped_lock l(socketMutex);
+
+			if (socket) {
+				callbackHandler.AddCallback(new Callback(CallbackEvent_Connect, this));
+			}
+		} // ~lock
+
+		ReceiveHandler(new char[16384], 16384, 0, boost::system::posix_error::make_error_code(boost::system::posix_error::success), handlerLock);
+		
+		delete resolver;
+			
+		return;
+	} else if (endpointIterator != typename SocketType::resolver::iterator()) {
+		{ // lock
+			boost::mutex::scoped_lock l(socketMutex);
+
+			if (socket) {
+				socket->close();
+			}
+		} // ~lock
+
+		ConnectPostResolveHandler(resolver, endpointIterator, boost::system::posix_error::make_error_code(boost::system::posix_error::success), handlerLock);
+			
+		return;
+	}
+
+	if (errorCode && errorCode != boost::asio::error::operation_aborted) {
+		boost::mutex::scoped_lock l(socketMutex);
+
+		if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_CONNECT_ERROR, errorCode.value()));
+	}
+
+	delete resolver;
+	delete handlerLock;
+}
+
+template <class SocketType>
+bool Socket<SocketType>::Disconnect() {
+	boost::mutex::scoped_lock l(socketMutex);
+
+	if (!socket) return false;
+
+	try {
+		socket->close();
+
+		return true;
+	} catch (std::exception& e) {
+	}
+
+	return false;
+}
+
+template <class SocketType>
+bool Socket<SocketType>::Listen() {
+	return false;
+}
+
+template<> void Socket<tcp>::ListenIncomingHandler(tcp::socket* newAsioSocket, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock);
+
+template<>
+bool Socket<tcp>::Listen() {
+	boost::shared_lock<boost::shared_mutex>* handlerLock = NULL;
+	tcp::socket* nextAsioSocket = NULL;
+
+	try {
+		if (!localEndpoint) throw std::logic_error("local endpoint not initialized, call bind() first");
+
+		if (!tcpAcceptor) {
+			tcpAcceptorMutex = new boost::mutex();
+
+			boost::mutex::scoped_lock tcpAcceptorLock(*tcpAcceptorMutex);
+			boost::mutex::scoped_lock locelEndpointLock(*localEndpointMutex);
+
+			tcpAcceptor = new tcp::acceptor(*socketHandler.ioService, *localEndpoint);
+
+			while (!socketOptionQueue.empty()) {
+				SetOption(socketOptionQueue.front()->option, socketOptionQueue.front()->value, false);
+				delete socketOptionQueue.front();
+				socketOptionQueue.pop();
+			}
+		}
+	
+		boost::mutex::scoped_lock l(*tcpAcceptorMutex);
+
+		handlerLock = new boost::shared_lock<boost::shared_mutex>(handlerMutex);
+
+		nextAsioSocket = new tcp::socket(*socketHandler.ioService);
+
+		tcpAcceptor->async_accept(*nextAsioSocket,
+								  boost::bind(&Socket<tcp>::ListenIncomingHandler,
+											  this,
+											  nextAsioSocket,
+											  boost::asio::placeholders::error,
+											  handlerLock));
+
+		return true;
+	} catch (std::exception& e) {
+		if (handlerLock) delete handlerLock;
+		if (nextAsioSocket) delete nextAsioSocket;
+	}
+
+	return false;
+}
+
+template <class SocketType>
+void Socket<SocketType>::ListenIncomingHandler(tcp::socket* newAsioSocket, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	// invalid
+}
+template<>
+void Socket<tcp>::ListenIncomingHandler(tcp::socket* newAsioSocket, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	if (!errorCode) {
+		boost::mutex::scoped_lock l(*tcpAcceptorMutex);
+
+		if (tcpAcceptor) {
+			Socket<tcp>* newSocket = socketHandler.CreateSocket<tcp>(sm_sockettype);
+			newSocket->socket = newAsioSocket;
+			callbackHandler.AddCallback(new Callback(CallbackEvent_Incoming, this, newSocket, newAsioSocket->remote_endpoint()));
+
+			newSocket->ReceiveHandler(new char[16384], 16384, 0, boost::system::posix_error::make_error_code(boost::system::posix_error::success), new boost::shared_lock<boost::shared_mutex>(newSocket->handlerMutex));
+
+			tcp::socket* nextAsioSocket = new tcp::socket(*socketHandler.ioService);
+
+			tcpAcceptor->async_accept(*nextAsioSocket,
+									  boost::bind(&Socket<tcp>::ListenIncomingHandler,
+												  this,
+												  nextAsioSocket,
+												  boost::asio::placeholders::error,
+												  handlerLock));
+			return;
+		}
+	}
+
+	if (errorCode && errorCode != boost::asio::error::operation_aborted) {
+		callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_LISTEN_ERROR, errorCode.value()));
+	}
+
+	delete newAsioSocket;
+	delete handlerLock;
+}
+
+template <class SocketType>
+bool Socket<SocketType>::Send(const std::string& data, bool async) {
+	char* buf = NULL;
+	boost::shared_lock<boost::shared_mutex>* handlerLock = NULL;
+
+	try {
+		if (!socket && !tcpAcceptor) throw std::logic_error("can't send without connection");
+
+		if (async) {
+			char* buf = new char[data.length()];
+			memcpy(buf, data.data(), data.length());
+
+			sendQueueLength++;
+
+			handlerLock = new boost::shared_lock<boost::shared_mutex>(handlerMutex);
+
+			boost::mutex::scoped_lock l(socketMutex);
+
+			if (socket) {
+				socket->async_send(boost::asio::buffer(buf, data.length()),
+								   boost::bind(&Socket<SocketType>::SendPostSendHandler,
+											   this,
+											   buf,
+											   boost::asio::placeholders::bytes_transferred,
+											   boost::asio::placeholders::error,
+											   handlerLock));
+			} else {
+				throw new std::logic_error("Operation cancelled.");
+			}
+		} else {
+			boost::mutex::scoped_lock l(socketMutex);
+
+			if (socket) {
+				socket->send(boost::asio::buffer(data, data.length()));
+			} else {
+				throw std::logic_error("Operation cancelled.");
+			}
+		}
+
+		return true;
+	} catch (std::exception& e) {
+		if (buf) delete[] buf;
+		if (handlerLock) delete handlerLock;
+	}
+
+	return false;
+}
+
+template <class SocketType>
+void Socket<SocketType>::SendPostSendHandler(char* buf, size_t bytesTransferred, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+// TODO: handle incomplete sends
+	if (--sendQueueLength == 0 && sendqueueEmptyCallback) {
+		boost::mutex::scoped_lock l(socketMutex);
+
+		if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_SendQueueEmpty, this));
+	}
+
+	if (errorCode && errorCode != boost::asio::error::operation_aborted) {
+		boost::mutex::scoped_lock l(socketMutex);
+		
+		if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_SEND_ERROR, errorCode.value()));
+	}
+
+	delete[] buf;
+	delete handlerLock;
+}
+
+template <class SocketType>
+bool Socket<SocketType>::SendTo(const std::string& data, const char* hostname, uint16_t port, bool async) {
+	return false;
+}
+
+template <>
+bool Socket<udp>::SendTo(const std::string& data, const char* hostname, uint16_t port, bool async) {
+	char* buf = NULL;
+	udp::resolver* resolver = NULL;
+	boost::shared_lock<boost::shared_mutex>* handlerLock = NULL;
+
+	try {
+		char sPort[6];
+		snprintf(sPort, sizeof(sPort), "%hu", port);
+
+		if (!socket) InitializeSocket();
+
+		if (async) {
+			buf = new char[data.length()];
+			memcpy(buf, data.data(), data.length());
+
+			sendQueueLength++;
+
+			resolver = new udp::resolver(*socketHandler.ioService);
+			handlerLock = new boost::shared_lock<boost::shared_mutex>(handlerMutex);
+
+			resolver->async_resolve(udp::resolver::query(udp::v4(), hostname, sPort),
+									boost::bind(&Socket<udp>::SendToPostResolveHandler,
+												this,
+												resolver,
+												boost::asio::placeholders::iterator,
+												buf,
+												data.length(),
+												boost::asio::placeholders::error,
+												handlerLock));
+		} else {
+			udp::resolver syncResolver(*socketHandler.ioService);
+
+			udp::resolver::iterator endpointIterator = syncResolver.resolve(udp::resolver::query(udp::v4(), hostname, sPort));
+
+			boost::mutex::scoped_lock l(socketMutex);
+
+			if (socket) {
+				socket->send_to(boost::asio::buffer(data, data.length()), *endpointIterator);
+			} else {
+				throw std::logic_error("Operation cancelled.");
+			}
+		}
+
+		return true;
+	} catch (std::exception& e) {
+		if (resolver) delete resolver;
+		if (buf) delete[] buf;
+		if (handlerLock) delete handlerLock;
+	}
+
+	return false;
+}
+
+template <class SocketType>
+void Socket<SocketType>::SendToPostResolveHandler(typename SocketType::resolver* resolver, typename SocketType::resolver::iterator endpointIterator, char* buf, size_t bufLen, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	if (!errorCode) {
+		typename SocketType::endpoint endpoint = *endpointIterator;
+
+		boost::mutex::scoped_lock l(socketMutex);
+
+		if (socket) {
+			socket->async_send_to(boost::asio::buffer(buf, bufLen),
+								endpoint,
+								boost::bind(&Socket<SocketType>::SendToPostSendHandler,
+											this,
+											resolver,
+											++endpointIterator,
+											buf,
+											bufLen,
+											boost::asio::placeholders::bytes_transferred,
+											boost::asio::placeholders::error,
+											handlerLock));
+			return;
+		}
+	}
+
+
+
+	if (errorCode && errorCode != boost::asio::error::operation_aborted) {
+		boost::mutex::scoped_lock l(socketMutex);
+		
+		if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_NO_HOST, errorCode.value()));
+	}
+	
+	delete resolver;
+	delete[] buf;
+	delete handlerLock;
+}
+
+template <class SocketType>
+void Socket<SocketType>::SendToPostSendHandler(typename SocketType::resolver* resolver, typename SocketType::resolver::iterator endpointIterator, char* buf, size_t bufLen, size_t bytesTransferred, const boost::system::error_code& errorCode, boost::shared_lock<boost::shared_mutex>* handlerLock) {
+	if (!errorCode) {
+		if (--sendQueueLength == 0 && sendqueueEmptyCallback) {
+			boost::mutex::scoped_lock l(socketMutex);
+		
+			if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_SendQueueEmpty, this));
+		}
+
+	} else if (endpointIterator != typename SocketType::resolver::iterator()) {
+		SendToPostResolveHandler(resolver, endpointIterator, buf, bufLen, boost::system::posix_error::make_error_code(boost::system::posix_error::success), handlerLock);
+		return;
+		
+	} else {
+		if (errorCode != boost::asio::error::operation_aborted) {
+			boost::mutex::scoped_lock l(socketMutex);
+		
+			if (socket) callbackHandler.AddCallback(new Callback(CallbackEvent_Error, this, SM_ErrorType_SEND_ERROR, errorCode.value()));
+		}
+	}
+
+	delete resolver;
+	delete[] buf;
+	delete handlerLock;
+}
+
+template <class SocketType>
+bool Socket<SocketType>::SetOption(SM_SocketOption so, int value, bool lock) {
+	boost::mutex::scoped_lock* l = NULL;
+
+	try {
+		if (socket) {
+			if (lock) l = new boost::mutex::scoped_lock(socketMutex);
+			if (!socket) return false;
+
+			switch (so) {
+				case SM_SO_SocketBroadcast:
+					socket->set_option(boost::asio::socket_base::broadcast(value!=0));
+					break;
+				case SM_SO_SocketReuseAddr:
+					socket->set_option(boost::asio::socket_base::reuse_address(value!=0));
+					break;
+				case SM_SO_SocketKeepAlive:
+					socket->set_option(boost::asio::socket_base::keep_alive(value!=0));
+					break;
+				case SM_SO_SocketLinger:
+					socket->set_option(boost::asio::socket_base::linger(value>0, value));
+					break;
+				case SM_SO_SocketOOBInline:
+					// TODO: implement?
+					if (l) delete l;
+					return false;
+				case SM_SO_SocketSendBuffer:
+					socket->set_option(boost::asio::socket_base::send_buffer_size(value));
+					break;
+				case SM_SO_SocketReceiveBuffer:
+					socket->set_option(boost::asio::socket_base::receive_buffer_size(value));
+					break;
+				case SM_SO_SocketDontRoute:
+					socket->set_option(boost::asio::socket_base::do_not_route(value!=0));
+					break;
+				case SM_SO_SocketReceiveLowWatermark:
+					socket->set_option(boost::asio::socket_base::receive_low_watermark(value));
+					break;
+				case SM_SO_SocketReceiveTimeout:
+					// TODO: implement?
+					if (l) delete l;
+					return false;
+				case SM_SO_SocketSendLowWatermark:
+					socket->set_option(boost::asio::socket_base::send_low_watermark(value));
+					break;
+				case SM_SO_SocketSendTimeout:
+					// TODO: implement?
+					if (l) delete l;
+					return false;
+				default:
+					if (l) delete l;
+					return false;
+			}
+		} else if (tcpAcceptor) {
+			if (lock) l = new boost::mutex::scoped_lock(*tcpAcceptorMutex);
+			if (!tcpAcceptor) return false;
+
+			switch (so) {
+				case SM_SO_SocketBroadcast:
+					tcpAcceptor->set_option(boost::asio::socket_base::broadcast(value!=0));
+					break;
+				case SM_SO_SocketReuseAddr:
+					tcpAcceptor->set_option(boost::asio::socket_base::reuse_address(value!=0));
+					break;
+				case SM_SO_SocketKeepAlive:
+					tcpAcceptor->set_option(boost::asio::socket_base::keep_alive(value!=0));
+					break;
+				case SM_SO_SocketLinger:
+					tcpAcceptor->set_option(boost::asio::socket_base::linger(value>0, value));
+					break;
+				case SM_SO_SocketOOBInline:
+					// TODO: implement?
+					if (l) delete l;
+					return false;
+				case SM_SO_SocketSendBuffer:
+					tcpAcceptor->set_option(boost::asio::socket_base::send_buffer_size(value));
+					break;
+				case SM_SO_SocketReceiveBuffer:
+					tcpAcceptor->set_option(boost::asio::socket_base::receive_buffer_size(value));
+					break;
+				case SM_SO_SocketDontRoute:
+					tcpAcceptor->set_option(boost::asio::socket_base::do_not_route(value!=0));
+					break;
+				case SM_SO_SocketReceiveLowWatermark:
+					tcpAcceptor->set_option(boost::asio::socket_base::receive_low_watermark(value));
+					break;
+				case SM_SO_SocketReceiveTimeout:
+					// TODO: implement?
+					if (l) delete l;
+					return false;
+				case SM_SO_SocketSendLowWatermark:
+					tcpAcceptor->set_option(boost::asio::socket_base::send_low_watermark(value));
+					break;
+				case SM_SO_SocketSendTimeout:
+					// TODO: implement?
+					if (l) delete l;
+					return false;
+				default:
+					if (l) delete l;
+					return false;
+			}
+		} else {
+			socketOptionQueue.push(new SocketOption(so, value));
+		}
+
+		if (l) delete l;
+		return true;
+	} catch (std::exception& e) {
+		if (l) delete l;
+		return false;
+	}
+}
+
+template <class SocketType>
+void Socket<SocketType>::InitializeSocket() {
+	assert(!socket);
+
+	boost::mutex::scoped_lock l(socketMutex);
+
+	if (!socket) {
+		if (localEndpointMutex) {
+			boost::mutex::scoped_lock l(*localEndpointMutex);
+
+			if (localEndpoint) {
+				socket = new typename SocketType::socket(*socketHandler.ioService, *localEndpoint);
+			} else {
+				socket = new typename SocketType::socket(*socketHandler.ioService, typename SocketType::endpoint(SocketType::v4(), 0));
+			}
+		} else {
+			socket = new typename SocketType::socket(*socketHandler.ioService);
+		}
+		
+		if (!socket->is_open()) socket->open(SocketType::v4());
+
+		while (!socketOptionQueue.empty()) {
+			SetOption(socketOptionQueue.front()->option, socketOptionQueue.front()->value, false);
+			delete socketOptionQueue.front();
+			socketOptionQueue.pop();
+		}
+	}
+}
+
+template Socket<tcp>::Socket(SM_SocketType, tcp::socket*);
+template Socket<tcp>::~Socket();
+template bool Socket<tcp>::IsOpen();
+template bool Socket<tcp>::Bind(const char*, uint16_t, bool);
+template bool Socket<tcp>::Connect(const char*, uint16_t, bool);
+template bool Socket<tcp>::Disconnect();
+template bool Socket<tcp>::Send(const std::string&, bool);
+template bool Socket<tcp>::SendTo(const std::string&, const char*, uint16_t, bool);
+template bool Socket<tcp>::SetOption(SM_SocketOption, int, bool);
+
+template Socket<udp>::Socket(SM_SocketType, udp::socket*);
+template Socket<udp>::~Socket();
+template bool Socket<udp>::IsOpen();
+template bool Socket<udp>::Bind(const char*, uint16_t, bool);
+template bool Socket<udp>::Connect(const char*, uint16_t, bool);
+template bool Socket<udp>::Disconnect();
+template bool Socket<udp>::Listen();
+template bool Socket<udp>::Send(const std::string&, bool);
+template bool Socket<udp>::SetOption(SM_SocketOption, int, bool);
+

Socket.h

@@ -0,0 +1,75 @@
+#ifndef INC_SEXT_SOCKET_H
+#define INC_SEXT_SOCKET_H
+
+#include <stdint.h>
+#include <string>
+#include <queue>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+#include "sdk/smsdk_ext.h"
+#include "Define.h"
+
+class SocketHandler;
+
+template <class SocketType>
+class Socket {
+public:
+	Socket(SM_SocketType st, typename SocketType::socket* asioSocket = NULL);
+	~Socket();
+
+	bool IsOpen();
+
+	bool Bind(const char* hostname, uint16_t port, bool async = true);
+	bool Connect(const char* hostname, uint16_t port, bool async = true);
+	bool Disconnect();
+	bool Listen();
+	bool Send(const std::string& data, bool async = true);
+	bool SendTo(const std::string& data, const char* hostname, uint16_t port, bool async = true);
+	bool SetOption(SM_SocketOption so, int value, bool lock=true);
+
+	IPluginFunction* connectCallback;
+	IPluginFunction* incomingCallback;
+	IPluginFunction* receiveCallback;
+	IPluginFunction* sendqueueEmptyCallback;
+	IPluginFunction* disconnectCallback;
+	IPluginFunction* errorCallback;
+
+	int32_t smHandle;
+	int32_t smCallbackArg;
+	volatile unsigned int sendQueueLength;
+
+private:
+	void ReceiveHandler(char* buf, size_t bufferSize, size_t bytes, const boost::system::error_code&, boost::shared_lock<boost::shared_mutex>*);
+
+	void BindPostResolveHandler(typename SocketType::resolver*, typename SocketType::resolver::iterator, const boost::system::error_code&, boost::shared_lock<boost::shared_mutex>*);
+
+	void ConnectPostResolveHandler(typename SocketType::resolver*, typename SocketType::resolver::iterator, const boost::system::error_code&, boost::shared_lock<boost::shared_mutex>*);
+	void ConnectPostConnectHandler(typename SocketType::resolver*, typename SocketType::resolver::iterator, const boost::system::error_code&, boost::shared_lock<boost::shared_mutex>*);
+
+	void ListenIncomingHandler(boost::asio::ip::tcp::socket* newAsioSocket, const boost::system::error_code&, boost::shared_lock<boost::shared_mutex>*);
+
+	void SendPostSendHandler(char* buf, size_t bytes, const boost::system::error_code& err, boost::shared_lock<boost::shared_mutex>*);
+
+	void SendToPostResolveHandler(typename SocketType::resolver*, typename SocketType::resolver::iterator, char* buf, size_t bufLen, const boost::system::error_code&, boost::shared_lock<boost::shared_mutex>*);
+	void SendToPostSendHandler(typename SocketType::resolver*, typename SocketType::resolver::iterator, char* buf, size_t bufLen, size_t bytesTransferred, const boost::system::error_code&, boost::shared_lock<boost::shared_mutex>*);
+
+	//void InitializeResolver();
+	void InitializeSocket();
+
+	SM_SocketType sm_sockettype;
+	std::queue<SocketOption*> socketOptionQueue;
+
+	typename SocketType::socket* socket;
+	boost::mutex socketMutex;
+	//typename SocketType::resolver* resolver;
+	typename SocketType::endpoint* localEndpoint;
+	boost::mutex* localEndpointMutex;
+	boost::asio::ip::tcp::acceptor* tcpAcceptor;
+	boost::mutex* tcpAcceptorMutex;
+
+	boost::shared_mutex handlerMutex;
+};
+
+#endif

SocketHandler.cpp

@@ -0,0 +1,117 @@
+#include "SocketHandler.h"
+
+#include <assert.h>
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+
+#include "CallbackHandler.h"
+
+using namespace boost::asio::ip;
+
+SocketWrapper::~SocketWrapper() {
+	switch (socketType) {
+		case SM_SocketType_Tcp:
+			delete (Socket<tcp>*) socket;
+			break;
+		case SM_SocketType_Udp:
+			delete (Socket<udp>*) socket;
+			break;
+		/*case SM_SocketType_Icmp:
+			delete (Socket<icmp>*) socket;
+			break;*/
+	}
+
+	callbackHandler.RemoveCallbacks(this);
+}
+
+template Socket<tcp>* SocketHandler::CreateSocket<tcp>(SM_SocketType);
+template Socket<udp>* SocketHandler::CreateSocket<udp>(SM_SocketType);
+
+SocketHandler::SocketHandler() : ioServiceProcessingThreadInitialized(false) {
+	ioService = new boost::asio::io_service();
+}
+
+SocketHandler::~SocketHandler() {
+	if (!socketList.empty() || ioServiceProcessingThreadInitialized) {
+		Shutdown();
+	}
+#ifndef WIN32
+	delete ioService;
+#endif
+}
+
+void SocketHandler::Shutdown() {
+	boost::mutex::scoped_lock l(socketListMutex);
+
+	for (std::deque<SocketWrapper*>::iterator it=socketList.begin(); it!=socketList.end(); it++) {
+		delete *it;
+	}
+
+	socketList.clear();
+
+	if (ioServiceProcessingThreadInitialized) StopProcessing();
+}
+
+template <class SocketType>
+Socket<SocketType>* SocketHandler::CreateSocket(SM_SocketType st) {
+	boost::mutex::scoped_lock l(socketListMutex);
+
+	SocketWrapper* sp = new SocketWrapper(new Socket<SocketType>(st), st);
+	socketList.push_back(sp);
+
+	return (Socket<SocketType>*) sp->socket;
+}
+
+void SocketHandler::DestroySocket(SocketWrapper* sw) {
+	assert(sw);
+
+	{ // lock
+		boost::mutex::scoped_lock l(socketListMutex);
+
+		for (std::deque<SocketWrapper*>::iterator it=socketList.begin(); it!=socketList.end(); it++) {
+			if (*it == sw) {
+				socketList.erase(it);
+				break;
+			}
+		}
+	} // ~lock
+
+	delete sw;
+}
+
+void SocketHandler::StartProcessing() {
+	assert(!ioServiceProcessingThreadInitialized);
+
+	ioServiceProcessingThread = new boost::thread(boost::bind(&SocketHandler::RunIoService, this));
+	ioServiceProcessingThreadInitialized = true;
+}
+
+void SocketHandler::StopProcessing() {
+	assert(ioServiceProcessingThreadInitialized);
+
+	ioService->stop();
+	delete ioServiceWork;
+	ioServiceProcessingThread->join();
+
+	ioServiceProcessingThreadInitialized = false;
+	delete ioServiceProcessingThread;
+}
+
+void SocketHandler::RunIoService() {
+	//boost::asio::io_service::work work(*ioService);
+	ioServiceWork = new boost::asio::io_service::work(*ioService);
+	ioService->run();
+}
+
+SocketWrapper* SocketHandler::GetSocketWrapper(const void* socket) {
+	boost::mutex::scoped_lock l(socketListMutex);
+
+	for (std::deque<SocketWrapper*>::iterator it=socketList.begin(); it!=socketList.end(); it++) {
+		if ((*it)->socket == socket) return *it;
+	}
+
+	return NULL;
+}
+
+SocketHandler socketHandler;
+

SocketHandler.h

@@ -0,0 +1,51 @@
+#ifndef INC_SEXT_SOCKETHANDLER_H
+#define INC_SEXT_SOCKETHANDLER_H
+
+#include <deque>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+
+#include "Socket.h"
+
+struct SocketWrapper {
+	SocketWrapper(void* socket, SM_SocketType socketType) : socket(socket), socketType(socketType) {}
+	~SocketWrapper();
+
+	void* socket;
+	SM_SocketType socketType;
+};
+
+class SocketHandler {
+public:
+	SocketHandler();
+	~SocketHandler();
+
+	void Shutdown();
+
+	SocketWrapper* GetSocketWrapper(const void* socket);
+
+	template <class SocketType> Socket<SocketType>* CreateSocket(SM_SocketType st);
+	void DestroySocket(SocketWrapper* sw);
+
+	void StartProcessing();
+	void StopProcessing();
+
+	//friend class Socket;
+	boost::asio::io_service* ioService;
+
+private:
+	std::deque<SocketWrapper*> socketList;
+	boost::mutex socketListMutex;
+
+	boost::asio::io_service::work* ioServiceWork;
+
+	boost::thread* ioServiceProcessingThread;
+	bool ioServiceProcessingThreadInitialized;
+
+	void RunIoService();
+};
+
+extern SocketHandler socketHandler;
+
+#endif
+

examples/example.sp

@@ -0,0 +1,54 @@
+// example for the socket extension
+
+#include <sourcemod>
+#include <socket>
+
+public Plugin:myinfo = {
+	name = "socket example",
+	author = "Player",
+	description = "This example demonstrates downloading a http file with the socket extension",
+	version = "1.1.0",
+	url = "http://www.player.to/"
+};
+ 
+public OnPluginStart() {
+	// create a new tcp socket
+	new Handle:socket = SocketCreate(SOCKET_TCP, OnSocketError);
+	// open a file handle for writing the result
+	new Handle:hFile = OpenFile("dl.htm", "wb");
+	// pass the file handle to the callbacks
+	SocketSetArg(socket, hFile);
+	// connect the socket
+	SocketConnect(socket, OnSocketConnected, OnSocketReceive, OnSocketDisconnected, "www.sourcemod.net", 80)
+}
+
+public OnSocketConnected(Handle:socket, any:arg) {
+	// socket is connected, send the http request
+
+	decl String:requestStr[100];
+	Format(requestStr, sizeof(requestStr), "GET /%s HTTP/1.0\r\nHost: %s\r\nConnection: close\r\n\r\n", "index.php", "www.sourcemod.net");
+	SocketSend(socket, requestStr);
+}
+
+public OnSocketReceive(Handle:socket, String:receiveData[], const dataSize, any:hFile) {
+	// receive another chunk and write it to <modfolder>/dl.htm
+	// we could strip the http response header here, but for example's sake we'll leave it in
+
+	WriteFileString(hFile, receiveData, false);
+}
+
+public OnSocketDisconnected(Handle:socket, any:hFile) {
+	// Connection: close advises the webserver to close the connection when the transfer is finished
+	// we're done here
+
+	CloseHandle(hFile);
+	CloseHandle(socket);
+}
+
+public OnSocketError(Handle:socket, const errorType, const errorNum, any:hFile) {
+	// a socket error occured
+
+	LogError("socket error %d (errno %d)", errorType, errorNum);
+	CloseHandle(hFile);
+	CloseHandle(socket);
+}

examples/listenexample.sp

@@ -0,0 +1,64 @@
+// listening socket example for the socket extension
+
+#include <sourcemod>
+#include <socket>
+
+public Plugin:myinfo = {
+	name = "listen socket example",
+	author = "Player",
+	description = "This example provides a simple echo server",
+	version = "1.0.1",
+	url = "http://www.player.to/"
+};
+ 
+public OnPluginStart() {
+	// enable socket debugging (only for testing purposes!)
+	SocketSetOption(INVALID_HANDLE, DebugMode, 1);
+
+
+	// create a new tcp socket
+	new Handle:socket = SocketCreate(SOCKET_TCP, OnSocketError);
+	// bind the socket to all interfaces, port 50000
+	SocketBind(socket, "0.0.0.0", 50000);
+	// let the socket listen for incoming connections
+	SocketListen(socket, OnSocketIncoming);
+}
+
+public OnSocketIncoming(Handle:socket, Handle:newSocket, String:remoteIP[], remotePort, any:arg) {
+	PrintToServer("%s:%d connected", remoteIP, remotePort);
+
+	// setup callbacks required to 'enable' newSocket
+	// newSocket won't process data until these callbacks are set
+	SocketSetReceiveCallback(newSocket, OnChildSocketReceive);
+	SocketSetDisconnectCallback(newSocket, OnChildSocketDisconnected);
+	SocketSetErrorCallback(newSocket, OnChildSocketError);
+
+	SocketSend(newSocket, "send quit to quit\n");
+}
+
+public OnSocketError(Handle:socket, const errorType, const errorNum, any:ary) {
+	// a socket error occured
+
+	LogError("socket error %d (errno %d)", errorType, errorNum);
+	CloseHandle(socket);
+}
+
+public OnChildSocketReceive(Handle:socket, String:receiveData[], const dataSize, any:hFile) {
+	// send (echo) the received data back
+	SocketSend(socket, receiveData);
+	// close the connection/socket/handle if it matches quit
+	if (strncmp(receiveData, "quit", 4) == 0) CloseHandle(socket);
+}
+
+public OnChildSocketDisconnected(Handle:socket, any:hFile) {
+	// remote side disconnected
+
+	CloseHandle(socket);
+}
+
+public OnChildSocketError(Handle:socket, const errorType, const errorNum, any:ary) {
+	// a socket error occured
+
+	LogError("child socket error %d (errno %d)", errorType, errorNum);
+	CloseHandle(socket);
+}

examples/selftest.sp

@@ -0,0 +1,309 @@
+/**
+ * Socket extension selftest
+ */
+
+#include <sourcemod>
+#include <socket>
+
+public Plugin:myinfo = {
+	name = "socket extension selftest",
+	author = "Player",
+	description = "basic functionality testing",
+	version = "1.1.0",
+	url = "http://www.player.to/"
+};
+
+new goalsReached;
+new trapsReached;
+
+new test;
+public OnGameFrame() {
+	if (test == 0) {
+		test++;
+
+		SocketSetOption(INVALID_HANDLE, DebugMode, 1);
+
+		selfTest1();
+	}
+}
+
+/**
+ * TEST #1 - binary data over tcp
+ *
+ * stuff tested:
+ * - create, close
+ * - connect
+ * - send, receive
+ * - listen
+ * - sendQueueEmpty
+ * - setoption reuseaddr
+ * - data containing x00
+ *
+ * This test is using three sockets:
+ * - Listening socket on port 12345
+ * - A socket which tries to connect to the listening socket and receives data
+ * - the child socket which sends the data
+ */
+selfTest1() {
+	goalsReached = 0;
+	trapsReached = 0;
+	CreateTimer(3.0, selfTest1Terminate);
+	PrintToServer("* |socket selftest| test #1 running");
+
+	new Handle:socket = SocketCreate(SOCKET_TCP, OnSocketErrorTrap);
+
+	SocketSetOption(socket, SocketReuseAddr, 1);
+
+	SocketBind(socket, "0.0.0.0", 12345);
+	SocketListen(socket, Test1_OnListenSocketIncoming);
+
+	new Handle:socket2 = SocketCreate(SOCKET_TCP, OnSocketErrorTrap);
+	SocketConnect(socket2, OnSocketConnectGoal, Test1_OnReceiveSocketReceive, Test1_OnReceiveSocketDisconnect, "127.0.0.1", 12345);
+}
+
+public Action:selfTest1Terminate(Handle:timer) {
+	if (goalsReached == 6 && trapsReached == 0) {
+		PrintToServer("* |socket selftest| ** test #1 passed **");
+		selfTest2();
+	} else {
+		PrintToServer("* |socket selftest| ** test #1 failed **");
+	}
+
+	return Plugin_Stop;
+}
+
+/**
+ * TEST #2 - reuse listening address from test #1
+ *
+ * stuff tested:
+ * - create, close
+ * - listen
+ * - setoption reuseaddr
+ *
+ * This test is using one socket:
+ * - Listening socket on port 12345
+ */
+selfTest2() {
+	goalsReached = 0;
+	trapsReached = 0;
+	CreateTimer(4.0, selfTest2Terminate);
+	PrintToServer("* |socket selftest| test #2 running");
+
+	new Handle:socket = SocketCreate(SOCKET_TCP, OnSocketErrorTrap);
+
+	SocketSetOption(socket, SocketReuseAddr, 1);
+
+	SocketBind(socket, "0.0.0.0", 12345);
+	SocketListen(socket, OnSocketIncomingTrap);
+
+	CloseHandle(socket);
+
+	goalsReached++;
+}
+
+public Action:selfTest2Terminate(Handle:timer) {
+	if (goalsReached == 1 && trapsReached == 0) {
+		PrintToServer("* |socket selftest| ** test #2 passed **");
+		selfTest3();
+	} else {
+		PrintToServer("* |socket selftest| ** test #2 failed **");
+	}
+
+	return Plugin_Stop;
+}
+
+selfTest3() {
+	goalsReached = 0;
+	trapsReached = 0;
+	CreateTimer(1.0, selfTest3Terminate);
+	PrintToServer("* |socket selftest| test #3 running");
+
+	decl Handle:socket[20];
+	
+	for (new count=1; count <= 20; count++) {
+		for (new i=0; i<count; i++) {
+			socket[i] = SocketCreate(SOCKET_TCP, OnSocketErrorTrap);
+		}
+
+		for (new i=0; i<count; i++) {
+			CloseHandle(socket[i]);
+		}
+	}
+
+	goalsReached++;
+}
+
+public Action:selfTest3Terminate(Handle:timer) {
+	if (goalsReached == 1 && trapsReached == 0) {
+		PrintToServer("* |socket selftest| ** test #3 passed **");
+		selfTest4();
+	} else {
+		PrintToServer("* |socket selftest| ** test #3 failed **");
+	}
+
+	return Plugin_Stop;
+}
+
+/**
+ * TEST #4 - connect, closehandle
+ *
+ * stuff tested:
+ * - create, close
+ * - connect
+ * - listen
+ */
+selfTest4() {
+	goalsReached = 0;
+	trapsReached = 0;
+	CreateTimer(5.0, selfTest4Terminate);
+	PrintToServer("* |socket selftest| test #4 running");
+
+	new Handle:listenSocket = SocketCreate(SOCKET_TCP, OnSocketErrorTrap);
+
+	SocketSetOption(listenSocket, SocketReuseAddr, 1);
+
+	SocketBind(listenSocket, "0.0.0.0", 12345);
+	SocketListen(listenSocket, Test3_OnListenSocketIncoming);
+
+	decl Handle:socket[8];
+	
+	for (new count=1; count <= 8; count++) {
+		for (new i=0; i<count; i++) {
+			socket[i] = SocketCreate(SOCKET_TCP, OnSocketErrorTrap);
+		}
+
+		for (new i=0; i<count; i++) {
+			SocketConnect(socket[i], OnSocketConnectGoal, OnSocketReceiveTrap, OnSocketDisconnectGoal, "127.0.0.1", 12345);
+		}
+	}
+
+	CloseHandle(listenSocket);
+
+	goalsReached++;
+}
+
+public Action:selfTest4Terminate(Handle:timer) {
+	if (goalsReached == 109 && trapsReached == 0) {
+		PrintToServer("* |socket selftest| ** test #4 passed **");
+		selfTest5();
+	} else {
+		PrintToServer("* |socket selftest| ** test #4 failed ** (%d goals of 109)", goalsReached);
+	}
+
+	return Plugin_Stop;
+}
+
+selfTest5() {
+}
+
+// ------------------------------------- TEST 1 callbacks -------------------------------------
+
+public Test1_OnListenSocketIncoming(Handle:socket, Handle:newSocket, String:remoteIP[], remotePort, any:arg) {
+	SocketSetReceiveCallback(newSocket, OnSocketReceiveTrap);
+	SocketSetDisconnectCallback(newSocket, OnSocketDisconnectTrap);
+	SocketSetErrorCallback(newSocket, OnSocketErrorTrap);
+
+	SocketSend(newSocket, "\x00abc\x00def\x01\x02\x03\x04", 12);
+	SocketSetSendqueueEmptyCallback(newSocket, Test1_OnChildSocketSQEmpty);
+
+	PrintToServer("* |socket selftest| goal Test1_OnListenSocketIncoming reached");
+	goalsReached++;
+
+	// close listening socket
+	CloseHandle(socket);
+
+	PrintToServer("* |socket selftest| goal Test1_OnListenSocketIncoming - CloseHandle reached");
+	goalsReached++;
+}
+
+public Test1_OnChildSocketSQEmpty(Handle:socket, any:arg) {
+	CloseHandle(socket);
+	PrintToServer("* |socket selftest| goal Test1_OnChildSocketSQEmpty reached");
+	goalsReached++;
+}
+
+new String:recvBuffer[128];
+new recvBufferPos = 0;
+
+public Test1_OnReceiveSocketReceive(Handle:socket, String:receiveData[], const dataSize, any:arg) {
+	PrintToServer("received %d bytes", dataSize);
+
+	if (recvBufferPos < 512) {
+		for (new i=0; i<dataSize && recvBufferPos<sizeof(recvBuffer); i++, recvBufferPos++) {
+			recvBuffer[recvBufferPos] = receiveData[i];
+		}
+	}
+}
+
+public Test1_OnReceiveSocketDisconnect(Handle:socket, any:arg) {
+	PrintToServer("* |socket selftest| goal Test1_OnReceiveSocketDisconnect reached");
+	goalsReached++;
+
+	new String:cmp[] = "\x00abc\x00def\x01\x02\x03\x04";
+	new i;
+	for (i=0; i<recvBufferPos && i<12; i++) {
+		if (recvBuffer[i] != cmp[i]) {
+			PrintToServer("comparison failed");
+			break;
+		}
+	}
+
+	CloseHandle(socket);
+
+	if (i == 12) {
+		PrintToServer("* |socket selftest| goal Test1_OnReceiveSocketDisconnect - i=12 reached");
+		goalsReached++;
+	} else {
+		PrintToServer("* |socket selftest| trap Test1_OnReceiveSocketDisconnect - i=%d!=12 triggered", i);
+		trapsReached++;
+	}
+}
+
+// ------------------------------------- TEST 3 callbacks -------------------------------------
+
+public Test3_OnListenSocketIncoming(Handle:socket, Handle:newSocket, String:remoteIP[], remotePort, any:arg) {
+	CloseHandle(newSocket);
+	goalsReached++;
+}
+
+// ------------------------------------- common callbacks -------------------------------------
+
+public OnSocketConnectGoal(Handle:socket, any:arg) {
+	goalsReached++;
+}
+public OnSocketReceiveGoal(Handle:socket, String:receiveData[], const dataSize, any:arg) {
+	goalsReached++;
+}
+public OnSocketDisconnectGoal(Handle:socket, any:arg) {
+	goalsReached++;
+}
+public OnSocketErrorGoal(Handle:socket, const errorType, const errorNum, any:arg) {
+	goalsReached++;
+}
+public OnSocketIncomingGoal(Handle:socket, Handle:newSocket, String:remoteIP[], remotePort, any:arg) {
+	goalsReached++;
+}
+
+public OnSocketConnectTrap(Handle:socket, any:arg) {
+	PrintToServer("* |socket selftest| trap OnSocketConnectTrap triggered");
+	trapsReached++;
+}
+public OnSocketReceiveTrap(Handle:socket, String:receiveData[], const dataSize, any:arg) {
+	PrintToServer("* |socket selftest| trap OnSocketReceiveTrap triggered (%d bytes received)", dataSize);
+	trapsReached++;
+}
+public OnSocketDisconnectTrap(Handle:socket, any:arg) {
+	PrintToServer("* |socket selftest| trap OnSocketDisconnectTrap triggered");
+	trapsReached++;
+}
+public OnSocketErrorTrap(Handle:socket, const errorType, const errorNum, any:arg) {
+	PrintToServer("* |socket selftest| trap OnSocketErrorTrap triggered (error %d, errno %d)", errorType, errorNum);
+	trapsReached++;
+}
+public OnSocketIncomingTrap(Handle:socket, Handle:newSocket, String:remoteIP[], remotePort, any:arg) {
+	PrintToServer("* |socket selftest| trap OnSocketIncomingTrap triggered");
+	trapsReached++;
+}
+
+// EOF
+

examples/sendto_test.sp

@@ -0,0 +1,116 @@
+/**
+ * Socket extension sendto selftest
+ */
+
+#include <sourcemod>
+#include <socket>
+
+public Plugin:myinfo = {
+	name = "socket extension sendto selftest",
+	author = "Player",
+	description = "basic functionality testing",
+	version = "1.0.0",
+	url = "http://www.player.to/"
+};
+ 
+public OnPluginStart() {
+	SocketSetOption(INVALID_HANDLE, DebugMode, 1);
+	
+	new port = 12346;
+
+	new Handle:socket = SocketCreate(SOCKET_UDP, OnLSocketError);
+
+	SocketBind(socket, "0.0.0.0", port);
+	SocketListen(socket, OnLSocketIncoming);
+
+	new Handle:socket2 = SocketCreate(SOCKET_UDP, OnCSocketError);
+	//SocketConnect(socket2, OnCSocketConnect, OnCSocketReceive, OnCSocketDisconnect, "127.0.0.1", port);
+}
+
+public OnLSocketIncoming(Handle:socket, Handle:newSocket, String:remoteIP[], remotePort, any:arg) {
+	PrintToServer("%s:%d connected", remoteIP, remotePort);
+
+	SocketSetReceiveCallback(newSocket, OnChildSocketReceive);
+	SocketSetDisconnectCallback(newSocket, OnChildSocketDisconnect);
+	SocketSetErrorCallback(newSocket, OnChildSocketError);
+
+	SocketSend(newSocket, "\x00abc\x00def\x01\x02\x03\x04", 12);
+	SocketSetSendqueueEmptyCallback(newSocket, OnChildSocketSQEmpty);
+}
+
+public OnLSocketError(Handle:socket, const errorType, const errorNum, any:arg) {
+	LogError("listen socket error %d (errno %d)", errorType, errorNum);
+	CloseHandle(socket);
+}
+
+public OnChildSocketReceive(Handle:socket, String:receiveData[], const dataSize, any:arg) {
+	// send (echo) the received data back
+	//SocketSend(socket, receiveData);
+	// close the connection/socket/handle if it matches quit
+	//if (strncmp(receiveData, "quit", 4) == 0) CloseHandle(socket);
+}
+
+public OnChildSocketSQEmpty(Handle:socket, any:arg) {
+	PrintToServer("sq empty");
+	CloseHandle(socket);
+}
+
+public OnChildSocketDisconnect(Handle:socket, any:arg) {
+	// remote side disconnected
+	PrintToServer("disc");
+	CloseHandle(socket);
+}
+
+public OnChildSocketError(Handle:socket, const errorType, const errorNum, any:arg) {
+	// a socket error occured
+
+	LogError("child socket error %d (errno %d)", errorType, errorNum);
+	CloseHandle(socket);
+}
+
+public OnCSocketConnect(Handle:socket, any:arg) {
+	// send (echo) the received data back
+	//SocketSend(socket, receiveData);
+	// close the connection/socket/handle if it matches quit
+	//if (strncmp(receiveData, "quit", 4) == 0) CloseHandle(socket);
+}
+
+new String:recvBuffer[128];
+new recvBufferPos = 0;
+
+public OnCSocketReceive(Handle:socket, String:receiveData[], const dataSize, any:arg) {
+	PrintToServer("received %d bytes", dataSize);
+
+	if (recvBufferPos < 512) {
+		for (new i=0; i<dataSize && recvBufferPos<sizeof(recvBuffer); i++, recvBufferPos++) {
+			recvBuffer[recvBufferPos] = receiveData[i];
+		}
+	}
+	// send (echo) the received data back
+	//SocketSend(socket, receiveData);
+	// close the connection/socket/handle if it matches quit
+	//if (strncmp(receiveData, "quit", 4) == 0) CloseHandle(socket);
+}
+
+public OnCSocketDisconnect(Handle:socket, any:arg) {
+	new String:cmp[] = "\x00abc\x00def\x01\x02\x03\x04";
+	new i;
+	for (i=0; i<recvBufferPos && i<12; i++) {
+		if (recvBuffer[i] != cmp[i]) {
+			PrintToServer("comparison failed");
+			break;
+		}
+	}
+
+	PrintToServer("comparison finished at pos %d/%d", i, recvBufferPos);
+
+	CloseHandle(socket);
+}
+
+public OnCSocketError(Handle:socket, const errorType, const errorNum, any:arg) {
+	// a socket error occured
+
+	LogError("connect socket error %d (errno %d)", errorType, errorNum);
+	CloseHandle(socket);
+}
+

examples/sockettest.sp

@@ -0,0 +1,68 @@
+// http://forums.alliedmods.net/showpost.php?p=717597&postcount=67
+
+#pragma semicolon 1
+#include <sourcemod>
+#include <socket>
+
+#define PLUGIN_VERSION "1.0.0"
+
+public Plugin:myinfo = 
+{
+    name = "Socket Test",
+    author = "Unknown",
+    description = "Test",
+    version = "1.0",
+    url = ""
+}
+
+public OnPluginStart()
+{
+	SocketSetOption(INVALID_HANDLE,DebugMode,1);
+    RegAdminCmd("sm_socket_test", CommandTest, ADMFLAG_CONVARS, "test");
+}
+
+public Action:CommandTest(client, args)
+{
+    // create a new tcp socket
+    new Handle:socket = SocketCreate(SOCKET_TCP, OnSocketError);
+    // open a file handle for writing the result
+    //new Handle:hFile = OpenFile("dl.htm", "wb");
+    // pass the file handle to the callbacks
+    //SocketSetArg(socket, hFile);
+    // connect the socket
+    SocketConnect(socket, OnSocketConnected, OnSocketReceive, OnSocketDisconnected, "www.sourcemod.net", 80);
+
+    return Plugin_Handled;
+}
+
+public OnSocketConnected(Handle:socket, any:hFile) {
+    // socket is connected, send the http request
+
+    decl String:requestStr[100];
+    Format(requestStr, sizeof(requestStr), "GET /%s HTTP/1.0\r\nHost: %s\r\nConnection: close\r\n\r\n", "index.php", "www.sourcemod.net");
+    SocketSend(socket, requestStr);
+}
+
+public OnSocketReceive(Handle:socket, String:receiveData[], const dataSize, any:hFile) {
+    // receive another chunk and write it to <modfolder>/dl.htm
+    // we could strip the http response header here, but for example's sake we'll leave it in
+
+    //WriteFileString(hFile, receiveData, false);
+}
+
+public OnSocketDisconnected(Handle:socket, any:hFile) {
+    // Connection: close advises the webserver to close the connection when the transfer is finished
+    // we're done here
+
+    //CloseHandle(hFile);
+    CloseHandle(socket);
+}
+
+public OnSocketError(Handle:socket, const errorType, const errorNum, any:hFile) {
+    // a socket error occured
+
+    LogError("socket error %d (errno %d)", errorType, errorNum);
+    //CloseHandle(hFile);
+    CloseHandle(socket);
+}
+

gpl-3.0.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

license.txt

@@ -0,0 +1,86 @@
+The code created by this project is being distributed under the terms of the
+GNU General Public License, version 3. Additional information about the license
+can be found in gpl-3.0.txt.
+
+(C) 2008-2009 sfPlayer
+(C) 2007-2008 Olly
+
+-----
+
+   Licenses from code inherited:
+
+
+1) SourceMod
+
+This project provides additional features to SourceMod plugins or extensions
+using the SourceMod C++ extension API.
+
+SOURCEMOD LICENSE INFORMATION
+VERSION: JUNE-13-2008
+-----------------------------
+
+SourceMod is licensed under the GNU General Public License, version 3.  
+
+As a special exception, AlliedModders LLC gives you permission to link the code
+of this program (as well as its derivative works) to "Half-Life 2," the "Source 
+Engine," the "SourcePawn JIT," and any Game MODs that run on software by the 
+Valve Corporation.  You must obey the GNU General Public License in all 
+respects for all other code used. Additionally, AlliedModders LLC grants this 
+exception to all derivative works.
+
+As an additional special exception to the GNU General Public License 3.0, 
+AlliedModders LLC permits dual-licensing of DERIVATIVE WORKS ONLY (that is, 
+SourcePawn/SourceMod Plugins and SourceMod Extensions, or any software built 
+from the SourceMod SDK or header files) under the GNU General Public License 
+version 2 "or any higher version."  As such, you may choose for your derivative 
+work(s) to be compatible with the GNU General Public License version 2 as long 
+as it is also compatible with the GNU General Public License version 3, via the 
+"or any higher version" clause.  This is intended for compatibility with other
+software.
+
+As a final exception to the above, any derivative works created prior to this 
+date (July 31, 2007) may be exclusively licensed under the GNU General Public 
+License version 2 (without an "or any higher version" clause) if and only if 
+the work was already GNU General Public License 2.0 exclusive.  This clause is 
+provided for backwards compatibility only.
+
+A copy of the JIT License is available in JIT.txt.
+A copy of the GNU General Public License 2.0 is available in GPLv2.txt.
+A copy of the GNU General Public License 3.0 is available in GPLv3.txt.
+
+SourcePawn is Copyright (C) 2006-2008 AlliedModders LLC.  All rights reserved.
+SourceMod is Copyright (C) 2006-2008 AlliedModders LLC.  All rights reserved.
+Pawn and SMALL are Copyright (C) 1997-2008 ITB CompuPhase.
+Source is Copyright (C) Valve Corporation.
+All trademarks are property of their respective owners in the US and other 
+
+
+2) Boost C++ Libraries
+
+This project makes use of boost C++ libraries licensed under the Boost Software
+License, version 1.0.
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+

msvc9/socket.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual C++ Express 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "socket", "socket.vcproj", "{2C94CF7D-12E5-4EB8-A024-34EB27B91F4B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2C94CF7D-12E5-4EB8-A024-34EB27B91F4B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{2C94CF7D-12E5-4EB8-A024-34EB27B91F4B}.Debug|Win32.Build.0 = Debug|Win32
+		{2C94CF7D-12E5-4EB8-A024-34EB27B91F4B}.Release|Win32.ActiveCfg = Release|Win32
+		{2C94CF7D-12E5-4EB8-A024-34EB27B91F4B}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

msvc9/socket.vcproj

@@ -0,0 +1,251 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="socket"
+	ProjectGUID="{2C94CF7D-12E5-4EB8-A024-34EB27B91F4B}"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="0"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="2"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..;C:\build\sourcemod-1-0\public;C:\build\sourcemod-1-0\public\sourcepawn;C:\build\boost_1_42_0;C:\build\msinttypes-r24"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;SOCKET_EXPORTS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;SOURCEMOD_BUILD;WIN32;_WIN32_WINNT=0x0501"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)\socket.ext.dll"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="C:\build\boost_1_42_0\stage\lib"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..;C:\build\sourcemod-1-0\public;C:\build\sourcemod-1-0\public\sourcepawn;C:\build\boost_1_42_0;C:\build\msinttypes-r24"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;SOCKET_EXPORTS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;SOURCEMOD_BUILD;WIN32;_WIN32_WINNT=0x0501"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)\$(ProjectName).ext.dll"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="C:\build\boost_1_42_0\stage\lib"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\Callback.h"
+				>
+			</File>
+			<File
+				RelativePath="..\CallbackHandler.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Define.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Extension.h"
+				>
+			</File>
+			<File
+				RelativePath="..\sdk\smsdk_config.h"
+				>
+			</File>
+			<File
+				RelativePath="..\sdk\smsdk_ext.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Socket.h"
+				>
+			</File>
+			<File
+				RelativePath="..\socket.inc"
+				>
+			</File>
+			<File
+				RelativePath="..\SocketHandler.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\Callback.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\CallbackHandler.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Extension.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\sdk\smsdk_ext.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Socket.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\SocketHandler.cpp"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

sdk/smsdk_config.h

@@ -0,0 +1,47 @@
+// vim: set ts=4 :
+#ifndef _INCLUDE_SOURCEMOD_EXTENSION_CONFIG_H_
+#define _INCLUDE_SOURCEMOD_EXTENSION_CONFIG_H_
+
+/**
+ * @file smsdk_config.h
+ * @brief Contains macros for configuring basic extension information.
+ */
+
+/* Basic information exposed publically */
+#define SMEXT_CONF_NAME			"Socket"
+#define SMEXT_CONF_DESCRIPTION	"Socket extension for SourceMod"
+#define SMEXT_CONF_VERSION		"3.0.1"
+#define SMEXT_CONF_AUTHOR		"Player"
+#define SMEXT_CONF_URL			"http://www.player.to/"
+#define SMEXT_CONF_LOGTAG		"SOCKET"
+#define SMEXT_CONF_LICENSE		"GPL"
+#define SMEXT_CONF_DATESTRING	__DATE__
+
+/**
+ * @brief Exposes plugin's main interface.
+ */
+#define SMEXT_LINK(name) SDKExtension *g_pExtensionIface = name;
+
+/**
+ * @brief Sets whether or not this plugin required Metamod.
+ * NOTE: Uncomment to enable, comment to disable.
+ * NOTE: This is enabled automatically if a Metamod build is chosen in
+ *		 the Visual Studio project.
+ */
+//#define SMEXT_CONF_METAMOD
+
+/** Enable interfaces you want to use here by uncommenting lines */
+//#define SMEXT_ENABLE_FORWARDSYS
+#define SMEXT_ENABLE_HANDLESYS
+//#define SMEXT_ENABLE_PLAYERHELPERS
+//#define SMEXT_ENABLE_DBMANAGER
+//#define SMEXT_ENABLE_GAMECONF
+//#define SMEXT_ENABLE_MEMUTILS
+//#define SMEXT_ENABLE_GAMEHELPERS
+//#define SMEXT_ENABLE_TIMERSYS
+//#define SMEXT_ENABLE_ADTFACTORY
+//#define SMEXT_ENABLE_PLUGINSYS
+//#define SMEXT_ENABLE_THREADER
+
+#endif //_INCLUDE_SOURCEMOD_EXTENSION_CONFIG_H_
+

sdk/smsdk_ext.cpp

@@ -0,0 +1,425 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod Base Extension Code
+ * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.
+ * Copyright (C) 2008 Player. All rights reserved. Modifications license: GPL v3
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include <stdio.h>
+#include <malloc.h>
+#include "smsdk_ext.h"
+
+/**
+ * @file smsdk_ext.cpp
+ * @brief Contains wrappers for making Extensions easier to write.
+ */
+
+IExtension *myself = NULL;				/**< Ourself */
+IShareSys *g_pShareSys = NULL;			/**< Share system */
+IShareSys *sharesys = NULL;				/**< Share system */
+ISourceMod *g_pSM = NULL;				/**< SourceMod helpers */
+ISourceMod *smutils = NULL;				/**< SourceMod helpers */
+
+#if defined SMEXT_ENABLE_FORWARDSYS
+IForwardManager *g_pForwards = NULL;	/**< Forward system */
+IForwardManager *forwards = NULL;		/**< Forward system */
+#endif
+#if defined SMEXT_ENABLE_HANDLESYS
+IHandleSys *g_pHandleSys = NULL;		/**< Handle system */
+IHandleSys *handlesys = NULL;			/**< Handle system */
+#endif
+#if defined SMEXT_ENABLE_PLAYERHELPERS
+IPlayerManager *playerhelpers = NULL;	/**< Player helpers */
+#endif //SMEXT_ENABLE_PLAYERHELPERS
+#if defined SMEXT_ENABLE_DBMANAGER
+IDBManager *dbi = NULL;					/**< DB Manager */
+#endif //SMEXT_ENABLE_DBMANAGER
+#if defined SMEXT_ENABLE_GAMECONF
+IGameConfigManager *gameconfs = NULL;	/**< Game config manager */
+#endif //SMEXT_ENABLE_DBMANAGER
+#if defined SMEXT_ENABLE_MEMUTILS
+IMemoryUtils *memutils = NULL;
+#endif //SMEXT_ENABLE_DBMANAGER
+#if defined SMEXT_ENABLE_GAMEHELPERS
+IGameHelpers *gamehelpers = NULL;
+#endif
+#if defined SMEXT_ENABLE_TIMERSYS
+ITimerSystem *timersys = NULL;
+#endif
+#if defined SMEXT_ENABLE_ADTFACTORY
+IADTFactory *adtfactory = NULL;
+#endif
+#if defined SMEXT_ENABLE_THREADER
+IThreader *threader = NULL;
+#endif
+#if defined SMEXT_ENABLE_LIBSYS
+ILibrarySys *libsys = NULL;
+#endif
+#if defined SMEXT_ENABLE_PLUGINSYS
+SourceMod::IPluginManager *plsys;
+#endif
+
+/** Exports the main interface */
+PLATFORM_EXTERN_C IExtensionInterface *GetSMExtAPI()
+{
+	return g_pExtensionIface;
+}
+
+SDKExtension::SDKExtension()
+{
+#if defined SMEXT_CONF_METAMOD
+	m_SourceMMLoaded = false;
+	m_WeAreUnloaded = false;
+	m_WeGotPauseChange = false;
+#endif
+}
+
+bool SDKExtension::OnExtensionLoad(IExtension *me, IShareSys *sys, char *error, size_t maxlength, bool late)
+{
+	g_pShareSys = sharesys = sys;
+	myself = me;
+
+#if defined SMEXT_CONF_METAMOD
+	m_WeAreUnloaded = true;
+
+	if (!m_SourceMMLoaded)
+	{
+		if (error)
+		{
+			snprintf(error, maxlength, "Metamod attach failed");
+		}
+		return false;
+	}
+#endif
+	SM_GET_IFACE(SOURCEMOD, g_pSM);
+	smutils = g_pSM;
+#if defined SMEXT_ENABLE_HANDLESYS
+	SM_GET_IFACE(HANDLESYSTEM, g_pHandleSys);
+	handlesys = g_pHandleSys;
+#endif
+#if defined SMEXT_ENABLE_FORWARDSYS
+	SM_GET_IFACE(FORWARDMANAGER, g_pForwards);
+	forwards = g_pForwards;
+#endif
+#if defined SMEXT_ENABLE_PLAYERHELPERS
+	SM_GET_IFACE(PLAYERMANAGER, playerhelpers);
+#endif
+#if defined SMEXT_ENABLE_DBMANAGER
+	SM_GET_IFACE(DBI, dbi);
+#endif
+#if defined SMEXT_ENABLE_GAMECONF
+	SM_GET_IFACE(GAMECONFIG, gameconfs);
+#endif
+#if defined SMEXT_ENABLE_MEMUTILS
+	SM_GET_IFACE(MEMORYUTILS, memutils);
+#endif
+#if defined SMEXT_ENABLE_GAMEHELPERS
+	SM_GET_IFACE(GAMEHELPERS, gamehelpers);
+#endif
+#if defined SMEXT_ENABLE_TIMERSYS
+	SM_GET_IFACE(TIMERSYS, timersys);
+#endif
+#if defined SMEXT_ENABLE_ADTFACTORY
+	SM_GET_IFACE(ADTFACTORY, adtfactory);
+#endif
+#if defined SMEXT_ENABLE_THREADER
+	SM_GET_IFACE(THREADER, threader);
+#endif
+#if defined SMEXT_ENABLE_LIBSYS
+	SM_GET_IFACE(LIBRARYSYS, libsys);
+#endif
+#if defined SMEXT_ENABLE_PLUGINSYS
+	SM_GET_IFACE(PLUGINSYSTEM, plsys);
+#endif
+
+	if (SDK_OnLoad(error, maxlength, late))
+	{
+#if defined SMEXT_CONF_METAMOD
+		m_WeAreUnloaded = true;
+#endif
+		return true;
+	}
+
+	return false;
+}
+
+bool SDKExtension::IsMetamodExtension()
+{
+#if defined SMEXT_CONF_METAMOD
+	return true;
+#else
+	return false;
+#endif
+}
+
+void SDKExtension::OnExtensionPauseChange(bool state)
+{
+#if defined SMEXT_CONF_METAMOD
+	m_WeGotPauseChange = true;
+#endif
+	SDK_OnPauseChange(state);
+}
+
+void SDKExtension::OnExtensionsAllLoaded()
+{
+	SDK_OnAllLoaded();
+}
+
+void SDKExtension::OnExtensionUnload()
+{
+#if defined SMEXT_CONF_METAMOD
+	m_WeAreUnloaded = true;
+#endif
+	SDK_OnUnload();
+}
+
+const char *SDKExtension::GetExtensionAuthor()
+{
+	return SMEXT_CONF_AUTHOR;
+}
+
+const char *SDKExtension::GetExtensionDateString()
+{
+	return SMEXT_CONF_DATESTRING;
+}
+
+const char *SDKExtension::GetExtensionDescription()
+{
+	return SMEXT_CONF_DESCRIPTION;
+}
+
+const char *SDKExtension::GetExtensionVerString()
+{
+	return SMEXT_CONF_VERSION;
+}
+
+const char *SDKExtension::GetExtensionName()
+{
+	return SMEXT_CONF_NAME;
+}
+
+const char *SDKExtension::GetExtensionTag()
+{
+	return SMEXT_CONF_LOGTAG;
+}
+
+const char *SDKExtension::GetExtensionURL()
+{
+	return SMEXT_CONF_URL;
+}
+
+bool SDKExtension::SDK_OnLoad(char *error, size_t maxlength, bool late)
+{
+	return true;
+}
+
+void SDKExtension::SDK_OnUnload()
+{
+}
+
+void SDKExtension::SDK_OnPauseChange(bool paused)
+{
+}
+
+void SDKExtension::SDK_OnAllLoaded()
+{
+}
+
+#if defined SMEXT_CONF_METAMOD
+
+PluginId g_PLID = 0;						/**< Metamod plugin ID */
+ISmmPlugin *g_PLAPI = NULL;					/**< Metamod plugin API */
+SourceHook::ISourceHook *g_SHPtr = NULL;	/**< SourceHook pointer */
+ISmmAPI *g_SMAPI = NULL;					/**< SourceMM API pointer */
+
+IVEngineServer *engine = NULL;				/**< IVEngineServer pointer */
+IServerGameDLL *gamedll = NULL;				/**< IServerGameDLL pointer */
+
+/** Exposes the extension to Metamod */
+SMM_API void *PL_EXPOSURE(const char *name, int *code)
+{
+	if (name && !strcmp(name, METAMOD_PLAPI_NAME))
+	{
+		if (code)
+		{
+			*code = IFACE_OK;
+		}
+		return static_cast<void *>(g_pExtensionIface);
+	}
+
+	if (code)
+	{
+		*code = IFACE_FAILED;
+	}
+
+	return NULL;
+}
+
+bool SDKExtension::Load(PluginId id, ISmmAPI *ismm, char *error, size_t maxlen, bool late)
+{
+	PLUGIN_SAVEVARS();
+
+	GET_V_IFACE_ANY(GetServerFactory, gamedll, IServerGameDLL, INTERFACEVERSION_SERVERGAMEDLL);
+	GET_V_IFACE_CURRENT(GetEngineFactory, engine, IVEngineServer, INTERFACEVERSION_VENGINESERVER);
+
+	m_SourceMMLoaded = true;
+
+	return SDK_OnMetamodLoad(ismm, error, maxlen, late);
+}
+
+bool SDKExtension::Unload(char *error, size_t maxlen)
+{
+	if (!m_WeAreUnloaded)
+	{
+		if (error)
+		{
+			snprintf(error, maxlen, "This extension must be unloaded by SourceMod.");
+		}
+		return false;
+	}
+
+	return SDK_OnMetamodUnload(error, maxlen);
+}
+
+bool SDKExtension::Pause(char *error, size_t maxlen)
+{
+	if (!m_WeGotPauseChange)
+	{
+		if (error)
+		{
+			snprintf(error, maxlen, "This extension must be paused by SourceMod.");
+		}
+		return false;
+	}
+
+	m_WeGotPauseChange = false;
+
+	return SDK_OnMetamodPauseChange(true, error, maxlen);
+}
+
+bool SDKExtension::Unpause(char *error, size_t maxlen)
+{
+	if (!m_WeGotPauseChange)
+	{
+		if (error)
+		{
+			snprintf(error, maxlen, "This extension must be unpaused by SourceMod.");
+		}
+		return false;
+	}
+
+	m_WeGotPauseChange = false;
+
+	return SDK_OnMetamodPauseChange(false, error, maxlen);
+}
+
+const char *SDKExtension::GetAuthor()
+{
+	return GetExtensionAuthor();
+}
+
+const char *SDKExtension::GetDate()
+{
+	return GetExtensionDateString();
+}
+
+const char *SDKExtension::GetDescription()
+{
+	return GetExtensionDescription();
+}
+
+const char *SDKExtension::GetLicense()
+{
+	return SMEXT_CONF_LICENSE;
+}
+
+const char *SDKExtension::GetLogTag()
+{
+	return GetExtensionTag();
+}
+
+const char *SDKExtension::GetName()
+{
+	return GetExtensionName();
+}
+
+const char *SDKExtension::GetURL()
+{
+	return GetExtensionURL();
+}
+
+const char *SDKExtension::GetVersion()
+{
+	return GetExtensionVerString();
+}
+
+bool SDKExtension::SDK_OnMetamodLoad(ISmmAPI *ismm, char *error, size_t maxlength, bool late)
+{
+	return true;
+}
+
+bool SDKExtension::SDK_OnMetamodUnload(char *error, size_t maxlength)
+{
+	return true;
+}
+
+bool SDKExtension::SDK_OnMetamodPauseChange(bool paused, char *error, size_t maxlength)
+{
+	return true;
+}
+
+#endif
+
+/* Overload a few things to prevent libstdc++ linking */
+#if defined __linux__
+/*extern "C" void __cxa_pure_virtual(void)
+{
+}
+
+void *operator new(size_t size)
+{
+	return malloc(size);
+}
+
+void *operator new[](size_t size)
+{
+	return malloc(size);
+}
+
+void operator delete(void *ptr)
+{
+	free(ptr);
+}
+
+void operator delete[](void * ptr)
+{
+	free(ptr);
+}
+
+extern "C" void _ZSt17__throw_bad_allocv(void) {}*/
+#endif

sdk/smsdk_ext.h

@@ -0,0 +1,310 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod Base Extension Code
+ * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SOURCEMOD_EXTENSION_BASESDK_H_
+#define _INCLUDE_SOURCEMOD_EXTENSION_BASESDK_H_
+
+/**
+ * @file smsdk_ext.h
+ * @brief Contains wrappers for making Extensions easier to write.
+ */
+
+#include "sdk/smsdk_config.h"
+#include <IExtensionSys.h>
+#include <IHandleSys.h>
+#include <sp_vm_api.h>
+#include <sm_platform.h>
+#include <ISourceMod.h>
+#if defined SMEXT_ENABLE_FORWARDSYS
+#include <IForwardSys.h>
+#endif //SMEXT_ENABLE_FORWARDSYS
+#if defined SMEXT_ENABLE_PLAYERHELPERS
+#include <IPlayerHelpers.h>
+#endif //SMEXT_ENABLE_PlAYERHELPERS
+#if defined SMEXT_ENABLE_DBMANAGER
+#include <IDBDriver.h>
+#endif //SMEXT_ENABLE_DBMANAGER
+#if defined SMEXT_ENABLE_GAMECONF
+#include <IGameConfigs.h>
+#endif
+#if defined SMEXT_ENABLE_MEMUTILS
+#include <IMemoryUtils.h>
+#endif
+#if defined SMEXT_ENABLE_GAMEHELPERS
+#include <IGameHelpers.h>
+#endif
+#if defined SMEXT_ENABLE_TIMERSYS
+#include <ITimerSystem.h>
+#endif
+#if defined SMEXT_ENABLE_ADTFACTORY
+#include <IADTFactory.h>
+#endif
+#if defined SMEXT_ENABLE_THREADER
+#include <IThreader.h>
+#endif
+#if defined SMEXT_ENABLE_LIBSYS
+#include <ILibrarySys.h>
+#endif
+#if defined SMEXT_ENABLE_PLUGINSYS
+#include <IPluginSys.h>
+#endif
+
+#if defined SMEXT_CONF_METAMOD
+#include <ISmmPlugin.h>
+#include <eiface.h>
+#endif
+
+#if !defined METAMOD_PLAPI_VERSION
+#include <metamod_wrappers.h>
+#endif
+
+using namespace SourceMod;
+using namespace SourcePawn;
+
+class SDKExtension : 
+#if defined SMEXT_CONF_METAMOD
+	public ISmmPlugin,
+#endif
+	public IExtensionInterface
+{
+public:
+	/** Constructor */
+	SDKExtension();
+public:
+	/**
+	 * @brief This is called after the initial loading sequence has been processed.
+	 *
+	 * @param error		Error message buffer.
+	 * @param maxlength	Size of error message buffer.
+	 * @param late		Whether or not the module was loaded after map load.
+	 * @return			True to succeed loading, false to fail.
+	 */
+	virtual bool SDK_OnLoad(char *error, size_t maxlength, bool late);
+	
+	/**
+	 * @brief This is called right before the extension is unloaded.
+	 */
+	virtual void SDK_OnUnload();
+
+	/**
+	 * @brief This is called once all known extensions have been loaded.
+	 */
+	virtual void SDK_OnAllLoaded();
+
+	/**
+	 * @brief Called when the pause state is changed.
+	 */
+	virtual void SDK_OnPauseChange(bool paused);
+
+#if defined SMEXT_CONF_METAMOD
+	/**
+	 * @brief Called when Metamod is attached, before the extension version is called.
+	 *
+	 * @param error			Error buffer.
+	 * @param maxlength		Maximum size of error buffer.
+	 * @param late			Whether or not Metamod considers this a late load.
+	 * @return				True to succeed, false to fail.
+	 */
+	virtual bool SDK_OnMetamodLoad(ISmmAPI *ismm, char *error, size_t maxlength, bool late);
+
+	/**
+	 * @brief Called when Metamod is detaching, after the extension version is called.
+	 * NOTE: By default this is blocked unless sent from SourceMod.
+	 *
+	 * @param error			Error buffer.
+	 * @param maxlength		Maximum size of error buffer.
+	 * @return				True to succeed, false to fail.
+	 */
+	virtual bool SDK_OnMetamodUnload(char *error, size_t maxlength);
+
+	/**
+	 * @brief Called when Metamod's pause state is changing.
+	 * NOTE: By default this is blocked unless sent from SourceMod.
+	 *
+	 * @param paused		Pause state being set.
+	 * @param error			Error buffer.
+	 * @param maxlength		Maximum size of error buffer.
+	 * @return				True to succeed, false to fail.
+	 */
+	virtual bool SDK_OnMetamodPauseChange(bool paused, char *error, size_t maxlength);
+#endif
+
+public: //IExtensionInterface
+	virtual bool OnExtensionLoad(IExtension *me, IShareSys *sys, char *error, size_t maxlength, bool late);
+	virtual void OnExtensionUnload();
+	virtual void OnExtensionsAllLoaded();
+
+	/** Returns whether or not this is a Metamod-based extension */
+	virtual bool IsMetamodExtension();
+
+	/**
+	 * @brief Called when the pause state changes.
+	 * 
+	 * @param state			True if being paused, false if being unpaused.
+	 */
+	virtual void OnExtensionPauseChange(bool state);
+
+	/** Returns name */
+	virtual const char *GetExtensionName();
+	/** Returns URL */
+	virtual const char *GetExtensionURL();
+	/** Returns log tag */
+	virtual const char *GetExtensionTag();
+	/** Returns author */
+	virtual const char *GetExtensionAuthor();
+	/** Returns version string */
+	virtual const char *GetExtensionVerString();
+	/** Returns description string */
+	virtual const char *GetExtensionDescription();
+	/** Returns date string */
+	virtual const char *GetExtensionDateString();
+#if defined SMEXT_CONF_METAMOD
+public: //ISmmPlugin
+	/** Called when the extension is attached to Metamod. */
+	virtual bool Load(PluginId id, ISmmAPI *ismm, char *error, size_t maxlength, bool late);
+	/** Returns the author to MM */
+	virtual const char *GetAuthor();
+	/** Returns the name to MM */
+	virtual const char *GetName();
+	/** Returns the description to MM */
+	virtual const char *GetDescription();
+	/** Returns the URL to MM */
+	virtual const char *GetURL();
+	/** Returns the license to MM */
+	virtual const char *GetLicense();
+	/** Returns the version string to MM */
+	virtual const char *GetVersion();
+	/** Returns the date string to MM */
+	virtual const char *GetDate();
+	/** Returns the logtag to MM */
+	virtual const char *GetLogTag();
+	/** Called on unload */
+	virtual bool Unload(char *error, size_t maxlength);
+	/** Called on pause */
+	virtual bool Pause(char *error, size_t maxlength);
+	/** Called on unpause */
+	virtual bool Unpause(char *error, size_t maxlength);
+private:
+	bool m_SourceMMLoaded;
+	bool m_WeAreUnloaded;
+	bool m_WeGotPauseChange;
+#endif
+};
+
+extern SDKExtension *g_pExtensionIface;
+extern IExtension *myself;
+
+extern IShareSys *g_pShareSys;
+extern IShareSys *sharesys;				/* Note: Newer name */
+extern ISourceMod *g_pSM;
+extern ISourceMod *smutils;				/* Note: Newer name */
+
+/* Optional interfaces are below */
+#if defined SMEXT_ENABLE_FORWARDSYS
+extern IForwardManager *g_pForwards;
+extern IForwardManager *forwards;		/* Note: Newer name */
+#endif //SMEXT_ENABLE_FORWARDSYS
+#if defined SMEXT_ENABLE_HANDLESYS
+extern IHandleSys *g_pHandleSys;
+extern IHandleSys *handlesys;			/* Note: Newer name */
+#endif //SMEXT_ENABLE_HANDLESYS
+#if defined SMEXT_ENABLE_PLAYERHELPERS
+extern IPlayerManager *playerhelpers;
+#endif //SMEXT_ENABLE_PLAYERHELPERS
+#if defined SMEXT_ENABLE_DBMANAGER
+extern IDBManager *dbi;
+#endif //SMEXT_ENABLE_DBMANAGER
+#if defined SMEXT_ENABLE_GAMECONF
+extern IGameConfigManager *gameconfs;
+#endif //SMEXT_ENABLE_DBMANAGER
+#if defined SMEXT_ENABLE_MEMUTILS
+extern IMemoryUtils *memutils;
+#endif
+#if defined SMEXT_ENABLE_GAMEHELPERS
+extern IGameHelpers *gamehelpers;
+#endif
+#if defined SMEXT_ENABLE_TIMERSYS
+extern ITimerSystem *timersys;
+#endif
+#if defined SMEXT_ENABLE_ADTFACTORY
+extern IADTFactory *adtfactory;
+#endif
+#if defined SMEXT_ENABLE_THREADER
+extern IThreader *threader;
+#endif
+#if defined SMEXT_ENABLE_LIBSYS
+extern ILibrarySys *libsys;
+#endif
+#if defined SMEXT_ENABLE_PLUGINSYS
+extern SourceMod::IPluginManager *plsys;
+#endif
+
+#if defined SMEXT_CONF_METAMOD
+PLUGIN_GLOBALVARS();
+extern IVEngineServer *engine;
+extern IServerGameDLL *gamedll;
+#endif
+
+/** Creates a SourceMod interface macro pair */
+#define SM_MKIFACE(name) SMINTERFACE_##name##_NAME, SMINTERFACE_##name##_VERSION
+/** Automates retrieving SourceMod interfaces */
+#define SM_GET_IFACE(prefix, addr) \
+	if (!g_pShareSys->RequestInterface(SM_MKIFACE(prefix), myself, (SMInterface **)&addr)) \
+	{ \
+		if (error != NULL && maxlength) \
+		{ \
+			size_t len = snprintf(error, maxlength, "Could not find interface: %s", SMINTERFACE_##prefix##_NAME); \
+			if (len >= maxlength) \
+			{ \
+				error[maxlength - 1] = '\0'; \
+			} \
+		} \
+		return false; \
+	}
+/** Automates retrieving SourceMod interfaces when needed outside of SDK_OnLoad() */
+#define SM_GET_LATE_IFACE(prefix, addr) \
+	g_pShareSys->RequestInterface(SM_MKIFACE(prefix), myself, (SMInterface **)&addr)
+/** Validates a SourceMod interface pointer */
+#define SM_CHECK_IFACE(prefix, addr) \
+	if (!addr) \
+	{ \
+		if (error != NULL && maxlength) \
+		{ \
+			size_t len = snprintf(error, maxlength, "Could not find interface: %s", SMINTERFACE_##prefix##_NAME); \
+			if (len >= maxlength) \
+			{ \
+				error[maxlength - 1] = '\0'; \
+			} \
+		} \
+		return false; \
+	}
+
+#endif // _INCLUDE_SOURCEMOD_EXTENSION_BASESDK_H_

sm_ext_socket.kdevelop

@@ -0,0 +1,227 @@
+<?xml version = '1.0'?>
+<kdevelop>
+  <general>
+    <author>m,,,</author>
+    <email>m@mkpc</email>
+    <version>1</version>
+    <projectmanagement>KDevCustomProject</projectmanagement>
+    <primarylanguage>C++</primarylanguage>
+    <ignoreparts/>
+    <projectname>sm_ext_socket</projectname>
+    <projectdirectory>.</projectdirectory>
+    <absoluteprojectpath>false</absoluteprojectpath>
+    <description/>
+    <defaultencoding/>
+    <versioncontrol/>
+  </general>
+  <kdevcustomproject>
+    <run>
+      <directoryradio>executable</directoryradio>
+      <mainprogram>/home/m/git/sm-ext-socket</mainprogram>
+      <programargs/>
+      <globaldebugarguments/>
+      <globalcwd>/home/m/git/sm-ext-socket</globalcwd>
+      <useglobalprogram>false</useglobalprogram>
+      <terminal>false</terminal>
+      <autocompile>false</autocompile>
+      <autoinstall>false</autoinstall>
+      <autokdesu>false</autokdesu>
+      <envvars/>
+    </run>
+    <filetypes>
+      <filetype>*.java</filetype>
+      <filetype>*.h</filetype>
+      <filetype>*.H</filetype>
+      <filetype>*.hh</filetype>
+      <filetype>*.hxx</filetype>
+      <filetype>*.hpp</filetype>
+      <filetype>*.c</filetype>
+      <filetype>*.C</filetype>
+      <filetype>*.cc</filetype>
+      <filetype>*.cpp</filetype>
+      <filetype>*.c++</filetype>
+      <filetype>*.cxx</filetype>
+      <filetype>Makefile</filetype>
+      <filetype>CMakeLists.txt</filetype>
+      <filetype>*.sp</filetype>
+      <filetype>*.inc</filetype>
+    </filetypes>
+    <blacklist/>
+    <build>
+      <buildtool>make</buildtool>
+      <builddir/>
+    </build>
+    <other>
+      <prio>0</prio>
+      <otherbin/>
+      <defaulttarget/>
+      <otheroptions/>
+      <selectedenvironment>default</selectedenvironment>
+      <environments>
+        <default/>
+      </environments>
+    </other>
+    <make>
+      <abortonerror>false</abortonerror>
+      <numberofjobs>0</numberofjobs>
+      <prio>0</prio>
+      <dontact>false</dontact>
+      <makebin/>
+      <defaulttarget/>
+      <makeoptions/>
+      <selectedenvironment>default</selectedenvironment>
+      <environments>
+        <default/>
+      </environments>
+    </make>
+  </kdevcustomproject>
+  <kdevdebugger>
+    <general>
+      <dbgshell/>
+      <gdbpath/>
+      <configGdbScript/>
+      <runShellScript/>
+      <runGdbScript/>
+      <breakonloadinglibs>true</breakonloadinglibs>
+      <separatetty>false</separatetty>
+      <floatingtoolbar>false</floatingtoolbar>
+      <raiseGDBOnStart>false</raiseGDBOnStart>
+    </general>
+    <display>
+      <staticmembers>false</staticmembers>
+      <demanglenames>true</demanglenames>
+      <outputradix>10</outputradix>
+    </display>
+  </kdevdebugger>
+  <kdevdoctreeview>
+    <ignoretocs>
+      <toc>ada</toc>
+      <toc>ada_bugs_gcc</toc>
+      <toc>bash</toc>
+      <toc>bash_bugs</toc>
+      <toc>clanlib</toc>
+      <toc>fortran_bugs_gcc</toc>
+      <toc>gnome1</toc>
+      <toc>gnustep</toc>
+      <toc>gtk</toc>
+      <toc>gtk_bugs</toc>
+      <toc>haskell</toc>
+      <toc>haskell_bugs_ghc</toc>
+      <toc>java_bugs_gcc</toc>
+      <toc>java_bugs_sun</toc>
+      <toc>kde2book</toc>
+      <toc>opengl</toc>
+      <toc>pascal_bugs_fp</toc>
+      <toc>php</toc>
+      <toc>php_bugs</toc>
+      <toc>perl</toc>
+      <toc>perl_bugs</toc>
+      <toc>python</toc>
+      <toc>python_bugs</toc>
+      <toc>qt-kdev3</toc>
+      <toc>ruby</toc>
+      <toc>ruby_bugs</toc>
+      <toc>sdl</toc>
+      <toc>sw</toc>
+      <toc>w3c-dom-level2-html</toc>
+      <toc>w3c-svg</toc>
+      <toc>w3c-uaag10</toc>
+      <toc>wxwidgets_bugs</toc>
+    </ignoretocs>
+    <ignoreqt_xml>
+      <toc>Guide to the Qt Translation Tools</toc>
+      <toc>Qt Assistant Manual</toc>
+      <toc>Qt Designer Manual</toc>
+      <toc>Qt Reference Documentation</toc>
+      <toc>qmake User Guide</toc>
+    </ignoreqt_xml>
+    <ignoredoxygen>
+      <toc>KDE Libraries (Doxygen)</toc>
+    </ignoredoxygen>
+  </kdevdoctreeview>
+  <kdevfilecreate>
+    <filetypes/>
+    <useglobaltypes>
+      <type ext="ui" />
+      <type ext="cpp" />
+      <type ext="h" />
+    </useglobaltypes>
+  </kdevfilecreate>
+  <kdevcppsupport>
+    <qt>
+      <used>false</used>
+      <version>3</version>
+      <includestyle>3</includestyle>
+      <root>/usr/share/qt3</root>
+      <designerintegration>EmbeddedKDevDesigner</designerintegration>
+      <qmake>/usr/bin/qmake</qmake>
+      <designer>/usr/bin/designer</designer>
+      <designerpluginpaths/>
+    </qt>
+    <references/>
+    <codecompletion>
+      <automaticCodeCompletion>true</automaticCodeCompletion>
+      <automaticArgumentsHint>true</automaticArgumentsHint>
+      <automaticHeaderCompletion>true</automaticHeaderCompletion>
+      <codeCompletionDelay>250</codeCompletionDelay>
+      <argumentsHintDelay>400</argumentsHintDelay>
+      <headerCompletionDelay>250</headerCompletionDelay>
+      <showOnlyAccessibleItems>false</showOnlyAccessibleItems>
+      <completionBoxItemOrder>0</completionBoxItemOrder>
+      <howEvaluationContextMenu>true</howEvaluationContextMenu>
+      <showCommentWithArgumentHint>true</showCommentWithArgumentHint>
+      <statusBarTypeEvaluation>false</statusBarTypeEvaluation>
+      <namespaceAliases>std=_GLIBCXX_STD;__gnu_cxx=std</namespaceAliases>
+      <processPrimaryTypes>true</processPrimaryTypes>
+      <processFunctionArguments>false</processFunctionArguments>
+      <preProcessAllHeaders>true</preProcessAllHeaders>
+      <parseMissingHeadersExperimental>false</parseMissingHeadersExperimental>
+      <resolveIncludePathsUsingMakeExperimental>false</resolveIncludePathsUsingMakeExperimental>
+      <alwaysParseInBackground>true</alwaysParseInBackground>
+      <usePermanentCaching>true</usePermanentCaching>
+      <alwaysIncludeNamespaces>false</alwaysIncludeNamespaces>
+      <includePaths>.;</includePaths>
+    </codecompletion>
+    <creategettersetter>
+      <prefixGet/>
+      <prefixSet>set</prefixSet>
+      <prefixVariable>m_,_</prefixVariable>
+      <parameterName>theValue</parameterName>
+      <inlineGet>true</inlineGet>
+      <inlineSet>true</inlineSet>
+    </creategettersetter>
+    <splitheadersource>
+      <enabled>false</enabled>
+      <synchronize>true</synchronize>
+      <orientation>Vertical</orientation>
+    </splitheadersource>
+  </kdevcppsupport>
+  <kdevfileview>
+    <groups>
+      <hidenonprojectfiles>false</hidenonprojectfiles>
+      <hidenonlocation>false</hidenonlocation>
+    </groups>
+    <tree>
+      <hidepatterns>*.o,*.lo,CVS</hidepatterns>
+      <hidenonprojectfiles>false</hidenonprojectfiles>
+    </tree>
+  </kdevfileview>
+  <cppsupportpart>
+    <filetemplates>
+      <interfacesuffix>.h</interfacesuffix>
+      <implementationsuffix>.cpp</implementationsuffix>
+    </filetemplates>
+  </cppsupportpart>
+  <kdevdocumentation>
+    <projectdoc>
+      <docsystem/>
+      <docurl/>
+      <usermanualurl/>
+    </projectdoc>
+  </kdevdocumentation>
+  <ctagspart>
+    <customArguments/>
+    <customTagfilePath>/home/m/git/sm-ext-socket/tags</customTagfilePath>
+    <activeTagsFiles/>
+  </ctagspart>
+</kdevelop>

sm_ext_socket.kdevelop.filelist

@@ -0,0 +1,24 @@
+# KDevelop Custom Project File List
+Callback.cpp
+Callback.h
+CallbackHandler.cpp
+CallbackHandler.h
+Define.h
+Extension.cpp
+Extension.h
+Makefile
+Socket.cpp
+Socket.h
+SocketHandler.cpp
+SocketHandler.h
+examples
+examples/example.sp
+examples/listenexample.sp
+examples/selftest.sp
+examples/sendto_test.sp
+examples/sockettest.sp
+sdk
+sdk/smsdk_config.h
+sdk/smsdk_ext.cpp
+sdk/smsdk_ext.h
+socket.inc

socket.inc

@@ -0,0 +1,482 @@
+// socket extension include file
+
+#if defined _socket_included
+  #endinput
+#endif
+#define _socket_included
+#include <core>
+
+enum SocketType {
+	SOCKET_TCP = 1,
+	SOCKET_UDP,
+	SOCKET_RAW
+}
+
+#define EMPTY_HOST 1
+#define NO_HOST 2
+#define CONNECT_ERROR 3
+#define SEND_ERROR 4
+#define BIND_ERROR 5
+#define RECV_ERROR 6
+#define LISTEN_ERROR 7
+
+
+/*************************************************************************************************/
+/******************************************** options ********************************************/
+/*************************************************************************************************/
+
+
+/**
+ * Options available for SocketSetOption()
+ *
+ * @note modifying these options is not required for normal operation, you can skip the whole
+ *       section in most cases.
+ */
+enum SocketOption {
+/**
+ * If this option is set the socket extension will try to concatenate SocketReceive callbacks.
+ *
+ * This will possibly lower the amount of callbacks passed to SourceMod plugins and improve the
+ * performance. The socket extension will preserve the packet order.
+ *
+ * @note this doesn't prevent multiple callbacks, it only reduces them for high load.
+ * @note this will not truncate packets below 4096 bytes, setting it lower will be ignored
+ * @note set this option if you expect lots of data in a short timeframe
+ * @note don't forget to set your buffer sizes at least to the value passed to this function, but
+ *       always at least to 4096
+ *
+ * @param cell_t	0(=default) to disable or max. chunk size including \0 terminator in bytes
+ * @return bool true on success
+ */
+	ConcatenateCallbacks = 1,
+/**
+ * If this option is set the socket extension will enforce a mutex lock in the GameFrame() hook.
+ *
+ * This will ensure that callbacks will be processed every gameframe as fast as possible with the
+ * drawback of potentially creating lag. It's not recommended to set this option for most cases.
+ * If this option is not set the gameframe will be skipped if quietly obtaining a lock fails.
+ *
+ * @note combine this with CallbacksPerFrame for best performance
+ * @note this option will affect all sockets from all plugins, use it with caution!
+ *
+ * @param bool	whether to force locking or not
+ * @return bool true on success
+ */
+	ForceFrameLock,
+/**
+ * This will specify the maximum amount of callbacks processed in every gameframe.
+ *
+ * The default value for this option is 1, setting it higher will possibly increase networking
+ * performance but may cause lag if it's set too high.
+ * The amount of callbacks actually being processed is limited by not being able to quietly obtain
+ * a lock (see ForceFrameLock) and the amount of callbacks in the queue.
+ *
+ * @note this option will affect all sockets from all plugins, use it with caution!
+ *
+ * @param cell_t	maximum amount of callbacks per gameframe
+ * @return bool 	true on success
+ */
+	CallbacksPerFrame,
+/**
+ * If this option is set the socket will be allowed to send broadcast messages in case the protocol
+ * supports it. This is a wrapper for setting SO_BROADCAST.
+ *
+ * @param bool	whether to allow broadcasting or not
+ * @return bool true on success
+ */
+	SocketBroadcast,
+/**
+ * If this option is set SocketBind() will allow reusing local adresses in case the protocol
+ * supports it. This is a wrapper for setting SO_REUSEADDR.
+ *
+ * @param bool	whether to allow broadcasting or not
+ * @return bool true on success
+ */
+	SocketReuseAddr,
+/**
+ * If this option is set the socket will try to keep the connection alive by periodically sending
+ * messages if the protocol supports it. This is a wrapper for setting SO_KEEPALIVE.
+ *
+ * @param bool	whether to allow broadcasting or not
+ * @return bool true on success
+ */
+	SocketKeepAlive,
+/**
+ * This option specifies how long a socket will wait if it's being closed and its send buffer is
+ * still filled. This is a wrapper for setting SO_LINGER.
+ *
+ * @param cell_t	0 (=default) to disable or time in s
+ * @return bool		true on success
+ */
+	SocketLinger,
+/**
+ * If this option is set out-of-band data will be inlined into the normal receive stream. This is a
+ * wrapper for setting SO_OOBINLINE.
+ *
+ * @param bool	whether to inline out-of-band data or not
+ * @return bool true on success
+ */
+	SocketOOBInline,
+/**
+ * This option specifies how large the send buffer will be. This is a wrapper for setting
+ * SO_SNDBUF.
+ *
+ * @param cell_t	size in bytes
+ * @return bool		true on success
+ */
+	SocketSendBuffer,
+/**
+ * This option specifies how large the receive buffer will be. This is a wrapper for setting
+ * SO_RCVBUF.
+ *
+ * @param cell_t	size in bytes
+ * @return bool		true on success
+ */
+	SocketReceiveBuffer,
+/**
+ * If this option is set outgoing messages will ignore the default routing facilities if the
+ * protocol implementation supports it. The remote site should be directly connected to the sender.
+ * This is a wrapper for setting SO_DONTROUTE.
+ *
+ * @param bool	whether to skip default routing or not
+ * @return bool true on success
+ */
+	SocketDontRoute,
+/**
+ * This option specifies the minimum amount of data to receive before processing it. This is a
+ * wrapper for setting SO_RCVLOWAT.
+ *
+ * @note this can probably block the extension, use it with caution!
+ *
+ * @param cell_t	size in bytes
+ * @return bool		true on success
+ */
+	SocketReceiveLowWatermark,
+/**
+ * This option specifies how long a socket will try to receive data before it times out and
+ * processes the data. This is a wrapper for setting SO_RCVTIMEO.
+ *
+ * @param cell_t	0 (=default) to disable or time in ms
+ * @return bool		true on success
+ */
+	SocketReceiveTimeout,
+/**
+ * This option specifies the minimum amount of data required in the send buffer before starting to
+ * send it. This is a wrapper for setting SO_SNDLOWAT.
+ *
+ * @note this can probably block the extension, use it with caution!
+ *
+ * @param cell_t	size in bytes
+ * @return bool		true on success
+ */
+	SocketSendLowWatermark,
+/**
+ * This option specifies how long a socket will try to send data before it times out and
+ * retries it later. This is a wrapper for setting SO_SNDTIMEO.
+ *
+ * @param cell_t	0 (=default) to disable or time in ms
+ * @return bool		true on success
+ */
+	SocketSendTimeout,
+/**
+ * If this option is set the socket extension will display debugging messages in the server console/logs.
+ *
+ * @param bool	whether to enable debugging or not
+ * @return bool true on success
+ */
+ 	DebugMode
+}
+
+
+/*************************************************************************************************/
+/******************************************* callbacks *******************************************/
+/*************************************************************************************************/
+
+
+/**
+ * triggered if a normal sockets finished connecting and is ready to be used
+ *
+ * @param socket	The socket handle pointing to the calling socket
+ * @param arg		The argument set by SocketSetArg()
+ * @noreturn
+ */
+funcenum SocketConnectCB
+{
+    public(Handle:socket, any:arg)
+};
+
+/**
+ * triggered if a listening socket received an incoming connection and is ready to be used
+ *
+ * @note The child-socket won't work until receive-, disconnect-, and errorcallback for it are set.
+ *
+ * @param Handle	socket		The socket handle pointing to the calling listen-socket
+ * @param Handle	newSocket	The socket handle to the newly spawned child socket
+ * @param String	remoteIP	The remote IP
+ * @param any		arg			The argument set by SocketSetArg() for the listen-socket
+ * @noreturn
+ */
+funcenum SocketIncomingCB
+{
+    public(Handle:socket, Handle:newSocket, const String:remoteIP[], remotePort, any:arg)
+};
+
+/**
+ * triggered if a socket receives data
+ *
+ * @note This is binary safe if you always use dataSize for operations on receiveData[]
+ * @note packets may be split up into multiple chunks -> multiple calls to the receive callback
+ * @note if not set otherwise by SocketSetOption(..., ConcatenateCallbacks, ...) receiveData will
+ *       never be longer than 4096 characters including \0 terminator
+ *
+ * @param Handle	socket		The socket handle pointing to the calling socket
+ * @param String	receiveData	The data which arrived, 0-terminated at receiveData[dataSize]
+ * @param cell_t	dataSize	The length of the arrived data excluding the 0-termination
+ * @param any		arg			The argument set by SocketSetArg() for the socket
+ * @noreturn
+ */
+funcenum SocketReceiveCB
+{
+    public(Handle:socket, const String:receiveData[], const dataSize, any:arg)
+};
+
+/**
+ * called after a socket sent all items in its send queue successfully
+ *
+ * @param Handle	socket		The socket handle pointing to the calling socket
+ * @param any		arg			The argument set by SocketSetArg() for the socket
+ * @noreturn
+ */
+funcenum SocketSendqueueEmptyCB
+{
+    public(Handle:socket, any:arg)
+};
+
+/**
+ * called if a socket has been properly disconnected by the remote side
+ *
+ * @note You should call CloseHandle(socket) or reuse the socket before this function ends
+ *
+ * @param Handle	socket		The socket handle pointing to the calling socket
+ * @param any		arg			The argument set by SocketSetArg() for the socket
+ * @noreturn
+ */
+funcenum SocketDisconnectCB
+{
+    public(Handle:socket, any:arg)
+};
+
+/**
+ * called if an unrecoverable error occured, close the socket without an additional call to a disconnect callback
+ *
+ * @note You should call CloseHandle(socket) or reuse the socket before this function ends
+ *
+ * @param Handle	socket		The socket handle pointing to the calling socket
+ * @param cell_t	errorType	The error type, see defines above
+ * @param cell_t	errorNum	The errno, see errno.h for details
+ * @param any		arg			The argument set by SocketSetArg() for the socket
+ * @noreturn
+ */
+funcenum SocketErrorCB
+{
+    public(Handle:socket, const errorType, const errorNum, any:arg)
+};
+
+
+/*************************************************************************************************/
+/******************************************** natives ********************************************/
+/*************************************************************************************************/
+
+
+/**
+ * Returns whether a socket is connected or not.
+ *
+ * @param	socket	Socket handle to check
+ * @return	bool	The connection status
+ */
+native bool:SocketIsConnected(Handle:socket);
+
+
+/**
+ * Creates a new socket.
+ *
+ * @note this function may be relatively expensive, reuse sockets if possible
+ *
+ * @param SocketType	protocol	The protocol to use, SOCKET_TCP is default
+ * @param SocketErrorCB efunc		The error callback
+ * @return Handle					The socket handle. Returns INVALID_HANDLE on failure
+ */
+native Handle:SocketCreate(SocketType:protocol=SOCKET_TCP, SocketErrorCB:efunc);
+
+/**
+ * Binds the socket to a local address
+ *
+ * @param Handle	socket		The handle of the socket to be used.␍ * @param String	hostname	The hostname (or IP) to bind the socket to.
+ * @param cell_t	port		The port to bind the socket to.
+ * @return bool 				true on success
+ */
+native bool:SocketBind(Handle:socket, const String:hostname[], port);
+
+/**
+ * Connects a socket
+ *
+ * @note this native is threaded, it may be still running after it executed, use the connect callback
+ * @note invokes the SocketError callback with errorType = CONNECT_ERROR or EMPTY_HOST if it fails
+ * @note invokes the SocketConnect callback if it succeeds
+ *
+ * @param Handle				socket		The handle of the socket to be used.
+ * @param SocketConnectCB		cfunc		The connect callback
+ * @param SocketReceiveCB		rfunc		The receive callback
+ * @param SocketDisconnectCB	dfunc		The disconnect callback␍ * @param String				hostname	The hostname (or IP) to connect to.
+ * @param cell_t				port		The port to connect to.
+ * @noreturn
+ */
+native SocketConnect(Handle:socket, SocketConnectCB:cfunc, SocketReceiveCB:rfunc, SocketDisconnectCB:dfunc, const String:hostname[], port);
+
+/**
+ * Disconnects a socket
+ *
+ * @note this will not close the handle, the socket will be reset to a state similar to after SocketCreate()
+ * @note this won't trigger any disconnect/error callbacks
+ *
+ * @noreturn
+ */
+native bool:SocketDisconnect(Handle:socket);
+
+/**
+ * Makes a socket listen for incoming connections
+ *
+ * @param Handle			socket	The handle of the socket to be used.
+ * @param SocketIncomingCB	ifunc	The callback for incoming connections
+ * @return bool 					true on success
+ */
+native bool:SocketListen(Handle:socket, SocketIncomingCB:ifunc);
+
+/**
+ * Sends data through the socket.
+ *
+ * @note specify size for binary safe operation
+ * @note if size is not specified the \0 terminator will not be included
+ * @note This native is threaded, it may be still running after it executed (not atomic).
+ * @note Use the SendqueueEmpty callback to determine when all data has been successfully sent.
+ * @note The socket extension will ensure that the data will be send in the correct order and split
+ *			the data if required.
+ *
+ * @param Handle	socket	The handle of the socket to be used.
+ * @param String	data	The data to send.
+ * @noreturn␍ */
+native SocketSend(Handle:socket, const String:data[], size=-1);
+
+/**␍ * Sends UDP data through the socket to a specific destination.
+ *
+ * @note specify size for binary safe operation
+ * @note if size is not specified the \0 terminator will not be included
+ * @note This native is threaded, it may be still running after it executed (not atomic).
+ * @note Use the SendqueueEmpty callback to determine when all data has been successfully sent.
+ * @note The socket extension will ensure that the data will be send in the correct order and split
+ *			the data if required.
+ *
+ * @param Handle	socket	The handle of the socket to be used.
+ * @param String	data	The data to send.
+ * @param String	hostname	The hostname (or IP) to send to.
+ * @param cell_t	port		The port to send to.
+ * @noreturn␍ */
+native SocketSendTo(Handle:socket, const String:data[], size=-1, const String:hostname[], port);
+
+/**
+ * Set a socket option.
+ *
+ * @param Handle		socket	The handle of the socket to be used. May be INVALID_HANDLE if not essential.
+ * @param SocketOption	option	The option to modify (see enum SocketOption for details).
+ * @param cellt_		value	The value to set the option to.
+ * @return cell_t			1 on success.␍ */
+native SocketSetOption(Handle:socket, SocketOption:option, value);
+
+
+/**
+ * Defines the callback function for when the socket receives data
+ *
+ * @note this is only useful and required for child-sockets spawned by listen-sockets
+ *       (otherwise you already set it in SocketConnect())
+ *
+ * @param Handle			socket	The handle of the socket to be used.
+ * @param SocketReceiveCB	rfunc	The receive callback
+ * @noreturn
+ */
+native SocketSetReceiveCallback(Handle:socket, SocketReceiveCB:rfunc);
+
+/**
+ * Defines the callback function for when the socket sent all items in its send queue
+ *
+ * @note this must be called AFTER sending (queueing) the data
+ * @note if no send-data is queued this will fire the callback itself
+ * @note the callback is guaranteed to fire
+ *
+ * @param Handle				socket	The handle of the socket to be used.
+ * @param SocketDisconnectCB	dfunc	The disconnect callback
+ * @noreturn
+ */
+native SocketSetSendqueueEmptyCallback(Handle:socket, SocketSendqueueEmptyCB:sfunc);
+
+/**
+ * Defines the callback function for when the socket was properly disconnected by the remote side
+ *
+ * @note this is only useful and required for child-sockets spawned by listen-sockets
+ *       (otherwise you already set it in SocketConnect())
+ *
+ * @param Handle				socket	The handle of the socket to be used.
+ * @param SocketDisconnectCB	dfunc	The disconnect callback
+ * @noreturn
+ */
+native SocketSetDisconnectCallback(Handle:socket, SocketDisconnectCB:dfunc);
+
+/**
+ * Defines the callback function for when the socket triggered an error
+ *
+ * @note this is only useful and required for child-sockets spawned by listen-sockets
+ *       (otherwise you already set it in SocketCreate())
+ *
+ * @param Handle		socket	The handle of the socket to be used.
+ * @param SocketErrorCB efunc	The error callback
+ * @noreturn
+ */
+native SocketSetErrorCallback(Handle:socket, SocketErrorCB:efunc);
+
+
+/**
+ * Sets the argument being passed to callbacks
+ *
+ * @param Handle	socket	The handle of the socket to be used.
+ * @param any		arg		The argument to set
+ * @noreturn
+ */
+native SocketSetArg(Handle:socket, any:arg);
+
+/**
+ * Retrieve the local system's hostname as the command "hostname" does.
+ *
+ * @param dest    Destination string buffer to copy to.
+ * @param destLen Destination buffer length (includes null terminator).
+ *
+ * @return			1 on success
+ */
+native SocketGetHostName(String:dest[], destLen);
+
+/**
+ * _________________Do not edit below this line!_______________________
+ */
+public Extension:__ext_smsock = 
+{
+	name = "Socket",
+	file = "socket.ext",
+#if defined AUTOLOAD_EXTENSIONS
+	autoload = 1,
+#else
+	autoload = 0,
+#endif
+#if defined REQUIRE_EXTENSIONS
+	required = 1,
+#else
+	required = 0,
+#endif
+};