fix borked configure options. client multi-threading bug fixes. cleanup

Author: jeremyhahn

Makefile.am

@@ -17,11 +17,12 @@ libwsclient_a_SOURCES = $(ECHO_CLIENT) $(COMMON) $(WEBSOCKET_CLIENT)
 libwsserver_a_SOURCES = $(ECHO_SERVER) $(COMMON) $(WEBSOCKET_SERVER)
 
 AM_CFLAGS = -Wall
+AM_LDFLAGS = 
 
 if DEBUG
-  AM_CFLAGS += -g3
+AM_CFLAGS += -g3
 else
-  AM_CFLAGS += -O3
+AM_CFLAGS += -O3
 endif
 
 so:

autogen.sh

@@ -1,5 +1,3 @@
 #!/bin/sh
 
-aclocal --install -I m4 &&
-  autoreconf -i &&
-  autoheader
+aclocal --install -I m4 && autoreconf -i -v

configure.ac

@@ -3,7 +3,7 @@
 
 AC_PREREQ([2.69])
 AC_INIT([cwebsocket], [0.01], [root@localhost])
-AM_INIT_AUTOMAKE([1.9 foreign])
+AM_INIT_AUTOMAKE([cwebsocket], [0.01])
 AC_CONFIG_SRCDIR([src/websocket-client.c])
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_MACRO_DIR([m4])
@@ -56,50 +56,42 @@ AC_FUNC_MALLOC
 AC_CHECK_FUNCS([gettimeofday memset socket strcasecmp strchr strerror strstr])
 
 AC_CONFIG_FILES([Makefile])
-AC_OUTPUT
 
 # Conditionals
 AC_ARG_ENABLE(debug,
-  AS_HELP_STRING(
-    [--enable-debug],
-    [Include debug symbols and enable verbose logging - default: yes]),
-    [case "${enableval}" in
-      yes) debug=true ;;
-      no)  debug=false ;;
-      *)   AC_MSG_ERROR([bad value ${enableval} for --enable-debug]) ;;
-    esac],
-    [debug=true])
-AM_CONDITIONAL(DEBUG, test x"$debug" = x"true")
-AM_COND_IF(DEBUG,
-    AC_DEFINE(DEBUG, 1, [Define to 0 if this is a release build]),
-    AC_DEFINE(DEBUG, 0, [Define to 1 or higher if this is a debug build]))
+[--enable-debug    Turn on debugging],
+[case "${enableval}" in
+  yes) debug=true ;;
+  no)  debug=false ;;
+  *) AC_MSG_ERROR(bad value ${enableval} for --enable-debug) ;;
+esac],[debug=true])
+AM_CONDITIONAL([DEBUG], [test "$debug" = true])
 
 AC_ARG_ENABLE(ssl,
   AS_HELP_STRING(
     [--enable-ssl],
-    [WebSocket SSL support - default: yes]),
+    [enable ssl, default: enabled]),
     [case "${enableval}" in
       yes) ssl=true ;;
       no)  ssl=false ;;
       *)   AC_MSG_ERROR([bad value ${enableval} for --enable-ssl]) ;;
     esac],
     [ssl=true])
-AM_CONDITIONAL(USESSL, test x"$ssl" = x"true")
-AM_COND_IF(USESSL,
-    AC_DEFINE(USESSL, 1, [Set to 1 to enable SSL support]),
-    AC_DEFINE(USESSL, 0, [Set to 0 to disable SSL support]))
+#AM_CONDITIONAL(USESSL, test x"$ssl" = x"true")
+if test "$ssl" = true; then
+    AC_DEFINE(ENABLE_SSL, [1], ["Compile with SSL support"])
+fi
 
 AC_ARG_ENABLE(threads,
-  AS_HELP_STRING(
-    [--enable-threads],
-    [Enable multi-threading - default: yes]),
-    [case "${enableval}" in
-      yes) threads=true ;;
-      no)  threads=false ;;
-      *)   AC_MSG_ERROR([bad value ${enableval} for --enable-threads]) ;;
-    esac],
-    [threads=true])
-AM_CONDITIONAL(THREADED, test x"$threads" = x"true")
-AM_COND_IF(THREADED,
-    AC_DEFINE(THREADED, 1, [Set to 1 to enable pthread support]),
-    AC_DEFINE(THREADED, 0, [Set to 0 to disable pthread support]))
+[--enable-threads    Enable multi-threading],
+[case "${enableval}" in
+  yes) threads=true ;;
+  no)  threads=false ;;
+  *) AC_MSG_ERROR(bad value ${enableval} for --enable-threads) ;;
+esac],[threads=true])
+#AM_CONDITIONAL([THREADED], [test "x$threads" = "xtrue"])
+if test "$threads" = true; then
+    AC_DEFINE(ENABLE_THREADS, [1], ["Compile with client multi-threading support"])
+fi
+
+AC_OUTPUT

src/cwebsocket/client.c

@@ -80,7 +80,7 @@ void cwebsocket_client_parse_uri(cwebsocket_client *websocket, const char *uri,
 		strcpy(querystring, "");
 		return;
 	}
-#ifdef USESSL
+#ifdef ENABLE_SSL
 	else if(sscanf(uri, "wss://%[^:]:%[^/]%[^?]%s", hostname, port, resource, querystring) == 4) {
 		websocket->flags |= WEBSOCKET_FLAG_SSL;
 		return;
@@ -137,7 +137,7 @@ int cwebsocket_client_connect(cwebsocket_client *websocket) {
 		return -1;
 	}
 
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 	if(pthread_mutex_init(&websocket->lock, NULL) != 0) {
 		syslog(LOG_ERR, "cwebsocket_client_connect: unable to initialize websocket mutex: %s\n", strerror(errno));
 		cwebsocket_client_onerror(websocket, strerror(errno));
@@ -239,7 +239,7 @@ int cwebsocket_client_connect(cwebsocket_client *websocket) {
 		return -1;
     }
 
-#ifdef USESSL
+#ifdef ENABLE_SSL
 
     websocket->ssl = NULL;
     websocket->sslctx = NULL;
@@ -275,7 +275,7 @@ int cwebsocket_client_connect(cwebsocket_client *websocket) {
 	}
 #endif
 
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 	pthread_mutex_lock(&websocket->lock);
 	websocket->state = WEBSOCKET_STATE_CONNECTED;
 	pthread_mutex_unlock(&websocket->lock);
@@ -295,7 +295,7 @@ int cwebsocket_client_connect(cwebsocket_client *websocket) {
 		return -1;
 	}
 
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 	pthread_mutex_lock(&websocket->lock);
 	websocket->state = WEBSOCKET_STATE_OPEN;
 	pthread_mutex_unlock(&websocket->lock);
@@ -426,9 +426,9 @@ void cwebsocket_client_listen(cwebsocket_client *websocket) {
 	syslog(LOG_DEBUG, "cwebsocket_client_listen: shutting down");
 }
 
-#ifdef THREADED
-void *cwebsocket_onmessage_thread(void *ptr) {
-	cwebsocket_thread_args *args = (cwebsocket_thread_args *)ptr;
+#ifdef ENABLE_THREADS
+void *cwebsocket_client_onmessage_thread(void *ptr) {
+	cwebsocket_client_thread_args *args = (cwebsocket_client_thread_args *)ptr;
 	cwebsocket_client_onmessage(args->socket, args->message);
 	free(args->message->payload);
 	free(args->message);
@@ -617,7 +617,7 @@ int cwebsocket_client_read_data(cwebsocket_client *websocket) {
 
 		if(websocket->subprotocol != NULL && websocket->subprotocol->onmessage != NULL) {
 
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 			cwebsocket_message *message = malloc(sizeof(cwebsocket_message));
 			if(message == NULL) {
 				perror("out of memory");
@@ -634,12 +634,12 @@ int cwebsocket_client_read_data(cwebsocket_client *websocket) {
 			strncpy(message->payload, payload, payload_length+1);
 			free(payload);
 
-		    cwebsocket_client_thread_args *args = malloc(sizeof(cwebsocket_thread_args));
+		    cwebsocket_client_thread_args *args = malloc(sizeof(cwebsocket_client_thread_args));
 		    if(args == NULL) {
 				perror("out of memory");
 				exit(-1);
 			}
-		    memset(args, 0, sizeof(cwebsocket_thread_args));
+		    memset(args, 0, sizeof(cwebsocket_client_thread_args));
 		    args->socket = websocket;
 		    args->message = message;
 
@@ -679,14 +679,14 @@ int cwebsocket_client_read_data(cwebsocket_client *websocket) {
 
 		if(websocket->subprotocol->onmessage != NULL) {
 
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 			cwebsocket_message *message = malloc(sizeof(cwebsocket_message));
 			message->opcode = frame.opcode;
 			message->payload_len = frame.payload_len;
 			message->payload = malloc(sizeof(char) * payload_length);
 			memcpy(message->payload, payload, payload_length);
 
-			cwebsocket_thread_args *args = malloc(sizeof(cwebsocket_thread_args));
+			cwebsocket_client_thread_args *args = malloc(sizeof(cwebsocket_client_thread_args));
 			args->socket = websocket;
 			args->message = message;
 
@@ -848,7 +848,7 @@ void cwebsocket_client_close(cwebsocket_client *websocket, uint16_t code, const
 		return;
 	}
 
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 	pthread_mutex_lock(&websocket->lock);
 	websocket->state = WEBSOCKET_STATE_CLOSING;
 	pthread_mutex_unlock(&websocket->lock);
@@ -876,7 +876,7 @@ void cwebsocket_client_close(cwebsocket_client *websocket, uint16_t code, const
 		cwebsocket_client_send_control_frame(websocket, CLOSE, "CLOSE", NULL, 0);
 	}
 
-#ifdef USESSL
+#ifdef ENABLE_SSL
 	if(websocket->ssl != NULL) {
        SSL_shutdown(websocket->ssl);
 	   SSL_free(websocket->ssl);
@@ -899,7 +899,7 @@ void cwebsocket_client_close(cwebsocket_client *websocket, uint16_t code, const
 
 	cwebsocket_client_onclose(websocket, code32, message);
 
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 	pthread_mutex_lock(&websocket->lock);
 	websocket->state = WEBSOCKET_STATE_CLOSED;
 	pthread_mutex_unlock(&websocket->lock);
@@ -917,7 +917,7 @@ void cwebsocket_client_close(cwebsocket_client *websocket, uint16_t code, const
 }
 
 ssize_t inline cwebsocket_client_read(cwebsocket_client *websocket, void *buf, int len) {
-#ifdef USESSL
+#ifdef ENABLE_SSL
 	return (websocket->flags & WEBSOCKET_FLAG_SSL) ?
 			SSL_read(websocket->ssl, buf, len) :
 			read(websocket->fd, buf, len);
@@ -927,7 +927,7 @@ ssize_t inline cwebsocket_client_read(cwebsocket_client *websocket, void *buf, i
 }
 
 ssize_t inline cwebsocket_client_write(cwebsocket_client *websocket, void *buf, int len) {
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 	ssize_t bytes_written;
 	pthread_mutex_lock(&websocket->write_lock);
 	#ifdef USESSL
@@ -940,7 +940,7 @@ ssize_t inline cwebsocket_client_write(cwebsocket_client *websocket, void *buf,
 	pthread_mutex_unlock(&websocket->write_lock);
 	return bytes_written;
 #else
-	#ifdef USESSL
+	#ifdef ENABLE_SSL
 		return (websocket->flags & WEBSOCKET_FLAG_SSL) ?
 				SSL_write(websocket->ssl, buf, len) :
 				write(websocket->fd, buf, len);

src/cwebsocket/client.h

@@ -44,11 +44,11 @@ typedef struct _cwebsocket {
 	char *uri;
 	uint8_t flags;
 	uint8_t state;
-#ifdef USESSL
+#ifdef ENABLE_SSL
 	SSL_CTX *sslctx;
 	SSL *ssl;
 #endif
-#ifdef THREADED
+#ifdef ENABLE_THREADS
 	pthread_t thread;
 	pthread_mutex_t lock;
 	pthread_mutex_t write_lock;
@@ -61,7 +61,7 @@ typedef struct _cwebsocket {
 typedef struct {
 	cwebsocket_client *socket;
 	cwebsocket_message *message;
-} cwebsocket_thread_args;
+} cwebsocket_client_thread_args;
 
 // "public"
 void cwebsocket_client_init(cwebsocket_client *websocket, cwebsocket_subprotocol *subprotocols[], int subprotocol_len);

src/cwebsocket/common.h

@@ -45,9 +45,11 @@
 #include <openssl/buffer.h>
 #include "utf8.h"
 
-#include <limits.h>
+#ifdef HAVE_CONFIG_H
+    #include "../../config.h"
+#endif
 
-#ifdef USESSL
+#ifdef ENABLE_SSL
 	#include <openssl/rand.h>
 	#include <openssl/ssl.h>
 	#include <openssl/err.h>

src/websocket-client.c

@@ -109,24 +109,17 @@ int main(int argc, char **argv) {
 	openlog("cwebsocket", LOG_CONS | LOG_PERROR, LOG_USER);
 	syslog(LOG_DEBUG, "starting cwebsocket client");
 
-
-	//cwebsocket_client_init(&websocket_client, NULL, 0);
-
-
-	cwebsocket_subprotocol *subprotocols[1];
-	subprotocols[0] = cwebsocket_subprotocol_echo_client_new();
-    cwebsocket_client_init(&websocket_client, subprotocols, 1);
-
+	cwebsocket_client_init(&websocket_client, NULL, 0);
+	websocket_client.subprotocol = cwebsocket_subprotocol_echo_client_new();   // Hardcoding instead of negotiating
 	websocket_client.uri = argv[1];
-	//websocket_client.flags |= WEBSOCKET_FLAG_AUTORECONNECT;  // OPTIONAL - retry failed connections
-	//websocket_client.retry = 5;                              // OPTIONAL - seconds to wait before retrying
+	//websocket_client.flags |= WEBSOCKET_FLAG_AUTORECONNECT;                  // OPTIONAL - retry failed connections
+	//websocket_client.retry = 5;                                              // OPTIONAL - seconds to wait before retrying
 	if(cwebsocket_client_connect(&websocket_client) == -1) {
 		return main_exit(EXIT_FAILURE);
 	}
 
 	run_websocket_org_echo_test(&websocket_client);
 
 	cwebsocket_client_close(&websocket_client, 1000, "main: run loop complete");
-	//free(subprotocols[0]);
 	return main_exit(EXIT_SUCCESS);
 }