# HG changeset patch
# User Teemu Piippo <crimsondusk64@gmail.com>
# Date 1418270335 -7200
# Node ID 146825d63b9af3498a8126b3884ffcd6ca0a651b
# Parent  ec5387e121fad05352bc98b25fa349d3f698af0e
- code cleanup
- added network-related classes (bytestream, ipaddress, udp socket)

diff -r ec5387e121fa -r 146825d63b9a CMakeLists.txt
--- a/CMakeLists.txt	Wed Dec 10 19:26:13 2014 +0200
+++ b/CMakeLists.txt	Thu Dec 11 05:58:55 2014 +0200
@@ -7,6 +7,9 @@
 	sources/main.cpp
 	sources/mystring.cpp
 	sources/version.cpp
+	sources/network/bytestream.cpp
+	sources/network/ipaddress.cpp
+	sources/network/udp.cpp
 )
 
 set (CURSES_NEED_NCURSES, True)
diff -r ec5387e121fa -r 146825d63b9a sources/basics.h
--- a/sources/basics.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/basics.h	Thu Dec 11 05:58:55 2014 +0200
@@ -33,11 +33,14 @@
 #include <functional>
 
 #define FUNCTION auto
+#define STATIC
 #define METHOD auto
 #define MACRO_TO_STRING_2(A) #A
 #define MACRO_TO_STRING(A) MACRO_TO_STRING_2(A)
 
 using std::swap;
+using std::min;
+using std::max;
 
 enum Color
 {
diff -r ec5387e121fa -r 146825d63b9a sources/filesystem.cpp
--- a/sources/filesystem.cpp	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/filesystem.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -37,7 +37,7 @@
 #endif
 
 // -------------------------------------------------------------------------------------------------
-
+//
 FUNCTION
 dirname (String const& path) -> String
 {
@@ -55,7 +55,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 FUNCTION
 basename (String const& path) -> String
 {
diff -r ec5387e121fa -r 146825d63b9a sources/filesystem.h
--- a/sources/filesystem.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/filesystem.h	Thu Dec 11 05:58:55 2014 +0200
@@ -31,5 +31,9 @@
 #pragma once
 #include "main.h"
 
+// -------------------------------------------------------------------------------------------------
+// A variant of basename() which operates with Strings
 FUNCTION basename (String const& path) -> String;
+
+// A variant of dirname() which operates with Strings
 FUNCTION dirname (String const& path) -> String;
diff -r ec5387e121fa -r 146825d63b9a sources/format.cpp
--- a/sources/format.cpp	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/format.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -31,7 +31,7 @@
 #include <cstdio>
 #include "format.h"
 
-//
+// -------------------------------------------------------------------------------------------------
 // Throws an error while formatting the string
 //
 static auto format_error (String fmtstr, const String errdescribe, int pos) -> void
@@ -44,14 +44,11 @@
 		errmsg += "-";
 
 	errmsg += "^\n" + errdescribe;
-	// throw std::logic_error (errmsg.stdString());
-	std::fprintf (stderr, "%s", errmsg.chars());
-	std::exit (EXIT_FAILURE);
+	throw std::logic_error (errmsg.std_string());
 }
 
-//
-// Main formatter algorithm autoion. Processes @fmtstr with @args and returns
-// the result.
+// -------------------------------------------------------------------------------------------------
+// Main formatter algorithm.
 //
 auto format_args (const String& fmtstr, const Vector<String>& args) -> String
 {
diff -r ec5387e121fa -r 146825d63b9a sources/format.h
--- a/sources/format.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/format.h	Thu Dec 11 05:58:55 2014 +0200
@@ -105,29 +105,24 @@
 	return result;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 // Formats the given string with the given args.
 //
-auto format_args (const String& fmtstr, const Vector<String>& args) -> String;
+FUNCTION format_args (const String& fmtstr, const Vector<String>& args) -> String;
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 // Expands the given arguments into a vector of strings.
 //
-template<typename T, typename... RestTypes>
-auto expand_format_arguments (Vector<String>& data, const T& arg, const RestTypes& ... rest) -> void
+template<typename T, typename... RestTypes> FUNCTION
+expand_format_arguments (Vector<String>& data, const T& arg, const RestTypes& ... rest) -> void
 {
 	data.append (make_format_argument (arg).text());
 	expand_format_arguments (data, rest...);
 }
 
-static void expand_format_arguments (Vector<String>&) __attribute__( (unused));
+static void expand_format_arguments (Vector<String>&) __attribute__((unused));
 static void expand_format_arguments (Vector<String>&) {}
 
-//
 // -------------------------------------------------------------------------------------------------
 //
 // Formats the given formatter string and args and returns the string.
@@ -153,40 +148,37 @@
 //      argument did not expand into a number in the first place, 0 is used
 //      and 0x0 is printed.
 //
-template<typename... argtypes>
-String format (const String& fmtstr, const argtypes&... raw_args)
+template<typename... argtypes> FUNCTION
+format (const String& fmtstr, const argtypes&... raw_args) -> String
 {
 	Vector<String> args;
 	expand_format_arguments (args, raw_args...);
 	return format_args (fmtstr, args);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 // This is an overload of format() where no arguments are supplied.
 // It returns the formatter string as-is.
 //
 static String format (const String& fmtstr) __attribute__ ((unused));
-static String format (const String& fmtstr)
+static String // FUNCTION
+format (const String& fmtstr) // -> String
 {
 	return fmtstr;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
+// Prints the formatting result to the given file handle
 //
-
-template<typename... Args>
-void print_to (FILE* fp, const String& fmtstr, Args const& ...args)
+template<typename... Args> FUNCTION
+print_to (FILE* fp, const String& fmtstr, Args const& ...args) -> void
 {
 	std::fprintf (fp, "%s", format (fmtstr, args...).chars());
 }
 
+// -------------------------------------------------------------------------------------------------
+// Appends the formatting result to the given filename, if opening it succeeds
 //
-// -------------------------------------------------------------------------------------------------
-//
-
 template<typename... argtypes>
 void print_to (const String& filename, const String& fmtstr, const argtypes&... args)
 {
@@ -199,18 +191,11 @@
 	}
 }
 
+// -------------------------------------------------------------------------------------------------
+// Prints the formatting result to stdout
 //
-// -------------------------------------------------------------------------------------------------
-//
-
 template<typename... argtypes>
 void print (const String& fmtstr, const argtypes&... args)
 {
 	print_to (stdout, fmtstr, args...);
 }
-
-#define PRINT_TO_LOG(...) \
-{ \
-	print_to (LOGFILE, "%1:%2: ", __PRETTY_FUNCTION__, __LINE__); \
-	print_to (LOGFILE, __VA_ARGS__); \
-}
diff -r ec5387e121fa -r 146825d63b9a sources/list.h
--- a/sources/list.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/list.h	Thu Dec 11 05:58:55 2014 +0200
@@ -37,10 +37,8 @@
 #include <cassert>
 #include "range.h"
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 class Container
 {
@@ -141,114 +139,90 @@
 template<typename T, typename C>
 Container<T, C>::Container() {}
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 Container<T, C>::Container (const C& other) :
 	m_container (other) {}
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 Container<T, C>::Container (std::initializer_list<T> && a) :
 	m_container (a) {}
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 Container<T, C>::Container (int numvalues) :
 	m_container (numvalues) {}
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::begin() -> Iterator
 {
 	return m_container.begin();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::begin() const -> ConstIterator
 {
 	return m_container.cbegin();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::end() -> Iterator
 {
 	return m_container.end();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::end() const -> ConstIterator
 {
 	return m_container.cend();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::rbegin() -> ReverseIterator
 {
 	return m_container.rbegin();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::crbegin() const -> ConstReverseIterator
 {
 	return m_container.crbegin();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::rend() -> ReverseIterator
 {
 	return m_container.rend();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::crend() const -> ConstReverseIterator
 {
 	return m_container.crend();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::remove_at (int pos) -> void
 {
@@ -256,10 +230,8 @@
 	m_container.erase (m_container.begin() + pos);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::prepend (const T& value) -> T&
 {
@@ -267,10 +239,8 @@
 	return m_container[0];
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::append (const T& value) -> T&
 {
@@ -278,10 +248,8 @@
 	return m_container[m_container.size() - 1];
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::merge (const Self& other) -> void
 {
@@ -290,10 +258,8 @@
 	std::copy (other.begin(), other.end(), begin() + oldsize);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::pop (T& val) -> bool
 {
@@ -305,10 +271,8 @@
 	return true;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::operator<< (const T& value) -> Self&
 {
@@ -316,10 +280,8 @@
 	return *this;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::operator<< (const Self& vals) -> Self&
 {
@@ -327,10 +289,8 @@
 	return *this;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::reverse() const -> Self
 {
@@ -339,30 +299,24 @@
 	return rev;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::clear() -> void
 {
 	m_container.clear();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::insert (int pos, const T& value) -> void
 {
 	m_container.insert (m_container.begin() + pos, value);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::remove_duplicates() -> void
 {
@@ -370,20 +324,16 @@
 	resize (std::distance (begin(), std::unique (begin(), end())));
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::size() const -> int
 {
 	return m_container.size();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::operator[] (int n) -> T&
 {
@@ -391,10 +341,8 @@
 	return m_container[n];
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::operator[] (int n) const -> const T&
 {
@@ -402,40 +350,32 @@
 	return m_container[n];
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::operator[] (const Range<int>& n) const -> Self
 {
 	return splice (n);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::resize (int size) -> void
 {
 	m_container.resize (size);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::sort() -> void
 {
 	std::sort (begin(), end());
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::find (const T& needle) -> Iterator
 {
@@ -447,10 +387,8 @@
 	return it;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::find (const T& needle) const -> ConstIterator
 {
@@ -462,10 +400,8 @@
 	return it;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::find (Function<bool (T const&)> func) -> Iterator
 {
@@ -478,10 +414,8 @@
 	return end();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::find (Function<bool (T const&)> func) const -> ConstIterator
 {
@@ -494,10 +428,8 @@
 	return end();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::remove_one (const T& a) -> void
 {
@@ -507,20 +439,16 @@
 		m_container.erase (it);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::is_empty() const -> bool
 {
 	return size() == 0;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::splice (int a, int b) const -> Self
 {
@@ -535,60 +463,48 @@
 	return result;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::splice (const Range<int>& a) const -> Self
 {
 	return splice (a.min(), a.max());
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::container() const -> const C&
 {
 	return m_container;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::first() const -> const T&
 {
 	return *m_container.cbegin();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::last() const -> const T&
 {
 	return *(m_container.cend() - 1);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::contains (const T& a) const -> bool
 {
 	return std::find (m_container.cbegin(), m_container.cend(), a) != m_container.end();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto Container<T, C>::operator+ (const Self& other) const -> Self
 {
@@ -597,10 +513,8 @@
 	return out;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T, typename C>
 auto operator>> (const T& value, Container<T, C>& haystack) -> Container<T, C>&
 {
diff -r ec5387e121fa -r 146825d63b9a sources/main.cpp
--- a/sources/main.cpp	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/main.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -29,7 +29,10 @@
 */
 
 #include "main.h"
+#include "network/bytestream.h"
 
+// -------------------------------------------------------------------------------------------------
+//
 FUNCTION
 main (int argc, char* argv[]) -> int
 {
diff -r ec5387e121fa -r 146825d63b9a sources/main.h
--- a/sources/main.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/main.h	Thu Dec 11 05:58:55 2014 +0200
@@ -19,7 +19,7 @@
 	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 	TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 	PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
-	OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+	OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE=CIAL,
 	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
diff -r ec5387e121fa -r 146825d63b9a sources/mystring.cpp
--- a/sources/mystring.cpp	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/mystring.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -34,7 +34,7 @@
 #include "format.h"
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::compare (const String& other) const -> int
 {
@@ -42,7 +42,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::trim (int n) -> void
 {
@@ -53,7 +53,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::strip (const List<char>& unwanted) -> String
 {
@@ -69,7 +69,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::to_uppercase() const -> String
 {
@@ -85,7 +85,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::to_lowercase() const -> String
 {
@@ -101,7 +101,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::split (char del) const -> StringList
 {
@@ -111,7 +111,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::split (const String& del) const -> StringList
 {
@@ -138,7 +138,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::replace (const char* a, const char* b) -> void
 {
@@ -149,7 +149,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::count (char needle) const -> int
 {
@@ -163,7 +163,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::mid (long a, long b) const -> String
 {
@@ -188,7 +188,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::word_position (int n) const -> int
 {
@@ -196,10 +196,7 @@
 
 	for (int i = 0; i < length(); ++i)
 	{
-		if (m_string[i] != ' ')
-			continue;
-
-		if (++count < n)
+		if (not isspace (m_string[i]) or ++count < n)
 			continue;
 
 		return i;
@@ -209,7 +206,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::find (const char* c, int a) const -> int
 {
@@ -222,7 +219,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::find_last (const char* c, int a) const -> int
 {
@@ -237,7 +234,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::to_int (bool* ok, int base) const -> long
 {
@@ -252,7 +249,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::to_float (bool* ok) const -> float
 {
@@ -267,7 +264,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::to_double (bool* ok) const -> double
 {
@@ -282,7 +279,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::operator+ (const String& data) const -> String
 {
@@ -292,7 +289,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::operator+ (const char* data) const -> String
 {
@@ -302,7 +299,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::is_numeric() const -> bool
 {
@@ -333,7 +330,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::ends_with (const String& other) -> bool
 {
@@ -345,7 +342,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::starts_with (const String& other) -> bool
 {
@@ -356,7 +353,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::sprintf (const char* fmtstr, ...) -> void
 {
@@ -375,7 +372,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 StringList::join (const String& delim) -> String
 {
@@ -393,7 +390,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::mask_against (const String& pattern) const -> bool
 {
@@ -442,7 +439,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::from_number (int a) -> String
 {
@@ -452,7 +449,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::from_number (long a) -> String
 {
@@ -462,7 +459,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::from_number (unsigned long a) -> String
 {
@@ -472,7 +469,7 @@
 }
 
 // -------------------------------------------------------------------------------------------------
-
+//
 METHOD
 String::from_number (double a) -> String
 {
diff -r ec5387e121fa -r 146825d63b9a sources/mystring.h
--- a/sources/mystring.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/mystring.h	Thu Dec 11 05:58:55 2014 +0200
@@ -38,6 +38,8 @@
 class String;
 class StringList;
 
+// -------------------------------------------------------------------------------------------------
+
 class String
 {
 public:
@@ -125,6 +127,8 @@
 	std::string m_string;
 };
 
+// -------------------------------------------------------------------------------------------------
+
 class StringList : public List<String>
 {
 public:
@@ -135,14 +139,12 @@
 	METHOD join (const String& delim) -> String;
 };
 
+// -------------------------------------------------------------------------------------------------
+
 inline FUNCTION operator== (const char* a, const String& b) -> bool;
 inline FUNCTION operator+ (const char* a, const String& b) -> String;
 
-//
 // -------------------------------------------------------------------------------------------------
-//
-// IMPLEMENTATIONS
-//
 
 inline METHOD
 String::is_empty() const -> bool
@@ -150,9 +152,7 @@
 	return m_string[0] == '\0';
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::append (const char* data) -> void
@@ -160,9 +160,7 @@
 	m_string.append (data);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::append (char data) -> void
@@ -170,9 +168,7 @@
 	m_string.push_back (data);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::append (const String& data) -> void
@@ -180,9 +176,7 @@
 	m_string.append (data.chars());
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::begin() -> std::string::iterator
@@ -190,9 +184,7 @@
 	return m_string.begin();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::begin() const -> std::string::const_iterator
@@ -200,18 +192,14 @@
 	return m_string.cbegin();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline const char* String::chars() const
 {
 	return m_string.c_str();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::end() -> std::string::iterator
@@ -219,9 +207,7 @@
 	return m_string.end();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::end() const -> std::string::const_iterator
@@ -229,9 +215,7 @@
 	return m_string.end();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::clear() -> void
@@ -239,9 +223,7 @@
 	m_string.clear();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::remove (int pos) -> void
@@ -249,9 +231,7 @@
 	m_string.erase (m_string.begin() + pos);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::insert (int pos, char c) -> void
@@ -259,9 +239,7 @@
 	m_string.insert (m_string.begin() + pos, c);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::length() const -> int
@@ -269,9 +247,7 @@
 	return m_string.length();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::remove (int pos, int len) -> void
@@ -279,9 +255,7 @@
 	m_string.replace (pos, len, "");
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::remove_from_start (int len) -> void
@@ -289,9 +263,7 @@
 	remove (0, len);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::remove_from_end (int len) -> void
@@ -299,9 +271,7 @@
 	remove (length() - len, len);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::replace (int pos, int n, const String& a) -> void
@@ -309,9 +279,7 @@
 	m_string.replace (pos, n, a.chars());
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::shrink_to_fit() -> void
@@ -319,18 +287,14 @@
 	m_string.shrink_to_fit();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline const std::string& String::std_string() const
 {
 	return m_string;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::strip (char unwanted) -> String
@@ -338,9 +302,7 @@
 	return strip ({unwanted});
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator+ (int num) const -> String
@@ -348,9 +310,7 @@
 	return *this + String::from_number (num);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator+= (const String& data) -> String&
@@ -359,9 +319,7 @@
 	return *this;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator+= (const char* data) -> String&
@@ -370,9 +328,7 @@
 	return *this;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator+= (int num) -> String&
@@ -380,9 +336,7 @@
 	return operator+= (String::from_number (num));
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::prepend (String a) -> void
@@ -390,9 +344,7 @@
 	m_string = (a + m_string).std_string();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator+= (char data) -> String&
@@ -401,9 +353,7 @@
 	return *this;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator== (const String& other) const -> bool
@@ -411,9 +361,7 @@
 	return std_string() == other.std_string();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator== (const char* other) const -> bool
@@ -421,9 +369,7 @@
 	return operator== (String (other));
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator!= (const String& other) const -> bool
@@ -431,9 +377,7 @@
 	return std_string() != other.std_string();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator!= (const char* other) const -> bool
@@ -441,9 +385,7 @@
 	return operator!= (String (other));
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator> (const String& other) const -> bool
@@ -451,9 +393,7 @@
 	return std_string() > other.std_string();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::operator< (const String& other) const -> bool
@@ -461,27 +401,21 @@
 	return std_string() < other.std_string();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline String::operator const char*() const
 {
 	return chars();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline String::operator const std::string&() const
 {
 	return std_string();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::modify_index (int& a) -> void
@@ -490,9 +424,7 @@
 		a = length() - a;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline METHOD
 String::index_difference (int a, int b) -> int
@@ -502,9 +434,7 @@
 	return b - a;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline FUNCTION
 operator== (const char* a, const String& b) -> bool
@@ -512,9 +442,7 @@
 	return b == a;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
-//
 
 inline FUNCTION
 operator+ (const char* a, const String& b) -> String
diff -r ec5387e121fa -r 146825d63b9a sources/network/bytestream.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sources/network/bytestream.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -0,0 +1,266 @@
+#include "bytestream.h"
+#include <string.h>
+
+bool Bytestream::sink;
+
+// -------------------------------------------------------------------------------------------------
+//
+Bytestream::Bytestream (unsigned long length) :
+	m_data (nullptr)
+{
+	resize (length);
+	clear();
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+Bytestream::Bytestream (const unsigned char* data, unsigned long length) :
+	m_data (nullptr)
+{
+	m_data = nullptr;
+	init (data, length);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+Bytestream::Bytestream (const Vector<unsigned char>& bytes) :
+	m_data (nullptr)
+{
+	init (bytes.data(), bytes.size());
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+Bytestream::~Bytestream()
+{
+	delete m_data;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::resize (unsigned long newsize)
+{
+	Vector<unsigned char> olddata;
+	unsigned long oldsize = 0L;
+
+	if (m_data != nullptr)
+	{
+		oldsize = allocated_size();
+		olddata.resize (oldsize);
+		memcpy (olddata.data(), m_data, oldsize);
+	}
+
+	delete[] m_data;
+	m_allocatedSize = newsize;
+	m_data = new unsigned char[newsize];
+
+	if (olddata > 0L)
+		memcpy (m_data, olddata, min (oldsize, newsize));
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::init (const unsigned char* data, unsigned long length)
+{
+	resize (length);
+	memcpy (m_data, data, length);
+	m_cursor = &m_data[0];
+	m_writtenLength = length;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::clear()
+{
+	m_cursor = &m_data[0];
+	m_writtenLength = 0;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+char Bytestream::read_byte (bool* ok)
+{
+	*ok = bytes_left() > 0;
+	return *ok ? *m_cursor++ : -1;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+short int Bytestream::read_short (bool* ok)
+{
+	if (bytes_left() < 2)
+	{
+		*ok = false;
+		return false;
+	}
+
+	short int val = 0;
+
+	for (int i = 0; i < 2; ++i)
+		val |= *m_cursor++ << (i * 8);
+
+	*ok = true;
+	return true;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+long int Bytestream::read_long (bool* ok)
+{
+	if (bytes_left() < 4)
+	{
+		*ok = false;
+		return -1;
+	}
+
+	long int val = 0;
+
+	for (int i = 0; i < 4; ++i)
+		val |= *m_cursor++ << (i * 8);
+
+	*ok = true;
+	return val;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+float Bytestream::read_float (bool* ok)
+{
+	int value = read_long (ok);
+
+	if (*ok == false)
+		return -1.0f;
+
+	return reinterpret_cast<float&> (value);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+String Bytestream::read_string (bool* ok)
+{
+	// Zandronum sends strings of maximum 2048 characters, though it only
+	// reads 2047-character long ones so I guess we can follow up and do
+	// the same :-)
+	static char buffer[MAX_NETWORK_STRING];
+	unsigned char* stringEnd;
+	unsigned char* stringBegin = m_cursor;
+	unsigned char* end = m_data + allocated_size();
+
+	// where's the end of the string?
+	for (stringEnd = m_cursor; *stringEnd != '\0'; ++stringEnd)
+	{
+		if (stringEnd == end)
+		{
+			// past the end of the buffer! Argh!
+			*ok = false;
+			return "";
+		}
+	}
+
+	m_cursor = stringEnd + 1;
+	*ok = true;
+	unsigned int length = stringEnd - m_cursor;
+
+	// ensure we won't write past the buffer (note: we still moved
+	// past the excess bytes in the above statement, those are ignored)
+	if (length >= MAX_NETWORK_STRING)
+		length = MAX_NETWORK_STRING - 1;
+
+	memcpy (buffer, stringBegin, length);
+	buffer[length] = '\0';
+	return String (buffer);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+METHOD
+Bytestream::read (unsigned char* buffer, unsigned long length, bool* ok) -> void
+{
+	if (bytes_left() < length)
+	{
+		*ok = false;
+		return;
+	}
+
+	memcpy (buffer, m_cursor, length);
+	m_cursor += length;
+	*ok = true;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write (unsigned char val)
+{
+	*m_cursor++ = val;
+	m_writtenLength++;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write (const unsigned char* val, unsigned int length)
+{
+	grow_to_fit (length);
+	memcpy (m_cursor, val, length);
+	m_cursor += length;
+	m_writtenLength += length;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::grow_to_fit (unsigned long bytes)
+{
+	if (space_left() < bytes)
+		resize (allocated_size() + bytes + 128);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write_byte (char val)
+{
+	grow_to_fit (1);
+	write (val);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write_short (short int val)
+{
+	grow_to_fit (2);
+
+	for (int i = 0; i < 2; ++i)
+		write ((val >> (i * 8)) & 0xFF);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write_long (long int val)
+{
+	grow_to_fit (4);
+
+	for (int i = 0; i < 4; ++i)
+		write ((val >> (i * 8)) & 0xFF);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write_float (float val)
+{
+	// I know this is probably dangerous but this is what Zandronum does so yeah
+	write_long (reinterpret_cast<int&> (val));
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write_string (const String& val)
+{
+	grow_to_fit (val.length() + 1);
+	write (reinterpret_cast<const unsigned char*> (val.chars()), val.length());
+	write (0);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+void Bytestream::write_buffer (const Bytestream& other)
+{
+	write (other.data(), other.written_length());
+}
diff -r ec5387e121fa -r 146825d63b9a sources/network/bytestream.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sources/network/bytestream.h	Thu Dec 11 05:58:55 2014 +0200
@@ -0,0 +1,146 @@
+#pragma once
+#include "../main.h"
+
+class String;
+
+enum { MAX_NETWORK_STRING = 0x800 };
+
+// TODO: Make able to handle big-endian too
+class Bytestream
+{
+public:
+	static bool sink;
+
+	Bytestream (unsigned long length = 0x800);
+	Bytestream (const unsigned char* data, unsigned long length);
+	Bytestream (const Vector<unsigned char>& bytes);
+	~Bytestream();
+
+	inline METHOD allocated_size() const -> unsigned long;
+	inline METHOD bytes_left() const -> unsigned long;
+	       METHOD clear() -> void;
+	inline METHOD data() -> unsigned char*;
+	inline METHOD data() const -> const unsigned char*;
+	       METHOD grow_to_fit (unsigned long bytes) -> void;
+	inline METHOD position() const -> unsigned long;
+	       METHOD read (unsigned char* buffer, unsigned long length, bool* ok = &sink) -> void;
+	       METHOD read_byte (bool* ok = &sink) -> char;
+	       METHOD read_short (bool* ok = &sink) -> short int;
+	       METHOD read_long (bool* ok = &sink) -> long int;
+	       METHOD read_string (bool* ok = &sink) -> String;
+	       METHOD read_float (bool* ok = &sink) -> float;
+	       METHOD resize (unsigned long length) -> void;
+	inline METHOD rewind() -> void;
+	inline METHOD seek (unsigned long pos) -> void;
+	       METHOD write (const unsigned char* val, unsigned int length) -> void;
+	       METHOD write_buffer (const Bytestream& other) -> void;
+	       METHOD write_buffer (const Vector<unsigned char>& other) -> void;
+	       METHOD write_byte (char val) -> void;
+	       METHOD write_double (double val) -> void;
+	       METHOD write_float (float val) -> void;
+	       METHOD write_long (long int val) -> void;
+	       METHOD write_short (short int val) -> void;
+	       METHOD write_string (const String& val) -> void;
+	inline METHOD written_length() const -> unsigned long;
+
+	inline METHOD operator[] (unsigned long idx) -> unsigned char&;
+	inline METHOD operator[] (unsigned long idx) const -> unsigned char;
+
+private:
+	unsigned char* m_data;
+	unsigned char* m_cursor;
+	unsigned long m_allocatedSize;
+	unsigned long m_writtenLength;
+
+	METHOD init (const unsigned char* data, unsigned long length) -> void;
+	METHOD write (unsigned char val) -> void;
+	inline METHOD space_left() const -> unsigned long;
+};
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::allocated_size() const -> unsigned long
+{
+	return m_allocatedSize;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::written_length() const -> unsigned long
+{
+	return m_writtenLength;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::operator[] (unsigned long idx) -> unsigned char&
+{
+	return m_data[idx];
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::operator[] (unsigned long idx) const -> unsigned char
+{
+	return m_data[idx];
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::position() const -> unsigned long
+{
+	return m_cursor - m_data;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::seek (unsigned long pos) -> void
+{
+	m_cursor = m_data + pos;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::rewind() -> void
+{
+	m_cursor = m_data;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::bytes_left() const -> unsigned long
+{
+	return (m_writtenLength - (m_cursor - &m_data[0]));
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::space_left() const -> unsigned long
+{
+	return (m_allocatedSize - m_writtenLength);
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::data() -> unsigned char*
+{
+	return m_data;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+inline METHOD
+Bytestream::data() const -> const unsigned char*
+{
+	return m_data;
+}
diff -r ec5387e121fa -r 146825d63b9a sources/network/ipaddress.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sources/network/ipaddress.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -0,0 +1,165 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include "ipaddress.h"
+
+const IPAddress localhost (0x7F000001, 0);
+bool IPAddress::sink;
+
+// -----------------------------------------------------------------------------
+//
+IPAddress::IPAddress() :
+	host (0),
+	port (0) {}
+
+// -----------------------------------------------------------------------------
+//
+IPAddress::IPAddress (unsigned long host, unsigned short port) :
+	host (host),
+	port (port) {}
+
+// -----------------------------------------------------------------------------
+//
+IPAddress::IPAddress (const IPAddress& other) :
+	host (other.host),
+	port (other.port) {}
+
+// -----------------------------------------------------------------------------
+//
+METHOD
+IPAddress::to_string (WithPort withport) const -> String
+{
+	String val;
+
+	if (withport == IP_WITH_PORT)
+		val.sprintf ("%u.%u.%u.%u:%u", octet (0), octet (1), octet (2), octet (3), port);
+	else
+		val.sprintf ("%u.%u.%u.%u", octet (0), octet (1), octet (2), octet (3));
+
+	return val;
+}
+
+// -----------------------------------------------------------------------------
+//
+METHOD
+IPAddress::octet (int n) const -> unsigned char
+{
+	return (host >> ((3 - n) * 8)) & 0xFF;
+}
+
+// -----------------------------------------------------------------------------
+//
+METHOD
+IPAddress::set_octet (int n, unsigned char oct) -> void
+{
+	// TODO: make a big-endian version
+	host &= ~(0xFF << (3 - n) * 8);
+	host |= oct << ((3 - n) * 8);
+}
+
+// -----------------------------------------------------------------------------
+//
+METHOD
+IPAddress::compare (const IPAddress& other) const -> bool
+{
+	for (int i = 0; i < 4; ++i)
+	{
+		if (octet (i) != other.octet (i))
+			return false;
+	}
+
+	if (port != 0
+		and other.port != 0
+		and port != other.port)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+// -----------------------------------------------------------------------------
+//
+METHOD
+IPAddress::operator< (const IPAddress& other) const -> bool
+{
+	for (int i = 0; i < 4; ++i)
+	{
+		if (octet (i) != other.octet (i))
+			return octet (i) < other.octet (i);
+	}
+
+	return port < other.port;
+}
+
+// -----------------------------------------------------------------------------
+//
+METHOD
+IPAddress::to_sockaddr_in() const -> sockaddr_in
+{
+	sockaddr_in claddr;
+	memset (&claddr, 0, sizeof claddr);
+	claddr.sin_addr.s_addr = htonl (host);
+	claddr.sin_port = htons (port);
+	claddr.sin_family = AF_INET;
+	return claddr;
+}
+
+// -----------------------------------------------------------------------------
+//
+STATIC METHOD
+IPAddress::from_string (String input, bool* ok) -> IPAddress
+{
+	unsigned int parts[4];
+	int colonpos = input.find (":");
+	String addressString = colonpos == -1 ? input : input.mid (0, colonpos);
+	IPAddress value;
+
+	// Try scanf the IPv4 host first. If it's not an IP string, it could
+	// be a hostname; thus try resolve it.
+	if (sscanf (addressString, "%u.%u.%u.%u", &parts[0], &parts[1], &parts[2], &parts[3]))
+	{
+		for (short i = 0; i < 4; ++i)
+			value.set_octet (i, parts[i]);
+	}
+	else
+	{
+		// try resolve it
+		return IPAddress::resolve (addressString, ok);
+	}
+
+	if (colonpos != -1)
+		value.port = atoi (input.mid (colonpos + 1, -1));
+
+	return value;
+}
+
+// -----------------------------------------------------------------------------
+//
+STATIC METHOD
+IPAddress::resolve (String node, bool* ok) -> IPAddress
+{
+	struct addrinfo hints;
+	struct addrinfo* lookup;
+	int errorcode;
+	memset (&hints, 0, sizeof hints);
+	hints.ai_family = AF_INET;
+
+	if ((errorcode = getaddrinfo (node, nullptr, &hints, &lookup)) != 0)
+	{
+		*ok = false;
+		return IPAddress();
+	}
+
+	IPAddress result;
+	assert (lookup != nullptr);
+	sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*> (lookup[0].ai_addr);
+	result.host = ntohl (addr->sin_addr.s_addr);
+	result.port = ntohs (addr->sin_port);
+	freeaddrinfo (lookup);
+	*ok = true;
+	return result;
+}
diff -r ec5387e121fa -r 146825d63b9a sources/network/ipaddress.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sources/network/ipaddress.h	Thu Dec 11 05:58:55 2014 +0200
@@ -0,0 +1,50 @@
+#pragma once
+#include "../main.h"
+
+struct sockaddr;
+
+enum WithPort { IP_WITH_PORT, IP_NO_PORT };
+
+struct IPAddress
+{
+	unsigned long host;
+	unsigned short port;
+	static bool sink;
+
+	IPAddress();
+	IPAddress (unsigned long host, unsigned short port);
+	IPAddress (const IPAddress& other);
+
+	       METHOD compare (const IPAddress& other) const -> bool;
+	       METHOD octet (int n) const -> unsigned char;
+	       METHOD set_octet (int n, unsigned char oct) -> void;
+	       METHOD to_string (WithPort withport = IP_NO_PORT) const -> String;
+	       METHOD to_sockaddr_in() const -> sockaddr_in;
+	       METHOD operator< (const IPAddress& other) const -> bool;
+	inline METHOD operator== (const IPAddress& other) const -> bool;
+	inline METHOD operator!= (const IPAddress& other) const -> bool;
+	inline METHOD operator[] (int n) const -> unsigned char;
+
+	static METHOD from_string (String input, bool* ok = &sink) -> IPAddress;
+	static METHOD resolve (String node, bool* ok = &sink) -> IPAddress;
+};
+
+extern const IPAddress localhost;
+
+inline METHOD
+IPAddress::operator[] (int n) const -> unsigned char
+{
+	return octet (n);
+}
+
+inline METHOD
+IPAddress::operator== (const IPAddress& other) const -> bool
+{
+	return compare (other);
+}
+
+inline METHOD
+IPAddress::operator!= (const IPAddress& other) const -> bool
+{
+	return not operator== (other);
+}
diff -r ec5387e121fa -r 146825d63b9a sources/network/udp.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sources/network/udp.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -0,0 +1,98 @@
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <fcntl.h>
+#include "udp.h"
+
+// -----------------------------------------------------------------------------
+//
+UDPSocket::UDPSocket() :
+	m_socket (socket (AF_INET, SOCK_DGRAM, 0)) {}
+
+// -----------------------------------------------------------------------------
+//
+UDPSocket::~UDPSocket() {}
+
+// -------------------------------------------------------------------------------------------------
+//
+METHOD
+UDPSocket::set_blocking (bool a) -> bool
+{
+	int flags = fcntl (m_socket, F_GETFL, 0);
+	int newflags = (a ? (flags | O_NONBLOCK) : (flags & ~O_NONBLOCK));
+
+	if (flags < 0 || fcntl (m_socket, F_SETFL, newflags) != 0)
+	{
+		m_error = "Unable to set socket as non-blocking";
+		return false;
+	}
+
+	return true;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+METHOD
+UDPSocket::bind (unsigned short port) -> bool
+{
+	struct sockaddr_in svaddr;
+	memset (&svaddr, 0, sizeof svaddr);
+	svaddr.sin_family = AF_INET;
+	svaddr.sin_port = htons (port);
+	svaddr.sin_addr.s_addr = htonl (INADDR_ANY);
+
+	if (::bind (m_socket, reinterpret_cast<struct sockaddr*> (&svaddr), sizeof svaddr) == -1)
+	{
+		m_error = String ("Couldn't bind to port ") + String::from_number (port);
+		return false;
+	}
+
+	return true;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+METHOD
+UDPSocket::read (Datagram& datagram) -> bool
+{
+	sockaddr_in claddr;
+	socklen_t socklen = sizeof claddr;
+	static unsigned char packet[MAX_DATAGRAM_LENGTH];
+	int length = ::recvfrom (m_socket, packet, sizeof packet, 0,
+		reinterpret_cast<struct sockaddr*> (&claddr), &socklen);
+
+	if (length == -1)
+	{
+		// We got an error, though EWOULDBLOCK is silent as it means no packets recieved.
+		if (errno != EWOULDBLOCK)
+			m_error.sprintf ("recvfrom error: %s", strerror (errno));;
+
+		return false;
+	}
+
+	datagram.from.host = ntohl (claddr.sin_addr.s_addr);
+	datagram.from.port = ntohs (claddr.sin_port);
+	datagram.data = Bytestream (packet, length);
+	return true;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+METHOD
+UDPSocket::send (const Bytestream& data, const IPAddress& addr) -> bool
+{
+	struct sockaddr_in claddr = addr.to_sockaddr_in();
+
+	int res = ::sendto (m_socket, data.data(), data.written_length(), 0,
+		reinterpret_cast<struct sockaddr*> (&claddr), sizeof claddr);
+
+	if (res == -1)
+	{
+		m_error = String ("Unable to launch packet: ") + strerror (errno);
+		return false;
+	}
+
+	return true;
+}
diff -r ec5387e121fa -r 146825d63b9a sources/network/udp.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sources/network/udp.h	Thu Dec 11 05:58:55 2014 +0200
@@ -0,0 +1,31 @@
+#pragma once
+#include "../main.h"
+#include "ipaddress.h"
+#include "bytestream.h"
+
+enum { MAX_DATAGRAM_LENGTH = 5120 };
+
+struct Datagram
+{
+	Bytestream data;
+	IPAddress from;
+};
+
+// -------------------------------------------------------------------------------------------------
+//
+class UDPSocket
+{
+public:
+	UDPSocket();
+	virtual ~UDPSocket();
+
+	METHOD bind (unsigned short port) -> bool;
+	METHOD read (Datagram& datagram) -> bool;
+	METHOD send (const Bytestream& data, const IPAddress& addr) -> bool;
+	METHOD set_blocking (bool a) -> bool;
+
+private:
+	IPAddress m_addr;
+	String m_error;
+	int m_socket;
+};
diff -r ec5387e121fa -r 146825d63b9a sources/range.h
--- a/sources/range.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/range.h	Thu Dec 11 05:58:55 2014 +0200
@@ -63,57 +63,14 @@
 	METHOD max() const -> T;
 	METHOD check_bounds() -> void;
 	METHOD contains (const T& c) const -> bool;
-	METHOD contains_exclusive (const T& c) const -> bool;
+	METHOD contains_exclusively (const T& c) const -> bool;
 	METHOD overlaps (Range<T> const& other) const -> bool;
 	METHOD operator== (Range<T> const& other) const -> bool;
 	METHOD operator!= (Range<T> const& other) const -> bool;
 };
 
-//
-// -------------------------------------------------------------------------------------------------
-//
-
-template<typename T> inline METHOD
-Range<T>::Iterator::operator*() -> T&
-{
-	return value;
-}
-
-//
-// -------------------------------------------------------------------------------------------------
-//
-
-template<typename T> inline METHOD
-Range<T>::Iterator::operator== (const Iterator& other) const -> bool
-{
-	return value == other.value;
-}
-
-//
 // -------------------------------------------------------------------------------------------------
 //
-
-template<typename T> inline METHOD
-Range<T>::Iterator::operator!= (const Iterator& other) const -> bool
-{
-	return value != other.value;
-}
-
-//
-// -------------------------------------------------------------------------------------------------
-//
-
-template<typename T> inline METHOD
-Range<T>::Iterator::operator++() -> Iterator&
-{
-	value += step;
-	return *this;
-}
-
-//
-// -------------------------------------------------------------------------------------------------
-//
-
 template<typename T>
 Range<T>::Range (const T& a, const T& b, const T& step) :
 	m_a (a),
@@ -123,19 +80,48 @@
 	check_bounds();
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T>
 Range<T>::Range() :
 	m_a (T()),
 	m_b (T()) {}
 
+// -------------------------------------------------------------------------------------------------
 //
+template<typename T> inline METHOD
+Range<T>::Iterator::operator*() -> T&
+{
+	return value;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
+template<typename T> inline METHOD
+Range<T>::Iterator::operator== (const Iterator& other) const -> bool
+{
+	return value == other.value;
+}
+
 // -------------------------------------------------------------------------------------------------
 //
+template<typename T> inline METHOD
+Range<T>::Iterator::operator!= (const Iterator& other) const -> bool
+{
+	return value != other.value;
+}
 
+// -------------------------------------------------------------------------------------------------
+//
+template<typename T> inline METHOD
+Range<T>::Iterator::operator++() -> Iterator&
+{
+	value += step;
+	return *this;
+}
+
+// -------------------------------------------------------------------------------------------------
+//
 template<typename T> METHOD
 Range<T>::check_bounds() -> void
 {
@@ -143,80 +129,64 @@
 		std::swap (m_a, m_b);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::contains (const T& c) const -> bool
 {
 	return (c >= m_a) and (c <= m_b);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
-Range<T>::contains_exclusive (const T& c) const -> bool
+Range<T>::contains_exclusively (const T& c) const -> bool
 {
 	return (c > m_a) and (c < m_b);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::overlaps (Range<T> const& other) const -> bool
 {
 	return contains (other.m_a) or contains (other.m_b);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::operator== (Range<T> const& other) const -> bool
 {
 	return m_a == other.m_a and m_b == other.m_b;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::operator!= (Range<T> const& other) const -> bool
 {
 	return not operator== (other);
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::min() const -> T
 {
 	return m_a;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::max() const -> T
 {
 	return m_b;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::begin() const -> Iterator
 {
@@ -226,10 +196,8 @@
 	return it;
 }
 
-//
 // -------------------------------------------------------------------------------------------------
 //
-
 template<typename T> METHOD
 Range<T>::end() const -> Iterator
 {
diff -r ec5387e121fa -r 146825d63b9a sources/version.cpp
--- a/sources/version.cpp	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/version.cpp	Thu Dec 11 05:58:55 2014 +0200
@@ -38,6 +38,8 @@
 #include "version.h"
 #include "hginfo.h"
 
+// -------------------------------------------------------------------------------------------------
+//
 FUNCTION
 full_version_string() -> const char*
 {
@@ -54,6 +56,8 @@
 	return buffer;
 }
 
+// -------------------------------------------------------------------------------------------------
+//
 FUNCTION
 changeset_date_string() -> const char*
 {
diff -r ec5387e121fa -r 146825d63b9a sources/version.h
--- a/sources/version.h	Wed Dec 10 19:26:13 2014 +0200
+++ b/sources/version.h	Thu Dec 11 05:58:55 2014 +0200
@@ -36,9 +36,9 @@
 #define VERSION_MINOR 0
 #define VERSION_PATCH 0
 
-//
+// -------------------------------------------------------------------------------------------------
 // Version string
-//
+
 #if VERSION_PATCH == 0
 # define VERSION_STRING \
 	MACRO_TO_STRING (VERSION_MAJOR) \
@@ -50,21 +50,17 @@
 	"." MACRO_TO_STRING (VERSION_PATCH)
 #endif
 
-//
+// -------------------------------------------------------------------------------------------------
 // Returns the bare version string (1.2.3)
-//
+
 inline FUNCTION
 version_string() -> const char*
 {
 	return VERSION_STRING;
 }
 
-//
-// Returns full version string, with hash (1.2.3-abcd123)
-//
+// Returns full version string, with hash (1.2.3-abcd456)
 FUNCTION full_version_string() -> const char*;
 
-//
 // Returns changeset date string
-//
 FUNCTION changeset_date_string() -> const char*;