Add Objective-C nullability & update code formatting

contrib/objc/RWSSocketObjc.h

@@ -34,7 +34,7 @@
 @required
 /**
  @brief Websocket connected.
- @detailed Connection extablished and handshake done. 
+ @detailed Connection extablished and handshake done.
  Web socket ready to send and receive.
  @param socket Socket object.
  */
@@ -43,7 +43,7 @@
 
 /**
  @brief Socket client disconnected.
- @detailed Internal socket already freed and dealocated. 
+ @detailed Internal socket already freed and dealocated.
  Connect once again.
  @param socket Socket object.
  @param error Disconnect error.
@@ -81,7 +81,7 @@
 /**
  @brief Weak read/write reference to delegate object.
  */
-@property (nonatomic, weak) id<RWSSocketObjcDelegate> delegate;
+@property (nullable, nonatomic, weak) id<RWSSocketObjcDelegate> delegate;
 
 
 /**

contrib/objc/RWSSocketObjc.m

@@ -24,8 +24,7 @@
 #import "RWSSocketObjc.h"
 #include "../../librws.h"
 
-@interface RWSSocketObjc()
-{
+@interface RWSSocketObjc() {
 @private
 	rws_socket _socket;
 	__strong NSURL * _url;
@@ -35,127 +34,118 @@
 
 @implementation RWSSocketObjc
 
-- (void) onDisconnected
-{
+- (void) onDisconnected {
 	rws_error error = rws_socket_get_error(_socket);
 	_socket = NULL;
-
+	
 	NSError * err = nil;
-	if (error) err = [NSError errorWithDomain:@"RWSSocket"
-										 code:rws_error_get_code(error)
-									 userInfo:@{ NSLocalizedDescriptionKey : [NSString stringWithUTF8String:rws_error_get_description(error)] }];
-
+	if (error) {
+		err = [NSError errorWithDomain:@"RWSSocket"
+								  code:rws_error_get_code(error)
+							  userInfo:@{ NSLocalizedDescriptionKey : [NSString stringWithUTF8String:rws_error_get_description(error)] }];
+	}
+	
 	id<RWSSocketObjcDelegate> d = self.delegate;
-	if (d && [d respondsToSelector:@selector(onRWSSocketDisconnected:withError:)])
-	{
+	if (d && [d respondsToSelector:@selector(onRWSSocketDisconnected:withError:)]) {
 		dispatch_async(dispatch_get_main_queue(), ^{ [d onRWSSocketDisconnected:self withError:err]; });
 	}
 }
 
-static void onRWSSocketObjcConnected(rws_socket socket)
-{
+static void onRWSSocketObjcConnected(rws_socket socket) {
 	RWSSocketObjc * s = (__bridge RWSSocketObjc *)rws_socket_get_user_object(socket);
 	id<RWSSocketObjcDelegate> d = s ? [s delegate] : nil;
-	if (d && [d respondsToSelector:@selector(onRWSSocketConnected:)])
-	{
+	if (d && [d respondsToSelector:@selector(onRWSSocketConnected:)]) {
 		dispatch_async(dispatch_get_main_queue(), ^{ [d onRWSSocketConnected:s]; });
 	}
 }
 
-static void onRWSSocketObjcDisconnected(rws_socket socket)
-{
+static void onRWSSocketObjcDisconnected(rws_socket socket) {
 	RWSSocketObjc * s = (__bridge RWSSocketObjc *)rws_socket_get_user_object(socket);
-	if (s) [s onDisconnected];
+	if (s) {
+		[s onDisconnected];
+	}
 }
 
-static void onRWSSocketObjcRecvdText(rws_socket socket, const char * text, const unsigned int length)
-{
+static void onRWSSocketObjcRecvdText(rws_socket socket, const char * text, const unsigned int length) {
 	RWSSocketObjc * s = (__bridge RWSSocketObjc *)rws_socket_get_user_object(socket);
 	id<RWSSocketObjcDelegate> d = s ? [s delegate] : nil;
-	if (text && length && d && [d respondsToSelector:@selector(onRWSSocket:receivedText:)])
-	{
+	if (text && length && d && [d respondsToSelector:@selector(onRWSSocket:receivedText:)]) {
 		NSString * t = [NSString stringWithUTF8String:text];
 		dispatch_async(dispatch_get_main_queue(), ^{ [d onRWSSocket:s receivedText:t]; });
 	}
 }
 
-static void onRWSSocketObjcRecvdBin(rws_socket socket, const void * data, const unsigned int length)
-{
+static void onRWSSocketObjcRecvdBin(rws_socket socket, const void * data, const unsigned int length) {
 	RWSSocketObjc * s = (__bridge RWSSocketObjc *)rws_socket_get_user_object(socket);
 	id<RWSSocketObjcDelegate> d = s ? [s delegate] : nil;
-	if (data && length && d && [d respondsToSelector:@selector(onRWSSocket:receivedData:)])
-	{
+	if (data && length && d && [d respondsToSelector:@selector(onRWSSocket:receivedData:)]) {
 		NSData * dt = [NSData dataWithBytes:data length:length];
 		dispatch_async(dispatch_get_main_queue(), ^{ [d onRWSSocket:s receivedData:dt]; });
 	}
 }
 
-- (BOOL) sendText:(NSString *) text
-{
-	if (text && [text length])
-	{
-		if (rws_socket_send_text(_socket, [text UTF8String])) return YES;
+- (BOOL) sendText:(NSString *) text {
+	if (text && [text length]) {
+		if (rws_socket_send_text(_socket, [text UTF8String])) {
+			return YES;
+		}
 	}
 	return NO;
 }
 
-- (void) cleanup
-{
-	if (_socket)
-	{
+- (void) cleanup {
+	if (_socket) {
 		rws_socket_set_user_object(_socket, NULL);
 		rws_socket_disconnect_and_release(_socket);
 		_socket = NULL;
 	}
 }
 
-- (BOOL) connect
-{
+- (BOOL) connect {
 	[self cleanup];
-	if (!_url) return NO;
-
+	if (!_url) {
+		return NO;
+	}
+	
 	_socket = rws_socket_create();
 	rws_socket_set_scheme(_socket, [[_url scheme] UTF8String]);
 	rws_socket_set_host(_socket, [[_url host] UTF8String]);
 	rws_socket_set_port(_socket, [[_url port] intValue]);
-
+	
 	NSString * path = [_url path];
-	if (!path || [path length] == 0) path = @"/";
+	if (!path || [path length] == 0) {
+		path = @"/";
+	}
 	rws_socket_set_path(_socket, [path UTF8String]);
-
+	
 	rws_socket_set_user_object(_socket, (__bridge void *)self);
-
+	
 	rws_socket_set_on_disconnected(_socket, &onRWSSocketObjcDisconnected);
 	rws_socket_set_on_connected(_socket, &onRWSSocketObjcConnected);
 	rws_socket_set_on_received_text(_socket, &onRWSSocketObjcRecvdText);
 	rws_socket_set_on_received_bin(_socket, &onRWSSocketObjcRecvdBin);
-
+	
 	return rws_socket_connect(_socket) ? YES : NO;
 }
 
-- (BOOL) isConnected
-{
+- (BOOL) isConnected {
 	return rws_socket_is_connected(_socket) ? YES : NO;
 }
 
-- (nullable id) initWithURL:(nonnull NSURL *) url
-{
+- (nullable id) initWithURL:(nonnull NSURL *) url {
 	self = [super init];
-	if (self && url)
-	{
+	if (self && url) {
 		_url = url;
 		return self;
 	}
 	return nil;
 }
 
-- (id) init
-{
+- (id) init {
 	return nil;
 }
 
-- (void) dealloc
-{
+- (void) dealloc {
 	[self cleanup];
 }
 

librws.h

@@ -280,7 +280,7 @@ RWS_API(rws_bool) rws_socket_connect(rws_socket socket);
 
 
 /**
- @brief Disconnect socket. 
+ @brief Disconnect socket.
  @detailed Cleanup prev. send messages and start disconnection sequence.
  SHOULD forget about this socket handle and don't use it anymore.
  @warning Don't use this socket object handler after this command.
@@ -338,25 +338,24 @@ RWS_API(void) rws_socket_set_on_received_bin(rws_socket socket, rws_on_socket_re
 
 // error
 
-typedef enum _rws_error_code
-{
+typedef enum _rws_error_code {
 	rws_error_code_none = 0,
-
+	
 	rws_error_code_missed_parameter,
-
+	
 	rws_error_code_send_handshake,
 	rws_error_code_parse_handshake,
 	rws_error_code_read_write_socket,
 	rws_error_code_connect_to_host,
-
+	
 	/**
 	 @brief Connection was closed by endpoint.
 	 Reasons: an endpoint shutting down, an endpoint having received a frame too large, or an
 	 endpoint having received a frame that does not conform to the format expected by the endpoint.
 	 */
 	rws_error_code_connection_closed,
-
-
+	
+	
 } rws_error_code;
 
 

src/rws_error.c

@@ -28,53 +28,44 @@
 
 
 // private
-_rws_error * rws_error_create(void)
-{
+_rws_error * rws_error_create(void) {
 	_rws_error * e = (_rws_error *)rws_malloc_zero(sizeof(_rws_error));
 	return e;
 }
 
-_rws_error * rws_error_new_code_descr(const int code, const char * description)
-{
+_rws_error * rws_error_new_code_descr(const int code, const char * description) {
 	_rws_error * e = (_rws_error *)rws_malloc_zero(sizeof(_rws_error));
 	e->code = code;
 	e->description = rws_string_copy(description);
 	return e;
 }
 
-void rws_error_delete(_rws_error * error)
-{
-	if (error)
-	{
+void rws_error_delete(_rws_error * error) {
+	if (error) {
 		rws_string_delete(error->description);
 		rws_free(error);
 	}
 }
 
-void rws_error_delete_clean(_rws_error ** error)
-{
-	if (error)
-	{
+void rws_error_delete_clean(_rws_error ** error) {
+	if (error) {
 		rws_error_delete(*error);
 		*error = NULL;
 	}
 }
 
 // public
-int rws_error_get_code(rws_error error)
-{
+int rws_error_get_code(rws_error error) {
 	_rws_error * e = (_rws_error *)error;
 	return e ? e->code : 0;
 }
 
-int rws_error_get_http_error(rws_error error)
-{
+int rws_error_get_http_error(rws_error error) {
 	_rws_error * e = (_rws_error *)error;
 	return e ? e->http_error : 0;
 }
 
-const char * rws_error_get_description(rws_error error)
-{
+const char * rws_error_get_description(rws_error error) {
 	_rws_error * e = (_rws_error *)error;
 	return e ? e->description : NULL;
 }

src/rws_error.h

@@ -26,8 +26,7 @@
 
 #include "rws_string.h"
 
-typedef struct _rws_error_struct
-{
+typedef struct _rws_error_struct {
 	int code;
 	int http_error;
 	char * description;

src/rws_frame.c

@@ -29,40 +29,39 @@
 #include <assert.h>
 #include <time.h>
 
-_rws_frame * rws_frame_create_with_recv_data(const void * data, const size_t data_size)
-{
-	if (data && data_size >= 2)
-	{
+_rws_frame * rws_frame_create_with_recv_data(const void * data, const size_t data_size) {
+	if (data && data_size >= 2) {
 		const unsigned char * udata = (const unsigned char *)data;
-
+		
 		const rws_opcode opcode = (rws_opcode)(udata[0] & 0x0f);
 		const unsigned int is_finshd = (udata[0] >> 7) & 0x01;
 		const unsigned int is_masked = (udata[1] >> 7) & 0x01;
 		const unsigned int payload = udata[1] & 0x7f;
 		unsigned int header_size = is_masked ? 6 : 2;
-
+		
 		unsigned int expected_size = 0, mask_pos = 0;
 		size_t index = 0;
 		_rws_frame * frame = NULL;
 		const unsigned char * actual_udata = NULL;
 		unsigned char * unmasked = NULL;
-
-		switch (payload)
-		{
+		
+		switch (payload) {
 			case 126: header_size += 2; break;
 			case 127: header_size += 8; break;
 			default: break;
 		}
-		if (data_size < header_size) return NULL;
-
-		switch (payload)
-		{
+		
+		if (data_size < header_size) {
+			return NULL;
+		}
+		
+		switch (payload) {
 			case 126:
 				expected_size |= ((unsigned int)udata[2]) << 8;
 				expected_size |= (unsigned int)udata[3];
 				mask_pos = 4;
 				break;
-
+				
 			case 127:
 				expected_size |= ((unsigned int)udata[6]) << 24;
 				expected_size |= ((unsigned int)udata[7]) << 16;
@@ -70,50 +69,45 @@ _rws_frame * rws_frame_create_with_recv_data(const void * data, const size_t dat
 				expected_size |= (unsigned int)udata[9];
 				mask_pos = 10;
 				break;
-
+				
 			default:
-				if (payload <= 125)
-				{
+				if (payload <= 125) {
 					mask_pos = 2;
 					expected_size = payload;
 				}
 				break;
 		}
-
+		
 		frame = rws_frame_create();
-
+		
 		frame->opcode = opcode;
 		if (is_finshd) frame->is_finished = rws_true;
 		frame->header_size = (unsigned char)header_size;
-		if (is_masked)
-		{
+		
+		if (is_masked) {
 			frame->is_masked = rws_true;
 			memcpy(frame->mask, &udata[mask_pos], 4);
 		}
-
-		if (opcode == rws_opcode_connection_close || opcode == rws_opcode_pong) return frame;
-
-		if (!is_finshd )
-		{
+		
+		if (opcode == rws_opcode_connection_close || opcode == rws_opcode_pong) {
+			return frame;
+		}
+		
+		if (!is_finshd) {
 			frame->is_finished = rws_false;
 		}
-
-		if (expected_size > 0)
-		{
+		
+		if (expected_size > 0) {
 			frame->data = rws_malloc(expected_size);
 			frame->data_size = expected_size;
 			actual_udata = udata + header_size;
-			if (is_masked)
-			{
+			if (is_masked) {
 				unmasked = (unsigned char *)frame->data;
-				for (index = 0; index < expected_size; index++)
-				{
+				for (index = 0; index < expected_size; index++) {
 					*unmasked = *actual_udata ^ frame->mask[index & 0x3];
 					unmasked++; actual_udata++;
 				}
-			}
-			else
-			{
+			} else {
 				memcpy(frame->data, actual_udata, expected_size);
 			}
 		}
@@ -122,67 +116,56 @@ _rws_frame * rws_frame_create_with_recv_data(const void * data, const size_t dat
 	return NULL;
 }
 
-void rws_frame_create_header(_rws_frame * f, unsigned char * header, const size_t data_size)
-{
+void rws_frame_create_header(_rws_frame * f, unsigned char * header, const size_t data_size) {
 	const unsigned int size = (unsigned int)data_size;
-
+	
 	*header++ = 0x80 | f->opcode;
-	if (size < 126)
-	{
+	if (size < 126) {
 		*header++ = (size & 0xff) | (f->is_masked ? 0x80 : 0);
 		f->header_size = 2;
-	}
-	else if (size < 65536)
-	{
+	} else if (size < 65536) {
 		*header++ = 126 | (f->is_masked ? 0x80 : 0);
 		*header++ = (size >> 8) & 0xff;
 		*header++ = size & 0xff;
 		f->header_size = 4;
-	}
-	else
-	{
+	} else {
 		*header++ = 127 | (f->is_masked ? 0x80 : 0);
-
+		
 		*(unsigned int *)header = 0;
 		header += 4;
-
+		
 		*header++ = (size >> 24) & 0xff;
 		*header++ = (size >> 16) & 0xff;
 		*header++ = (size >> 8) & 0xff;
 		*header++ = size & 0xff;
 		f->header_size = 10;
 	}
-
-	if (f->is_masked)
-	{
+	
+	if (f->is_masked) {
 		memcpy(header, f->mask, 4);
 		f->header_size += 4;
 	}
 }
 
-void rws_frame_fill_with_send_data(_rws_frame * f, const void * data, const size_t data_size)
-{
+void rws_frame_fill_with_send_data(_rws_frame * f, const void * data, const size_t data_size) {
 	unsigned char header[16];
 	unsigned char * frame = NULL;
 	unsigned char mask[4];
 	size_t index = 0;
-
+	
 	rws_frame_create_header(f, header, data_size);
 	f->data_size = data_size + f->header_size;
 	f->data = rws_malloc(f->data_size);
 	frame = (unsigned char *)f->data;
 	memcpy(frame, header, f->header_size);
-
-	if (data) // have data to send
-	{
+	
+	if (data) { // have data to send
 		frame += f->header_size;
 		memcpy(frame, data, data_size);
-
-		if (f->is_masked)
-		{
+		
+		if (f->is_masked) {
 			memcpy(mask, &f->mask, 4);
-			for (index = 0; index < data_size; index++)
-			{
+			for (index = 0; index < data_size; index++) {
 				*frame = *frame ^ mask[index & 0x3];
 				frame++;
 			}
@@ -191,98 +174,94 @@ void rws_frame_fill_with_send_data(_rws_frame * f, const void * data, const size
 	f->is_finished = rws_true;
 }
 
-void rws_frame_combine_datas(_rws_frame * to, _rws_frame * from)
-{
+void rws_frame_combine_datas(_rws_frame * to, _rws_frame * from) {
 	unsigned char * comb_data = (unsigned char *)rws_malloc(to->data_size + from->data_size);
-	if (comb_data)
-	{
-		if (to->data && to->data_size) memcpy(comb_data, to->data, to->data_size);
+	if (comb_data) {
+		if (to->data && to->data_size) {
+			memcpy(comb_data, to->data, to->data_size);
+		}
 		comb_data += to->data_size;
-		if (from->data && from->data_size) memcpy(comb_data, from->data, from->data_size);
+		if (from->data && from->data_size) {
+			memcpy(comb_data, from->data, from->data_size);
+		}
 	}
 	rws_free(to->data);
 	to->data = comb_data;
 	to->data_size += from->data_size;
 }
 
-_rws_frame * rws_frame_create(void)
-{
+_rws_frame * rws_frame_create(void) {
 	_rws_frame * f = (_rws_frame *)rws_malloc_zero(sizeof(_rws_frame));
 	union {
 		unsigned int ui;
 		unsigned char b[4];
 	} mask_union;
 	assert(sizeof(unsigned int) == 4);
-//	mask_union.ui = 2018915346;
+	//	mask_union.ui = 2018915346;
 	mask_union.ui = (rand() / (RAND_MAX / 2) + 1) * rand();
 	memcpy(f->mask, mask_union.b, 4);
 	return f;
 }
 
-void rws_frame_delete(_rws_frame * f)
-{
-	if (f)
-	{
+void rws_frame_delete(_rws_frame * f) {
+	if (f) {
 		rws_free(f->data);
 		rws_free(f);
 	}
 }
 
-void rws_frame_delete_clean(_rws_frame ** f)
-{
-	if (f)
-	{
+void rws_frame_delete_clean(_rws_frame ** f) {
+	if (f) {
 		rws_frame_delete(*f);
 		*f = NULL;
 	}
 }
 
-size_t rws_check_recv_frame_size( const void *data ,const size_t data_size)
-{
-    if (data && data_size >= 2)
-    {
-        const unsigned char * udata = (const unsigned char *)data;
-//        const unsigned int is_finshd = (udata[0] >> 7) & 0x01;
-        const unsigned int is_masked = (udata[1] >> 7) & 0x01;
-        const unsigned int payload = udata[1] & 0x7f;
-        unsigned int header_size = is_masked ? 6 : 2;
-
-        unsigned int expected_size = 0;
-      
-
-        switch (payload)
-        {
-        case 126: header_size += 2; break;
-        case 127: header_size += 8; break;
-        default: break;
-        }
-        if (data_size < header_size) return 0;
-
-        switch (payload)
-        {
-        case 126:
-            expected_size |= ((unsigned int)udata[2]) << 8;
-            expected_size |= (unsigned int)udata[3];
-            break;
-
-        case 127:
-            expected_size |= ((unsigned int)udata[6]) << 24;
-            expected_size |= ((unsigned int)udata[7]) << 16;
-            expected_size |= ((unsigned int)udata[8]) << 8;
-            expected_size |= (unsigned int)udata[9];
-            break;
-
-        default:
-            if (payload <= 125)
-            {
-                expected_size = payload;
-            }
-            break;
-        }
-        unsigned int nPackSize = expected_size+header_size;
-        return (nPackSize <= data_size)?nPackSize:0;
-    }
-    return 0;
+size_t rws_check_recv_frame_size( const void *data ,const size_t data_size) {
+	if (data && data_size >= 2) {
+		const unsigned char * udata = (const unsigned char *)data;
+		//        const unsigned int is_finshd = (udata[0] >> 7) & 0x01;
+		const unsigned int is_masked = (udata[1] >> 7) & 0x01;
+		const unsigned int payload = udata[1] & 0x7f;
+		unsigned int header_size = is_masked ? 6 : 2;
+		
+		unsigned int expected_size = 0;
+		
+		
+		switch (payload) {
+			case 126: header_size += 2; break;
+			case 127: header_size += 8; break;
+			default: break;
+		}
+		
+		if (data_size < header_size) {
+			return 0;
+		}
+		
+		switch (payload) {
+			case 126:
+				expected_size |= ((unsigned int)udata[2]) << 8;
+				expected_size |= (unsigned int)udata[3];
+				break;
+				
+			case 127:
+				expected_size |= ((unsigned int)udata[6]) << 24;
+				expected_size |= ((unsigned int)udata[7]) << 16;
+				expected_size |= ((unsigned int)udata[8]) << 8;
+				expected_size |= (unsigned int)udata[9];
+				break;
+				
+			default:
+				if (payload <= 125) {
+					expected_size = payload;
+				}
+				break;
+		}
+		
+		const unsigned int nPackSize = expected_size + header_size;
+		return (nPackSize <= data_size) ? nPackSize : 0;
+	}
+	return 0;
 }
 
 

src/rws_frame.h

@@ -27,8 +27,7 @@
 #include "../librws.h"
 #include "rws_common.h"
 
-typedef enum _rws_opcode
-{
+typedef enum _rws_opcode {
 	rws_opcode_continuation = 0x0, // %x0 denotes a continuation frame
 	rws_opcode_text_frame = 0x1, // %x1 denotes a text frame
 	rws_opcode_binary_frame = 0x2, // %x2 denotes a binary frame
@@ -37,8 +36,7 @@ typedef enum _rws_opcode
 	rws_opcode_pong = 0xA // %xA denotes a pong
 } rws_opcode;
 
-typedef struct _rws_frame_struct
-{
+typedef struct _rws_frame_struct {
 	void * data;
 	size_t data_size;
 	rws_opcode opcode;
@@ -64,4 +62,4 @@ void rws_frame_delete(_rws_frame * f);
 
 void rws_frame_delete_clean(_rws_frame ** f);
 
-#endif 
+#endif

src/rws_list.c

@@ -24,35 +24,28 @@
 #include "rws_list.h"
 #include "rws_memory.h"
 
-_rws_list * rws_list_create(void)
-{
+_rws_list * rws_list_create(void) {
 	return (_rws_list *)rws_malloc_zero(sizeof(_rws_list));
 }
 
-void rws_list_delete(_rws_list * list)
-{
+void rws_list_delete(_rws_list * list) {
 	_rws_list * cur = list;
-	while (cur)
-	{
+	while (cur) {
 		_rws_list * prev = cur;
 		cur = cur->next;
 		rws_free(prev);
 	}
 }
 
-void rws_list_delete_clean(_rws_list ** list)
-{
-	if (list)
-	{
+void rws_list_delete_clean(_rws_list ** list) {
+	if (list) {
 		rws_list_delete(*list);
 		*list = NULL;
 	}
 }
 
-void rws_list_append(_rws_list * list, _rws_node_value value)
-{
-	if (list)
-	{
+void rws_list_append(_rws_list * list, _rws_node_value value) {
+	if (list) {
 		_rws_list * cur = list;
 		while (cur->next) cur = cur->next;
 		cur->next = (_rws_node *)rws_malloc_zero(sizeof(_rws_node));

src/rws_list.h

@@ -26,16 +26,14 @@
 
 #include <stdio.h>
 
-typedef union _rws_node_value_union
-{
+typedef union _rws_node_value_union {
 	void * object;
 	char * string;
 	int int_value;
 	unsigned int uint_value;
 } _rws_node_value;
 
-typedef struct _rws_node_struct
-{
+typedef struct _rws_node_struct {
 	_rws_node_value value;
 	struct _rws_node_struct * next;
 } _rws_node, _rws_list;

src/rws_memory.c

@@ -26,10 +26,8 @@
 #include <stdlib.h>
 #include <assert.h>
 
-void * rws_malloc(const size_t size)
-{
-	if (size > 0)
-	{
+void * rws_malloc(const size_t size) {
+	if (size > 0) {
 		void * mem = malloc(size);
 		assert(mem);
 		return mem;
@@ -37,29 +35,24 @@ void * rws_malloc(const size_t size)
 	return NULL;
 }
 
-void * rws_malloc_zero(const size_t size)
-{
+void * rws_malloc_zero(const size_t size) {
 	void * mem = rws_malloc(size);
-	if (mem)
-	{
+	if (mem) {
 		memset(mem, 0, size);
 	}
 	return mem;
 }
 
-void rws_free(void * mem)
-{
-	if (mem) free(mem);
+void rws_free(void * mem) {
+	if (mem) {
+		free(mem);
+	}
 }
 
-void rws_free_clean(void ** mem)
-{
-	if (mem)
-	{
+void rws_free_clean(void ** mem) {
+	if (mem) {
 		rws_free(*mem);
 		*mem = NULL;
 	}
 }
 
-
-

src/rws_socket.h

@@ -59,8 +59,7 @@ typedef int rws_socket_t;
 static const char * k_rws_socket_min_http_ver = "1.1";
 static const char * k_rws_socket_sec_websocket_accept = "Sec-WebSocket-Accept";
 
-typedef struct _rws_socket_struct
-{
+typedef struct _rws_socket_struct {
 	int port;
 	rws_socket_t socket;
 	char * scheme;

src/rws_socketpriv.c

@@ -34,15 +34,15 @@
 #define	WSAEINPROGRESS     EINPROGRESS	
 #endif
 
-unsigned int rws_socket_get_next_message_id(_rws_socket * s)
-{
+unsigned int rws_socket_get_next_message_id(_rws_socket * s) {
 	const unsigned int mess_id = ++s->next_message_id;
-	if (mess_id > 9999999) s->next_message_id = 0;
+	if (mess_id > 9999999) {
+		s->next_message_id = 0;
+	}
 	return mess_id;
 }
 
-void rws_socket_send_ping(_rws_socket * s)
-{
+void rws_socket_send_ping(_rws_socket * s) {
 	char buff[16];
 	size_t len = 0;
 	_rws_frame * frame = rws_frame_create();
@@ -55,54 +55,58 @@ void rws_socket_send_ping(_rws_socket * s)
 	rws_socket_append_send_frames(s, frame);
 }
 
-void rws_socket_inform_recvd_frames(_rws_socket * s)
-{
+void rws_socket_inform_recvd_frames(_rws_socket * s) {
 	rws_bool is_all_finished = rws_true;
 	_rws_frame * frame = NULL;
 	_rws_node * cur = s->recvd_frames;
-	while (cur)
-	{
+	while (cur) {
 		frame = (_rws_frame *)cur->value.object;
-		if (frame)
-		{
-			if (frame->is_finished)
-			{
-				switch (frame->opcode)
-				{
+		if (frame) {
+			if (frame->is_finished) {
+				switch (frame->opcode) {
 					case rws_opcode_text_frame:
-						if (s->on_recvd_text) s->on_recvd_text(s, (const char *)frame->data, (unsigned int)frame->data_size);
+						if (s->on_recvd_text) {
+							s->on_recvd_text(s, (const char *)frame->data, (unsigned int)frame->data_size);
+						}
 						break;
 					case rws_opcode_binary_frame:
-						if (s->on_recvd_bin) s->on_recvd_bin(s, frame->data, (unsigned int)frame->data_size);
+						if (s->on_recvd_bin) {
+							s->on_recvd_bin(s, frame->data, (unsigned int)frame->data_size);
+						}
 						break;
 					default: break;
 				}
 				rws_frame_delete(frame);
 				cur->value.object = NULL;
-			}
-			else
-			{
+			} else {
 				is_all_finished = rws_false;
 			}
 		}
 		cur = cur->next;
 	}
-	if (is_all_finished) rws_list_delete_clean(&s->recvd_frames);
+	if (is_all_finished) {
+		rws_list_delete_clean(&s->recvd_frames);
+	}
 }
 
-void rws_socket_read_handshake_responce_value(const char * str, char ** value)
-{
+void rws_socket_read_handshake_responce_value(const char * str, char ** value) {
 	const char * s = NULL;
 	size_t len = 0;
 
-	while (*str == ':' || *str == ' ') { str++; }
+	while (*str == ':' || *str == ' ') {
+		str++;
+	}
 	s = str;
-	while (*s != '\r' && *s != '\n') { s++; len++; }
-	if (len > 0) *value = rws_string_copy_len(str, len);
+	while (*s != '\r' && *s != '\n') {
+		s++;
+		len++;
+	}
+	if (len > 0) {
+		*value = rws_string_copy_len(str, len);
+	}
 }
 
-rws_bool rws_socket_process_handshake_responce(_rws_socket * s)
-{
+rws_bool rws_socket_process_handshake_responce(_rws_socket * s) {
 	const char * str = (const char *)s->received;
 	const char * sub = NULL;
 	float http_ver = -1;
@@ -113,20 +117,18 @@ rws_bool rws_socket_process_handshake_responce(_rws_socket * s)
 	if (!sub) return rws_false;
 	
 	sub += 5;
-	if (rws_sscanf(sub, "%f %i", &http_ver, &http_code) != 2)
-	{
-		http_ver = -1; http_code = -1;
+	if (rws_sscanf(sub, "%f %i", &http_ver, &http_code) != 2) {
+		http_ver = -1;
+		http_code = -1;
 	}
 
 	sub = strstr(str, k_rws_socket_sec_websocket_accept); // "Sec-WebSocket-Accept"
-	if (sub)
-	{
+	if (sub) {
 		sub += strlen(k_rws_socket_sec_websocket_accept);
 		rws_socket_read_handshake_responce_value(sub, &s->sec_ws_accept);
 	}
 
-	if (http_code != 101 || !s->sec_ws_accept)
-	{
+	if (http_code != 101 || !s->sec_ws_accept) {
 		s->error = rws_error_new_code_descr(rws_error_code_parse_handshake,
 											(http_code != 101) ? "HTPP code not found or non 101" : "Accept key not found");
 		return rws_false;
@@ -135,8 +137,7 @@ rws_bool rws_socket_process_handshake_responce(_rws_socket * s)
 }
 
 // need close socket on error
-rws_bool rws_socket_send(_rws_socket * s, const void * data, const size_t data_size)
-{
+rws_bool rws_socket_send(_rws_socket * s, const void * data, const size_t data_size) {
 	int sended = -1, error_number = -1;
 	rws_error_delete_clean(&s->error);
 
@@ -150,52 +151,48 @@ rws_bool rws_socket_send(_rws_socket * s, const void * data, const size_t data_s
 #endif
 
 
-	if (sended > 0) return rws_true;
+	if (sended > 0) {
+		return rws_true;
+	}
 
 	rws_socket_check_write_error(s, error_number);
-	if (s->error)
-	{
+	if (s->error) {
 		rws_socket_close(s);
 		return rws_false;
 	}
 	return rws_true;
 }
 
-rws_bool rws_socket_recv(_rws_socket * s)
-{
+rws_bool rws_socket_recv(_rws_socket * s) {
 	int is_reading = 1, error_number = -1, len = -1;
 	char * received = NULL;
 	size_t total_len = 0;
 	char buff[8192];
 	rws_error_delete_clean(&s->error);
-	while (is_reading)
-	{
+	while (is_reading) {
 		len = (int)recv(s->socket, buff, 8192, 0);
 #if defined(RWS_OS_WINDOWS)
         error_number = WSAGetLastError();
 #else
         error_number = errno;
 #endif
-		if (len > 0)
-		{
+		if (len > 0) {
 			total_len += len;
-			if (s->received_size-s->received_len < len)
-			{
+			if (s->received_size-s->received_len < len) {
 				rws_socket_resize_received(s, s->received_size+len);
 			}
 			received = (char *)s->received;
-			if (s->received_len) received += s->received_len;
+			if (s->received_len) {
+				received += s->received_len;
+			}
 			memcpy(received, buff, len);
 			s->received_len += len;
-		}
-		else
-		{
+		} else {
 			is_reading = 0;
 		}
 	}
 	//if (error_number < 0) return rws_true;
-	if (error_number != WSAEWOULDBLOCK && error_number != WSAEINPROGRESS)
-	{
+	if (error_number != WSAEWOULDBLOCK && error_number != WSAEINPROGRESS) {
 		s->error = rws_error_new_code_descr(rws_error_code_read_write_socket, "Failed read/write socket");
 		rws_socket_close(s);
 		return rws_false;
@@ -203,16 +200,13 @@ rws_bool rws_socket_recv(_rws_socket * s)
 	return rws_true;
 }
 
-_rws_frame * rws_socket_last_unfin_recvd_frame_by_opcode(_rws_socket * s, const rws_opcode opcode)
-{
+_rws_frame * rws_socket_last_unfin_recvd_frame_by_opcode(_rws_socket * s, const rws_opcode opcode) {
 	_rws_frame * last = NULL;
 	_rws_frame * frame = NULL;
 	_rws_node * cur = s->recvd_frames;
-	while (cur)
-	{
+	while (cur) {
 		frame = (_rws_frame *)cur->value.object;
-		if (frame)
-		{
+		if (frame) {
             //  [FIN=0,opcode !=0 ],[FIN=0,opcode ==0 ],....[FIN=1,opcode ==0 ]
 			if (!frame->is_finished /*&& frame->opcode == opcode*/) last = frame;
 		}
@@ -221,24 +215,20 @@ _rws_frame * rws_socket_last_unfin_recvd_frame_by_opcode(_rws_socket * s, const
 	return last;
 }
 
-void rws_socket_process_bin_or_text_frame(_rws_socket * s, _rws_frame * frame)
-{
+void rws_socket_process_bin_or_text_frame(_rws_socket * s, _rws_frame * frame) {
 	_rws_frame * last_unfin = rws_socket_last_unfin_recvd_frame_by_opcode(s, frame->opcode);
-	if (last_unfin)
-	{
+	if (last_unfin) {
 		rws_frame_combine_datas(last_unfin, frame);
 		last_unfin->is_finished = frame->is_finished;
 		rws_frame_delete(frame);
-	}
-	else
-	{
-		if (frame->data && frame->data_size) rws_socket_append_recvd_frames(s, frame);
-		else rws_frame_delete(frame);
+	} else if (frame->data && frame->data_size) {
+		rws_socket_append_recvd_frames(s, frame);
+	} else {
+		rws_frame_delete(frame);
 	}
 }
 
-void rws_socket_process_ping_frame(_rws_socket * s, _rws_frame * frame)
-{
+void rws_socket_process_ping_frame(_rws_socket * s, _rws_frame * frame) {
 	_rws_frame * pong_frame = rws_frame_create();
 	pong_frame->opcode = rws_opcode_pong;
 	pong_frame->is_masked = rws_true;
@@ -247,22 +237,19 @@ void rws_socket_process_ping_frame(_rws_socket * s, _rws_frame * frame)
 	rws_socket_append_send_frames(s, pong_frame);
 }
 
-void rws_socket_process_conn_close_frame(_rws_socket * s, _rws_frame * frame)
-{
+void rws_socket_process_conn_close_frame(_rws_socket * s, _rws_frame * frame) {
 	s->command = COMMAND_INFORM_DISCONNECTED;
 	s->error = rws_error_new_code_descr(rws_error_code_connection_closed, "Connection was closed by endpoint");
 	//rws_socket_close(s);
 	rws_frame_delete(frame);
 }
 
-void rws_socket_process_received_frame(_rws_socket * s, _rws_frame * frame)
-{
-	switch (frame->opcode)
-	{
+void rws_socket_process_received_frame(_rws_socket * s, _rws_frame * frame) {
+	switch (frame->opcode) {
 		case rws_opcode_ping: rws_socket_process_ping_frame(s, frame); break;
 		case rws_opcode_text_frame:
 		case rws_opcode_binary_frame:
-        case rws_opcode_continuation:
+		case rws_opcode_continuation:
 			rws_socket_process_bin_or_text_frame(s, frame);
 			break;
 		case rws_opcode_connection_close: rws_socket_process_conn_close_frame(s, frame); break;
@@ -273,31 +260,27 @@ void rws_socket_process_received_frame(_rws_socket * s, _rws_frame * frame)
 	}
 }
 
-void rws_socket_idle_recv(_rws_socket * s)
-{
+void rws_socket_idle_recv(_rws_socket * s) {
 	_rws_frame * frame = NULL;
 
-	if (!rws_socket_recv(s))
-	{
+	if (!rws_socket_recv(s)) {
 		// sock already closed
-		if (s->error) s->command = COMMAND_INFORM_DISCONNECTED;
+		if (s->error) {
+			s->command = COMMAND_INFORM_DISCONNECTED;
+		}
 		return;
 	}
 
    const size_t nframe_size = rws_check_recv_frame_size(s->received, s->received_len);
-   if (nframe_size)
-   {
+   if (nframe_size) {
        frame = rws_frame_create_with_recv_data(s->received, nframe_size);
-       if (frame) 
-       {
+       if (frame)  {
            rws_socket_process_received_frame(s, frame);
        }
-       if (nframe_size == s->received_len)
-       {
+	   
+       if (nframe_size == s->received_len) {
            s->received_len = 0;
-       }
-       else if (s->received_len > nframe_size)
-       {
+       } else if (s->received_len > nframe_size) {
            const size_t nLeftLen = s->received_len - nframe_size;
            memmove((char*)s->received, (char*)s->received + nframe_size, nLeftLen);
            s->received_len = nLeftLen;
@@ -305,18 +288,15 @@ void rws_socket_idle_recv(_rws_socket * s)
    }
 }
 
-void rws_socket_idle_send(_rws_socket * s)
-{
+void rws_socket_idle_send(_rws_socket * s) {
 	_rws_node * cur = NULL;
 	rws_bool sending = rws_true;
 	_rws_frame * frame = NULL;
 
 	rws_mutex_lock(s->send_mutex);
 	cur = s->send_frames;
-	if (cur)
-	{
-		while (cur && s->is_connected && sending)
-		{
+	if (cur) {
+		while (cur && s->is_connected && sending) {
 			frame = (_rws_frame *)cur->value.object;
 			cur->value.object = NULL;
 			if (frame) sending = rws_socket_send(s, frame->data, frame->data_size);
@@ -324,36 +304,37 @@ void rws_socket_idle_send(_rws_socket * s)
 			cur = cur->next;
 		}
 		rws_list_delete_clean(&s->send_frames);
-		if (s->error) s->command = COMMAND_INFORM_DISCONNECTED;
+		if (s->error) {
+			s->command = COMMAND_INFORM_DISCONNECTED;
+		}
 	}
 	rws_mutex_unlock(s->send_mutex);
 }
 
-void rws_socket_wait_handshake_responce(_rws_socket * s)
-{
-	if (!rws_socket_recv(s))
-	{
+void rws_socket_wait_handshake_responce(_rws_socket * s) {
+	if (!rws_socket_recv(s)) {
 		// sock already closed
-		if (s->error) s->command = COMMAND_INFORM_DISCONNECTED;
+		if (s->error) {
+			s->command = COMMAND_INFORM_DISCONNECTED;
+		}
+		return;
+	}
+	
+	if (s->received_len == 0) {
 		return;
 	}
-	if (s->received_len == 0) return;
 
-	if (rws_socket_process_handshake_responce(s))
-	{
+	if (rws_socket_process_handshake_responce(s)) {
         s->received_len = 0;
 		s->is_connected = rws_true;
 		s->command = COMMAND_INFORM_CONNECTED;
-	}
-	else
-	{
+	} else {
 		rws_socket_close(s);
 		s->command = COMMAND_INFORM_DISCONNECTED;
 	}
 }
 
-void rws_socket_send_disconnect(_rws_socket * s)
-{
+void rws_socket_send_disconnect(_rws_socket * s) {
 	char buff[16];
 	size_t len = 0;
 	_rws_frame * frame = rws_frame_create();
@@ -369,9 +350,7 @@ void rws_socket_send_disconnect(_rws_socket * s)
 	rws_thread_sleep(RWS_CONNECT_RETRY_DELAY); // little bit wait after send message
 }
 
-void rws_socket_send_handshake(_rws_socket * s)
-{
-
+void rws_socket_send_handshake(_rws_socket * s) {
 	char buff[512];
 	char * ptr = buff;
 	size_t writed = 0;
@@ -395,21 +374,20 @@ void rws_socket_send_handshake(_rws_socket * s)
 						  "\r\n",
 						  "dGhlIHNhbXBsZSBub25jZQ==");
 
-	if (rws_socket_send(s, buff, writed))
-	{
+	if (rws_socket_send(s, buff, writed)) {
 		s->command = COMMAND_WAIT_HANDSHAKE_RESPONCE;
-	}
-	else
-	{
-		if (s->error) s->error->code = rws_error_code_send_handshake;
-		else s->error = rws_error_new_code_descr(rws_error_code_send_handshake, "Send handshake");
+	} else {
+		if (s->error) {
+			s->error->code = rws_error_code_send_handshake;
+		} else {
+			s->error = rws_error_new_code_descr(rws_error_code_send_handshake, "Send handshake");
+		}
 		rws_socket_close(s);
 		s->command = COMMAND_INFORM_DISCONNECTED;
 	}
 }
 
-struct addrinfo * rws_socket_connect_getaddr_info(_rws_socket * s)
-{
+struct addrinfo * rws_socket_connect_getaddr_info(_rws_socket * s) {
 	struct addrinfo hints;
 	char portstr[16];
 	struct addrinfo * result = NULL;
@@ -422,8 +400,7 @@ struct addrinfo * rws_socket_connect_getaddr_info(_rws_socket * s)
 
 #if defined(RWS_OS_WINDOWS)
 	memset(&wsa, 0, sizeof(WSADATA));
-	if (WSAStartup(MAKEWORD(2,2), &wsa) != 0)
-	{
+	if (WSAStartup(MAKEWORD(2,2), &wsa) != 0) {
 		s->error = rws_error_new_code_descr(rws_error_code_connect_to_host, "Failed initialise winsock");
 		s->command = COMMAND_INFORM_DISCONNECTED;
 		return NULL;
@@ -431,18 +408,25 @@ struct addrinfo * rws_socket_connect_getaddr_info(_rws_socket * s)
 #endif
 
 	rws_sprintf(portstr, 16, "%i", s->port);
-	while (++retry_number < RWS_CONNECT_ATTEMPS)
-	{
+	while (++retry_number < RWS_CONNECT_ATTEMPS) {
 		result = NULL;
 		memset(&hints, 0, sizeof(hints));
 		hints.ai_family = AF_UNSPEC;
 		hints.ai_socktype = SOCK_STREAM;
 
 		ret = getaddrinfo(s->host, portstr, &hints, &result);
-		if (ret == 0 && result) return result;
+		if (ret == 0 && result) {
+			return result;
+		}
 
-		if (ret != 0) last_ret = ret;
-		if (result) freeaddrinfo(result);
+		if (ret != 0) {
+			last_ret = ret;
+		}
+		
+		if (result) {
+			freeaddrinfo(result);
+		}
+		
 		rws_thread_sleep(RWS_CONNECT_RETRY_DELAY);
 	}
 
@@ -456,8 +440,7 @@ struct addrinfo * rws_socket_connect_getaddr_info(_rws_socket * s)
 	return NULL;
 }
 
-void rws_socket_connect_to_host(_rws_socket * s)
-{
+void rws_socket_connect_to_host(_rws_socket * s) {
 	struct addrinfo * result = NULL;
 	struct addrinfo * p = NULL;
 	rws_socket_t sock = RWS_INVALID_SOCKET;
@@ -467,20 +450,18 @@ void rws_socket_connect_to_host(_rws_socket * s)
 #endif
 
 	result = rws_socket_connect_getaddr_info(s);
-	if (!result) return;
+	if (!result) {
+		return;
+	}
 
-	while ((++retry_number < RWS_CONNECT_ATTEMPS) && (sock == RWS_INVALID_SOCKET))
-	{
-		for (p = result; p != NULL; p = p->ai_next)
-		{
+	while ((++retry_number < RWS_CONNECT_ATTEMPS) && (sock == RWS_INVALID_SOCKET)) {
+		for (p = result; p != NULL; p = p->ai_next) {
 			sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
-			if (sock != RWS_INVALID_SOCKET)
-			{
+			if (sock != RWS_INVALID_SOCKET) {
 				rws_socket_set_option(sock, SO_ERROR, 1); // When an error occurs on a socket, set error variable so_error and notify process
 				rws_socket_set_option(sock, SO_KEEPALIVE, 1); // Periodically test if connection is alive
 
-				if (connect(sock, p->ai_addr, p->ai_addrlen) == 0)
-				{
+				if (connect(sock, p->ai_addr, p->ai_addrlen) == 0) {
                     s->received_len = 0;
 					s->socket = sock;
 #if defined(RWS_OS_WINDOWS)
@@ -495,65 +476,76 @@ void rws_socket_connect_to_host(_rws_socket * s)
 				RWS_SOCK_CLOSE(sock);
 			}
 		}
-		if (sock == RWS_INVALID_SOCKET) rws_thread_sleep(RWS_CONNECT_RETRY_DELAY);
+		if (sock == RWS_INVALID_SOCKET) {
+			rws_thread_sleep(RWS_CONNECT_RETRY_DELAY);
+		}
 	}
 
 	freeaddrinfo(result);
 
-	if (s->socket == RWS_INVALID_SOCKET)
-	{
+	if (s->socket == RWS_INVALID_SOCKET) {
 #if defined(RWS_OS_WINDOWS)
 		WSACleanup();
 #endif
 		s->error = rws_error_new_code_descr(rws_error_code_connect_to_host, "Failed connect to host");
 		s->command = COMMAND_INFORM_DISCONNECTED;
-	}
-	else
-	{
+	} else {
 		s->command = COMMAND_SEND_HANDSHAKE;
 	}
 }
 
-static void rws_socket_work_th_func(void * user_object)
-{
+static void rws_socket_work_th_func(void * user_object) {
 	_rws_socket * s = (_rws_socket *)user_object;
 	size_t loop_number = 0;
-	while (s->command < COMMAND_END)
-	{
+	while (s->command < COMMAND_END) {
 		loop_number++;
 		rws_mutex_lock(s->work_mutex);
-		switch (s->command)
-		{
+		switch (s->command) {
 			case COMMAND_CONNECT_TO_HOST: rws_socket_connect_to_host(s); break;
 			case COMMAND_SEND_HANDSHAKE: rws_socket_send_handshake(s); break;
 			case COMMAND_WAIT_HANDSHAKE_RESPONCE: rws_socket_wait_handshake_responce(s); break;
 			case COMMAND_DISCONNECT: rws_socket_send_disconnect(s); break;
 			case COMMAND_IDLE:
-				if (loop_number >= 400) { if (s->is_connected) rws_socket_send_ping(s); loop_number = 0; }
-				if (s->is_connected) rws_socket_idle_send(s);
-				if (s->is_connected) rws_socket_idle_recv(s);
+				if (loop_number >= 400) {
+					loop_number = 0;
+					
+					if (s->is_connected) {
+						rws_socket_send_ping(s);
+					}
+				}
+				
+				if (s->is_connected) {
+					rws_socket_idle_send(s);
+				}
+				
+				if (s->is_connected) {
+					rws_socket_idle_recv(s);
+				}
 				break;
 			default: break;
 		}
+		
 		rws_mutex_unlock(s->work_mutex);
-		switch (s->command)
-		{
+		
+		switch (s->command) {
 			case COMMAND_INFORM_CONNECTED:
 				s->command = COMMAND_IDLE;
-				if (s->on_connected) s->on_connected(s);
+				if (s->on_connected) {
+					s->on_connected(s);
+				}
 				break;
-			case COMMAND_INFORM_DISCONNECTED:
-                {
+			case COMMAND_INFORM_DISCONNECTED: {
                     s->command = COMMAND_END;
                     rws_socket_send_disconnect(s);
-                    if (s->on_disconnected) 
-                    {
+                    if (s->on_disconnected)  {
                         s->on_disconnected(s);
                     }
                 }
 				break;
 			case COMMAND_IDLE:
-				if (s->recvd_frames) rws_socket_inform_recvd_frames(s);
+				if (s->recvd_frames) {
+					rws_socket_inform_recvd_frames(s);
+				}
 				break;
 			default: break;
 		}
@@ -565,21 +557,18 @@ static void rws_socket_work_th_func(void * user_object)
 	rws_socket_delete(s);
 }
 
-rws_bool rws_socket_create_start_work_thread(_rws_socket * s)
-{
+rws_bool rws_socket_create_start_work_thread(_rws_socket * s) {
 	rws_error_delete_clean(&s->error);
 	s->command = COMMAND_NONE;
 	s->work_thread = rws_thread_create(&rws_socket_work_th_func, s);
-	if (s->work_thread)
-	{
+	if (s->work_thread) {
 		s->command = COMMAND_CONNECT_TO_HOST;
 		return rws_true;
 	}
 	return rws_false;
 }
 
-void rws_socket_resize_received(_rws_socket * s, const size_t size)
-{
+void rws_socket_resize_received(_rws_socket * s, const size_t size) {
 	void * res = NULL;
 	size_t min = 0;
 	if (size == s->received_size) return;
@@ -588,17 +577,17 @@ void rws_socket_resize_received(_rws_socket * s, const size_t size)
 	assert(res && (size > 0));
 
 	min = (s->received_size < size) ? s->received_size : size;
-	if (min > 0 && s->received) memcpy(res, s->received, min);
+	if (min > 0 && s->received) {
+		memcpy(res, s->received, min);
+	}
 	rws_free_clean(&s->received);
 	s->received = res;
 	s->received_size = size;
 }
 
-void rws_socket_close(_rws_socket * s)
-{
+void rws_socket_close(_rws_socket * s) {
     s->received_len = 0;
-	if (s->socket != RWS_INVALID_SOCKET)
-	{
+	if (s->socket != RWS_INVALID_SOCKET) {
 		RWS_SOCK_CLOSE(s->socket);
 		s->socket = RWS_INVALID_SOCKET;
 #if defined(RWS_OS_WINDOWS)
@@ -608,42 +597,35 @@ void rws_socket_close(_rws_socket * s)
 	s->is_connected = rws_false;
 }
 
-void rws_socket_append_recvd_frames(_rws_socket * s, _rws_frame * frame)
-{
+void rws_socket_append_recvd_frames(_rws_socket * s, _rws_frame * frame) {
 	_rws_node_value frame_list_var;
 	frame_list_var.object = frame;
-	if (s->recvd_frames)
-	{
+	if (s->recvd_frames) {
 		rws_list_append(s->recvd_frames, frame_list_var);
-	}
-	else
-	{
+	} else {
 		s->recvd_frames = rws_list_create();
 		s->recvd_frames->value = frame_list_var;
 	}
 }
 
-void rws_socket_append_send_frames(_rws_socket * s, _rws_frame * frame)
-{
+void rws_socket_append_send_frames(_rws_socket * s, _rws_frame * frame) {
 	_rws_node_value frame_list_var;
 	frame_list_var.object = frame;
-	if (s->send_frames)
-	{
+	if (s->send_frames) {
 		rws_list_append(s->send_frames, frame_list_var);
-	}
-	else
-	{
+	} else {
 		s->send_frames = rws_list_create();
 		s->send_frames->value = frame_list_var;
 	}
 }
 
-rws_bool rws_socket_send_text_priv(_rws_socket * s, const char * text)
-{
+rws_bool rws_socket_send_text_priv(_rws_socket * s, const char * text) {
 	size_t len = text ? strlen(text) : 0;
 	_rws_frame * frame = NULL;
 
-	if (len <= 0) return rws_false;
+	if (len <= 0) {
+		return rws_false;
+	}
 
 	frame = rws_frame_create();
 	frame->is_masked = rws_true;
@@ -654,25 +636,23 @@ rws_bool rws_socket_send_text_priv(_rws_socket * s, const char * text)
 	return rws_true;
 }
 
-void rws_socket_delete_all_frames_in_list(_rws_list * list_with_frames)
-{
+void rws_socket_delete_all_frames_in_list(_rws_list * list_with_frames) {
 	_rws_frame * frame = NULL;
 	_rws_node * cur = list_with_frames;
-	while (cur)
-	{
+	while (cur) {
 		frame = (_rws_frame *)cur->value.object;
-		if (frame) rws_frame_delete(frame);
+		if (frame) {
+			rws_frame_delete(frame);
+		}
 		cur->value.object = NULL;
 	}
 }
 
-void rws_socket_set_option(rws_socket_t s, int option, int value)
-{
+void rws_socket_set_option(rws_socket_t s, int option, int value) {
 	setsockopt(s, SOL_SOCKET, option, (char *)&value, sizeof(int));
 }
 
-void rws_socket_check_write_error(_rws_socket * s, int error_num)
-{
+void rws_socket_check_write_error(_rws_socket * s, int error_num) {
 #if defined(RWS_OS_WINDOWS)
 	int socket_code = 0, code = 0;
 	unsigned int socket_code_size = sizeof(int);
@@ -681,19 +661,24 @@ void rws_socket_check_write_error(_rws_socket * s, int error_num)
 	socklen_t socket_code_size = sizeof(socket_code);
 #endif
 
-	if (s->socket != RWS_INVALID_SOCKET)
-	{
+	if (s->socket != RWS_INVALID_SOCKET) {
 #if defined(RWS_OS_WINDOWS)
-		if (getsockopt(s->socket, SOL_SOCKET, SO_ERROR, (char *)&socket_code, (int*)&socket_code_size) != 0) socket_code = 0;
+		if (getsockopt(s->socket, SOL_SOCKET, SO_ERROR, (char *)&socket_code, (int*)&socket_code_size) != 0) {
+			socket_code = 0;
+		}
 #else
-		if (getsockopt(s->socket, SOL_SOCKET, SO_ERROR, &socket_code, &socket_code_size) != 0) socket_code = 0;
+		if (getsockopt(s->socket, SOL_SOCKET, SO_ERROR, &socket_code, &socket_code_size) != 0) {
+			socket_code = 0;
+		}
 #endif
 	}
 
 	code = (socket_code > 0) ? socket_code : error_num;
-	if (code <= 0) return;
-	switch (code)
-	{
+	if (code <= 0) {
+		return;
+	}
+	
+	switch (code) {
 		// send errors
 		case EACCES: //
 

src/rws_socketpub.c

@@ -32,61 +32,69 @@
 #endif
 
 // public
-rws_bool rws_socket_connect(rws_socket socket)
-{
+rws_bool rws_socket_connect(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	const char * params_error_msg = NULL;
-	if (!s) return rws_false;
+	if (!s) {
+		return rws_false;
+	}
 
 	rws_error_delete_clean(&s->error);
 
-	if (s->port <= 0) params_error_msg = "No URL port provided";
-	if (!s->scheme) params_error_msg = "No URL scheme provided";
-	if (!s->host) params_error_msg = "No URL host provided";
-	if (!s->path) params_error_msg = "No URL path provided";
-	if (!s->on_disconnected) params_error_msg = "No on_disconnected callback provided";
+	if (s->port <= 0) {
+		params_error_msg = "No URL port provided";
+	}
+	if (!s->scheme) {
+		params_error_msg = "No URL scheme provided";
+	}
+	if (!s->host) {
+		params_error_msg = "No URL host provided";
+	}
+	if (!s->path) {
+		params_error_msg = "No URL path provided";
+	}
+	if (!s->on_disconnected) {
+		params_error_msg = "No on_disconnected callback provided";
+	}
     s->received_len = 0;
-	if (params_error_msg)
-	{
+	if (params_error_msg) {
 		s->error = rws_error_new_code_descr(rws_error_code_missed_parameter, params_error_msg);
 		return rws_false;
 	}
 	return rws_socket_create_start_work_thread(s);
 }
 
-void rws_socket_disconnect_and_release(rws_socket socket)
-{
+void rws_socket_disconnect_and_release(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (!s) return;
+	if (!s) {
+		return;
+	}
 	
 	rws_mutex_lock(s->work_mutex);
 
 	rws_socket_delete_all_frames_in_list(s->send_frames);
 	rws_list_delete_clean(&s->send_frames);
 
-	if (s->is_connected) // connected in loop
-	{
+	if (s->is_connected) { // connected in loop
 		s->command = COMMAND_DISCONNECT;
 		rws_mutex_unlock(s->work_mutex);
-	}
-	else if (s->work_thread) // disconnected in loop
-	{
+	} else if (s->work_thread) { // disconnected in loop
 		s->command = COMMAND_END;
 		rws_mutex_unlock(s->work_mutex);
-	}
-	else if (s->command != COMMAND_END)
-	{
+	} else if (s->command != COMMAND_END) {
 		// not in loop
 		rws_mutex_unlock(s->work_mutex);
 		rws_socket_delete(s);
 	}
 }
 
-rws_bool rws_socket_send_text(rws_socket socket, const char * text)
-{
+rws_bool rws_socket_send_text(rws_socket socket, const char * text) {
 	_rws_socket * s = (_rws_socket *)socket;
 	rws_bool r = rws_false;
-	if (!s) return r;
+	if (!s) {
+		return r;
+	}
+	
 	rws_mutex_lock(s->send_mutex);
 	r = rws_socket_send_text_priv(s, text);
 	rws_mutex_unlock(s->send_mutex);
@@ -94,8 +102,7 @@ rws_bool rws_socket_send_text(rws_socket socket, const char * text)
 }
 
 #if !defined(RWS_OS_WINDOWS)
-void rws_socket_handle_sigpipe(int signal_number)
-{
+void rws_socket_handle_sigpipe(int signal_number) {
 	printf("\nlibrws handle sigpipe %i", signal_number);
 	return;
 }
@@ -104,15 +111,15 @@ void rws_socket_handle_sigpipe(int signal_number)
 #define STRING_I(s) #s
 #define TO_STRING(s) STRING_I(s)
 
-void rws_socket_check_info(const char * info)
-{
+void rws_socket_check_info(const char * info) {
 	assert(info);
 }
 
-rws_socket rws_socket_create(void)
-{
+rws_socket rws_socket_create(void) {
 	_rws_socket * s = (_rws_socket *)rws_malloc_zero(sizeof(_rws_socket));
-	if (!s) return NULL;
+	if (!s) {
+		return NULL;
+	}
 
 #if !defined(RWS_OS_WINDOWS)
 	signal(SIGPIPE, rws_socket_handle_sigpipe);
@@ -131,8 +138,7 @@ rws_socket rws_socket_create(void)
 	return s;
 }
 
-void rws_socket_delete(_rws_socket * s)
-{
+void rws_socket_delete(_rws_socket * s) {
 	rws_socket_close(s);
 
 	rws_string_delete_clean(&s->sec_ws_accept);
@@ -170,10 +176,12 @@ void rws_socket_set_url(rws_socket socket,
 						const char * scheme,
 						const char * host,
 						const int port,
-						const char * path)
-{
+						const char * path) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (!s) return;
+	if (!s) {
+		return;
+	}
+	
 	rws_string_delete(s->scheme);
 	s->scheme = rws_string_copy(scheme);
 	rws_string_delete(s->host);
@@ -183,129 +191,144 @@ void rws_socket_set_url(rws_socket socket,
 	s->port = port;
 }
 
-void rws_socket_set_scheme(rws_socket socket, const char * scheme)
-{
+void rws_socket_set_scheme(rws_socket socket, const char * scheme) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (!s) return;
+	if (!s) {
+		return;
+	}
+	
 	rws_string_delete(s->scheme);
 	s->scheme = rws_string_copy(scheme);
 }
 
-const char * rws_socket_get_scheme(rws_socket socket)
-{
+const char * rws_socket_get_scheme(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	return s ? s->scheme : NULL;
 }
 
-void rws_socket_set_host(rws_socket socket, const char * host)
-{
+void rws_socket_set_host(rws_socket socket, const char * host) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (!s) return;
+	if (!s) {
+		return;
+	}
+	
 	rws_string_delete(s->host);
 	s->host = rws_string_copy(host);
 }
 
-const char * rws_socket_get_host(rws_socket socket)
-{
+const char * rws_socket_get_host(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	return s ? s->host : NULL;
 }
 
-void rws_socket_set_path(rws_socket socket, const char * path)
-{
+void rws_socket_set_path(rws_socket socket, const char * path) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (!s) return;
+	if (!s) {
+		return;
+	}
+	
 	rws_string_delete(s->path);
 	s->path = rws_string_copy(path);
 }
 
-const char * rws_socket_get_path(rws_socket socket)
-{
+const char * rws_socket_get_path(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	return s ? s->path : NULL;
 }
 
-void rws_socket_set_port(rws_socket socket, const int port)
-{
+void rws_socket_set_port(rws_socket socket, const int port) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (s) s->port = port;
+	if (s) {
+		s->port = port;
+	}
 }
 
-int rws_socket_get_port(rws_socket socket)
-{
+int rws_socket_get_port(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	return s ? s->port : -1;
 }
 
 /*
-unsigned int _rws_socket_get_receive_buffer_size(rws_socket_t socket)
-{
+unsigned int _rws_socket_get_receive_buffer_size(rws_socket_t socket) {
 	unsigned int size = 0;
 #if defined(RWS_OS_WINDOWS)
 	int len = sizeof(unsigned int);
-	if (getsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&size, &len) == -1) size = 0;
+	if (getsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&size, &len) == -1) { 
+		size = 0;
+	}
 #else
 	socklen_t len = sizeof(unsigned int);
-	if (getsockopt(socket, SOL_SOCKET, SO_RCVBUF, &size, &len) == -1) size = 0;
+	if (getsockopt(socket, SOL_SOCKET, SO_RCVBUF, &size, &len) == -1) { 
+		size = 0; 
+	}
 #endif
 	return size;
 }
 
-unsigned int rws_socket_get_receive_buffer_size(rws_socket socket)
-{
+unsigned int rws_socket_get_receive_buffer_size(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (!s) return 0;
-	if (s->socket == RWS_INVALID_SOCKET) return 0;
+	if (!s) { 
+		return 0; 
+	}
+	if (s->socket == RWS_INVALID_SOCKET) { 
+		return 0; 
+	}
 	return _rws_socket_get_receive_buffer_size(s->socket);
 }
 */
-rws_error rws_socket_get_error(rws_socket socket)
-{
+
+rws_error rws_socket_get_error(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	return s ? s->error : NULL;
 }
 
-void rws_socket_set_user_object(rws_socket socket, void * user_object)
-{
+void rws_socket_set_user_object(rws_socket socket, void * user_object) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (s) s->user_object = user_object;
+	if (s) {
+		s->user_object = user_object;
+	}
 }
 
-void * rws_socket_get_user_object(rws_socket socket)
-{
+void * rws_socket_get_user_object(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	return s ? s->user_object : NULL;
 }
 
-void rws_socket_set_on_connected(rws_socket socket, rws_on_socket callback)
-{
+void rws_socket_set_on_connected(rws_socket socket, rws_on_socket callback) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (s) s->on_connected = callback;
+	if (s) {
+		s->on_connected = callback;
+	}
 }
 
-void rws_socket_set_on_disconnected(rws_socket socket, rws_on_socket callback)
-{
+void rws_socket_set_on_disconnected(rws_socket socket, rws_on_socket callback) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (s) s->on_disconnected = callback;
+	if (s) {
+		s->on_disconnected = callback;
+	}
 }
 
-void rws_socket_set_on_received_text(rws_socket socket, rws_on_socket_recvd_text callback)
-{
+void rws_socket_set_on_received_text(rws_socket socket, rws_on_socket_recvd_text callback) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (s) s->on_recvd_text = callback;
+	if (s) {
+		s->on_recvd_text = callback;
+	}
 }
 
-void rws_socket_set_on_received_bin(rws_socket socket, rws_on_socket_recvd_bin callback)
-{
+void rws_socket_set_on_received_bin(rws_socket socket, rws_on_socket_recvd_bin callback) {
 	_rws_socket * s = (_rws_socket *)socket;
-	if (s) s->on_recvd_bin = callback;
+	if (s) {
+		s->on_recvd_bin = callback;
+	}
 }
 
-rws_bool rws_socket_is_connected(rws_socket socket)
-{
+rws_bool rws_socket_is_connected(rws_socket socket) {
 	_rws_socket * s = (_rws_socket *)socket;
 	rws_bool r = rws_false;
-	if (!s) return r;
+	if (!s) {
+		return r;
+	}
+	
 	rws_mutex_lock(s->send_mutex);
 	r = s->is_connected;
 	rws_mutex_unlock(s->send_mutex);

src/rws_string.c

@@ -24,16 +24,13 @@
 #include "rws_string.h"
 #include "rws_memory.h"
 
-char * rws_string_copy(const char * str)
-{
+char * rws_string_copy(const char * str) {
 	return str ? rws_string_copy_len(str, strlen(str)) : NULL;
 }
 
-char * rws_string_copy_len(const char * str, const size_t len)
-{
+char * rws_string_copy_len(const char * str, const size_t len) {
 	char * s = (str && len > 0) ? (char *)rws_malloc(len + 1) : NULL;
-	if (s)
-	{
+	if (s) {
 		memcpy(s, str, len);
 		s[len] = 0;
 		return s;
@@ -41,15 +38,12 @@ char * rws_string_copy_len(const char * str, const size_t len)
 	return NULL;
 }
 
-void rws_string_delete(char * str)
-{
+void rws_string_delete(char * str) {
 	rws_free(str);
 }
 
-void rws_string_delete_clean(char ** str)
-{
-	if (str)
-	{
+void rws_string_delete_clean(char ** str) {
+	if (str) {
 		rws_free(*str);
 		*str = NULL;
 	}

src/rws_thread.c

@@ -35,8 +35,7 @@
 #include <unistd.h>
 #endif
 
-typedef struct _rws_thread_struct
-{
+typedef struct _rws_thread_struct {
 	rws_thread_funct thread_function;
 	void * user_object;
 #if defined(RWS_OS_WINDOWS)
@@ -46,15 +45,13 @@ typedef struct _rws_thread_struct
 #endif
 } _rws_thread;
 
-typedef struct _rws_threads_joiner_struct
-{
+typedef struct _rws_threads_joiner_struct {
 	_rws_thread * thread;
 	rws_mutex mutex;
 } _rws_threads_joiner;
 
 static _rws_threads_joiner * _threads_joiner = NULL;
-static void rws_threads_joiner_clean(void) // private
-{
+static void rws_threads_joiner_clean(void) { // private
 	_rws_thread * t = _threads_joiner->thread;
 #if defined(RWS_OS_WINDOWS)
 	DWORD dwExitCode = 0;
@@ -62,7 +59,9 @@ static void rws_threads_joiner_clean(void) // private
 	void * r = NULL;
 #endif
 
-	if (!t) return;
+	if (!t) {
+		return;
+	}
 	_threads_joiner->thread = NULL;
 
 #if defined(RWS_OS_WINDOWS)
@@ -78,27 +77,26 @@ static void rws_threads_joiner_clean(void) // private
 	rws_free(t);
 }
 
-static void rws_threads_joiner_add(_rws_thread * thread) // public
-{
+static void rws_threads_joiner_add(_rws_thread * thread) { // public
 	rws_mutex_lock(_threads_joiner->mutex);
 	rws_threads_joiner_clean();
 	_threads_joiner->thread = thread;
 	rws_mutex_unlock(_threads_joiner->mutex);
 }
 
-static void rws_threads_joiner_create_ifneed(void)
-{
-	if (_threads_joiner) return;
+static void rws_threads_joiner_create_ifneed(void) {
+	if (_threads_joiner) {
+		return;
+	}
 	_threads_joiner = (_rws_threads_joiner *)rws_malloc_zero(sizeof(_rws_threads_joiner));
 	_threads_joiner->mutex = rws_mutex_create_recursive();
 }
 
 #if defined(RWS_OS_WINDOWS)
-static DWORD WINAPI rws_thread_func_priv(LPVOID some_pointer)
+static DWORD WINAPI rws_thread_func_priv(LPVOID some_pointer) {
 #else
-static void * rws_thread_func_priv(void * some_pointer)
+static void * rws_thread_func_priv(void * some_pointer) {
 #endif
-{
 	_rws_thread * t = (_rws_thread *)some_pointer;
 	t->thread_function(t->user_object);
 	rws_threads_joiner_add(t);
@@ -110,8 +108,7 @@ static void * rws_thread_func_priv(void * some_pointer)
 #endif
 }
 
-rws_thread rws_thread_create(rws_thread_funct thread_function, void * user_object)
-{
+rws_thread rws_thread_create(rws_thread_funct thread_function, void * user_object) {
 	_rws_thread * t = NULL;
 	int res = -1;
 #if !defined(RWS_OS_WINDOWS)
@@ -127,12 +124,9 @@ rws_thread rws_thread_create(rws_thread_funct thread_function, void * user_objec
 	t->thread = CreateThread(NULL, 0, &rws_thread_func_priv, (LPVOID)t, 0, NULL);
 	assert(t->thread);
 #else
-	if (pthread_attr_init(&attr) == 0)
-	{
-		if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) == 0)
-		{
-			if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) == 0)
-			{
+	if (pthread_attr_init(&attr) == 0) {
+		if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) == 0) {
+			if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) == 0) {
 				res = pthread_create(&t->thread, &attr, &rws_thread_func_priv, (void *)t);
 			}
 		}
@@ -143,8 +137,7 @@ rws_thread rws_thread_create(rws_thread_funct thread_function, void * user_objec
 	return t;
 }
 
-void rws_thread_sleep(const unsigned int millisec)
-{
+void rws_thread_sleep(const unsigned int millisec) {
 #if defined(RWS_OS_WINDOWS)
 	Sleep(millisec); // 1s = 1'000 millisec.
 #else
@@ -152,8 +145,7 @@ void rws_thread_sleep(const unsigned int millisec)
 #endif
 }
 
-rws_mutex rws_mutex_create_recursive(void)
-{
+rws_mutex rws_mutex_create_recursive(void) {
 #if defined(RWS_OS_WINDOWS)
 	CRITICAL_SECTION * mutex = (CRITICAL_SECTION *)rws_malloc_zero(sizeof(CRITICAL_SECTION));
 	InitializeCriticalSection((LPCRITICAL_SECTION)mutex);
@@ -162,10 +154,10 @@ rws_mutex rws_mutex_create_recursive(void)
 	pthread_mutex_t * mutex = (pthread_mutex_t *)rws_malloc_zero(sizeof(pthread_mutex_t));
 	int res = -1;
 	pthread_mutexattr_t attr;
-	if (pthread_mutexattr_init(&attr) == 0)
-	{
-		if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0)
+	if (pthread_mutexattr_init(&attr) == 0) {
+		if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0) {
 			res = pthread_mutex_init(mutex, &attr);
+		}
 		pthread_mutexattr_destroy(&attr);
 	}
 	assert(res == 0);
@@ -173,28 +165,28 @@ rws_mutex rws_mutex_create_recursive(void)
 #endif
 }
 
-void rws_mutex_lock(rws_mutex mutex)
-{
+void rws_mutex_lock(rws_mutex mutex) {
+	if (mutex) {
 #if defined(RWS_OS_WINDOWS)
-	if (mutex) EnterCriticalSection((LPCRITICAL_SECTION)mutex);
+		EnterCriticalSection((LPCRITICAL_SECTION)mutex);
 #else
-	if (mutex) pthread_mutex_lock((pthread_mutex_t *)mutex);
+		pthread_mutex_lock((pthread_mutex_t *)mutex);
 #endif
+	}
 }
 
-void rws_mutex_unlock(rws_mutex mutex)
-{
+void rws_mutex_unlock(rws_mutex mutex) {
+	if (mutex) {
 #if defined(RWS_OS_WINDOWS)
-	if (mutex) LeaveCriticalSection((LPCRITICAL_SECTION)mutex);
+		LeaveCriticalSection((LPCRITICAL_SECTION)mutex);
 #else
-	if (mutex) pthread_mutex_unlock((pthread_mutex_t *)mutex);
+		pthread_mutex_unlock((pthread_mutex_t *)mutex);
 #endif
+	}
 }
 
-void rws_mutex_delete(rws_mutex mutex)
-{
-	if (mutex)
-	{
+void rws_mutex_delete(rws_mutex mutex) {
+	if (mutex) {
 #if defined(RWS_OS_WINDOWS)
 		DeleteCriticalSection((LPCRITICAL_SECTION)mutex);
 #else

test/librws_test/ViewController.m

@@ -7,14 +7,12 @@
 
 @implementation ViewController
 
-- (void)viewDidLoad
-{
+- (void)viewDidLoad {
 	[super viewDidLoad];
 	// Do any additional setup after loading the view, typically from a nib.
 }
 
-- (void)didReceiveMemoryWarning
-{
+- (void)didReceiveMemoryWarning {
 	[super didReceiveMemoryWarning];
 	// Dispose of any resources that can be recreated.
 }

test/librws_testTests/ObjcContrib.m

@@ -32,8 +32,7 @@
 
 @implementation ObjcContrib
 
-- (void)setUp
-{
+- (void)setUp {
     [super setUp];
     // Put setup code here. This method is called before the invocation of each test method in the class.
 
@@ -49,14 +48,12 @@
     [super tearDown];
 }
 
-- (void)testConnect
-{
+- (void)testConnect {
     // This is an example of a functional test case.
     // Use XCTAssert and related functions to verify your tests produce the correct results.
 	[self.socket connect];
 	
-	while (![self.socket isConnected])
-	{
+	while (![self.socket isConnected]) {
 		[NSThread sleepForTimeInterval:0.1];
 	}
 }

test/librws_testTests/connection.m

@@ -24,8 +24,7 @@
 #import <XCTest/XCTest.h>
 #import "librws.h"
 
-@interface connection : XCTestCase
-{
+@interface connection : XCTestCase {
 @private
 	rws_socket * _socket;
 }
@@ -41,12 +40,10 @@
 
 static const char * _testSendText = "{\"version\":\"1.0\",\"supportedConnectionTypes\":[\"websocket\"],\"minimumVersion\":\"1.0\",\"channel\":\"/meta/handshake\"}";
 
-static void on_socket_received_text(rws_socket socket, const char * text, const unsigned int length)
-{
+static void on_socket_received_text(rws_socket socket, const char * text, const unsigned int length) {
 	connection * con = (__bridge connection *)rws_socket_get_user_object(socket);
 
-	if (strncmp(text, _testSendText, length) != 0)
-	{
+	if (strncmp(text, _testSendText, length) != 0) {
 		con.isError = YES;
 		con.errorMessage = @"send and echo test/len not equal";
 	}
@@ -54,18 +51,15 @@ static void on_socket_received_text(rws_socket socket, const char * text, const
 	con.isFinished = YES;
 }
 
-static void on_socket_connected(rws_socket socket)
-{
+static void on_socket_connected(rws_socket socket) {
 	NSLog(@"Socket connected");
 
 	rws_socket_send_text(socket, _testSendText);
 }
 
-static void on_socket_disconnected(rws_socket socket)
-{
+static void on_socket_disconnected(rws_socket socket) {
 	rws_error error = rws_socket_get_error(socket);
-	if (error)
-	{
+	if (error) {
 		NSLog(@"Socket disconnect with code, error: %i, %s",
 			  rws_error_get_code(error),
 			  rws_error_get_description(error));
@@ -77,16 +71,14 @@ static void on_socket_disconnected(rws_socket socket)
 	con.isFinished = YES;
 }
 
-- (void)setUp
-{
+- (void)setUp {
     [super setUp];
     // Put setup code here. This method is called before the invocation of each test method in the class.
 
 	_socket = rws_socket_create();
 }
 
-- (void)tearDown
-{
+- (void)tearDown {
     // Put teardown code here. This method is called after the invocation of each test method in the class.
     [super tearDown];
 
@@ -94,8 +86,7 @@ static void on_socket_disconnected(rws_socket socket)
 	_socket = NULL;
 }
 
-- (void) testConnection
-{
+- (void) testConnection {
     // This is an example of a functional test case.
     // Use XCTAssert and related functions to verify your tests produce the correct results.
 
@@ -111,8 +102,7 @@ static void on_socket_disconnected(rws_socket socket)
 	self.isFinished = NO;
 	rws_socket_connect(_socket);
 
-	while (self.isWorking)
-	{
+	while (self.isWorking) {
 		rws_thread_sleep(100);
 	}
 	XCTAssertFalse(self.isError, @"error during connection");

test/librws_testTests/getterAndSetters.m

@@ -24,8 +24,7 @@
 #import <XCTest/XCTest.h>
 #import "librws.h"
 
-@interface getterAndSetters : XCTestCase
-{
+@interface getterAndSetters : XCTestCase {
 @private
 	rws_socket * _socket;
 }
@@ -33,23 +32,20 @@
 
 @implementation getterAndSetters
 
-- (void) setUp
-{
+- (void) setUp {
     [super setUp];
     // Put setup code here. This method is called before the invocation of each test method in the class.
 	_socket = rws_socket_create();
 }
 
-- (void) tearDown
-{
+- (void) tearDown {
     // Put teardown code here. This method is called after the invocation of each test method in the class.
     [super tearDown];
 	rws_socket_disconnect_and_release(_socket);
 	_socket = NULL;
 }
 
-- (void) testSetURL
-{
+- (void) testSetURL {
     // This is an example of a functional test case.
     // Use XCTAssert and related functions to verify your tests produce the correct results.
 

test/test_librws_creation.c

@@ -43,8 +43,7 @@
 
 static rws_socket _socket = NULL;
 
-static void on_socket_received_text(rws_socket socket, const char * text, const unsigned int length)
-{
+static void on_socket_received_text(rws_socket socket, const char * text, const unsigned int length) {
 	char buff[8*1024];
 	memcpy(buff, text, length);
 	buff[length] = 0;
@@ -52,8 +51,7 @@ static void on_socket_received_text(rws_socket socket, const char * text, const
 	printf("\nSocket text: %s", text);
 }
 
-static void on_socket_received_bin(rws_socket socket, const void * data, const unsigned int length)
-{
+static void on_socket_received_bin(rws_socket socket, const void * data, const unsigned int length) {
 	char buff[8*1024];
 	memcpy(buff, data, length);
 	buff[length] = 0;
@@ -61,8 +59,7 @@ static void on_socket_received_bin(rws_socket socket, const void * data, const u
 	printf("\nSocket bin: <%s>", buff);
 }
 
-static void on_socket_connected(rws_socket socket)
-{
+static void on_socket_connected(rws_socket socket) {
 	const char * test_send_text =
 	"{\"version\":\"1.0\",\"supportedConnectionTypes\":[\"websocket\"],\"minimumVersion\":\"1.0\",\"channel\":\"/meta/handshake\"}";
 
@@ -71,19 +68,16 @@ static void on_socket_connected(rws_socket socket)
 	rws_socket_send_text(socket, test_send_text);
 }
 
-static void on_socket_disconnected(rws_socket socket)
-{
+static void on_socket_disconnected(rws_socket socket) {
 	rws_error error = rws_socket_get_error(socket);
-	if (error)
-	{
+	if (error) {
 		printf("\nSocket disconnect with code, error: %i, %s",
 			  rws_error_get_code(error),
 			  rws_error_get_description(error));
 	}
 }
 
-int main(int argc, char* argv[])
-{
+int main(int argc, char* argv[]) {
 	_socket = rws_socket_create(); // create and store socket handle
 	assert(_socket);
 

test/test_librws_socket_get_set.c

@@ -40,8 +40,7 @@
 #undef CMAKE_BUILD
 #endif
 
-int main(int argc, char* argv[])
-{
+int main(int argc, char* argv[]) {
 	const char * scheme = "ws";
 	const char * host = "echo.websocket.org";
 	const char * path = "/";