Epic commit to replace most of the strings in Anope with a single Anope::string class, plus some other little fixes here and there. If you follow 1.9.x development and are testing things, THIS is one of those things that NEEDS testing.

47 files changed, 1950 insertions, 3084 deletions

diff --git a/src/actions.cpp b/src/actions.cpp
index bff5b36fa..17c0a2898 100644
--- a/src/actions.cpp
+++ b/src/actions.cpp
@@ -48,18 +48,16 @@ bool bad_password(User *u)
  * @param reason for the kill
  * @return void
  */
-void kill_user(const std::string &source, const std::string &user, const std::string &reason)
+void kill_user(const Anope::string &source, const Anope::string &user, const Anope::string &reason)
 {
-	char buf[BUFSIZE];
-
 	if (user.empty())
 		return;
 
-	std::string real_source = source.empty() ? Config.ServerName : source;
+	Anope::string real_source = source.empty() ? Config.ServerName : source;
 
-	snprintf(buf, sizeof(buf), "%s (%s)", source.c_str(), reason.c_str());
+	Anope::string buf = real_source + " (" + reason + ")";
 
-	ircdproto->SendSVSKill(findbot(source), finduser(user), buf);
+	ircdproto->SendSVSKill(findbot(source), finduser(user), "%s", buf.c_str());
 
 	if (!ircd->quitonkill && finduser(user))
 		do_kill(user, buf);
@@ -73,9 +71,9 @@ void kill_user(const std::string &source, const std::string &user, const std::st
  * @param nick to remove the ban for
  * @return void
  */
-void common_unban(ChannelInfo *ci, const std::string &nick)
+void common_unban(ChannelInfo *ci, const Anope::string &nick)
 {
-	char *host = NULL;
+	Anope::string host;
 	uint32 ip = 0;
 	User *u;
 	Entry *ban, *next;
@@ -89,18 +87,18 @@ void common_unban(ChannelInfo *ci, const std::string &nick)
 	if (!ci->c->bans || !ci->c->bans->count)
 		return;
 
-	if (!u->hostip)
+	if (u->hostip.empty())
 	{
 		host = host_resolve(u->host);
 		/* we store the just resolved hostname so we don't
 		 * need to do this again */
-		if (host)
-			u->hostip = sstrdup(host);
+		if (!host.empty())
+			u->hostip = host;
 	}
 	else
-		host = sstrdup(u->hostip);
+		host = u->hostip;
 	/* Convert the host to an IP.. */
-	if (host)
+	if (!host.empty())
 		ip = str_is_ip(host);
 
 	if (ircd->svsmode_unban)
@@ -109,12 +107,9 @@ void common_unban(ChannelInfo *ci, const std::string &nick)
 		for (ban = ci->c->bans->entries; ban; ban = next)
 		{
 			next = ban->next;
-			if (entry_match(ban, u->nick.c_str(), u->GetIdent().c_str(), u->host, ip) || entry_match(ban, u->nick.c_str(), u->GetIdent().c_str(), u->GetDisplayedHost().c_str(), ip))
+			if (entry_match(ban, u->nick, u->GetIdent(), u->host, ip) || entry_match(ban, u->nick, u->GetIdent(), u->GetDisplayedHost(), ip))
 				ci->c->RemoveMode(NULL, CMODE_BAN, ban->mask);
 		}
-	/* host_resolve() sstrdup us this info so we gotta free it */
-	if (host)
-		delete [] host;
 }
 
 /*************************************************************************/
diff --git a/src/base64.cpp b/src/base64.cpp
index 2071ad40a..4f51eb5e8 100644
--- a/src/base64.cpp
+++ b/src/base64.cpp
@@ -9,31 +9,9 @@
  * Based on the original code of Services by Andy Church.
  */
 
-/*
-   This is borrowed from Unreal
-*/
-
 #include "services.h"
 
-static char *int_to_base64(long);
-static long base64_to_int(const char *);
-
-const char *base64enc(long i)
-{
-	if (i < 0)
-		return "0";
-	return int_to_base64(i);
-}
-
-long base64dec(const char *b64)
-{
-	if (b64)
-		return base64_to_int(b64);
-	else
-		return 0;
-}
-
-static const char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const Anope::string Base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static const char Pad64 = '=';
 
 /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
@@ -99,223 +77,97 @@ static const char Pad64 = '=';
 	   characters followed by one "=" padding character.
    */
 
-int b64_encode(const char *src, size_t srclength, char *target, size_t targsize)
+void b64_encode(const Anope::string &src, Anope::string &target)
 {
-	size_t datalength = 0;
+	size_t src_pos = 0, src_len = src.length();
 	unsigned char input[3];
-	unsigned char output[4];
-	size_t i;
-
-	while (srclength > 2)
-	{
-		input[0] = *src++;
-		input[1] = *src++;
-		input[2] = *src++;
-		srclength -= 3;
 
-		output[0] = input[0] >> 2;
-		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
-		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
-		output[3] = input[2] & 0x3f;
+	target.clear();
 
-		if (datalength + 4 > targsize)
-			return -1;
-		target[datalength++] = Base64[output[0]];
-		target[datalength++] = Base64[output[1]];
-		target[datalength++] = Base64[output[2]];
-		target[datalength++] = Base64[output[3]];
+	while (src_len - src_pos > 2)
+	{
+		input[0] = src[src_pos++];
+		input[1] = src[src_pos++];
+		input[2] = src[src_pos++];
+
+		target += Base64[input[0] >> 2];
+		target += Base64[((input[0] & 0x03) << 4) + (input[1] >> 4)];
+		target += Base64[((input[1] & 0x0f) << 2) + (input[2] >> 6)];
+		target += Base64[input[2] & 0x3f];
 	}
 
-	/* Now we worry about padding. */
-	if (srclength)
+	/* Now we worry about padding */
+	if (src_pos != src_len)
 	{
-		/* Get what's left. */
-		input[0] = input[1] = input[2] = '\0';
-		for (i = 0; i < srclength; ++i)
-			input[i] = *src++;
-
-		output[0] = input[0] >> 2;
-		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
-		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
-
-		if (datalength + 4 > targsize)
-			return -1;
-		target[datalength++] = Base64[output[0]];
-		target[datalength++] = Base64[output[1]];
-		if (srclength == 1)
-			target[datalength++] = Pad64;
+		input[0] = input[1] = input[2] = 0;
+		for (size_t i = 0; i < src_len - src_pos; ++i)
+			input[i] = src[src_pos + i];
+
+		target += Base64[input[0] >> 2];
+		target += Base64[((input[0] & 0x03) << 4) + (input[1] >> 4)];
+		if (src_pos == src_len - 1)
+			target += Pad64;
 		else
-			target[datalength++] = Base64[output[2]];
-		target[datalength++] = Pad64;
+			target += Base64[((input[1] & 0x0f) << 2) + (input[2] >> 6)];
+		target += Pad64;
 	}
-	if (datalength >= targsize)
-		return -1;
-	target[datalength] = '\0'; /* Returned value doesn't count \0. */
-	return datalength;
 }
 
 /* skips all whitespace anywhere.
    converts characters, four at a time, starting at (or after)
    src from base - 64 numbers into three 8 bit bytes in the target area.
-   it returns the number of data bytes stored at the target, or -1 on error.
  */
 
-int b64_decode(const char *src, char *target, size_t targsize)
+void b64_decode(const Anope::string &src, Anope::string &target)
 {
-	int tarindex, state, ch;
-	char *pos;
+	target.clear();
 
-	state = 0;
-	tarindex = 0;
-
-	while ((ch = *src++) != '\0')
+	unsigned state = 0;
+	Anope::string::const_iterator ch = src.begin(), end = src.end();
+	for (; ch != end; ++ch)
 	{
-		if (isspace(ch)) /* Skip whitespace anywhere. */
+		if (isspace(*ch)) /* Skip whitespace anywhere */
 			continue;
 
-		if (ch == Pad64)
+		if (*ch == Pad64)
 			break;
 
-		pos = const_cast<char *>(strchr(Base64, ch));
-		if (!pos) /* A non-base64 character. */
-			return -1;
+		size_t pos = Base64.find(*ch);
+		if (pos == Anope::string::npos) /* A non-base64 character */
+			return;
 
 		switch (state)
 		{
 			case 0:
-				if (target)
-				{
-					if (static_cast<size_t>(tarindex) >= targsize)
-						return -1;
-					target[tarindex] = (pos - Base64) << 2;
-				}
+				target += pos << 2;
 				state = 1;
 				break;
 			case 1:
-				if (target)
-				{
-					if (static_cast<size_t>(tarindex) + 1 >= targsize)
-						return -1;
-					target[tarindex] |= (pos - Base64) >> 4;
-					target[tarindex + 1] = ((pos - Base64) & 0x0f) << 4;
-				}
-				++tarindex;
+				target[target.length() - 1] |= pos >> 4;
+				target += (pos & 0x0f) << 4;
 				state = 2;
 				break;
 			case 2:
-				if (target)
-				{
-					if (static_cast<size_t>(tarindex) + 1 >= targsize)
-						return -1;
-					target[tarindex] |= (pos - Base64) >> 2;
-					target[tarindex + 1] = ((pos - Base64) & 0x03) << 6;
-				}
-				++tarindex;
+				target[target.length() - 1] |= pos >> 2;
+				target += (pos & 0x03) << 6;
 				state = 3;
 				break;
 			case 3:
-				if (target)
-				{
-					if (static_cast<size_t>(tarindex) >= targsize)
-						return -1;
-					target[tarindex] |= (pos - Base64);
-				}
-				++tarindex;
+				target[target.length() - 1] |= pos;
 				state = 0;
-				break;
-			default:
-				abort();
 		}
 	}
-
-	/*
-	 * We are done decoding Base-64 chars.  Let's see if we ended
-	 * on a byte boundary, and/or with erroneous trailing characters.
-	 */
-
-	if (ch == Pad64) /* We got a pad char. */
-	{
-		ch = *src++; /* Skip it, get next. */
-		switch (state)
-		{
-			case 0: /* Invalid = in first position */
-			case 1: /* Invalid = in second position */
-				return -1;
-
-			case 2: /* Valid, means one byte of info */
-				/* Skip any number of spaces. */
-				for (; ch != '\0'; ch = *src++)
-					if (!isspace(ch))
-						break;
-				/* Make sure there is another trailing = sign. */
-				if (ch != Pad64)
-					return -1;
-				ch = *src++; /* Skip the = */
-				/* Fall through to "single trailing =" case. */
-				/* FALLTHROUGH */
-
-			case 3: /* Valid, means two bytes of info */
-				/*
-				 * We know this char is an =.  Is there anything but
-				 * whitespace after it?
-				 */
-				for (; ch != '\0'; ch = *src++)
-					if (!isspace(ch))
-						return -1;
-
-				/*
-				 * Now make sure for cases 2 and 3 that the "extra"
-				 * bits that slopped past the last full byte were
-				 * zeros.  If we don't check them, they become a
-				 * subliminal channel.
-				 */
-				if (target && target[tarindex])
-					return -1;
-		}
-	}
-	else
-	{
-		/*
-		 * We ended by seeing the end of the string.  Make sure we
-		 * have no partial bytes lying around.
-		 */
-		if (state)
-			return -1;
-	}
-
-	return tarindex;
+	if (!target[target.length() - 1])
+		target.erase(target.length() - 1);
 }
 
-const char *encode_ip(unsigned char *ip)
+int decode_ip(const Anope::string &buf)
 {
-	static char buf[25];
-	unsigned char *cp;
-	struct in_addr ia;	/* For IPv4 */
-	char *s_ip;			/* Signed ip string */
-
-	if (!ip)
-		return "*";
+	int len = buf.length();
+	Anope::string targ;
 
-	if (strchr(reinterpret_cast<char *>(ip), ':'))
-		return NULL;
-	else
-	{
-		s_ip = str_signed(ip);
-		ia.s_addr = inet_addr(s_ip);
-		cp = reinterpret_cast<unsigned char *>(ia.s_addr);
-		b64_encode(reinterpret_cast<const char *>(&cp), sizeof(struct in_addr), buf, 25);
-	}
-	return buf;
-}
-
-int decode_ip(const char *buf)
-{
-	int len = strlen(buf);
-	char targ[25];
-	struct in_addr ia;
-
-	b64_decode(buf, targ, 25);
-	ia = *reinterpret_cast<struct in_addr *>(targ);
+	b64_decode(buf, targ);
+	const struct in_addr ia = *reinterpret_cast<const struct in_addr *>(targ.c_str());
 	if (len == 24) /* IPv6 */
 		return 0;
 	else if (len == 8) /* IPv4 */
@@ -323,91 +175,3 @@ int decode_ip(const char *buf)
 	else /* Error?? */
 		return 0;
 }
-
-/* ':' and '#' and '&' and '+' and '@' must never be in this table. */
-/* these tables must NEVER CHANGE! >) */
-char int6_to_base64_map[] = {
-	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
-	'E', 'F',
-	'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
-	'U', 'V',
-	'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
-	'k', 'l',
-	'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-	'{', '}'
-};
-
-char base64_to_int6_map[] = {
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
-	-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
-	25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
-	-1, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-	51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, -1, 63, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-};
-
-static char *int_to_base64(long val)
-{
-	/* 32/6 == max 6 bytes for representation,
-	 * +1 for the null, +1 for byte boundaries
-	 */
-	static char base64buf[8];
-	long i = 7;
-
-	base64buf[i] = '\0';
-
-	/* Temporary debugging code.. remove before 2038 ;p.
-	 * This might happen in case of 64bit longs (opteron/ia64),
-	 * if the value is then too large it can easily lead to
-	 * a buffer underflow and thus to a crash. -- Syzop
-	 */
-	if (val > 2147483647L)
-		abort();
-
-	do
-	{
-		base64buf[--i] = int6_to_base64_map[val & 63];
-	} while (val >>= 6);
-
-	return base64buf + i;
-}
-
-static long base64_to_int(const char *b64)
-{
-	int v = base64_to_int6_map[static_cast<const unsigned char>(*b64++)];
-
-	if (!b64)
-		return 0;
-
-	while (*b64)
-	{
-		v <<= 6;
-		v += base64_to_int6_map[static_cast<const unsigned char>(*b64++)];
-	}
-
-	return v;
-}
-
-long base64dects(const char *ts)
-{
-	if (!ts)
-		return 0;
-
-	char *token = myStrGetToken(ts, '!', 1);
-	if (!token)
-		return strtoul(ts, NULL, 10);
-
-	long value = base64dec(token);
-	delete [] token;
-	return value;
-}
diff --git a/src/bots.cpp b/src/bots.cpp
index 4114d4317..88b981dcc 100644
--- a/src/bots.cpp
+++ b/src/bots.cpp
@@ -20,32 +20,31 @@ BotInfo *MemoServ = NULL;
 BotInfo *NickServ = NULL;
 BotInfo *OperServ = NULL;
 
-BotInfo::BotInfo(const std::string &nnick, const std::string &nuser, const std::string &nhost, const std::string &nreal) : User(nnick, ts6_uid_retrieve())
+BotInfo::BotInfo(const Anope::string &nnick, const Anope::string &nuser, const Anope::string &nhost, const Anope::string &nreal) : User(nnick, ts6_uid_retrieve())
 {
 	this->ident = nuser;
-	this->host = sstrdup(nhost.c_str());
-	this->realname = sstrdup(nreal.c_str());
+	this->host = nhost;
+	this->realname = nreal;
 	this->server = Me;
 
 	this->lastmsg = this->created = time(NULL);
 
-	ci::string ci_nick(nnick.c_str());
-	if (Config.s_ChanServ && ci_nick == Config.s_ChanServ)
+	if (!Config.s_ChanServ.empty() && nnick.equals_ci(Config.s_ChanServ))
 		ChanServ = this;
-	else if (Config.s_BotServ && ci_nick == Config.s_BotServ)
+	else if (!Config.s_BotServ.empty() && nnick.equals_ci(Config.s_BotServ))
 		BotServ = this;
-	else if (Config.s_HostServ && ci_nick == Config.s_HostServ)
+	else if (!Config.s_HostServ.empty() && nnick.equals_ci(Config.s_HostServ))
 		HostServ = this;
-	else if (Config.s_OperServ && ci_nick == Config.s_OperServ)
+	else if (!Config.s_OperServ.empty() && nnick.equals_ci(Config.s_OperServ))
 		OperServ = this;
-	else if (Config.s_MemoServ && ci_nick == Config.s_MemoServ)
+	else if (!Config.s_MemoServ.empty() && nnick.equals_ci(Config.s_MemoServ))
 		MemoServ = this;
-	else if (Config.s_NickServ && ci_nick == Config.s_NickServ)
+	else if (!Config.s_NickServ.empty() && nnick.equals_ci(Config.s_NickServ))
 		NickServ = this;
-	else if (Config.s_GlobalNoticer && ci_nick == Config.s_GlobalNoticer)
+	else if (!Config.s_GlobalNoticer.empty() && nnick.equals_ci(Config.s_GlobalNoticer))
 		Global = this;
 
-	BotListByNick[this->nick.c_str()] = this;
+	BotListByNick[this->nick] = this;
 	if (!this->uid.empty())
 		BotListByUID[this->uid] = this;
 
@@ -53,7 +52,7 @@ BotInfo::BotInfo(const std::string &nnick, const std::string &nuser, const std::
 	if (Me && Me->GetUplink() && Me->GetUplink()->IsSynced())
 	{
 		ircdproto->SendClientIntroduction(this->nick, this->GetIdent(), this->host, this->realname, ircd->pseudoclient_mode, this->uid);
-		XLine x(this->nick.c_str(), "Reserved for services");
+		XLine x(this->nick, "Reserved for services");
 		ircdproto->SendSQLine(&x);
 	}
 }
@@ -68,21 +67,21 @@ BotInfo::~BotInfo()
 			ci->bi = NULL;
 	}
 
-	BotListByNick.erase(this->nick.c_str());
+	BotListByNick.erase(this->nick);
 	if (!this->uid.empty())
 		BotListByUID.erase(this->uid);
 }
 
 
-void BotInfo::SetNewNick(const std::string &newnick)
+void BotInfo::SetNewNick(const Anope::string &newnick)
 {
-	UserListByNick.erase(this->nick.c_str());
-	BotListByNick.erase(this->nick.c_str());
+	UserListByNick.erase(this->nick);
+	BotListByNick.erase(this->nick);
 
 	this->nick = newnick;
 
-	UserListByNick[this->nick.c_str()] = this;
-	BotListByNick[this->nick.c_str()] = this;
+	UserListByNick[this->nick] = this;
+	BotListByNick[this->nick] = this;
 }
 
 void BotInfo::RejoinAll()
@@ -142,14 +141,14 @@ void BotInfo::Join(Channel *c)
 			{
 				next = ban->next;
 
-				if (entry_match(ban, this->nick.c_str(), this->GetIdent().c_str(), this->host, 0))
+				if (entry_match(ban, this->nick, this->GetIdent(), this->host, 0))
 					c->RemoveMode(NULL, CMODE_BAN, ban->mask);
 			}
 
-			std::string Limit;
+			Anope::string Limit;
 			int limit = 0;
-			if (c->GetParam(CMODE_LIMIT, Limit))
-				limit = atoi(Limit.c_str());
+			if (c->GetParam(CMODE_LIMIT, Limit) && Limit.is_number_only())
+				limit = convertTo<int>(Limit);
 
 			/* Should we be invited? */
 			if (c->HasMode(CMODE_INVITE) || (limit && c->users.size() >= limit))
@@ -157,21 +156,21 @@ void BotInfo::Join(Channel *c)
 		}
 	}
 
-	ircdproto->SendJoin(this, c->name.c_str(), c->creation_time);
+	ircdproto->SendJoin(this, c->name, c->creation_time);
 	for (std::list<ChannelModeStatus *>::iterator it = BotModes.begin(), it_end = BotModes.end(); it != it_end; ++it)
 		c->SetMode(this, *it, this->nick, false);
 	c->JoinUser(this);
 	FOREACH_MOD(I_OnBotJoin, OnBotJoin(c->ci, this));
 }
 
-void BotInfo::Join(const std::string &chname)
+void BotInfo::Join(const Anope::string &chname)
 {
 	Channel *c = findchan(chname);
 	return this->Join(c ? c : new Channel(chname));
 }
 
-void BotInfo::Part(Channel *c, const std::string &reason)
+void BotInfo::Part(Channel *c, const Anope::string &reason)
 {
-	ircdproto->SendPart(this, c, !reason.empty() ? reason.c_str() : "");
+	ircdproto->SendPart(this, c, "%s", !reason.empty() ? reason.c_str() : "");
 	c->DeleteUser(this);
 }
diff --git a/src/botserv.cpp b/src/botserv.cpp
index 85f559f24..ae62e7e69 100644
--- a/src/botserv.cpp
+++ b/src/botserv.cpp
@@ -42,12 +42,12 @@ void get_botserv_stats(long *nrec, long *memuse)
 	{
 		BotInfo *bi = it->second;
 
-		count++;
+		++count;
 		mem += sizeof(*bi);
-		mem += bi->nick.size() + 1;
-		mem += bi->GetIdent().size() + 1;
-		mem += strlen(bi->host) + 1;
-		mem += strlen(bi->realname) + 1;
+		mem += bi->nick.length() + 1;
+		mem += bi->GetIdent().length() + 1;
+		mem += bi->host.length() + 1;
+		mem += bi->realname.length() + 1;
 	}
 
 	*nrec = count;
@@ -61,7 +61,7 @@ void get_botserv_stats(long *nrec, long *memuse)
 
 void bs_init()
 {
-	if (Config.s_BotServ)
+	if (!Config.s_BotServ.empty())
 		moduleAddBotServCmds();
 }
 
@@ -69,17 +69,17 @@ void bs_init()
 
 /* Main BotServ routine. */
 
-void botserv(User *u, BotInfo *bi, const std::string &buf)
+void botserv(User *u, BotInfo *bi, const Anope::string &buf)
 {
 	if (!u || !bi || buf.empty())
 		return;
 
-	if (buf.find("\1PING ", 0, 6) != std::string::npos && buf[buf.length() - 1] == '\1')
+	if (buf.substr(0, 6).equals_ci("\1PING ") && buf[buf.length() - 1] == '\1')
 	{
-		std::string command = buf;
+		Anope::string command = buf;
 		command.erase(command.begin());
 		command.erase(command.end());
-		ircdproto->SendCTCP(bi, u->nick.c_str(), "%s", command.c_str());
+		ircdproto->SendCTCP(bi, u->nick, "%s", command.c_str());
 	}
 	else
 		mod_run_cmd(bi, u, buf);
@@ -91,27 +91,27 @@ void botserv(User *u, BotInfo *bi, const std::string &buf)
  * bot is on.
  */
 
-void botchanmsgs(User *u, ChannelInfo *ci, const std::string &buf)
+void botchanmsgs(User *u, ChannelInfo *ci, const Anope::string &buf)
 {
 	if (!u || !ci || !ci->c || buf.empty())
 		return;
 
 	/* Answer to ping if needed */
-	if (buf.find("\1PING ", 0, 6) != std::string::npos && buf[buf.length() - 1] == '\1')
+	if (buf.substr(0, 6).equals_ci("\1PING ") && buf[buf.length() - 1] == '\1')
 	{
-		std::string ctcp = buf;
+		Anope::string ctcp = buf;
 		ctcp.erase(ctcp.begin());
 		ctcp.erase(ctcp.end());
-		ircdproto->SendCTCP(ci->bi, u->nick.c_str(), "%s", ctcp.c_str());
+		ircdproto->SendCTCP(ci->bi, u->nick, "%s", ctcp.c_str());
 	}
 
 	bool was_action = false;
-	std::string realbuf = buf;
+	Anope::string realbuf = buf;
 
 	/* If it's a /me, cut the CTCP part because the ACTION will cause
 	 * problems with the caps or badwords kicker
 	 */
-	if (realbuf.find("\1ACTION ", 0, 8) && realbuf[buf.length() - 1] == '\1')
+	if (!realbuf.substr(0, 8).equals_ci("\1ACTION ") && realbuf[buf.length() - 1] == '\1')
 	{
 		realbuf.erase(0, 8);
 		realbuf.erase(realbuf.end());
@@ -141,7 +141,7 @@ void botchanmsgs(User *u, ChannelInfo *ci, const std::string &buf)
 	if (!check_access(u, ci, CA_NOKICK) && Allow)
 	{
 		/* Bolds kicker */
-		if (ci->botflags.HasFlag(BS_KICK_BOLDS) && realbuf.find_first_of(2) != std::string::npos)
+		if (ci->botflags.HasFlag(BS_KICK_BOLDS) && realbuf.find(2) != Anope::string::npos)
 		{
 			check_ban(ci, u, TTB_BOLDS);
 			bot_kick(ci, u, BOT_REASON_BOLD);
@@ -149,7 +149,7 @@ void botchanmsgs(User *u, ChannelInfo *ci, const std::string &buf)
 		}
 
 		/* Color kicker */
-		if (ci->botflags.HasFlag(BS_KICK_COLORS) && realbuf.find_first_of(3) != std::string::npos)
+		if (ci->botflags.HasFlag(BS_KICK_COLORS) && realbuf.find(3) != Anope::string::npos)
 		{
 			check_ban(ci, u, TTB_COLORS);
 			bot_kick(ci, u, BOT_REASON_COLOR);
@@ -157,7 +157,7 @@ void botchanmsgs(User *u, ChannelInfo *ci, const std::string &buf)
 		}
 
 		/* Reverses kicker */
-		if (ci->botflags.HasFlag(BS_KICK_REVERSES) && realbuf.find_first_of(22) != std::string::npos)
+		if (ci->botflags.HasFlag(BS_KICK_REVERSES) && realbuf.find(22) != Anope::string::npos)
 		{
 			check_ban(ci, u, TTB_REVERSES);
 			bot_kick(ci, u, BOT_REASON_REVERSE);
@@ -165,7 +165,7 @@ void botchanmsgs(User *u, ChannelInfo *ci, const std::string &buf)
 		}
 
 		/* Underlines kicker */
-		if (ci->botflags.HasFlag(BS_KICK_UNDERLINES) && realbuf.find_first_of(31) != std::string::npos)
+		if (ci->botflags.HasFlag(BS_KICK_UNDERLINES) && realbuf.find(31) != Anope::string::npos)
 		{
 			check_ban(ci, u, TTB_UNDERLINES);
 			bot_kick(ci, u, BOT_REASON_UNDERLINE);
@@ -204,39 +204,32 @@ void botchanmsgs(User *u, ChannelInfo *ci, const std::string &buf)