Improve logging with macros that consistently output strerror(errno) and

errno, replacing almost all use of strerror() in the main code.

Log a more detailed error message before throwing an exception for some
more system call failures.

Make FileStream store its filename on all platforms, not just Windows.

Wrap some long lines at less than 80 characters to improve readability.

Fix some minor violations of coding standard (white space) and a typo
in a comment.

11 files changed, 179 insertions, 108 deletions

diff --git a/lib/backupclient/BackupClientRestore.cpp b/lib/backupclient/BackupClientRestore.cpp
index b5a54964..aab514ad 100644
--- a/lib/backupclient/BackupClientRestore.cpp
+++ b/lib/backupclient/BackupClientRestore.cpp
@@ -267,14 +267,14 @@ static int BackupClientRestoreDir(BackupProtocolClient &rConnection, int64_t Dir
 					"restore this object.");
 				if(::unlink(rLocalDirectoryName.c_str()) != 0)
 				{
-					BOX_ERROR("Failed to delete file " <<
-						rLocalDirectoryName << ": " <<
-						strerror(errno));
+					BOX_LOG_SYS_ERROR("Failed to delete "
+						"file '" << 
+						rLocalDirectoryName << "'");
 					return Restore_UnknownError;
 				}
 				BOX_TRACE("In restore, directory name " 
-					"collision with file " <<
-					rLocalDirectoryName);
+					"collision with file '" <<
+					rLocalDirectoryName << "'");
 			}
 			break;
 		case ObjectExists_NoObject:
@@ -378,9 +378,8 @@ static int BackupClientRestoreDir(BackupProtocolClient &rConnection, int64_t Dir
 		exists == ObjectExists_File) && 
 		::mkdir(rLocalDirectoryName.c_str(), S_IRWXU) != 0)
 	{
-		BOX_ERROR("Failed to create directory '" <<
-			rLocalDirectoryName << "': " << 
-			strerror(errno));
+		BOX_LOG_SYS_ERROR("Failed to create directory '" <<
+			rLocalDirectoryName << "'");
 		return Restore_UnknownError;
 	}
 
@@ -451,7 +450,9 @@ static int BackupClientRestoreDir(BackupProtocolClient &rConnection, int64_t Dir
 			{
 				// Local name
 				BackupStoreFilenameClear nm(en->GetName());
-				std::string localFilename(rLocalDirectoryName + DIRECTORY_SEPARATOR_ASCHAR + nm.GetClearFilename());
+				std::string localFilename(rLocalDirectoryName +
+					DIRECTORY_SEPARATOR_ASCHAR +
+					nm.GetClearFilename());
 				
 				// Unlink anything which already exists:
 				// For resuming restores, we can't overwrite
@@ -459,20 +460,23 @@ static int BackupClientRestoreDir(BackupProtocolClient &rConnection, int64_t Dir
 				if(ObjectExists(localFilename) != ObjectExists_NoObject &&
 					::unlink(localFilename.c_str()) != 0)
 				{
-					BOX_ERROR("Failed to delete file '" <<
-						localFilename << "': " <<
-						strerror(errno));
+					BOX_LOG_SYS_ERROR("Failed to delete "
+						"file '" << localFilename << 
+						"'");
 					return Restore_UnknownError;
 				}
 				
 				// Request it from the store
-				rConnection.QueryGetFile(DirectoryID, en->GetObjectID());
+				rConnection.QueryGetFile(DirectoryID,
+					en->GetObjectID());
 		
 				// Stream containing encoded file
-				std::auto_ptr<IOStream> objectStream(rConnection.ReceiveStream());
+				std::auto_ptr<IOStream> objectStream(
+					rConnection.ReceiveStream());
 		
-				// Decode the file -- need to do different things depending on whether 
-				// the directory entry has additional attributes
+				// Decode the file -- need to do different
+				// things depending on whether the directory
+				// entry has additional attributes
 				try
 				{
 					if(en->HasAttributes())
diff --git a/lib/common/BoxTime.cpp b/lib/common/BoxTime.cpp
index 1ddcffd4..7d7b1b40 100644
--- a/lib/common/BoxTime.cpp
+++ b/lib/common/BoxTime.cpp
@@ -39,8 +39,8 @@ box_time_t GetCurrentBoxTime()
 		struct timeval tv;
 		if (gettimeofday(&tv, NULL) != 0)
 		{
-			BOX_ERROR("Failed to gettimeofday(), dropping "
-				"precision: " << strerror(errno));
+			BOX_LOG_SYS_ERROR("Failed to gettimeofday(), "
+				"dropping precision");
 		}
 		else
 		{
diff --git a/lib/common/EventWatchFilesystemObject.cpp b/lib/common/EventWatchFilesystemObject.cpp
index 84781113..43533fc8 100644
--- a/lib/common/EventWatchFilesystemObject.cpp
+++ b/lib/common/EventWatchFilesystemObject.cpp
@@ -26,9 +26,10 @@
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    EventWatchFilesystemObject::EventWatchFilesystemObject(const char *)
-//		Purpose: Constructor -- opens the file object
-//		Created: 12/3/04
+//	Name:    EventWatchFilesystemObject::EventWatchFilesystemObject
+//		 (const char *)
+//	Purpose: Constructor -- opens the file object
+//	Created: 12/3/04
 //
 // --------------------------------------------------------------------------
 EventWatchFilesystemObject::EventWatchFilesystemObject(const char *Filename)
@@ -39,9 +40,8 @@ EventWatchFilesystemObject::EventWatchFilesystemObject(const char *Filename)
 #ifdef HAVE_KQUEUE
 	if(mDescriptor == -1)
 	{
-		BOX_ERROR("EventWatchFilesystemObject: "
-			"Failed to open file '" << Filename << "': " <<
-			strerror(errno));
+		BOX_LOG_SYS_ERROR("EventWatchFilesystemObject: "
+			"Failed to open file '" << Filename << "'");
 		THROW_EXCEPTION(CommonException, OSFileOpenError)
 	}
 #else
@@ -53,9 +53,9 @@ EventWatchFilesystemObject::EventWatchFilesystemObject(const char *Filename)
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    EventWatchFilesystemObject::~EventWatchFilesystemObject()
-//		Purpose: Destructor
-//		Created: 12/3/04
+//	Name:    EventWatchFilesystemObject::~EventWatchFilesystemObject()
+//	Purpose: Destructor
+//	Created: 12/3/04
 //
 // --------------------------------------------------------------------------
 EventWatchFilesystemObject::~EventWatchFilesystemObject()
@@ -70,12 +70,14 @@ EventWatchFilesystemObject::~EventWatchFilesystemObject()
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    EventWatchFilesystemObject::EventWatchFilesystemObject(const EventWatchFilesystemObject &)
-//		Purpose: Copy constructor
-//		Created: 12/3/04
+//	Name:    EventWatchFilesystemObject::EventWatchFilesystemObject
+//		 (const EventWatchFilesystemObject &)
+//	Purpose: Copy constructor
+//	Created: 12/3/04
 //
 // --------------------------------------------------------------------------
-EventWatchFilesystemObject::EventWatchFilesystemObject(const EventWatchFilesystemObject &rToCopy)
+EventWatchFilesystemObject::EventWatchFilesystemObject(
+	const EventWatchFilesystemObject &rToCopy)
 	: mDescriptor(::dup(rToCopy.mDescriptor))
 {
 	if(mDescriptor == -1)
@@ -89,17 +91,20 @@ EventWatchFilesystemObject::EventWatchFilesystemObject(const EventWatchFilesyste
 // --------------------------------------------------------------------------
 //
 // Function
-//		Name:    EventWatchFilesystemObject::FillInKEvent(struct kevent &, int)
-//		Purpose: For WaitForEvent
-//		Created: 12/3/04
+//	Name:    EventWatchFilesystemObject::FillInKEvent(struct kevent &, int)
+//	Purpose: For WaitForEvent
+//	Created: 12/3/04
 //
 // --------------------------------------------------------------------------
-void EventWatchFilesystemObject::FillInKEvent(struct kevent &rEvent, int Flags) const
+void EventWatchFilesystemObject::FillInKEvent(struct kevent &rEvent,
+	int Flags) const
 {
-	EV_SET(&rEvent, mDescriptor, EVFILT_VNODE, EV_CLEAR, NOTE_DELETE | NOTE_WRITE, 0, (void*)this);
+	EV_SET(&rEvent, mDescriptor, EVFILT_VNODE, EV_CLEAR,
+		NOTE_DELETE | NOTE_WRITE, 0, (void*)this);
 }
 #else
-void EventWatchFilesystemObject::FillInPoll(int &fd, short &events, int Flags) const
+void EventWatchFilesystemObject::FillInPoll(int &fd, short &events,
+	int Flags) const
 {
 	THROW_EXCEPTION(CommonException, KQueueNotSupportedOnThisPlatform)
 }
diff --git a/lib/common/FileStream.cpp b/lib/common/FileStream.cpp
index e0806e10..57fb8274 100644
--- a/lib/common/FileStream.cpp
+++ b/lib/common/FileStream.cpp
@@ -30,7 +30,8 @@ FileStream::FileStream(const char *Filename, int flags, int mode)
 #else
 	: mOSFileHandle(::open(Filename, flags, mode)),
 #endif
-	  mIsEOF(false)
+	  mIsEOF(false),
+	  mFileName(Filename)
 {
 #ifdef WIN32
 	if(mOSFileHandle == INVALID_HANDLE_VALUE)
@@ -49,9 +50,6 @@ FileStream::FileStream(const char *Filename, int flags, int mode)
 			THROW_EXCEPTION(CommonException, OSFileOpenError)
 		}
 	}
-#ifdef WIN32
-	this->fileName = Filename;
-#endif
 }
 
 
@@ -65,7 +63,8 @@ FileStream::FileStream(const char *Filename, int flags, int mode)
 // --------------------------------------------------------------------------
 FileStream::FileStream(tOSFileHandle FileDescriptor)
 	: mOSFileHandle(FileDescriptor),
-	  mIsEOF(false)
+	  mIsEOF(false),
+	  mFileName("HANDLE")
 {
 #ifdef WIN32
 	if(mOSFileHandle == INVALID_HANDLE_VALUE)
@@ -77,9 +76,6 @@ FileStream::FileStream(tOSFileHandle FileDescriptor)
 		BOX_ERROR("FileStream: called with invalid file handle");
 		THROW_EXCEPTION(CommonException, OSFileOpenError)
 	}
-#ifdef WIN32
-	this->fileName = "HANDLE";
-#endif
 }
 
 #if 0
@@ -150,27 +146,32 @@ int FileStream::Read(void *pBuffer, int NBytes, int Timeout)
 		NULL
 		);
 
-	if ( valid )
+	if(valid)
 	{
 		r = numBytesRead;
 	}
-	else if (GetLastError() == ERROR_BROKEN_PIPE)
+	else if(GetLastError() == ERROR_BROKEN_PIPE)
 	{
 		r = 0;
 	}
 	else
 	{
-		BOX_ERROR("Failed to read from file: " <<
-			GetErrorMessage(GetLastError()));
+		BOX_LOG_WIN_ERROR("Failed to read from file: " << mFileName);
 		r = -1;
 	}
 #else
 	int r = ::read(mOSFileHandle, pBuffer, NBytes);
+	if(r == -1)
+	{
+		BOX_LOG_SYS_ERROR("Failed to read from file: " << mFileName);
+	}
 #endif
+
 	if(r == -1)
 	{
 		THROW_EXCEPTION(CommonException, OSFileReadError)
 	}
+
 	if(r == 0)
 	{
 		mIsEOF = true;
diff --git a/lib/common/FileStream.h b/lib/common/FileStream.h
index 721bf3dd..23cc8e75 100644
--- a/lib/common/FileStream.h
+++ b/lib/common/FileStream.h
@@ -57,10 +57,8 @@ private:
 	bool mIsEOF;
 	FileStream(const FileStream &rToCopy) { /* do not call */ }
 
-#ifdef WIN32
 	// for debugging..
-	std::string fileName;
-#endif
+	std::string mFileName;
 };
 
 
diff --git a/lib/common/Guards.h b/lib/common/Guards.h
index d2fb84e0..cd2e4628 100644
--- a/lib/common/Guards.h
+++ b/lib/common/Guards.h
@@ -37,8 +37,8 @@ public:
 	{
 		if(mOSFileHandle < 0)
 		{
-			BOX_ERROR("FileHandleGuard: failed to open file '" <<
-				rFilename << "': " << strerror(errno));
+			BOX_LOG_SYS_ERROR("FileHandleGuard: failed to open " 
+				"file '" << rFilename << "'");
 			THROW_EXCEPTION(CommonException, OSFileOpenError)
 		}
 	}
diff --git a/lib/common/Logging.h b/lib/common/Logging.h
index 2d726627..2d09b319 100644
--- a/lib/common/Logging.h
+++ b/lib/common/Logging.h
@@ -48,6 +48,20 @@
 	if (Logging::IsEnabled(Log::TRACE)) \
 	{ BOX_LOG(Log::TRACE, stuff) }
 
+#define BOX_LOG_SYS_WARNING(stuff) \
+	BOX_WARNING(stuff << ": " << strerror(errno) << " (" << errno << ")")
+#define BOX_LOG_SYS_ERROR(stuff) \
+	BOX_ERROR(stuff << ": " << strerror(errno) << " (" << errno << ")")
+#define BOX_LOG_SYS_FATAL(stuff) \
+	BOX_FATAL(stuff << ": " << strerror(errno) << " (" << errno << ")")
+
+#ifdef WIN32
+	#define BOX_LOG_WIN_ERROR(stuff) \
+		BOX_ERROR(stuff << ": " << GetErrorMessage(GetLastError()))
+	#define BOX_LOG_WIN_ERROR_NUMBER(stuff, number) \
+		BOX_ERROR(stuff << ": " << GetErrorMessage(number))
+#endif
+
 #define BOX_FORMAT_ACCOUNT(accno) \
 	std::hex << \
 	std::showbase << \
diff --git a/lib/server/Daemon.cpp b/lib/server/Daemon.cpp
index 95f5c338..292a628c 100644
--- a/lib/server/Daemon.cpp
+++ b/lib/server/Daemon.cpp
@@ -465,8 +465,7 @@ int Daemon::Main(const std::string &rConfigFileName)
 			// Set new session
 			if(::setsid() == -1)
 			{
-				BOX_ERROR("Failed to setsid(): " << 
-					strerror(errno));
+				BOX_LOG_SYS_ERROR("Failed to setsid()");
 				THROW_EXCEPTION(ServerException, DaemoniseFailed)
 			}
 
@@ -475,6 +474,7 @@ int Daemon::Main(const std::string &rConfigFileName)
 			{
 			case -1:
 				// error
+				BOX_LOG_SYS_ERROR("Failed to fork() a child");
 				THROW_EXCEPTION(ServerException, DaemoniseFailed)
 				break;
 
@@ -497,9 +497,11 @@ int Daemon::Main(const std::string &rConfigFileName)
 		struct sigaction sa;
 		sa.sa_handler = SignalHandler;
 		sa.sa_flags = 0;
-		sigemptyset(&sa.sa_mask);		// macro
-		if(::sigaction(SIGHUP, &sa, NULL) != 0 || ::sigaction(SIGTERM, &sa, NULL) != 0)
+		sigemptyset(&sa.sa_mask); // macro
+		if(::sigaction(SIGHUP, &sa, NULL) != 0 ||
+			::sigaction(SIGTERM, &sa, NULL) != 0)
 		{
+			BOX_LOG_SYS_ERROR("Failed to set signal handlers");
 			THROW_EXCEPTION(ServerException, DaemoniseFailed)
 		}
 #endif // !WIN32
@@ -515,7 +517,8 @@ int Daemon::Main(const std::string &rConfigFileName)
 
 		if(::write(pidFile, pid, pidsize) != pidsize)
 		{
-			BOX_FATAL("can't write pid file");
+			BOX_LOG_SYS_FATAL("Failed to write PID file: " <<
+				pidFileName);
 			THROW_EXCEPTION(ServerException, DaemoniseFailed)
 		}
 		
@@ -544,6 +547,7 @@ int Daemon::Main(const std::string &rConfigFileName)
 			int devnull = ::open(PLATFORM_DEV_NULL, O_RDWR, 0);
 			if(devnull == -1)
 			{
+				BOX_LOG_SYS_ERROR("Failed to open /dev/null");
 				THROW_EXCEPTION(CommonException, OSFileError);
 			}
 			// Then duplicate them to all three handles
@@ -890,6 +894,8 @@ box_time_t Daemon::GetConfigFileModifiedTime() const
 		{
 			return 0;
 		}
+		BOX_LOG_SYS_ERROR("Failed to stat configuration file: " <<
+			GetConfigFileName());
 		THROW_EXCEPTION(CommonException, OSFileError)
 	}
 	
diff --git a/lib/server/ServerControl.h b/lib/server/ServerControl.h
index ce5620c2..771f88fb 100644
--- a/lib/server/ServerControl.h
+++ b/lib/server/ServerControl.h
@@ -142,8 +142,7 @@ inline bool KillServerInternal(int pid)
 	bool killed = (::kill(pid, SIGTERM) == 0);
 	if (!killed)
 	{
-		BOX_ERROR("Failed to kill process " << pid << ": " <<
-			strerror(errno));
+		BOX_LOG_SYS_ERROR("Failed to kill process " << pid);
 	}
 	TEST_THAT(killed);
 	return killed;
diff --git a/lib/server/SocketListen.h b/lib/server/SocketListen.h
index ff08fb8f..1cfce648 100644
--- a/lib/server/SocketListen.h
+++ b/lib/server/SocketListen.h
@@ -108,45 +108,57 @@ public:
 			if(::close(mSocketHandle) == -1)
 #endif
 			{
-				THROW_EXCEPTION(ServerException, SocketCloseError)
+				BOX_LOG_SYS_ERROR("Failed to close network "
+					"socket");
+				THROW_EXCEPTION(ServerException,
+					SocketCloseError)
 			}
 		}
 		mSocketHandle = -1;
 	}
 
-	// --------------------------------------------------------------------------
+	// ------------------------------------------------------------------
 	//
 	// Function
 	//		Name:    SocketListen::Listen(int, char*, int)
 	//		Purpose: Initialises, starts the socket listening.
 	//		Created: 2003/07/31
 	//
-	// --------------------------------------------------------------------------
+	// ------------------------------------------------------------------
 	void Listen(int Type, const char *Name, int Port = 0)
 	{
-		if(mSocketHandle != -1) {THROW_EXCEPTION(ServerException, SocketAlreadyOpen)}
+		if(mSocketHandle != -1)
+		{
+			THROW_EXCEPTION(ServerException, SocketAlreadyOpen);
+		}
 		
 		// Setup parameters based on type, looking up names if required
 		int sockDomain = 0;
 		SocketAllAddr addr;
 		int addrLen = 0;
-		Socket::NameLookupToSockAddr(addr, sockDomain, Type, Name, Port, addrLen);
+		Socket::NameLookupToSockAddr(addr, sockDomain, Type, Name,
+			Port, addrLen);
 	
 		// Create the socket
-		mSocketHandle = ::socket(sockDomain, SOCK_STREAM, 0 /* let OS choose protocol */);
+		mSocketHandle = ::socket(sockDomain, SOCK_STREAM,
+			0 /* let OS choose protocol */);
 		if(mSocketHandle == -1)
 		{
+			BOX_LOG_SYS_ERROR("Failed to create a network socket");
 			THROW_EXCEPTION(ServerException, SocketOpenError)
 		}
 		
 		// Set an option to allow reuse (useful for -HUP situations!)
 #ifdef WIN32
-		if(::setsockopt(mSocketHandle, SOL_SOCKET, SO_REUSEADDR, "", 0) == -1)
+		if(::setsockopt(mSocketHandle, SOL_SOCKET, SO_REUSEADDR, "",
+			0) == -1)
 #else
 		int option = true;
-		if(::setsockopt(mSocketHandle, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) == -1)
+		if(::setsockopt(mSocketHandle, SOL_SOCKET, SO_REUSEADDR,
+			&option, sizeof(option)) == -1)
 #endif
 		{
+			BOX_LOG_SYS_ERROR("Failed to set socket options");
 			THROW_EXCEPTION(ServerException, SocketOpenError)
 		}
 
@@ -161,19 +173,25 @@ public:
 		}	
 	}
 	
-	// --------------------------------------------------------------------------
+	// ------------------------------------------------------------------
 	//
 	// Function
 	//		Name:    SocketListen::Accept(int)
-	//		Purpose: Accepts a connection, returning a pointer to a class of
-	//				 the specified type. May return a null pointer if a signal happens,
-	//				 or there's a timeout. Timeout specified in milliseconds, defaults to infinite time.
+	//		Purpose: Accepts a connection, returning a pointer to
+	//			 a class of the specified type. May return a
+	//			 null pointer if a signal happens, or there's
+	//			 a timeout. Timeout specified in
+	//			 milliseconds, defaults to infinite time.
 	//		Created: 2003/07/31
 	//
-	// --------------------------------------------------------------------------
-	std::auto_ptr<SocketType> Accept(int Timeout = INFTIM, std::string *pLogMsg = 0)
+	// ------------------------------------------------------------------
+	std::auto_ptr<SocketType> Accept(int Timeout = INFTIM,
+		std::string *pLogMsg = 0)
 	{
-		if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+		if(mSocketHandle == -1)
+		{
+			THROW_EXCEPTION(ServerException, BadSocketHandle);
+		}
 		
 		// Do the accept, using the supplied locking type
 		int sock;
@@ -185,8 +203,10 @@ public:
 			
 			if(!socklock.HaveLock())
 			{
-				// Didn't get the lock for some reason. Wait a while, then
-				// return nothing.
+				// Didn't get the lock for some reason.
+				// Wait a while, then return nothing.
+				BOX_ERROR("Failed to get a lock on incoming "
+					"connection");
 				::sleep(1);
 				return std::auto_ptr<SocketType>();
 			}
@@ -202,12 +222,18 @@ public:
 				// signal?
 				if(errno == EINTR)
 				{
+					BOX_ERROR("Failed to accept "
+						"connection: interrupted by "
+						"signal");
 					// return nothing
 					return std::auto_ptr<SocketType>();
 				}
 				else
 				{
-					THROW_EXCEPTION(ServerException, SocketPollError)
+					BOX_LOG_SYS_ERROR("Failed to poll "
+						"connection");
+					THROW_EXCEPTION(ServerException,
+						SocketPollError)
 				}
 				break;
 			case 0:	// timed out
@@ -220,16 +246,19 @@ public:
 			
 			sock = ::accept(mSocketHandle, &addr, &addrlen);
 		}
-		// Got socket (or error), unlock (implcit in destruction)
+
+		// Got socket (or error), unlock (implicit in destruction)
 		if(sock == -1)
 		{
+			BOX_LOG_SYS_ERROR("Failed to accept connection");
 			THROW_EXCEPTION(ServerException, SocketAcceptError)
 		}
 
 		// Log it
 		if(pLogMsg)
 		{
-			*pLogMsg = Socket::IncomingConnectionLogMessage(&addr, addrlen);
+			*pLogMsg = Socket::IncomingConnectionLogMessage(&addr,
+				addrlen);
 		}
 		else
 		{
@@ -243,27 +272,29 @@ public:
 	// Functions to allow adding to WaitForEvent class, for efficient waiting
 	// on multiple sockets.
 #ifdef HAVE_KQUEUE
-	// --------------------------------------------------------------------------
+	// ------------------------------------------------------------------
 	//
 	// Function
 	//		Name:    SocketListen::FillInKEevent
 	//		Purpose: Fills in a kevent structure for this socket
 	//		Created: 9/3/04
 	//
-	// --------------------------------------------------------------------------
+	// ------------------------------------------------------------------
 	void FillInKEvent(struct kevent &rEvent, int Flags = 0) const
 	{
-		EV_SET(&rEvent, mSocketHandle, EVFILT_READ, 0, 0, 0, (void*)this);
+		EV_SET(&rEvent, mSocketHandle, EVFILT_READ, 0, 0, 0,
+			(void*)this);
 	}
 #else
-	// --------------------------------------------------------------------------
+	// ------------------------------------------------------------------
 	//
 	// Function
 	//		Name:    SocketListen::FillInPoll
-	//		Purpose: Fills in the data necessary for a poll operation
+	//		Purpose: Fills in the data necessary for a poll
+	//			 operation
 	//		Created: 9/3/04
 	//
-	// --------------------------------------------------------------------------
+	// ------------------------------------------------------------------
 	void FillInPoll(int &fd, short &events, int Flags = 0) const
 	{
 		fd = mSocketHandle;
diff --git a/lib/server/SocketStream.cpp b/lib/server/SocketStream.cpp
index 5cb252bd..13f7c310 100644
--- a/lib/server/SocketStream.cpp
+++ b/lib/server/SocketStream.cpp
@@ -150,9 +150,11 @@ void SocketStream::Open(int Type, const char *Name, int Port)
 	Socket::NameLookupToSockAddr(addr, sockDomain, Type, Name, Port, addrLen);
 
 	// Create the socket
-	mSocketHandle = ::socket(sockDomain, SOCK_STREAM, 0 /* let OS choose protocol */);
+	mSocketHandle = ::socket(sockDomain, SOCK_STREAM,
+		0 /* let OS choose protocol */);
 	if(mSocketHandle == INVALID_SOCKET_VALUE)
 	{
+		BOX_LOG_SYS_ERROR("Failed to create a network socket");
 		THROW_EXCEPTION(ServerException, SocketOpenError)
 	}
 	
@@ -163,22 +165,16 @@ void SocketStream::Open(int Type, const char *Name, int Port)
 #ifdef WIN32
 		DWORD err = WSAGetLastError();
 		::closesocket(mSocketHandle);
-#else
+		BOX_LOG_WIN_ERROR_NUMBER("Failed to connect to socket " 
+			"(type " << Type << ", name " << Name <<
+			", port " << Port << ")", err);
+#else // !WIN32
 		int err = errno;
 		::close(mSocketHandle);
-#endif
-
-#ifdef WIN32
-		BOX_ERROR("Failed to connect to socket (type " << Type <<
-			", name " << Name << ", port " << Port << "): " <<
-				GetErrorMessage(err)
-			);
-#else
-		BOX_ERROR("Failed to connect to socket (type " << Type <<
-			", name " << Name << ", port " << Port << "): " <<
-				strerror(err) << " (" << err << ")"
-			);
-#endif
+		BOX_LOG_SYS_ERROR("Failed to connect to socket (type " <<
+			Type << ", name " << Name << ", port " << Port <<
+			")");
+#endif // WIN32
 
 		mSocketHandle = INVALID_SOCKET_VALUE;
 		THROW_EXCEPTION(ConnectionException, Conn_SocketConnectError)
@@ -220,7 +216,9 @@ int SocketStream::Read(void *pBuffer, int NBytes, int Timeout)
 			else
 			{
 				// Bad!
-				THROW_EXCEPTION(ServerException, SocketPollError)
+				BOX_LOG_SYS_ERROR("Failed to poll socket");
+				THROW_EXCEPTION(ServerException,
+					SocketPollError)
 			}
 			break;
 			
@@ -250,9 +248,12 @@ int SocketStream::Read(void *pBuffer, int NBytes, int Timeout)
 		else
 		{
 			// Other error
-			THROW_EXCEPTION(ConnectionException, Conn_SocketReadError)
+			BOX_LOG_SYS_ERROR("Failed to read from socket");
+			THROW_EXCEPTION(ConnectionException,
+				Conn_SocketReadError);
 		}
 	}
+
 	// Closed for reading?
 	if(r == 0)
 	{
@@ -297,7 +298,9 @@ void SocketStream::Write(const void *pBuffer, int NBytes)
 		{
 			// Error.
 			mWriteClosed = true;	// assume can't write again
-			THROW_EXCEPTION(ConnectionException, Conn_SocketWriteError)
+			BOX_LOG_SYS_ERROR("Failed to write to socket");
+			THROW_EXCEPTION(ConnectionException,
+				Conn_SocketWriteError);
 		}
 		
 		// Knock off bytes sent
@@ -310,7 +313,9 @@ void SocketStream::Write(const void *pBuffer, int NBytes)
 		// Need to wait until it can send again?
 		if(bytesLeft > 0)
 		{
-			TRACE3("Waiting to send data on socket %d, (%d to send of %d)\n", mSocketHandle, bytesLeft, NBytes);
+			BOX_TRACE("Waiting to send data on socket " << 
+				mSocketHandle << " (" << bytesLeft <<
+				" of " << NBytes << " bytes left)");
 			
 			// Wait for data to send.
 			struct pollfd p;
@@ -323,7 +328,10 @@ void SocketStream::Write(const void *pBuffer, int NBytes)
 				// Don't exception if it's just a signal
 				if(errno != EINTR)
 				{
-					THROW_EXCEPTION(ServerException, SocketPollError)
+					BOX_LOG_SYS_ERROR("Failed to poll "
+						"socket");
+					THROW_EXCEPTION(ServerException,
+						SocketPollError)
 				}
 			}
 		}
@@ -350,6 +358,7 @@ void SocketStream::Close()
 	if(::close(mSocketHandle) == -1)
 #endif
 	{
+		BOX_LOG_SYS_ERROR("Failed to close socket");
 		THROW_EXCEPTION(ServerException, SocketCloseError)
 	}
 	mSocketHandle = INVALID_SOCKET_VALUE;
@@ -380,6 +389,7 @@ void SocketStream::Shutdown(bool Read, bool Write)
 	// Shut it down!
 	if(::shutdown(mSocketHandle, how) == -1)
 	{
+		BOX_LOG_SYS_ERROR("Failed to shutdown socket");
 		THROW_EXCEPTION(ConnectionException, Conn_SocketShutdownError)
 	}
 }
@@ -458,12 +468,15 @@ bool SocketStream::GetPeerCredentials(uid_t &rUidOut, gid_t &rGidOut)
 	struct ucred cred;
 	socklen_t credLen = sizeof(cred);
 
-	if(::getsockopt(mSocketHandle, SOL_SOCKET, SO_PEERCRED, &cred, &credLen) == 0)
+	if(::getsockopt(mSocketHandle, SOL_SOCKET, SO_PEERCRED, &cred,
+		&credLen) == 0)
 	{
 		rUidOut = cred.uid;
 		rGidOut = cred.gid;
 		return true;
 	}
+
+	BOX_LOG_SYS_ERROR("Failed to get peer credentials on socket");
 #endif
 
 	// Not available