Add ddnet masterserver registration

CMakeLists.txt

@@ -1269,6 +1269,7 @@ set_src(BASE GLOB_RECURSE src/base
   hash_ctxt.h
   hash_libtomcrypt.c
   hash_openssl.c
+  lock.h
   math.h
   system.c
   system.h
@@ -1358,6 +1359,8 @@ set_src(ENGINE_SHARED GLOB src/engine/shared
   snapshot.cpp
   snapshot.h
   storage.cpp
+  uuid_manager.cpp
+  uuid_manager.h
 )
 set(ENGINE_GENERATED_SHARED src/generated/nethash.cpp src/generated/protocol.cpp src/generated/protocol.h)
 set_src(GAME_SHARED GLOB src/game

src/base/lock.h

@@ -0,0 +1,135 @@
+#ifndef BASE_LOCK_H
+#define BASE_LOCK_H
+
+#include <mutex>
+
+// Enable thread safety attributes only with clang.
+// The attributes can be safely erased when compiling with other compilers.
+#if defined(__clang__) && (!defined(SWIG))
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
+#else
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
+#endif
+
+#define CAPABILITY(x) \
+	THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
+
+#define SCOPED_CAPABILITY \
+	THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+#define GUARDED_BY(x) \
+	THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+
+#define PT_GUARDED_BY(x) \
+	THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+#define ACQUIRED_BEFORE(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+#define ACQUIRED_AFTER(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define REQUIRES(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
+
+#define REQUIRES_SHARED(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
+
+#define ACQUIRE(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
+
+#define ACQUIRE_SHARED(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
+
+#define RELEASE(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
+
+#define RELEASE_SHARED(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
+
+#define RELEASE_GENERIC(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(release_generic_capability(__VA_ARGS__))
+
+#define TRY_ACQUIRE(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
+
+#define TRY_ACQUIRE_SHARED(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
+
+#define EXCLUDES(...) \
+	THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+#define ASSERT_CAPABILITY(x) \
+	THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
+
+#define ASSERT_SHARED_CAPABILITY(x) \
+	THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
+
+#define RETURN_CAPABILITY(x) \
+	THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#define NO_THREAD_SAFETY_ANALYSIS \
+	THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+/**
+ * @defgroup Locks
+ * @see Threads
+ */
+
+/**
+ * Wrapper for `std::mutex`.
+ *
+ * @ingroup Locks
+ *
+ * @remark This wrapper is only necessary because the clang thread-safety attributes
+ * are not available for `std::mutex` except when explicitly using libc++.
+ */
+class CAPABILITY("mutex") CLock
+{
+public:
+	CLock() = default;
+
+	void lock() ACQUIRE()
+	{
+		m_Mutex.lock();
+	}
+
+	void unlock() RELEASE()
+	{
+		m_Mutex.unlock();
+	}
+
+	// To support negative capabilities, otherwise EXCLUDES(m_Lock) must be used instead of REQUIRES(!m_Lock)
+	const CLock &operator!() const { return *this; }
+
+private:
+	std::mutex m_Mutex;
+};
+
+/**
+ * RAII-style wrapper for owning a `CLock`.
+ *
+ * @ingroup Locks
+ * 
+ * @remark This wrapper is only necessary because the clang thread-safety attributes
+ * are not available for `std::lock_guard` except when explicitly using libc++.
+ */
+class SCOPED_CAPABILITY CLockScope
+{
+public:
+	explicit CLockScope(CLock &Lock) ACQUIRE(Lock, m_Lock) :
+		m_Lock(Lock)
+	{
+		m_Lock.lock();
+	}
+
+	~CLockScope() RELEASE() REQUIRES(m_Lock)
+	{
+		m_Lock.unlock();
+	}
+
+private:
+	CLock &m_Lock;
+};
+
+#endif

src/base/system.c

@@ -2513,6 +2513,65 @@ void str_hex(char *dst, int dst_size, const void *data, int data_size)
 	}
 }
 
+static int hexval(char x)
+{
+	switch(x)
+	{
+	case '0': return 0;
+	case '1': return 1;
+	case '2': return 2;
+	case '3': return 3;
+	case '4': return 4;
+	case '5': return 5;
+	case '6': return 6;
+	case '7': return 7;
+	case '8': return 8;
+	case '9': return 9;
+	case 'a':
+	case 'A': return 10;
+	case 'b':
+	case 'B': return 11;
+	case 'c':
+	case 'C': return 12;
+	case 'd':
+	case 'D': return 13;
+	case 'e':
+	case 'E': return 14;
+	case 'f':
+	case 'F': return 15;
+	default: return -1;
+	}
+}
+
+static int byteval(const char *hex, unsigned char *dst)
+{
+	int v1 = hexval(hex[0]);
+	int v2 = hexval(hex[1]);
+
+	if(v1 < 0 || v2 < 0)
+		return 1;
+
+	*dst = v1 * 16 + v2;
+	return 0;
+}
+
+int str_hex_decode(void *dst, int dst_size, const char *src)
+{
+	unsigned char *cdst = (unsigned char *)dst;
+	int slen = str_length(src);
+	int len = slen / 2;
+	int i;
+	if(slen != dst_size * 2)
+		return 2;
+
+	for(i = 0; i < len && dst_size; i++, dst_size--)
+	{
+		if(byteval(src + i * 2, cdst++))
+			return 1;
+	}
+	return 0;
+}
+
 int str_is_number(const char *str)
 {
 	while(*str)
@@ -2830,6 +2889,37 @@ unsigned str_quickhash(const char *str)
 	return hash;
 }
 
+static const char *str_token_get(const char *str, const char *delim, int *length)
+{
+	size_t len = strspn(str, delim);
+	if(len > 1)
+		str++;
+	else
+		str += len;
+	if(!*str)
+		return NULL;
+
+	*length = strcspn(str, delim);
+	return str;
+}
+
+const char *str_next_token(const char *str, const char *delim, char *buffer, int buffer_size)
+{
+	int len = 0;
+	const char *tok = str_token_get(str, delim, &len);
+	if(len < 0 || tok == NULL)
+	{
+		buffer[0] = '\0';
+		return NULL;
+	}
+
+	len = buffer_size > len ? len : buffer_size - 1;
+	mem_copy(buffer, tok, len);
+	buffer[len] = '\0';
+
+	return tok + len;
+}
+
 struct SECURE_RANDOM_DATA
 {
 	int initialized;

src/base/system.h

@@ -1279,6 +1279,26 @@ const char *str_find(const char *haystack, const char *needle);
 */
 void str_hex(char *dst, int dst_size, const void *data, int data_size);
 
+/*
+	Function: str_hex_decode
+		Takes a hex string *without spaces between bytes* and returns a
+		byte array.
+
+	Parameters:
+		dst - Buffer for the byte array
+		dst_size - size of the buffer
+		data - String to decode
+
+	Returns:
+		2 - String doesn't exactly fit the buffer
+		1 - Invalid character in string
+		0 - Success
+
+	Remarks:
+		- The contents of the buffer is only valid on success
+*/
+int str_hex_decode(void *dst, int dst_size, const char *src);
+
 /*
 	Function: str_is_number
 		Check if the string contains only digits.
@@ -1617,6 +1637,24 @@ int str_isspace(char c);
 char str_uppercase(char c);
 unsigned str_quickhash(const char *str);
 
+/*
+	Function: str_next_token
+		Writes the next token after str into buf, returns the rest of the string.
+
+	Parameters:
+		str - Pointer to string.
+		delim - Delimiter for tokenization.
+		buffer - Buffer to store token in.
+		buffer_size - Size of the buffer.
+
+	Returns:
+		Pointer to rest of the string.
+
+	Remarks:
+		- The token is always null-terminated.
+*/
+const char *str_next_token(const char *str, const char *delim, char *buffer, int buffer_size);
+
 enum
 {
 	UTF8_BYTE_LENGTH = 4

src/engine/client/client.cpp

@@ -1770,28 +1770,28 @@ void CClient::VersionUpdate()
 	}
 	else if(m_VersionInfo.m_State == CVersionInfo::STATE_START)
 	{
-		if(m_VersionInfo.m_VersionServeraddr.m_Job.Status() == CJob::STATE_DONE)
-		{
-			if(m_VersionInfo.m_VersionServeraddr.m_Job.Result() == 0)
-			{
-				CNetChunk Packet;
-
-				mem_zero(&Packet, sizeof(Packet));
-
-				m_VersionInfo.m_VersionServeraddr.m_Addr.port = VERSIONSRV_PORT;
-
-				Packet.m_ClientID = -1;
-				Packet.m_Address = m_VersionInfo.m_VersionServeraddr.m_Addr;
-				Packet.m_pData = VERSIONSRV_GETVERSION;
-				Packet.m_DataSize = sizeof(VERSIONSRV_GETVERSION);
-				Packet.m_Flags = NETSENDFLAG_CONNLESS;
-
-				m_ContactClient.Send(&Packet);
-				m_VersionInfo.m_State = CVersionInfo::STATE_READY;
-			}
-			else
-				m_VersionInfo.m_State = CVersionInfo::STATE_ERROR;
-		}
+		// if(m_VersionInfo.m_VersionServeraddr.m_Job.Status() == CJob::STATE_DONE)
+		// {
+		// 	if(m_VersionInfo.m_VersionServeraddr.m_Job.Result() == 0)
+		// 	{
+		// 		CNetChunk Packet;
+
+		// 		mem_zero(&Packet, sizeof(Packet));
+
+		// 		m_VersionInfo.m_VersionServeraddr.m_Addr.port = VERSIONSRV_PORT;
+
+		// 		Packet.m_ClientID = -1;
+		// 		Packet.m_Address = m_VersionInfo.m_VersionServeraddr.m_Addr;
+		// 		Packet.m_pData = VERSIONSRV_GETVERSION;
+		// 		Packet.m_DataSize = sizeof(VERSIONSRV_GETVERSION);
+		// 		Packet.m_Flags = NETSENDFLAG_CONNLESS;
+
+		// 		m_ContactClient.Send(&Packet);
+		// 		m_VersionInfo.m_State = CVersionInfo::STATE_READY;
+		// 	}
+		// 	else
+		// 		m_VersionInfo.m_State = CVersionInfo::STATE_ERROR;
+		// }
 	}
 }