Minor fixes #2

awwit · awwit · commit 0fc589e61526 · 2016-01-10T19:32:23.000+03:00
diff --git a/projects/qt-creator/httpserverapp.pro.user b/projects/qt-creator/httpserverapp.pro.user
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 3.5.1, 2016-01-09T02:26:09. -->
+<!-- Written by QtCreator 3.5.1, 2016-01-10T19:16:23. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
@@ -61,7 +61,7 @@
    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{c77ee4a2-1c2a-4bac-9185-8378ec4ebf5d}</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
+   <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value>
    <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
    <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
    <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
diff --git a/src/Socket.cpp b/src/Socket.cpp
@@ -27,6 +27,17 @@ namespace HttpServer
 	#endif
 	}
 
+	int Socket::getLastError()
+	{
+	#ifdef WIN32
+		return ::WSAGetLastError();
+	#elif POSIX
+		return errno;
+	#else
+		#error "Undefine platform"
+	#endif
+	}
+
 	Socket::Socket(): socket_handle(~0)
 	{
 		
@@ -47,16 +58,16 @@ namespace HttpServer
 		obj.socket_handle = ~0;
 	}
 
-	System::native_socket_type Socket::open()
+	bool Socket::open()
 	{
 		close();
 
 		socket_handle = ::socket(AF_INET, SOCK_STREAM, 0);
 
-		return socket_handle;
+		return is_open();
 	}
 
-	int Socket::close()
+	bool Socket::close()
 	{
 		if (is_open() )
 		{
@@ -71,15 +82,15 @@ namespace HttpServer
 			if (0 == result)
 			{
 				socket_handle = ~0;
-			}
 
-			return result;
+				return true;
+			}
 		}
 
-		return ~0;
+		return false;
 	}
 
-	int Socket::bind(const int port) const
+	bool Socket::bind(const int port) const
 	{
 		const ::sockaddr_in sock_addr = {
             AF_INET,
@@ -88,12 +99,12 @@ namespace HttpServer
             0
         };
 
-		return ::bind(socket_handle, reinterpret_cast<const sockaddr *>(&sock_addr), sizeof(sockaddr_in) );
+		return 0 == ::bind(socket_handle, reinterpret_cast<const sockaddr *>(&sock_addr), sizeof(sockaddr_in) );
 	}
 
-	int Socket::listen() const
+	bool Socket::listen() const
 	{
-		return ::listen(socket_handle, SOMAXCONN);
+		return 0 == ::listen(socket_handle, SOMAXCONN);
 	}
 
 	Socket Socket::accept() const
@@ -170,20 +181,20 @@ namespace HttpServer
 		return Socket(client_socket);
 	}
 
-	int Socket::shutdown() const
+	bool Socket::shutdown() const
 	{
 		if (is_open() )
 		{
 		#ifdef WIN32
-			return ::shutdown(socket_handle, SD_BOTH);
+			return 0 == ::shutdown(socket_handle, SD_BOTH);
 		#elif POSIX
-			return ::shutdown(socket_handle, SHUT_RDWR);
+			return 0 == ::shutdown(socket_handle, SHUT_RDWR);
 		#else
 			#error "Undefine platform"
 		#endif
 		}
 
-		return -1;
+		return false;
 	}
 
 	bool Socket::nonblock(const bool isNonBlock) const
@@ -192,32 +203,34 @@ namespace HttpServer
 		unsigned long value = isNonBlock;
 		return 0 == ::ioctlsocket(socket_handle, FIONBIO, &value);
 	#elif POSIX
-		return -1 != ::fcntl(socket_handle, F_SETFL, isNonBlock ? O_NONBLOCK : O_SYNC);
+		return ~0 != ::fcntl(socket_handle, F_SETFL, isNonBlock ? O_NONBLOCK : O_SYNC);
 	#else
 		#error "Undefine platform"
 	#endif
 	}
 
-/*	bool Socket::is_nonblock() const
+/*
+	bool Socket::is_nonblock() const
 	{
 	#ifdef WIN32
 		
 	#elif POSIX
-		int flags = ::fcntl(socket_handle, F_GETFL, 0);
-		return (flags != -1) && (flags & O_NONBLOCK);
+		const int flags = ::fcntl(socket_handle, F_GETFL, 0);
+		return (flags != ~0) && (flags & O_NONBLOCK);
 	#else
 		#error "Undefine platform"
 	#endif
-	}*/
+	}
+*/
 
 	bool Socket::tcp_nodelay(const bool nodelay) const
 	{
 	#ifdef WIN32
 		int flags = nodelay ? 1 : 0;
-		return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, (char *)&flags, sizeof(flags) );
+		return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&flags), sizeof(flags) );
 	#elif POSIX
 		int flags = nodelay ? 1 : 0;
-		return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, (char *)&flags, sizeof(flags) );
+		return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, &flags, sizeof(flags) );
 	#else
 		#error "Undefine platform"
 	#endif
diff --git a/src/Socket.h b/src/Socket.h
@@ -36,6 +36,7 @@ namespace HttpServer
 	public:
 		bool static Startup();
 		bool static Cleanup();
+		int static getLastError();
 
 	public:
 		Socket();
@@ -45,8 +46,8 @@ namespace HttpServer
 
 		~Socket() = default;
 
-		System::native_socket_type open();
-		int close();
+		bool open();
+		bool close();
 
 		inline bool is_open() const
 		{
@@ -59,14 +60,14 @@ namespace HttpServer
 		#endif
 		}
 
-		int bind(const int port) const;
-		int listen() const;
+		bool bind(const int port) const;
+		bool listen() const;
 
 		Socket accept() const;
 		Socket nonblock_accept() const;
 		Socket nonblock_accept(const std::chrono::milliseconds &timeout) const;
 
-		int shutdown() const;
+		bool shutdown() const;
 
 		bool nonblock(const bool isNonBlock = true) const;
 	//	bool is_nonblock() const;
diff --git a/src/System.cpp b/src/System.cpp
@@ -21,9 +21,9 @@ namespace System
 		::HWND hWnd;
 	};
 
-    ::BOOL WINAPI EnumProc(::HWND hWnd, ::LPARAM lParam)
+	static ::BOOL WINAPI EnumProc(const ::HWND hWnd, const ::LPARAM lParam)
 	{
-		EnumData &ed = *reinterpret_cast<EnumData *>(lParam);
+		EnumData &ed = *reinterpret_cast<EnumData * const>(lParam);
 
 		native_processid_type process_id = 0;
 
@@ -143,7 +143,7 @@ namespace System
 			const std::string &file_path = filePath;
 		#endif
 
-		::HANDLE hFile = ::CreateFile(file_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
+		const ::HANDLE hFile = ::CreateFile(file_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
 
 		if (INVALID_HANDLE_VALUE == hFile)
 		{
@@ -187,7 +187,6 @@ namespace System
 
 		return true;
 	#elif POSIX
-		struct ::tm *clock;
 		struct ::stat attrib;
 
 		if (-1 == ::stat(filePath.c_str(), &attrib) )
@@ -197,7 +196,7 @@ namespace System
 
 		*fileSize = attrib.st_size;
 
-		clock = ::gmtime(&(attrib.st_mtime) );
+		struct ::tm *clock = ::gmtime(&(attrib.st_mtime) );
 
 		*fileTime = ::mktime(clock);
 

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,17 @@ namespace HttpServer`
`27`	`27`	`#endif`
`28`	`28`	`}`
`29`	`29`
	`30`	`+ int Socket::getLastError()`
	`31`	`+ {`
	`32`	`+ #ifdef WIN32`
	`33`	`+ return ::WSAGetLastError();`
	`34`	`+ #elif POSIX`
	`35`	`+ return errno;`
	`36`	`+ #else`
	`37`	`+ #error "Undefine platform"`
	`38`	`+ #endif`
	`39`	`+ }`
	`40`	`+`
`30`	`41`	`Socket::Socket(): socket_handle(~0)`
`31`	`42`	`{`
`32`	`43`
`@@ -47,16 +58,16 @@ namespace HttpServer`
`47`	`58`	`obj.socket_handle = ~0;`
`48`	`59`	`}`
`49`	`60`
`50`		`- System::native_socket_type Socket::open()`
	`61`	`+ bool Socket::open()`
`51`	`62`	`{`
`52`	`63`	`close();`
`53`	`64`
`54`	`65`	`socket_handle = ::socket(AF_INET, SOCK_STREAM, 0);`
`55`	`66`
`56`		`- return socket_handle;`
	`67`	`+ return is_open();`
`57`	`68`	`}`
`58`	`69`
`59`		`- int Socket::close()`
	`70`	`+ bool Socket::close()`
`60`	`71`	`{`
`61`	`72`	`if (is_open() )`
`62`	`73`	`{`
`@@ -71,15 +82,15 @@ namespace HttpServer`
`71`	`82`	`if (0 == result)`
`72`	`83`	`{`
`73`	`84`	`socket_handle = ~0;`
`74`		`- }`
`75`	`85`
`76`		`- return result;`
	`86`	`+ return true;`
	`87`	`+ }`
`77`	`88`	`}`
`78`	`89`
`79`		`- return ~0;`
	`90`	`+ return false;`
`80`	`91`	`}`
`81`	`92`
`82`		`- int Socket::bind(const int port) const`
	`93`	`+ bool Socket::bind(const int port) const`
`83`	`94`	`{`
`84`	`95`	`const ::sockaddr_in sock_addr = {`
`85`	`96`	`AF_INET,`
`@@ -88,12 +99,12 @@ namespace HttpServer`
`88`	`99`	`0`
`89`	`100`	`};`
`90`	`101`
`91`		`- return ::bind(socket_handle, reinterpret_cast<const sockaddr *>(&sock_addr), sizeof(sockaddr_in) );`
	`102`	`+ return 0 == ::bind(socket_handle, reinterpret_cast<const sockaddr *>(&sock_addr), sizeof(sockaddr_in) );`
`92`	`103`	`}`
`93`	`104`
`94`		`- int Socket::listen() const`
	`105`	`+ bool Socket::listen() const`
`95`	`106`	`{`
`96`		`- return ::listen(socket_handle, SOMAXCONN);`
	`107`	`+ return 0 == ::listen(socket_handle, SOMAXCONN);`
`97`	`108`	`}`
`98`	`109`
`99`	`110`	`Socket Socket::accept() const`
`@@ -170,20 +181,20 @@ namespace HttpServer`
`170`	`181`	`return Socket(client_socket);`
`171`	`182`	`}`
`172`	`183`
`173`		`- int Socket::shutdown() const`
	`184`	`+ bool Socket::shutdown() const`
`174`	`185`	`{`
`175`	`186`	`if (is_open() )`
`176`	`187`	`{`
`177`	`188`	`#ifdef WIN32`
`178`		`- return ::shutdown(socket_handle, SD_BOTH);`
	`189`	`+ return 0 == ::shutdown(socket_handle, SD_BOTH);`
`179`	`190`	`#elif POSIX`
`180`		`- return ::shutdown(socket_handle, SHUT_RDWR);`
	`191`	`+ return 0 == ::shutdown(socket_handle, SHUT_RDWR);`
`181`	`192`	`#else`
`182`	`193`	`#error "Undefine platform"`
`183`	`194`	`#endif`
`184`	`195`	`}`
`185`	`196`
`186`		`- return -1;`
	`197`	`+ return false;`
`187`	`198`	`}`
`188`	`199`
`189`	`200`	`bool Socket::nonblock(const bool isNonBlock) const`
`@@ -192,32 +203,34 @@ namespace HttpServer`
`192`	`203`	`unsigned long value = isNonBlock;`
`193`	`204`	`return 0 == ::ioctlsocket(socket_handle, FIONBIO, &value);`
`194`	`205`	`#elif POSIX`
`195`		`- return -1 != ::fcntl(socket_handle, F_SETFL, isNonBlock ? O_NONBLOCK : O_SYNC);`
	`206`	`+ return ~0 != ::fcntl(socket_handle, F_SETFL, isNonBlock ? O_NONBLOCK : O_SYNC);`
`196`	`207`	`#else`
`197`	`208`	`#error "Undefine platform"`
`198`	`209`	`#endif`
`199`	`210`	`}`
`200`	`211`
`201`		`-/* bool Socket::is_nonblock() const`
	`212`	`+/*`
	`213`	`+ bool Socket::is_nonblock() const`
`202`	`214`	`{`
`203`	`215`	`#ifdef WIN32`
`204`	`216`
`205`	`217`	`#elif POSIX`
`206`		`- int flags = ::fcntl(socket_handle, F_GETFL, 0);`
`207`		`- return (flags != -1) && (flags & O_NONBLOCK);`
	`218`	`+ const int flags = ::fcntl(socket_handle, F_GETFL, 0);`
	`219`	`+ return (flags != ~0) && (flags & O_NONBLOCK);`
`208`	`220`	`#else`
`209`	`221`	`#error "Undefine platform"`
`210`	`222`	`#endif`
`211`		`- }*/`
	`223`	`+ }`
	`224`	`+*/`
`212`	`225`
`213`	`226`	`bool Socket::tcp_nodelay(const bool nodelay) const`
`214`	`227`	`{`
`215`	`228`	`#ifdef WIN32`
`216`	`229`	`int flags = nodelay ? 1 : 0;`
`217`		`- return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, (char *)&flags, sizeof(flags) );`
	`230`	`+ return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&flags), sizeof(flags) );`
`218`	`231`	`#elif POSIX`
`219`	`232`	`int flags = nodelay ? 1 : 0;`
`220`		`- return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, (char *)&flags, sizeof(flags) );`
	`233`	`+ return 0 == setsockopt(socket_handle, IPPROTO_TCP, TCP_NODELAY, &flags, sizeof(flags) );`
`221`	`234`	`#else`
`222`	`235`	`#error "Undefine platform"`
`223`	`236`	`#endif`