Console initial implementation

common/CMakeLists.txt

@@ -73,6 +73,8 @@ SET(common_sources
 	platform.cpp
 	event/event_loop.cpp
 	json/jsoncpp.cpp
+	net/console_server.cpp
+	net/console_server_connection.cpp
 	net/crc32.cpp
 	net/daybreak_connection.cpp
 	net/eqstream.cpp
@@ -207,6 +209,8 @@ SET(common_headers
 	event/timer.h
 	json/json.h
 	json/json-forwards.h
+	net/console_server.h
+	net/console_server_connection.h
 	net/crc32.h
 	net/daybreak_connection.h
 	net/daybreak_structs.h
@@ -270,6 +274,10 @@ SOURCE_GROUP(Json FILES
 )
 
 SOURCE_GROUP(Net FILES
+	net/console_server.cpp
+	net/console_server.h
+	net/console_server_connection.cpp
+	net/console_server_connection.h
 	net/crc32.cpp
 	net/crc32.h
 	net/daybreak_connection.cpp

common/net/console_server.cpp

@@ -0,0 +1,78 @@
+#include "console_server.h"
+#include "../string_util.h"
+#include <fmt/format.h>
+
+EQ::Net::ConsoleServer::ConsoleServer(const std::string &addr, int port)
+{
+	m_server.reset(new EQ::Net::TCPServer());
+	m_server->Listen(addr, port, false, [this](std::shared_ptr<EQ::Net::TCPConnection> connection) {
+		ConsoleServerConnection *c = new ConsoleServerConnection(this, connection);
+		m_connections.insert(std::make_pair(c->GetUUID(), std::unique_ptr<ConsoleServerConnection>(c)));
+	});
+}
+
+EQ::Net::ConsoleServer::~ConsoleServer()
+{
+}
+
+void EQ::Net::ConsoleServer::RegisterCall(const std::string &command, int status_required, const std::string& help_definition, ConsoleServerCallback fn)
+{
+	m_commands[command] = { fn, status_required, help_definition };
+}
+
+void EQ::Net::ConsoleServer::RegisterLogin(ConsoleServerLoginCallback fn)
+{
+	m_login = fn;
+}
+
+void EQ::Net::ConsoleServer::ConnectionDisconnected(ConsoleServerConnection *c)
+{
+	auto iter = m_connections.find(c->GetUUID());
+	if (iter != m_connections.end()) {
+		m_connections.erase(iter);
+	}
+}
+
+void EQ::Net::ConsoleServer::ProcessCommand(ConsoleServerConnection *c, const std::string &cmd)
+{
+	auto split = SplitString(cmd, ' ');
+	
+	if (split.size() > 0) {
+		auto command = split[0];
+		ToLowerString(command);
+
+		if (command == "help" || command == "?") {
+			c->SendLine("Commands:");
+			for (auto &cmd_def : m_commands) {
+				if (cmd_def.second.status_required <= c->Admin()) {
+					auto display = fmt::format("  {0}", cmd_def.second.help_definition);
+					c->SendLine(display);
+				}
+			}
+
+			c->SendPrompt();
+			return;
+		}
+	
+		split.erase(split.begin(), split.begin() + 1);
+		
+		auto cmd_def = m_commands.find(command);
+		if (cmd_def != m_commands.end()) {
+			if (c->Admin() >= cmd_def->second.status_required) {
+				cmd_def->second.fn(c, command, split);
+				c->SendPrompt();
+			}
+			else {
+				c->SendLine(fmt::format("Access denied for command: {0}", command));
+				c->SendPrompt();
+			}
+		}
+		else {
+			c->SendLine(fmt::format("Command not found: {0}", command));
+			c->SendPrompt();
+		}
+	}
+	else {
+		c->SendPrompt();
+	}
+}

common/net/console_server.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "console_server_connection.h"
+#include <functional>
+#include <vector>
+
+namespace EQ
+{
+	namespace Net
+	{
+		struct ConsoleLoginStatus
+		{
+			int status;
+			int account_id;
+			std::string account_name;
+		};
+
+		class ConsoleServer
+		{
+		public:
+			typedef std::function<void(ConsoleServerConnection*, const std::string&, const std::vector<std::string>&)> ConsoleServerCallback;
+			typedef std::function<struct ConsoleLoginStatus(const std::string&, const std::string&)> ConsoleServerLoginCallback;
+			ConsoleServer(const std::string &addr, int port);
+			~ConsoleServer();
+
+			void RegisterCall(const std::string& command, int status_required, const std::string& help_definition, ConsoleServerCallback fn);
+			void RegisterLogin(ConsoleServerLoginCallback fn);
+
+		private:
+			void ConnectionDisconnected(ConsoleServerConnection *c);
+			void ProcessCommand(ConsoleServerConnection *c, const std::string& cmd);
+
+			std::unique_ptr<TCPServer> m_server;
+
+			std::map<std::string, std::unique_ptr<ConsoleServerConnection>> m_connections;
+
+			struct ConsoleServerCommand
+			{
+				ConsoleServerCallback fn;
+				int status_required;
+				std::string help_definition;
+			};
+
+			std::map<std::string, ConsoleServerCommand> m_commands;
+			ConsoleServerLoginCallback m_login;
+			friend class ConsoleServerConnection;
+		};
+	}
+}

common/net/console_server_connection.cpp

@@ -0,0 +1,221 @@
+#include "console_server.h"
+#include "../common/util/uuid.h"
+#include "../common/net/packet.h"
+#include "../common/eqemu_logsys.h"
+
+EQ::Net::ConsoleServerConnection::ConsoleServerConnection(ConsoleServer *parent, std::shared_ptr<TCPConnection> connection)
+{
+	m_parent = parent;
+	m_connection = connection;
+	m_uuid = EQ::Util::UUID::Generate().ToString();
+	m_cursor = 0;
+	memset(m_line, 0, MaxConsoleLineLength);
+	m_accept_messages = false;
+	m_user_id = 0;
+	m_admin = 0;
+
+	m_connection->OnRead(std::bind(&ConsoleServerConnection::OnRead, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+	m_connection->OnDisconnect(std::bind(&ConsoleServerConnection::OnDisconnect, this, std::placeholders::_1));
+	m_connection->Start();
+	ClearBuffer();
+	
+	auto addr = m_connection->RemoteIP();
+
+	SendLine(fmt::format("Establishing connection from: {0}:{1}", addr, m_connection->RemotePort()));
+
+	if (addr.find("127.0.0.1") != std::string::npos || addr.find("::0") != std::string::npos) {
+		SendLine("Connection established from localhost, assuming admin");
+		m_status = ConsoleStatusLoggedIn;
+		m_admin = 255;
+		SendPrompt();
+	}
+	else {
+		m_status = ConsoleStatusWaitingForLogin;
+		Send("Username: ");
+	}
+}
+
+EQ::Net::ConsoleServerConnection::~ConsoleServerConnection()
+{
+}
+
+void EQ::Net::ConsoleServerConnection::SendClear()
+{
+	EQ::Net::DynamicPacket clear;
+	clear.PutUInt8(0, 0);
+	m_connection->Write((const char*)clear.Data(), clear.Length());
+}
+
+void EQ::Net::ConsoleServerConnection::Send(const std::string &msg)
+{
+	m_connection->Write(msg.c_str(), msg.length());
+}
+
+void EQ::Net::ConsoleServerConnection::SendLine(const std::string &line)
+{
+	Send(line);
+	SendNewLine();
+}
+
+void EQ::Net::ConsoleServerConnection::SendNewLine()
+{
+	EQ::Net::DynamicPacket newline;
+	newline.PutUInt8(0, 10);
+	newline.PutUInt8(1, 13);
+	m_connection->Write((const char*)newline.Data(), newline.Length());
+}
+
+void EQ::Net::ConsoleServerConnection::QueueMessage(const std::string &msg)
+{
+	if (!m_accept_messages) {
+		return;
+	}
+
+	if (m_cursor == 0) {
+		size_t len = m_user.length() + 2;
+		for (size_t i = 0; i < len; ++i) {
+			Send("\x08");
+		}
+
+		SendLine(msg);
+		SendPrompt();
+	}
+	else {
+		std::string cmd(m_line, m_line + m_cursor);
+		
+		size_t len = m_user.length() + 2 + cmd.length();
+		for (size_t i = 0; i < len; ++i) {
+			Send("\x08");
+		}
+		
+		if (msg.length() < cmd.length()) {
+			Send(msg);
+			size_t blank_spaces = 2 + cmd.length() - msg.length();
+
+			for (size_t i = 0; i < blank_spaces; ++i) {
+				Send(" ");
+			}
+
+			SendNewLine();
+		}
+		else {
+			SendLine(msg);
+		}
+
+		SendPrompt();
+		Send(cmd);
+	}
+}
+
+void EQ::Net::ConsoleServerConnection::OnRead(TCPConnection *c, const unsigned char *data, size_t sz)
+{
+	for (size_t i = 0; i < sz; ++i) {
+		unsigned char c = data[i];
+
+		switch (c) {
+		case 0:
+			m_cursor = 0;
+			break;
+		case 10: // \n
+		{
+			if (m_cursor > 0) {
+				std::string cmd(m_line, m_line + m_cursor);
+				ProcessCommand(cmd);
+				m_cursor = 0;
+			}
+			else {
+				ProcessCommand("");
+			}
+		}
+			break;
+		case 13: // \r
+			break;
+		case 8:
+			if (m_cursor > 0) {
+				m_cursor--;
+			}
+			break;
+		case 255:
+			//255 is always followed by a character
+			i++;
+			if (i < sz) {
+				unsigned char c = data[i];
+
+				if (c == 255) {
+					//Escaped 255
+					if (m_cursor < MaxConsoleLineLength && isprint(c)) {
+						m_line[m_cursor] = c;
+						m_cursor++;
+					}
+
+					break;
+				}
+
+				if (c == 251 || c == 252 || c == 253 || c == 254) {
+					//Option code is always followed by an extra character
+
+					//We don't really care about negotiation tho.
+					i++;
+				}
+			}
+
+
+			break;
+		default:
+			if (m_cursor < MaxConsoleLineLength && isprint(c)) {
+				m_line[m_cursor] = c;
+				m_cursor++;
+			}
+
+			break;
+		}
+	}
+}
+
+void EQ::Net::ConsoleServerConnection::OnDisconnect(TCPConnection *c)
+{
+	m_parent->ConnectionDisconnected(this);
+}
+
+void EQ::Net::ConsoleServerConnection::ProcessCommand(const std::string &cmd)
+{
+	if (m_status == ConsoleStatusWaitingForLogin) {
+		m_user = cmd;
+		m_status = ConsoleStatusWaitingForPassword;
+		Send("Password: ");
+		return;
+	}
+
+	if (m_status == ConsoleStatusWaitingForPassword) {
+		auto status = m_parent->m_login(m_user, cmd);
+		if (status.account_id == 0) {
+			m_status = ConsoleStatusFailedLogin;
+			SendLine("Access denied");
+			m_connection->Disconnect();
+			return;
+		}
+
+		if (status.status < ConsoleLoginStatus) {
+			m_status = ConsoleStatusFailedLogin;
+			SendLine("Access denied");
+			m_connection->Disconnect();
+			return;
+		}
+
+		m_user = status.account_name;
+		m_user_id = status.account_id;
+		m_admin = status.status;
+		m_status = ConsoleStatusLoggedIn;
+		SendPrompt();
+		return;
+	}
+
+	if (m_status == ConsoleStatusLoggedIn) {
+		m_parent->ProcessCommand(this, cmd);
+	}
+}
+
+void EQ::Net::ConsoleServerConnection::SendPrompt()
+{
+	Send(fmt::format("{0}> ", m_user));
+}

common/net/console_server_connection.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "tcp_server.h"
+#include <memory>
+#include <map>
+
+namespace EQ
+{
+	namespace Net
+	{
+		enum ConsoleConnectionStatus
+		{
+			ConsoleStatusWaitingForLogin,
+			ConsoleStatusWaitingForPassword,
+			ConsoleStatusLoggedIn,
+			ConsoleStatusFailedLogin
+		};
+
+		const int MaxConsoleLineLength = 512;
+		const int ConsoleLoginStatus = 50;
+		class ConsoleServer;
+		class ConsoleServerConnection
+		{
+		public:
+			ConsoleServerConnection(ConsoleServer *parent, std::shared_ptr<TCPConnection> connection);
+			~ConsoleServerConnection();
+
+			std::string GetUUID() const { return m_uuid; }
+			void ClearBuffer() { m_cursor = 0; }
+			void Close() { m_connection->Disconnect(); }
+
+			void SendClear();
+			void Send(const std::string &msg);
+			void SendLine(const std::string &line);
+			void SendNewLine();
+			void SendPrompt();
+			ConsoleConnectionStatus Status() const { return m_status; }
+			std::string UserName() const { return m_user; }
+			int UserId() const { return m_user_id; }
+			int Admin() const { return m_admin; }
+
+			bool AcceptMessages() const { return m_accept_messages; }
+			void SetAcceptMessages(bool v) { m_accept_messages = v; }
+			void QueueMessage(const std::string &msg);
+		private:
+			void OnRead(TCPConnection* c, const unsigned char* data, size_t sz);
+			void OnDisconnect(TCPConnection* c);
+			void ProcessCommand(const std::string &cmd);
+
+			ConsoleServer *m_parent;
+			std::shared_ptr<TCPConnection> m_connection;
+			std::string m_uuid;
+			ConsoleConnectionStatus m_status;
+			std::string m_user;
+			int m_user_id;
+			int m_admin;
+			bool m_accept_messages;
+
+			size_t m_cursor;
+			char m_line[MaxConsoleLineLength];
+		};
+	}
+}

common/net/tcp_server.cpp

@@ -15,6 +15,16 @@ EQ::Net::TCPServer::~TCPServer() {
 }
 
 void EQ::Net::TCPServer::Listen(int port, bool ipv6, std::function<void(std::shared_ptr<TCPConnection>)> cb)
+{
+	if (ipv6) {
+		Listen("::", port, ipv6, cb);
+	}
+	else {
+		Listen("0.0.0.0", port, ipv6, cb);
+	}
+}
+
+void EQ::Net::TCPServer::Listen(const std::string &addr, int port, bool ipv6, std::function<void(std::shared_ptr<TCPConnection>)> cb)
 {
 	if (m_socket) {
 		return;
@@ -29,10 +39,10 @@ void EQ::Net::TCPServer::Listen(int port, bool ipv6, std::function<void(std::sha
 
 	sockaddr_storage iaddr;
 	if (ipv6) {
-		uv_ip6_addr("::", port, (sockaddr_in6*)&iaddr);
+		uv_ip6_addr(addr.c_str(), port, (sockaddr_in6*)&iaddr);
 	}
 	else {
-		uv_ip4_addr("0.0.0.0", port, (sockaddr_in*)&iaddr);
+		uv_ip4_addr(addr.c_str(), port, (sockaddr_in*)&iaddr);
 	}
 
 	uv_tcp_bind(m_socket, (sockaddr*)&iaddr, 0);

common/net/tcp_server.h

@@ -13,6 +13,7 @@ namespace EQ
 			~TCPServer();
 
 			void Listen(int port, bool ipv6, std::function<void(std::shared_ptr<TCPConnection>)> cb);
+			void Listen(const std::string &addr, int port, bool ipv6, std::function<void(std::shared_ptr<TCPConnection>)> cb);
 			void Close();
 			void AddClient(uv_tcp_t *c);
 

common/string_util.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "string_util.h"
+#include <algorithm>
 
 #ifdef _WINDOWS
 	#include <windows.h>
@@ -71,246 +72,6 @@ const std::string StringFormat(const char* format, ...)
 	return output;
 }
 
-// normal strncpy doesnt put a null term on copied strings, this one does
-// ref: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wcecrt/htm/_wcecrt_strncpy_wcsncpy.asp
-char* strn0cpy(char* dest, const char* source, uint32 size) {
-	if (!dest)
-		return 0;
-	if (size == 0 || source == 0) {
-		dest[0] = 0;
-		return dest;
-	}
-	strncpy(dest, source, size);
-	dest[size - 1] = 0;
-	return dest;
-}
-
-// String N w/null Copy Truncated?
-// return value =true if entire string(source) fit, false if it was truncated
-bool strn0cpyt(char* dest, const char* source, uint32 size) {
-	if (!dest)
-		return 0;
-	if (size == 0 || source == 0) {
-		dest[0] = 0;
-		return false;
-	}
-	strncpy(dest, source, size);
-	dest[size - 1] = 0;
-	return (bool) (source[strlen(dest)] == 0);
-}
-
-const char *MakeLowerString(const char *source) {
-	static char str[128];
-	if (!source)
-		return nullptr;
-	MakeLowerString(source, str);
-	return str;
-}
-
-void MakeLowerString(const char *source, char *target) {
-	if (!source || !target) {
-	*target=0;
-		return;
-	}
-	while (*source)
-	{
-		*target = tolower(*source);
-		target++;source++;
-	}
-	*target = 0;
-}
-
-int MakeAnyLenString(char** ret, const char* format, ...) {
-	int buf_len = 128;
-	int chars = -1;
-	va_list argptr, tmpargptr;
-	va_start(argptr, format);
-	while (chars == -1 || chars >= buf_len) {
-		safe_delete_array(*ret);
-		if (chars == -1)
-			buf_len *= 2;
-		else
-			buf_len = chars + 1;
-		*ret = new char[buf_len];
-		va_copy(tmpargptr, argptr);
-		chars = vsnprintf(*ret, buf_len, format, tmpargptr);
-	}
-	va_end(argptr);
-	return chars;
-}
-
-uint32 AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...) {
-	if (*bufsize == 0)
-		*bufsize = 256;
-	if (*ret == 0)
-		*strlen = 0;
-	int chars = -1;
-	char* oldret = 0;
-	va_list argptr, tmpargptr;
-	va_start(argptr, format);
-	while (chars == -1 || chars >= (int32)(*bufsize-*strlen)) {
-		if (chars == -1)
-			*bufsize += 256;
-		else
-			*bufsize += chars + 25;
-		oldret = *ret;
-		*ret = new char[*bufsize];
-		if (oldret) {
-			if (*strlen)
-				memcpy(*ret, oldret, *strlen);
-			safe_delete_array(oldret);
-		}
-		va_copy(tmpargptr, argptr);
-		chars = vsnprintf(&(*ret)[*strlen], (*bufsize-*strlen), format, tmpargptr);
-	}
-	va_end(argptr);
-	*strlen += chars;
-	return *strlen;
-}
-
-uint32 hextoi(const char* num) {
-	if (num == nullptr)
-		return 0;
-
-	int len = strlen(num);
-	if (len < 3)
-		return 0;
-
-	if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
-		return 0;
-
-	uint32 ret = 0;
-	int mul = 1;
-	for (int i=len-1; i>=2; i--) {
-		if (num[i] >= 'A' && num[i] <= 'F')
-			ret += ((num[i] - 'A') + 10) * mul;
-		else if (num[i] >= 'a' && num[i] <= 'f')
-			ret += ((num[i] - 'a') + 10) * mul;
-		else if (num[i] >= '0' && num[i] <= '9')
-			ret += (num[i] - '0') * mul;
-		else
-			return 0;
-		mul *= 16;
-	}
-	return ret;
-}
-
-uint64 hextoi64(const char* num) {
-	if (num == nullptr)
-		return 0;
-
-	int len = strlen(num);
-	if (len < 3)
-		return 0;
-
-	if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
-		return 0;
-
-	uint64 ret = 0;
-	int mul = 1;
-	for (int i=len-1; i>=2; i--) {
-		if (num[i] >= 'A' && num[i] <= 'F')
-			ret += ((num[i] - 'A') + 10) * mul;
-		else if (num[i] >= 'a' && num[i] <= 'f')
-			ret += ((num[i] - 'a') + 10) * mul;
-		else if (num[i] >= '0' && num[i] <= '9')
-			ret += (num[i] - '0') * mul;
-		else
-			return 0;
-		mul *= 16;
-	}
-	return ret;
-}
-
-bool atobool(const char* iBool) {
-
-	if (iBool == nullptr)
-		return false;
-	if (!strcasecmp(iBool, "true"))
-		return true;
-	if (!strcasecmp(iBool, "false"))
-		return false;
-	if (!strcasecmp(iBool, "yes"))
-		return true;
-	if (!strcasecmp(iBool, "no"))
-		return false;
-	if (!strcasecmp(iBool, "on"))
-		return true;
-	if (!strcasecmp(iBool, "off"))
-		return false;
-	if (!strcasecmp(iBool, "enable"))
-		return true;
-	if (!strcasecmp(iBool, "disable"))
-		return false;
-	if (!strcasecmp(iBool, "enabled"))
-		return true;
-	if (!strcasecmp(iBool, "disabled"))
-		return false;
-	if (!strcasecmp(iBool, "y"))
-		return true;
-	if (!strcasecmp(iBool, "n"))
-		return false;
-	if (atoi(iBool))
-		return true;
-	return false;
-}
-
-// removes the crap and turns the underscores into spaces.
-char *CleanMobName(const char *in, char *out)
-{
-	unsigned i, j;
-	
-	for(i = j = 0; i < strlen(in); i++)
-	{
-		// convert _ to space.. any other conversions like this?  I *think* this
-		// is the only non alpha char that's not stripped but converted.
-		if(in[i] == '_')
-		{
-			out[j++] = ' ';
-		}
-		else
-		{
-			if(isalpha(in[i]) || (in[i] == '`'))	// numbers, #, or any other crap just gets skipped
-				out[j++] = in[i];
-		}
-	}
-	out[j] = 0;	// terimnate the string before returning it
-	return out;
-}
-
-
-void RemoveApostrophes(std::string &s)
-{
-	for(unsigned int i = 0; i < s.length(); ++i)
-		if(s[i] == '\'')
-			 s[i] = '_';
-}
-
-char *RemoveApostrophes(const char *s)
-{
-	auto NewString = new char[strlen(s) + 1];
-
-	strcpy(NewString, s);
-
-	for(unsigned int i = 0 ; i < strlen(NewString); ++i)
-		if(NewString[i] == '\'')
-			 NewString[i] = '_';
-
-	return NewString;
-}
-
-const char *ConvertArray(int input, char *returnchar)
-{
-	sprintf(returnchar, "%i" ,input);
-	return returnchar;
-}
-
-const char *ConvertArrayF(float input, char *returnchar)
-{
-	sprintf(returnchar, "%0.2f", input);
-	return returnchar;
-}
-
 std::vector<std::string> SplitString(const std::string &str, char delim) {
 	std::vector<std::string> ret;
 	std::stringstream ss(str);
@@ -396,16 +157,35 @@ std::string EscapeString(const char *src, size_t sz) {
 	return ret;
 }
 
-bool isAlphaNumeric(const char *text)
-{
-	for (unsigned int charIndex=0; charIndex<strlen(text); charIndex++) {
-		if ((text[charIndex] < 'a' || text[charIndex] > 'z') &&
-			(text[charIndex] < 'A' || text[charIndex] > 'Z') &&
-			(text[charIndex] < '0' || text[charIndex] > '9'))
-			return false;
+bool StringIsNumber(const std::string &s) {
+	try {
+		auto r = stod(s);
+		return true;
+	}
+	catch (std::exception) {
+		return false;
+	}
+}
+
+void ToLowerString(std::string &s) {
+	std::transform(s.begin(), s.end(), s.begin(), ::tolower);
+}
+
+void ToUpperString(std::string &s) {
+	std::transform(s.begin(), s.end(), s.begin(), ::toupper);
+}
+
+std::string JoinString(const std::vector<std::string>& ar, const std::string &delim) {
+	std::string ret;
+	for (size_t i = 0; i < ar.size(); ++i) {
+		if (i != 0) {
+			ret += delim;
+		}
+
+		ret += ar[i];
 	}
 
-	return true;
+	return ret;
 }
 
 void find_replace(std::string& string_subject, const std::string& search_string, const std::string& replace_string) {
@@ -415,3 +195,257 @@ void find_replace(std::string& string_subject, const std::string& search_string,
 		index = string_subject.find_first_of(search_string);
 	}
 }
+
+//Const char based
+
+// normal strncpy doesnt put a null term on copied strings, this one does
+// ref: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wcecrt/htm/_wcecrt_strncpy_wcsncpy.asp
+char* strn0cpy(char* dest, const char* source, uint32 size) {
+	if (!dest)
+		return 0;
+	if (size == 0 || source == 0) {
+		dest[0] = 0;
+		return dest;
+	}
+	strncpy(dest, source, size);
+	dest[size - 1] = 0;
+	return dest;
+}
+
+// String N w/null Copy Truncated?
+// return value =true if entire string(source) fit, false if it was truncated
+bool strn0cpyt(char* dest, const char* source, uint32 size) {
+	if (!dest)
+		return 0;
+	if (size == 0 || source == 0) {
+		dest[0] = 0;
+		return false;
+	}
+	strncpy(dest, source, size);
+	dest[size - 1] = 0;
+	return (bool)(source[strlen(dest)] == 0);
+}
+
+const char *MakeLowerString(const char *source) {
+	static char str[128];
+	if (!source)
+		return nullptr;
+	MakeLowerString(source, str);
+	return str;
+}
+
+void MakeLowerString(const char *source, char *target) {
+	if (!source || !target) {
+		*target = 0;
+		return;
+	}
+	while (*source)
+	{
+		*target = tolower(*source);
+		target++; source++;
+	}
+	*target = 0;
+}
+
+int MakeAnyLenString(char** ret, const char* format, ...) {
+	int buf_len = 128;
+	int chars = -1;
+	va_list argptr, tmpargptr;
+	va_start(argptr, format);
+	while (chars == -1 || chars >= buf_len) {
+		safe_delete_array(*ret);
+		if (chars == -1)
+			buf_len *= 2;
+		else
+			buf_len = chars + 1;
+		*ret = new char[buf_len];
+		va_copy(tmpargptr, argptr);
+		chars = vsnprintf(*ret, buf_len, format, tmpargptr);
+	}
+	va_end(argptr);
+	return chars;
+}
+
+uint32 AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...) {
+	if (*bufsize == 0)
+		*bufsize = 256;
+	if (*ret == 0)
+		*strlen = 0;
+	int chars = -1;
+	char* oldret = 0;
+	va_list argptr, tmpargptr;
+	va_start(argptr, format);
+	while (chars == -1 || chars >= (int32)(*bufsize - *strlen)) {
+		if (chars == -1)
+			*bufsize += 256;
+		else
+			*bufsize += chars + 25;
+		oldret = *ret;
+		*ret = new char[*bufsize];
+		if (oldret) {
+			if (*strlen)
+				memcpy(*ret, oldret, *strlen);
+			safe_delete_array(oldret);
+		}
+		va_copy(tmpargptr, argptr);
+		chars = vsnprintf(&(*ret)[*strlen], (*bufsize - *strlen), format, tmpargptr);
+	}
+	va_end(argptr);
+	*strlen += chars;
+	return *strlen;
+}
+
+uint32 hextoi(const char* num) {
+	if (num == nullptr)
+		return 0;
+
+	int len = strlen(num);
+	if (len < 3)
+		return 0;
+
+	if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
+		return 0;
+
+	uint32 ret = 0;
+	int mul = 1;
+	for (int i = len - 1; i >= 2; i--) {
+		if (num[i] >= 'A' && num[i] <= 'F')
+			ret += ((num[i] - 'A') + 10) * mul;
+		else if (num[i] >= 'a' && num[i] <= 'f')
+			ret += ((num[i] - 'a') + 10) * mul;
+		else if (num[i] >= '0' && num[i] <= '9')
+			ret += (num[i] - '0') * mul;
+		else
+			return 0;
+		mul *= 16;
+	}
+	return ret;
+}
+
+uint64 hextoi64(const char* num) {
+	if (num == nullptr)
+		return 0;
+
+	int len = strlen(num);
+	if (len < 3)
+		return 0;
+
+	if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
+		return 0;
+
+	uint64 ret = 0;
+	int mul = 1;
+	for (int i = len - 1; i >= 2; i--) {
+		if (num[i] >= 'A' && num[i] <= 'F')
+			ret += ((num[i] - 'A') + 10) * mul;
+		else if (num[i] >= 'a' && num[i] <= 'f')
+			ret += ((num[i] - 'a') + 10) * mul;
+		else if (num[i] >= '0' && num[i] <= '9')
+			ret += (num[i] - '0') * mul;
+		else
+			return 0;
+		mul *= 16;
+	}
+	return ret;
+}
+
+bool atobool(const char* iBool) {
+
+	if (iBool == nullptr)
+		return false;
+	if (!strcasecmp(iBool, "true"))
+		return true;
+	if (!strcasecmp(iBool, "false"))
+		return false;
+	if (!strcasecmp(iBool, "yes"))
+		return true;
+	if (!strcasecmp(iBool, "no"))
+		return false;
+	if (!strcasecmp(iBool, "on"))
+		return true;
+	if (!strcasecmp(iBool, "off"))
+		return false;
+	if (!strcasecmp(iBool, "enable"))
+		return true;
+	if (!strcasecmp(iBool, "disable"))
+		return false;
+	if (!strcasecmp(iBool, "enabled"))
+		return true;
+	if (!strcasecmp(iBool, "disabled"))
+		return false;
+	if (!strcasecmp(iBool, "y"))
+		return true;
+	if (!strcasecmp(iBool, "n"))
+		return false;
+	if (atoi(iBool))
+		return true;
+	return false;
+}
+
+// removes the crap and turns the underscores into spaces.
+char *CleanMobName(const char *in, char *out)
+{
+	unsigned i, j;
+
+	for (i = j = 0; i < strlen(in); i++)
+	{
+		// convert _ to space.. any other conversions like this?  I *think* this
+		// is the only non alpha char that's not stripped but converted.
+		if (in[i] == '_')
+		{
+			out[j++] = ' ';
+		}
+		else
+		{
+			if (isalpha(in[i]) || (in[i] == '`'))	// numbers, #, or any other crap just gets skipped
+				out[j++] = in[i];
+		}
+	}
+	out[j] = 0;	// terimnate the string before returning it
+	return out;
+}
+
+
+void RemoveApostrophes(std::string &s)
+{
+	for (unsigned int i = 0; i < s.length(); ++i)
+		if (s[i] == '\'')
+			s[i] = '_';
+}
+
+char *RemoveApostrophes(const char *s)
+{
+	auto NewString = new char[strlen(s) + 1];
+
+	strcpy(NewString, s);
+
+	for (unsigned int i = 0; i < strlen(NewString); ++i)
+		if (NewString[i] == '\'')
+			NewString[i] = '_';
+
+	return NewString;
+}
+
+const char *ConvertArray(int input, char *returnchar)
+{
+	sprintf(returnchar, "%i", input);
+	return returnchar;
+}
+
+const char *ConvertArrayF(float input, char *returnchar)
+{
+	sprintf(returnchar, "%0.2f", input);
+	return returnchar;
+}
+
+bool isAlphaNumeric(const char *text)
+{
+	for (unsigned int charIndex = 0; charIndex<strlen(text); charIndex++) {
+		if ((text[charIndex] < 'a' || text[charIndex] > 'z') &&
+			(text[charIndex] < 'A' || text[charIndex] > 'Z') &&
+			(text[charIndex] < '0' || text[charIndex] > '9'))
+			return false;
+	}
+
+	return true;
+}

common/string_util.h

@@ -23,34 +23,34 @@
 
 #include "types.h"
 
+//std::string based
+const std::string StringFormat(const char* format, ...);
+const std::string vStringFormat(const char* format, va_list args);
+std::vector<std::string> SplitString(const std::string &s, char delim);
+std::string EscapeString(const char *src, size_t sz);
+std::string EscapeString(const std::string &s);
+bool StringIsNumber(const std::string &s);
+void ToLowerString(std::string &s);
+void ToUpperString(std::string &s);
+std::string JoinString(const std::vector<std::string>& ar, const std::string &delim);
+void find_replace(std::string& string_subject, const std::string& search_string, const std::string& replace_string);
+
+//const char based
+
 bool atobool(const char* iBool);
 bool isAlphaNumeric(const char *text);
 bool strn0cpyt(char* dest, const char* source, uint32 size);
-
 char *CleanMobName(const char *in, char *out);
 char *RemoveApostrophes(const char *s);
 char* strn0cpy(char* dest, const char* source, uint32 size);
-
 const char *ConvertArray(int input, char *returnchar);
 const char *ConvertArrayF(float input, char *returnchar);
 const char *MakeLowerString(const char *source);
-const std::string StringFormat(const char* format, ...);
-const std::string vStringFormat(const char* format, va_list args);
-
 int MakeAnyLenString(char** ret, const char* format, ...);
-
-std::string EscapeString(const char *src, size_t sz);
-std::string EscapeString(const std::string &s);
-
-std::vector<std::string> SplitString(const std::string &s, char delim);
-
 uint32 AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...);
 uint32 hextoi(const char* num);
-
 uint64 hextoi64(const char* num);
-
 void MakeLowerString(const char *source, char *target);
 void RemoveApostrophes(std::string &s);
-void find_replace(std::string& string_subject, const std::string& search_string, const std::string& replace_string);
 
 #endif