No OneTemporary
Actions

Authored By

Unknown

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/network/irc.cpp b/util/network/irc.cpp
	index 1c3b8ee9..a9fd1f11 100644
	--- a/util/network/irc.cpp
	+++ b/util/network/irc.cpp
	@@ -1,555 +1,555 @@
	#include "irc.h"

	#include "util/regex.h"

	#include <stdexcept>

	namespace Network{
	namespace IRC{

	static Command::Type convertCommand(const std::string & cmd){
	Command::Type command = Command::Unknown;
	if (cmd == "PASS"){
	command = Command::Pass;
	} else if (cmd == "NICK"){
	command = Command::Nick;
	} else if (cmd == "USER"){
	command = Command::User;
	} else if (cmd == "SERVER"){
	command = Command::Server;
	} else if (cmd == "OPER"){
	command = Command::Oper;
	} else if (cmd == "QUIT"){
	command = Command::Quit;
	} else if (cmd == "SQUIT"){
	command = Command::Squit;
	} else if (cmd == "JOIN"){
	command = Command::Join;
	} else if (cmd == "PART"){
	command = Command::Part;
	} else if (cmd == "MODE"){
	command = Command::Mode;
	} else if (cmd == "TOPIC"){
	command = Command::Topic;
	} else if (cmd == "NAMES"){
	command = Command::Names;
	} else if (cmd == "LIST"){
	command = Command::List;
	} else if (cmd == "INVITE"){
	command = Command::Invite;
	} else if (cmd == "KICK"){
	command = Command::Kick;
	} else if (cmd == "VERSION"){
	command = Command::Version;
	} else if (cmd == "STATS"){
	command = Command::Stats;
	} else if (cmd == "LINKS"){
	command = Command::Links;
	} else if (cmd == "TIME"){
	command = Command::Time;
	} else if (cmd == "CONNECT"){
	command = Command::Connect;
	} else if (cmd == "TRACE"){
	command = Command::Trace;
	} else if (cmd == "ADMIN"){
	command = Command::Admin;
	} else if (cmd == "INFO"){
	command = Command::Info;
	} else if (cmd == "PRIVMSG"){
	command = Command::PrivateMessage;
	} else if (cmd == "NOTICE"){
	command = Command::Notice;
	} else if (cmd == "WHO"){
	command = Command::Who;
	} else if (cmd == "WHOIS"){
	command = Command::Whois;
	} else if (cmd == "WHOWAS"){
	command = Command::Whowas;
	} else if (cmd == "KILL"){
	command = Command::Kill;
	} else if (cmd == "PING"){
	command = Command::Ping;
	} else if (cmd == "PONG"){
	command = Command::Pong;
	} else if (cmd == "ERROR"){
	command = Command::Error;
	} else if (cmd == "433"){
	command = Command::ErrorNickInUse;
	} else if (cmd == "401"){
	command = Command::ErrorNoSuchNick;
	} else if (cmd == "403"){
	command = Command::ErrorNoSuchChannel;
	} else if (cmd == "461"){
	command = Command::ErrorNeedMoreParams;
	} else if (cmd == "473"){
	command = Command::ErrorInviteOnlyChannel;
	} else if (cmd == "474"){
	command = Command::ErrorBannedFromChannel;
	} else if (cmd == "475"){
	command = Command::ErrorBadChannelKey;
	} else if (cmd == "471"){
	command = Command::ErrorChannelIsFull;
	} else if (cmd == "331"){
	command = Command::ReplyNoTopic;
	} else if (cmd == "332"){
	command = Command::ReplyTopic;
	} else if (cmd == "333"){
	command = Command::ReplyTopicAuthor;
	} else if (cmd == "353"){
	command = Command::ReplyNames;
	} else if (cmd == "366"){
	command = Command::ReplyNamesEndOf;
	} else if (cmd == "372"){
	command = Command::ReplyMOTD;
	} else if (cmd == "375"){
	command = Command::ReplyMOTDStart;
	} else if (cmd == "376"){
	command = Command::ReplyMOTDEndOf;
	}
	return command;

	}

	static std::string convertCommand(const Command::Type & cmd){
	switch (cmd){
	case Command::Pass: return "PASS";
	case Command::Nick: return "NICK";
	case Command::User: return "USER";
	case Command::Server: return "SERVER";
	case Command::Oper: return "OPER";
	case Command::Quit: return "QUIT";
	case Command::Squit: return "SQUIT";
	case Command::Join: return "JOIN";
	case Command::Part: return "PART";
	case Command::Mode: return "MODE";
	case Command::Topic: return "TOPIC";
	case Command::Names: return "NAMES";
	case Command::List: return "LIST";
	case Command::Invite: return "INVITE";
	case Command::Kick: return "KICK";
	case Command::Version: return "VERSION";
	case Command::Stats: return "STATS";
	case Command::Links: return "LINKS";
	case Command::Time: return "TIME";
	case Command::Connect: return "CONNECT";
	case Command::Trace: return "TRACE";
	case Command::Admin: return "ADMIN";
	case Command::Info: return "INFO";
	case Command::PrivateMessage: return "PRIVMSG";
	case Command::Notice: return "NOTICE";
	case Command::Who: return "WHO";
	case Command::Whois: return "WHOIS";
	case Command::Whowas: return "WHOAS";
	case Command::Kill: return "KILL";
	case Command::Ping: return "PING";
	case Command::Pong: return "PONG";
	case Command::Error: return "ERROR";
	case Command::Unknown:
	default:
	break;
	}

	return "";
	}

	static std::vector<std::string> split(std::string str, char splitter){
	std::vector<std::string> strings;
	size_t next = str.find(splitter);
	while (next != std::string::npos){
	strings.push_back(str.substr(0, next));
	str = str.substr(next+1);
	next = str.find(splitter);
	}
	if (str != ""){
	strings.push_back(str);
	}

	return strings;
	}

	Command::Command(const std::string & message){
	std::vector< std::string > messageSplit = split(message, ' ');
	std::vector< std::string >::iterator current = messageSplit.begin();
	if (Util::matchRegex(current, Util::Regex("^:."))){
	// Found owner (":") indicates the user, otherwise it's going to be the command
	// Grab just the username, ignore everything else
	try{
	owner = split(*current, '!').at(0).substr(1);
	} catch (const std::out_of_range & ex){
	}
	current++;
	}
	// Next is the actual command
	type = convertCommand(*current);
	if (type == Unknown){
	Global::debug(0) << "Got unhandled response: " << message << std::endl;
	}
	current++;
	// Parameters
	bool foundCtcp = false;
	bool concactenate = false;
	std::string concactenated;
	for (std::vector< std::string >::iterator i = current; i != messageSplit.end(); ++i){
	const std::string & parameter = *i;
	// If there is a colon in the parameter the rest of split string is the whole parameter rejoin
	if (Util::matchRegex(parameter, Util::Regex("^:\001.*")) && !foundCtcp){
	foundCtcp = true;
	// Drop the ':\001'
	ctcp.push_back(parameter.substr(2));
	continue;
	} else if (Util::matchRegex(parameter, Util::Regex(".*\001")) && foundCtcp){
	foundCtcp = false;
	// Drop the '\001'
	ctcp.push_back(parameter.substr(0, parameter.size()-1));
	continue;
	} else if (Util::matchRegex(parameter, Util::Regex("^:.*")) && !concactenate){
	concactenate = true;
	// Drop the ':'
	concactenated += parameter.substr(1) + " ";
	continue;
	} else if (Util::matchRegex(parameter, Util::Regex("=")) \|\|
	Util::matchRegex(parameter, Util::Regex("@"))){
	// Ignore
	continue;
	}
	if (concactenate){
	concactenated += parameter + " ";
	} else {
	if (!foundCtcp){
	parameters.push_back(parameter);
	} else {
	ctcp.push_back(parameter);
	}
	}
	}
	if (concactenate){
	parameters.push_back(concactenated);
	}
	}

	Command::Command(const std::string & owner, const Type & type):
	owner(owner),
	type(type){
	}

	Command::Command(const Command & copy):
	owner(copy.owner),
	type(copy.type),
	parameters(copy.parameters),
	ctcp(copy.ctcp){
	}

	Command::~Command(){
	}

	const Command & Command::operator=(const Command & copy){
	owner = copy.owner;
	type = copy.type;
	parameters = copy.parameters;
	ctcp = copy.ctcp;
	return *this;
	}

	std::string Command::getSendable() const {
	std::string sendable;
	// Name
	if (!owner.empty()){
	sendable += ":" + owner + " ";
	}
	// Command
	sendable += convertCommand(type) + " ";
	// Params
	/*for (std::vector<std::string>::const_iterator i = parameters.begin(); i != parameters.end(); ++i){
	sendable+= *i + " ";
	}*/
	for (unsigned int i = 0; i < parameters.size(); ++i){
	sendable += parameters[i] + (i < parameters.size()-1 ? " " : "");
	}
	// End
	sendable += "\r\n";
	return sendable;
	}

	Channel::Channel(){
	}

	Channel::Channel(const std::string & name):
	name(name){
	}

	Channel::Channel(const Channel & copy):
	name(copy.name),
	topic(copy.topic),
	topicAuthor(copy.topicAuthor),
	topicDate(copy.topicDate),
	users(copy.users){
	}

	Channel::~Channel(){
	}

	const Channel & Channel::operator=(const Channel & copy){
	name = copy.name;
	topic = copy.topic;
	topicAuthor = copy.topicAuthor;
	topicDate = copy.topicDate;
	users = copy.users;
	return *this;
	}

	void Channel::addUser(const std::string & user){
	// Can't add same user twice
	for (std::vector<std::string>::iterator i = users.begin(); i != users.end(); ++i){
	const std::string & name = *i;
	if (name == user){
	return;
	}
	}
	users.push_back(user);
	}

	void Channel::removeUser(const std::string & user){
	for (std::vector<std::string>::iterator i = users.begin(); i != users.end(); ++i){
	const std::string & name = *i;
	if (name == user){
	users.erase(i);
	break;
	}
	}
	}

	void Channel::addUsers(const std::vector<std::string> & list){
	for (std::vector<std::string>::const_iterator i = list.begin(); i != list.end(); ++i){
	const std::string & name = *i;
	addUser(name);
	}
	}

	Client::Client(const std::string & hostname, int port):
	previousUsername("AUTH"),
	username("AUTH"),
	previousChannel(0),
	currentChannel(0),
	hostname(hostname),
	port(port),
	end(false){
	}

	Client::~Client(){
	}

	void Client::connect(){
	if (username.empty()){
	throw NetworkException("Set username first.");
	}
	Global::debug(0) << "Connecting to " << hostname << " on port " << port << std::endl;
	- socket = Network::connect(hostname, port);
	+ socket = Network::connectReliable(hostname, port);
	start();
	setName("paintown-test");
	Command user("AUTH", Command::User);
	user.setParameters(username, "*", "0", ":auth");
	sendCommand(user);
	// ^^^^^^^^ Should get a response from this crap!
	joinChannel("#paintown");

	Global::debug(0) << "Connected" << std::endl;
	}



	bool Client::hasCommands() const{
	::Util::Thread::ScopedLock scope(lock);
	return !commands.empty();
	}

	Command Client::nextCommand() const {
	::Util::Thread::ScopedLock scope(lock);
	Command command = commands.front();
	commands.pop();
	return command;
	}

	void Client::sendCommand(const Command & command){
	const std::string & sendable = command.getSendable();
	Network::sendBytes(socket, (uint8_t *) sendable.c_str(), sendable.size());
	}

	void Client::sendCommand(const Command::Type & type){
	Command command(username, type);
	sendCommand(command);
	}

	void Client::sendCommand(const Command::Type & type, const std::string & param1){
	Command command(username, type);
	command.setParameters(param1);
	sendCommand(command);
	}

	void Client::sendCommand(const Command::Type & type, const std::string & param1, const std::string & param2){
	Command command(username, type);
	command.setParameters(param1, param2);
	sendCommand(command);
	}

	void Client::sendCommand(const Command::Type & type, const std::string & param1, const std::string & param2, const std::string & param3){
	Command command(username, type);
	command.setParameters(param1, param2, param3);
	sendCommand(command);
	}

	void Client::sendCommand(const Command::Type & type, const std::string & param1, const std::string & param2, const std::string & param3, const std::string & param4){
	Command command(username, type);
	command.setParameters(param1, param2, param3, param4);
	sendCommand(command);
	}

	void Client::setName(const std::string & name){
	previousUsername = username;
	// Update channel list
	//channel.removeUser(username);
	//channel.addUser(name);
	for (std::vector< ChannelPointer >::iterator i = activeChannels.begin(); i != activeChannels.end(); ++i){
	ChannelPointer activeChannel = *i;
	activeChannel->removeUser(username);
	activeChannel->addUser(name);
	}
	username = name;
	sendCommand(Command::Nick, name);
	}

	void Client::joinChannel(const std::string & chan){
	for (std::vector< ChannelPointer >::iterator i = activeChannels.begin(); i != activeChannels.end(); ++i){
	ChannelPointer activeChannel = *i;
	if (activeChannel->getName() == chan){
	// Already belonging to this channel
	return;
	}
	}
	previousChannel = currentChannel;
	ChannelPointer newChannel = ChannelPointer(new Channel(chan));
	/*if (!currentChannel.getName().empty()){
	sendCommand(Command::Part, currentChannel.getName());
	}*/
	activeChannels.push_back(newChannel);
	currentChannel = activeChannels.size()-1;
	sendCommand(Command::Join, getChannel()->getName());
	}

	void Client::removeChannel(const std::string & name){
	for (std::vector< ChannelPointer >::iterator i = activeChannels.begin(); i != activeChannels.end(); ++i){
	ChannelPointer activeChannel = *i;
	if (activeChannel->getName() == name){
	activeChannels.erase(i);
	return;
	}
	}
	}

	ChannelPointer Client::findChannel(const std::string & name){
	for (std::vector< ChannelPointer >::iterator i = activeChannels.begin(); i != activeChannels.end(); ++i){
	ChannelPointer activeChannel = *i;
	if (activeChannel->getName() == name){
	return activeChannel;
	}
	}
	return ChannelPointer(NULL);
	}

	void Client::sendMessage(const std::string & msg){
	sendCommand(Command::PrivateMessage, getChannel()->getName(), ":" + msg);
	}

	void Client::sendPong(const Command & ping){
	Command pong(username, Command::Pong);
	pong.setParameters(ping.getParameters());
	sendCommand(pong);
	}

	std::string Client::readMessage(){
	std::string received;
	bool foundReturn = false;
	while (true){
	try {
	char nextCharacter = Network::read8(socket);
	/* NOTE the latest RFC says that either \r or \n is the end of the message
	* http://www.irchelp.org/irchelp/rfc/chapter8.html
	*/
	if (nextCharacter == '\r'){
	// Found return
	foundReturn = true;
	continue;
	} else if ((nextCharacter == '\n') && foundReturn){
	// Should be the end of the message assuming \r is before it
	break;
	}
	received += nextCharacter;
	} catch (const Network::MessageEnd & ex){
	// end of message get out
	throw ex;
	}
	}
	//Global::debug(0) << "Read next string: " << received << std::endl;
	return received;
	}

	void Client::checkResponseAndHandle(const Command & command){
	// Checks for username or channel errors
	if (command.getType() == Command::ErrorNickInUse){
	::Util::Thread::ScopedLock scope(lock);
	// Change the username back to what it was
	getChannel()->removeUser(username);
	username = previousUsername;
	getChannel()->addUser(username);
	} else if (command.getType() == Command::ErrorBannedFromChannel \|\|
	command.getType() == Command::ErrorInviteOnlyChannel \|\|
	command.getType() == Command::ErrorBadChannelKey \|\|
	command.getType() == Command::ErrorChannelIsFull \|\|
	command.getType() == Command::ErrorNoSuchChannel){
	::Util::Thread::ScopedLock scope(lock);
	// Revert old channel
	removeChannel(getChannel()->getName());
	currentChannel = previousChannel;
	} else if (command.getType() == Command::ReplyTopic){
	::Util::Thread::ScopedLock scope(lock);
	// Set topic
	getChannel()->setTopic(command.getParameters().at(2));
	} else if (command.getType() == Command::ReplyTopicAuthor){
	::Util::Thread::ScopedLock scope(lock);
	// Set topic and author
	const std::vector<std::string> & params = command.getParameters();
	getChannel()->setTopicAuthor(split(params.at(1), '!').at(0), atoi(params.at(2).c_str()));
	} else if (command.getType() == Command::ReplyNames){
	// Add names
	const std::vector<std::string> & params = command.getParameters();
	//if (params.at(1) == currentChannel->getName()){
	const std::vector<std::string> & names = split(params.at(2), ' ');
	::Util::Thread::ScopedLock scope(lock);
	//currentChannel->addUsers(names);
	ChannelPointer update = findChannel(params.at(1));
	if (update != NULL){
	update->addUsers(names);
	}
	//}
	}
	}

	void Client::run(){
	while (!end){
	try {
	const std::string & message = readMessage();
	// Check if the message is empty it might be because of (\n)
	if (!message.empty()){
	Command command(message);
	::Util::Thread::ScopedLock scope(lock);
	checkResponseAndHandle(command);
	commands.push(command);
	} else {
	}
	} catch (const Network::MessageEnd & ex){
	end = true;
	}
	}
	}

	}
	}
	diff --git a/util/network/network.cpp b/util/network/network.cpp
	index 0f299c9f..1560aef0 100644
	--- a/util/network/network.cpp
	+++ b/util/network/network.cpp
	@@ -1,354 +1,371 @@
	#ifdef HAVE_NETWORKING
	#include "hawknl/nl.h"
	#endif
	#include "network.h"
	#include "util/debug.h"
	#include <string>
	#include <sstream>
	#include <string.h>
	#include "util/system.h"
	#include "util/compress.h"
	#include "util/thread.h"

	#ifdef HAVE_NETWORKING
	#ifdef WII
	#include <network.h>
	#elif defined(WINDOWS)
	#include <winsock.h>
	#else
	#include <arpa/inet.h>
	#endif
	#else
	#ifndef htonl
	#define htonl(x) x
	#endif
	#ifndef htons
	#define htons(x) x
	#endif
	#ifndef ntohl
	#define ntohl(x) x
	#endif
	#ifndef ntohs
	#define ntohs(x) x
	#endif
	#endif

	using namespace std;

	/* TODO: Wrap open_sockets with a mutex */
	namespace Network{

	NetworkException::~NetworkException() throw (){
	}

	MessageEnd::MessageEnd(){
	}

	InvalidPortException::InvalidPortException( int port, const string message ):
	NetworkException(""){
	ostringstream num;
	num << port;
	num << ". ";
	num << message;
	this->setMessage( "Invalid port " + num.str() );
	}

	/*
	template <typename M>
	int messageSize(const M& message);
	*/

	/*
	template <>
	int messageSize<Message>(Message const & message){
	return message.size();
	}

	template <>
	int messageSize<Message>(Message const & message){
	return message->size();
	}
	*/
	/*
	template <class M>
	uint8_t * messageDump(const M& message, uint8_t * buffer);

	template <>
	uint8_t * messageDump<Message>(const Message & message, uint8_t * buffer){
	return message.dump(buffer);
	}

	template <>
	uint8_t * messageDump<Message>(Message const & message, uint8_t * buffer){
	return message->dump(buffer);
	}
	*/

	#ifdef HAVE_NETWORKING

	static string getHawkError(){
	return string(" HawkNL error: '") +
	string(nlGetErrorStr(nlGetError())) +
	string("' HawkNL system error: '") +
	string(nlGetSystemErrorStr(nlGetSystemError()));
	}

	template<typename X>
	static X readX(Socket socket){
	X data;
	readBytes(socket, (uint8_t*) &data, sizeof(X));
	return data;
	}

	int8_t read8(Socket socket){
	return readX<uint8_t>(socket);
	}

	int16_t read16(Socket socket){
	return ntohs(readX<uint16_t>(socket));
	}

	int32_t read32(Socket socket){
	return ntohl(readX<uint32_t>(socket));
	}

	void send16(Socket socket, int16_t bytes){
	bytes = htons(bytes);
	sendBytes(socket, (uint8_t *) &bytes, sizeof(bytes));
	}

	char * dump16(char * where, int16_t bytes){
	bytes = htons(bytes);
	(uint16_t) where = bytes;
	return where + sizeof(uint16_t);
	}

	char * parse16(char * where, uint16_t * out){
	out = ntohs((uint16_t*) where);
	return where + sizeof(uint16_t);
	}

	char * parseString(char * where, string * out, uint16_t length){
	*out = string(where);
	return where + length;
	}

	char * dumpStr(char * where, const std::string & str){
	memcpy(where, str.c_str(), str.size() + 1);
	return where + str.size() + 1;
	}

	string readStr(Socket socket, const uint16_t length){
	char buffer[length + 1];
	NLint bytes = nlRead(socket, buffer, length);
	if (bytes == NL_INVALID){
	throw NetworkException(string("Could not read string.") + getHawkError());
	}
	buffer[length] = 0;
	bytes += 1;
	return string(buffer);
	}

	void sendStr(Socket socket, const string & str){
	if (nlWrite(socket, str.c_str(), str.length() + 1) != (signed)(str.length() + 1)){
	throw NetworkException( string("Could not write string.") + getHawkError() );
	}
	}

	void sendBytes(Socket socket, const uint8_t * data, int length){
	const uint8_t * position = data;
	int written = 0;
	while ( written < length ){
	int bytes = nlWrite(socket, position, length - written);
	if (bytes == NL_INVALID){
	throw NetworkException(string("Could not send bytes.") + getHawkError());
	}
	written += bytes;
	position += bytes;
	}
	}

	void readBytes(Socket socket, uint8_t * data, int length){
	uint8_t * position = data;
	int read = 0;
	while (read < length){
	int bytes = nlRead(socket, position, length - read);
	if (bytes == NL_INVALID){
	switch (nlGetError()){
	case NL_MESSAGE_END : throw MessageEnd();
	default : throw NetworkException(string("Could not read bytes.") + getHawkError());
	}
	}
	read += bytes;
	position += bytes;
	}
	}

	Util::Thread::Lock socketsLock;

	Socket openReliable(int port){
	// NLsocket server = nlOpen( port, NL_RELIABLE_PACKETS );
	Global::debug(1, "network") << "Attemping to open reliable port " << port << endl;
	Socket server = nlOpen(port, NL_RELIABLE);
	/* server will either be NL_INVALID (-1) or some low integer. hawknl
	* sockets are mapped internally to real sockets, so don't be surprised
	* if you get a socket back like 0.
	*/
	if (server == NL_INVALID){
	throw InvalidPortException(port, nlGetSystemErrorStr(nlGetSystemError()));
	}
	Global::debug(1, "network") << "Successfully opened a socket: " << server << endl;
	Util::Thread::acquireLock(&socketsLock);
	open_sockets.push_back(server);
	Util::Thread::releaseLock(&socketsLock);
	return server;
	}

	Socket openUnreliable(int port){
	// NLsocket server = nlOpen( port, NL_RELIABLE_PACKETS );
	Global::debug(1, "network") << "Attemping to open unreliable port " << port << endl;
	Socket server = nlOpen(port, NL_UNRELIABLE);
	/* server will either be NL_INVALID (-1) or some low integer. hawknl
	* sockets are mapped internally to real sockets, so don't be surprised
	* if you get a socket back like 0.
	*/
	if (server == NL_INVALID){
	throw InvalidPortException(port, nlGetSystemErrorStr(nlGetSystemError()));
	}
	Global::debug(1, "network") << "Successfully opened a socket: " << server << endl;
	Util::Thread::acquireLock(&socketsLock);
	open_sockets.push_back(server);
	Util::Thread::releaseLock(&socketsLock);
	return server;
	}

	-Socket connect(string server, int port) throw (NetworkException){
	+Socket connectReliable(string server, int port){
	NLaddress address;
	nlGetAddrFromName(server.c_str(), &address);
	nlSetAddrPort(&address, port);
	/* The port that this socket has opened will be immediately rebound to some
	* other port by sock_connect, but we still need to call openReliable to get
	* an NL_RELIABLE socket.
	*/
	Socket socket = openReliable(0);
	if (nlConnect(socket, &address) == NL_FALSE){
	close(socket);
	throw NetworkException("Could not connect");
	}
	return socket;
	}

	+Socket connectUnReliable(string server, int port){
	+ NLaddress address;
	+ nlGetAddrFromName(server.c_str(), &address);
	+ nlSetAddrPort(&address, port);
	+ /* The port that this socket has opened will be immediately rebound to some
	+ * other port by sock_connect, but we still need to call openReliable to get
	+ * an NL_RELIABLE socket.
	+ */
	+ Socket socket = openUnreliable(0);
	+ if (nlConnect(socket, &address) == NL_FALSE){
	+ close(socket);
	+ throw NetworkException("Could not connect");
	+ }
	+ return socket;
	+}
	+
	+
	void close(Socket s){
	Util::Thread::acquireLock(&socketsLock);
	for (vector< Socket >::iterator it = open_sockets.begin(); it != open_sockets.end(); ){
	if ( *it == s ){
	Global::debug(1, "network") << "Closing socket " << s << endl;
	nlClose(*it);
	Global::debug(1, "network") << "Closed" << endl;
	it = open_sockets.erase(it);
	} else {
	it++;
	}
	}
	Util::Thread::releaseLock(&socketsLock);
	}

	void closeAll(){
	Global::debug(1, "network") << "Closing all sockets" << std::endl;
	Util::Thread::acquireLock(&socketsLock);
	for (vector<Socket>::iterator it = open_sockets.begin(); it != open_sockets.end(); it++ ){
	nlClose(*it);
	}
	open_sockets.clear();
	Util::Thread::releaseLock(&socketsLock);
	}

	void init(){
	nlInit();
	nlSelectNetwork(NL_IP);
	nlEnable(NL_BLOCKING_IO);
	Util::Thread::initializeLock(&socketsLock);
	// nlDisable( NL_BLOCKING_IO );
	}

	bool blocking(Socket s, bool b){
	return nlSetSocketOpt(s, NL_BLOCKING_IO, b) == NL_TRUE;
	}

	void blocking(bool b){
	if (b){
	nlEnable(NL_BLOCKING_IO);
	} else {
	nlDisable(NL_BLOCKING_IO);
	}
	}

	bool noDelay(Socket s, bool b){
	return nlSetSocketOpt(s, NL_TCP_NO_DELAY, b) == NL_TRUE;
	}

	void listen( Socket s ) throw( NetworkException ){
	if ( nlListen( s ) == NL_FALSE ){
	throw CannotListenException( string(nlGetSystemErrorStr( nlGetSystemError() )) );
	}
	}

	Socket accept( Socket s ) throw( NetworkException ){
	Socket connection = nlAcceptConnection( s );
	if ( connection == NL_INVALID ){
	/*
	if ( nlGetError() == NL_NO_PENDING ){
	error = NO_CONNECTIONS_PENDING;
	} else {
	error = NETWORK_ERROR;
	}
	return s;
	*/
	if ( nlGetError() == NL_NO_PENDING ){
	throw NoConnectionsPendingException();
	}
	throw NetworkException("Could not accept connection");
	}
	Util::Thread::acquireLock(&socketsLock);
	open_sockets.push_back(connection);
	Util::Thread::releaseLock(&socketsLock);
	return connection;
	}

	void shutdown(){
	nlShutdown();
	}

	#else

	/* Dummy implementations */
	char * dump16(char * where, int16_t length){
	return where;
	}

	int8_t read8(Socket socket){
	return 0;
	}

	int16_t read16(Socket socket){
	return 0;
	}

	char * dumpStr(char * where, const std::string & str){
	return where;
	}

	void readBytes(Socket socket, uint8_t * data, int length){
	}

	void sendBytes(Socket socket, const uint8_t * data, int length){
	}

	char * parseString(char * where, std::string * out, uint16_t length){
	return where;
	}

	#endif


	}
	diff --git a/util/network/network.h b/util/network/network.h
	index 58b228ee..52ec5806 100644
	--- a/util/network/network.h
	+++ b/util/network/network.h
	@@ -1,126 +1,127 @@
	#ifndef _paintown_network_h
	#define _paintown_network_h

	#include <stdint.h>
	#ifdef HAVE_NETWORKING
	#include "hawknl/nl.h"
	#endif
	#include <string>
	#include <vector>
	#include <exception>

	namespace Network{

	#ifdef HAVE_NETWORKING
	typedef NLsocket Socket;
	#else
	typedef int Socket;
	#endif

	const int NO_CONNECTIONS_PENDING = 1;
	const int NETWORK_ERROR = 2;

	const int DATA_SIZE = 16;

	class NetworkException: public std::exception{
	public:
	NetworkException( const std::string message = "" ):std::exception(),message(message){}

	inline const std::string getMessage() const {
	return message;
	}

	~NetworkException() throw();

	protected:
	inline void setMessage( const std::string & m ){
	this->message = m;
	}

	private:
	std::string message;
	};

	class NoConnectionsPendingException: public NetworkException{
	public:
	NoConnectionsPendingException(const std::string message = ""):
	NetworkException(message){
	}
	};

	class MessageEnd: public NetworkException {
	public:
	MessageEnd();
	};

	class InvalidPortException: public NetworkException{
	public:
	InvalidPortException( int port, const std::string message = "" );
	};

	class CannotListenException: public NetworkException{
	public:
	CannotListenException( const std::string message = "" ):
	NetworkException( message ){
	}
	};

	/*
	template <class M>
	int totalSize(const std::vector<M> & messages);

	template <class M>
	void dump(const std::vector<M> & messages, uint8_t * buffer );
	*/

	int8_t read8(Socket socket);
	int16_t read16(Socket socket);
	int32_t read32(Socket socket);
	char * dump16(char * where, int16_t length);
	void send16(Socket socket, int16_t length);

	/* Reads a string by expecting the string to be terminated with a null byte */
	std::string readStr(Socket socket, const uint16_t length);

	/* This will send a string plus its null byte. If you just wanted to send the string
	* without a null byte then use sendBytes(socket, str.c_str(), str.size())
	*/
	void sendStr(Socket socket, const std::string & str );
	void sendBytes(Socket socket, const uint8_t * data, int length);
	void readBytes(Socket socket, uint8_t * data, int length);

	/* Copies the string plus its null byte to the `where' buffer.
	* Returns a pointer that is where + str.size() + 1
	*/
	char * dumpStr(char * where, const std::string & str);
	char * parse16(char * where, uint16_t * out);

	/* Reads a string into 'out' from 'where' that is expected to be 'length' bytes.
	* Right now the function lies, it just does *out = string(where) so if the actual
	* string is longer than 'length' the returned pointer will be into the middle
	* of the 'where' buffer.
	*/
	char * parseString(char * where, std::string * out, uint16_t length);
	void init();
	void shutdown();
	/* Whether or not blocking is enabled by default for new sockets */
	void blocking(bool b);
	/* Enable/disable blocking for a specific socket */
	bool blocking(Socket s, bool b);
	/* Enable/disable NODELAY -- the Nagle algorithm for TCP */
	bool noDelay(Socket s, bool b);

	void listen(Socket s) throw (NetworkException);
	Socket accept(Socket s) throw (NetworkException);

	Socket openReliable(int port);
	Socket openUnreliable(int port);
	-Socket connect(std::string server, int port) throw (NetworkException);
	+Socket connectReliable(std::string server, int port);
	+Socket connectUnReliable(std::string server, int port);
	void close(Socket);
	void closeAll();

	static std::vector<Socket> open_sockets;

	}

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jun 15, 4:42 PM (2 w, 3 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71847
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions