Merge branch 'develop'

Conflicts:
	CMakeLists.txt
	Doxyfile
	changelog.md
	readme.md
	websocketpp/version.hpp

.gitattributes

@@ -0,0 +1,18 @@
+# Lineendings
+*.sln       eol=crlf
+*.vcproj    eol=crlf
+*.vcxproj*  eol=crlf
+
+# Whitespace rules
+# strict (no trailing, no tabs)
+*.cpp       whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
+*.hpp       whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
+*.c         whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
+*.h         whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
+
+# normal (no trailing)
+*.sql       whitespace=trailing-space,space-before-tab,cr-at-eol
+*.txt       whitespace=trailing-space,space-before-tab,cr-at-eol
+
+# special files which must ignore whitespace
+*.patch     whitespace=-trailing-space

.gitignore

@@ -1,3 +1,7 @@
+# make .git* files visible to git
+!.gitignore
+!.gitattributes
+
 .DS_Store
 
 #vim stuff
@@ -6,8 +10,36 @@
 
 *.o
 *.so
+*.so.?
+*.so.?.?.?
 *.a
 *.dylib
+lib/*
+
+# CMake
+*.cmake
+*.dir
+CMakeFiles
+INSTALL.*
+ZERO_CHECK.*
+CMakeCache.txt
+install_manifest.txt
+
+# Windows/Visual Studio
+*.vcproj*
+*.sln
+*.suo
+*.ncb
+*/Debug/*
+*/*/Debug/*
+bin/Debug
+*/Release/*
+*/*/Release/*
+*/RelWithDebInfo/*
+*/*/RelWithDebInfo/*
+
+# explicitly allow this path with /debug/ in it
+!websocketpp/transport/debug/*
 
 objs_shared/
 objs_static/
@@ -22,3 +54,37 @@ libwebsocketpp.dylib.0.1.0
 websocketpp.xcodeproj/xcuserdata/*
 websocketpp.xcodeproj/project.xcworkspace/xcuserdata/*
 policy_based_notes.hpp
+
+examples/echo_server_tls/echo_server_tls
+
+examples/fuzzing_client/fuzzing_client
+
+examples/stress_client/stress_client
+
+examples/broadcast_server_tls/broadcast_server
+
+test/basic/perf
+
+examples/echo_server_tls/echo_server_tls
+
+examples/concurrent_server/concurrent_server
+
+examples/fuzzing_server_tls/fuzzing_server
+
+examples/wsperf/wsperf
+
+.sconsign.dblite
+
+build/
+doxygen/
+examples/wsperf/wsperf_client
+
+*.out
+
+*.log
+*.opensdf
+*.sdf
+*.vcxproj
+*.vcxproj.filters
+*.user
+install

.travis.yml

@@ -0,0 +1,23 @@
+language: cpp
+compiler:
+  - gcc
+before_install:
+ - sudo apt-get install libboost-chrono1.48-dev libboost-regex1.48-dev libboost-system1.48-dev libboost-thread1.48-dev libboost-test1.48-dev libboost-random1.48-dev -y
+env:
+  global:
+    - BOOST_INCLUDES=/usr/include
+    - BOOST_LIBS=/usr/lib
+script: scons -j 2 && scons test
+branches:
+  only:
+    - master
+    - permessage-deflate
+    - experimental
+    - 0.3.x-cmake
+    - develop
+notifications:
+  recipients:
+    - travis@zaphoyd.com
+  email:
+    on_success: change
+    on_failure: always

CMakeLists.txt

@@ -0,0 +1,244 @@
+
+############ Setup project and cmake
+
+# Project name
+project (websocketpp)
+
+# Minimum cmake requirement. We should require a quite recent
+# cmake for the dependency find macros etc. to be up to date.
+cmake_minimum_required (VERSION 2.6)
+
+set (WEBSOCKETPP_MAJOR_VERSION 0)
+set (WEBSOCKETPP_MINOR_VERSION 6)
+set (WEBSOCKETPP_PATCH_VERSION 0)
+set (WEBSOCKETPP_VERSION ${WEBSOCKETPP_MAJOR_VERSION}.${WEBSOCKETPP_MINOR_VERSION}.${WEBSOCKETPP_PATCH_VERSION})
+
+set(INSTALL_INCLUDE_DIR include CACHE PATH "Installation directory for header files")
+if (WIN32 AND NOT CYGWIN)
+  set (DEF_INSTALL_CMAKE_DIR cmake)
+else ()
+  set (DEF_INSTALL_CMAKE_DIR lib/cmake/websocketpp)
+endif ()
+set (INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
+
+# Make relative paths absolute (needed later on)
+foreach (p INCLUDE CMAKE)
+  set (var INSTALL_${p}_DIR)
+  if (NOT IS_ABSOLUTE "${${var}}")
+    set (${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
+  endif ()
+endforeach ()
+
+# Set CMake library search policy
+if (COMMAND cmake_policy)
+    cmake_policy (SET CMP0003 NEW)
+    cmake_policy (SET CMP0005 NEW)
+endif ()
+
+# Disable unnecessary build types
+set (CMAKE_CONFIGURATION_TYPES "Release;RelWithDebInfo;Debug" CACHE STRING "Configurations" FORCE)
+
+# Include our cmake macros
+set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+include (CMakeHelpers)
+
+############ Paths
+
+set (WEBSOCKETPP_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
+set (WEBSOCKETPP_INCLUDE ${WEBSOCKETPP_ROOT}/websocketpp)
+set (WEBSOCKETPP_BUILD_ROOT ${CMAKE_CURRENT_BINARY_DIR})
+set (WEBSOCKETPP_BIN ${WEBSOCKETPP_BUILD_ROOT}/bin)
+set (WEBSOCKETPP_LIB ${WEBSOCKETPP_BUILD_ROOT}/lib)
+
+# CMake install step prefix. I assume linux users want the prefix to
+# be the default /usr or /usr/local so this is only adjusted on Windows.
+# - Windows: Build the INSTALL project in your solution file.
+# - Linux/OSX: make install.
+if (MSVC)
+    set (CMAKE_INSTALL_PREFIX "${WEBSOCKETPP_ROOT}/install")
+endif ()
+
+############  Build customization
+
+# Override from command line "CMake -D<OPTION>=TRUE/FALSE/0/1/ON/OFF"
+option (ENABLE_CPP11 "Build websocketpp with CPP11 features enabled." TRUE)
+option (BUILD_EXAMPLES "Build websocketpp examples." FALSE)
+option (BUILD_TESTS "Build websocketpp tests." FALSE)
+
+if (BUILD_TESTS OR BUILD_EXAMPLES)
+
+    ############ Compiler specific setup
+
+    set (WEBSOCKETPP_PLATFORM_LIBS "")
+    set (WEBSOCKETPP_PLATFORM_TLS_LIBS "")
+    set (WEBSOCKETPP_BOOST_LIBS "")
+
+    # VC9 and C++11 reasoning
+    if (ENABLE_CPP11 AND MSVC AND MSVC90)
+        message("* Detected Visual Studio 9 2008, disabling C++11 support.")
+        set (ENABLE_CPP11 FALSE)
+    endif ()
+
+    # Detect clang. Not officially reported by cmake.
+    execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "-v" ERROR_VARIABLE CXX_VER_STDERR)
+    if ("${CXX_VER_STDERR}" MATCHES ".*clang.*")
+        set (CMAKE_COMPILER_IS_CLANGXX 1)
+    endif ()
+
+    # C++11 defines
+    if (ENABLE_CPP11)
+        if (MSVC)
+            add_definitions (-D_WEBSOCKETPP_CPP11_FUNCTIONAL_)
+            add_definitions (-D_WEBSOCKETPP_CPP11_SYSTEM_ERROR_)
+            add_definitions (-D_WEBSOCKETPP_CPP11_RANDOM_DEVICE_)
+            add_definitions (-D_WEBSOCKETPP_CPP11_MEMORY_)
+        else()
+            add_definitions (-D_WEBSOCKETPP_CPP11_STL_)
+        endif()
+    endif ()
+
+    # Visual studio
+    if (MSVC)
+        set (WEBSOCKETPP_BOOST_LIBS system thread)
+        set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GL /Gy /GF /Ox /Ob2 /Ot /Oi /MP /arch:SSE2 /fp:fast")
+        set (CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /INCREMENTAL:NO /OPT:REF /OPT:ICF")
+        add_definitions (/W3 /wd4996 /wd4995 /wd4355)
+        add_definitions (-DUNICODE -D_UNICODE)
+        add_definitions (-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS)
+        add_definitions (-DNOMINMAX)
+    endif ()
+
+    # g++
+    if (CMAKE_COMPILER_IS_GNUCXX)
+        set (WEBSOCKETPP_PLATFORM_LIBS pthread rt)
+        set (WEBSOCKETPP_PLATFORM_TLS_LIBS ssl crypto)
+        set (WEBSOCKETPP_BOOST_LIBS system thread)
+        set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+        if (NOT APPLE)
+            add_definitions (-DNDEBUG -Wall -Wcast-align) # todo: should we use CMAKE_C_FLAGS for these?
+        endif ()
+
+        # Try to detect version. Note: Not tested!
+        execute_process (COMMAND ${CMAKE_CXX_COMPILER} "-dumpversion" OUTPUT_VARIABLE GCC_VERSION)
+        if ("${GCC_VERSION}" STRGREATER "4.4.0")
+            message("* C++11 support partially enabled due to GCC version ${GCC_VERSION}")
+            set (WEBSOCKETPP_BOOST_LIBS system thread)
+        endif ()
+    endif ()
+
+    # clang
+    if (CMAKE_COMPILER_IS_CLANGXX)
+        if (NOT APPLE)
+            set (WEBSOCKETPP_PLATFORM_LIBS pthread rt)
+        else()
+            set (WEBSOCKETPP_PLATFORM_LIBS pthread)
+        endif()
+        set (WEBSOCKETPP_PLATFORM_TLS_LIBS ssl crypto)
+        set (WEBSOCKETPP_BOOST_LIBS system thread)
+        set (CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-std=c++0x -stdlib=libc++") # todo: is libc++ really needed here?
+        if (NOT APPLE)
+            add_definitions (-DNDEBUG -Wall -Wno-padded) # todo: should we use CMAKE_C_FLAGS for these?
+        endif ()
+    endif ()
+
+    # OSX, can override above.
+    if (APPLE)
+        add_definitions (-DNDEBUG -Wall)
+    endif ()
+
+    if (BUILD_EXAMPLES)
+        list (APPEND WEBSOCKETPP_BOOST_LIBS random)
+    endif()
+
+    ############ Dependencies
+
+    # Set BOOST_ROOT env variable or pass with cmake -DBOOST_ROOT=path.
+    # BOOST_ROOT can also be defined by a previous run from cmake cache.
+    if (NOT "$ENV{BOOST_ROOT_CPP11}" STREQUAL "")
+        # Scons documentation for BOOST_ROOT_CPP11:
+        # "look for optional second boostroot compiled with clang's libc++ STL library
+        # this prevents warnings/errors when linking code built with two different
+        # incompatible STL libraries."
+        file (TO_CMAKE_PATH "$ENV{BOOST_ROOT_CPP11}" BOOST_ROOT)
+        set (BOOST_ROOT ${BOOST_ROOT} CACHE PATH "BOOST_ROOT dependency path" FORCE)
+    endif ()
+    if ("${BOOST_ROOT}" STREQUAL "")
+        file (TO_CMAKE_PATH "$ENV{BOOST_ROOT}" BOOST_ROOT)
+        # Cache BOOST_ROOT for runs that do not define $ENV{BOOST_ROOT}.
+        set (BOOST_ROOT ${BOOST_ROOT} CACHE PATH "BOOST_ROOT dependency path" FORCE)
+    endif ()
+
+    message ("* Configuring Boost")
+    message (STATUS "-- Using BOOST_ROOT")
+    message (STATUS "       " ${BOOST_ROOT})
+
+    if (MSVC)
+        set (Boost_USE_MULTITHREADED TRUE)
+        set (Boost_USE_STATIC_LIBS TRUE)
+    else ()
+        set (Boost_USE_MULTITHREADED FALSE)
+        set (Boost_USE_STATIC_LIBS FALSE)
+    endif ()
+
+    set (Boost_FIND_REQUIRED TRUE)
+    set (Boost_FIND_QUIETLY TRUE)
+    set (Boost_DEBUG FALSE)
+    set (Boost_USE_MULTITHREADED TRUE)
+    set (Boost_ADDITIONAL_VERSIONS "1.39.0" "1.40.0" "1.41.0" "1.42.0" "1.43.0" "1.44.0" "1.46.1") # todo: someone who knows better spesify these!
+
+    find_package (Boost 1.39.0 COMPONENTS "${WEBSOCKETPP_BOOST_LIBS}")
+
+    if (Boost_FOUND)
+        # Boost is a project wide global dependency.
+        include_directories (${Boost_INCLUDE_DIRS})
+        link_directories (${Boost_LIBRARY_DIRS})
+
+        # Pretty print status
+        message (STATUS "-- Include Directories")
+        foreach (include_dir ${Boost_INCLUDE_DIRS})
+            message (STATUS "       " ${include_dir})
+        endforeach ()
+        message (STATUS "-- Library Directories")
+        foreach (library_dir ${Boost_LIBRARY_DIRS})
+            message (STATUS "       " ${library_dir})
+        endforeach ()
+        message (STATUS "-- Libraries")
+        foreach (boost_lib ${Boost_LIBRARIES})
+            message (STATUS "       " ${boost_lib})
+        endforeach ()
+        message ("")
+    else ()
+        message (FATAL_ERROR "Failed to find required dependency: boost")
+    endif ()
+
+    find_package(OpenSSL)
+endif()
+
+############ Add projects
+
+# Add main library
+add_subdirectory (websocketpp)
+
+# Add examples
+if (BUILD_EXAMPLES)
+    add_subdirectory (examples)
+endif ()
+
+# Add tests
+if (BUILD_TESTS)
+    add_subdirectory (test)
+endif ()
+
+print_used_build_config()
+
+export (PACKAGE websocketpp)
+
+configure_file (websocketpp-config.cmake.in "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-config.cmake" @ONLY)
+configure_file (websocketpp-configVersion.cmake.in "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-configVersion.cmake" @ONLY)
+
+# Install the websocketpp-config.cmake and websocketpp-configVersion.cmake
+install (FILES
+  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-config.cmake"
+  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-configVersion.cmake"
+  DESTINATION "${INSTALL_CMAKE_DIR}" COMPONENT dev)
+

COPYING

@@ -0,0 +1,145 @@
+Main Library:
+
+Copyright (c) 2014, Peter Thorson. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the WebSocket++ Project nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Bundled Libraries:
+
+****** Base 64 Library (base64/base64.hpp) ******
+base64.hpp is a repackaging of the base64.cpp and base64.h files into a
+single header suitable for use as a header only library. This conversion was
+done by Peter Thorson (webmaster@zaphoyd.com) in 2012. All modifications to
+the code are redistributed under the same license as the original, which is
+listed below.
+
+base64.cpp and base64.h
+
+Copyright (C) 2004-2008 René Nyffenegger
+
+This source code is provided 'as-is', without any express or implied
+warranty. In no event will the author be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this source code must not be misrepresented; you must not
+  claim that you wrote the original source code. If you use this source code
+  in a product, an acknowledgment in the product documentation would be
+  appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+  misrepresented as being the original source code.
+
+3. This notice may not be removed or altered from any source distribution.
+
+René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+
+****** SHA1 Library (sha1/sha1.hpp) ******
+sha1.hpp is a repackaging of the sha1.cpp and sha1.h files from the shallsha1
+library (http://code.google.com/p/smallsha1/) into a single header suitable for
+use as a header only library. This conversion was done by Peter Thorson
+(webmaster@zaphoyd.com) in 2013. All modifications to the code are redistributed
+under the same license as the original, which is listed below.
+
+ Copyright (c) 2011, Micael Hildenborg
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Micael Hildenborg nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
+ EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+****** MD5 Library (common/md5.hpp) ******
+md5.hpp is a reformulation of the md5.h and md5.c code from
+http://www.opensource.apple.com/source/cups/cups-59/cups/md5.c to allow it to
+function as a component of a header only library. This conversion was done by
+Peter Thorson (webmaster@zaphoyd.com) in 2012 for the WebSocket++ project. The
+changes are released under the same license as the original (listed below)
+
+Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+L. Peter Deutsch
+ghost@aladdin.com
+
+****** UTF8 Validation logic (utf8_validation.hpp) ******
+utf8_validation.hpp is adapted from code originally written by Bjoern Hoehrmann
+<bjoern@hoehrmann.de>. See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for
+details.
+
+The original license:
+
+Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -1,201 +0,0 @@
-################################################################################
-# 
-#  Copyright (c) 2011, Peter Thorson. All rights reserved.
-# 
-#  Redistribution and use in source and binary forms, with or without
-#  modification, are permitted provided that the following conditions are met:
-#      * Redistributions of source code must retain the above copyright
-#        notice, this list of conditions and the following disclaimer.
-#      * Redistributions in binary form must reproduce the above copyright
-#        notice, this list of conditions and the following disclaimer in the
-#        documentation and/or other materials provided with the distribution.
-#      * Neither the name of the WebSocket++ Project nor the
-#        names of its contributors may be used to endorse or promote products
-#        derived from this software without specific prior written permission.
-#  
-#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-#  ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
-#  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-#  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-#  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-#  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-#  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#  
-#  This Makefile was derived from a similar one included in the libjson project
-#  It's authors were Jonathan Wallace and Bernhard Fluehmann.
-
-
-objects = websocket_server_session.o websocket_client_session.o websocket_session.o  websocket_server.o websocket_client.o websocket_frame.o \
-          network_utilities.o sha1.o base64.o
-
-libs = -lboost_system -lboost_date_time -lboost_regex -lboost_random
-
-OS=$(shell uname)
-
-# Defaults
-ifeq ($(OS), Darwin)
-	cxxflags_default = -c -O2 -DNDEBUG
-else
-	cxxflags_default = -c -O2 -DNDEBUG
-endif
-cxxflags_small   = -c 
-cxxflags_debug   = -c -g
-cxxflags_shared  = -f$(PIC)
-libname          = libwebsocketpp
-libname_hdr      = websocketpp
-libname_debug    = $(libname)
-suffix_shared    = so
-suffix_shared_darwin = dylib
-suffix_static    = a
-major_version    = 0
-minor_version    = 1.0
-objdir           = objs
-
-# Variables
-prefix          ?= /usr/local
-exec_prefix     ?= $(prefix)
-libdir          ?= lib
-includedir      ?= include
-srcdir          ?= src
-CXX             ?= c++
-AR              ?= ar
-PIC             ?= PIC
-BUILD_TYPE      ?= "default"
-SHARED          ?= "1"
-
-# Internal Variables
-inst_path        = $(exec_prefix)/$(libdir)
-include_path     = $(prefix)/$(includedir)
-
-# BUILD_TYPE specific settings
-ifeq ($(BUILD_TYPE), debug)
-	CXXFLAGS     = $(cxxflags_debug)
-	libname     := $(libname_debug)
-else
-	CXXFLAGS    ?= $(cxxflags_default)
-endif
-
-# SHARED specific settings
-ifeq ($(SHARED), 1)
-	ifeq ($(OS), Darwin)
-		libname_shared           = $(libname).$(suffix_shared_darwin)
-	else
-		libname_shared           = $(libname).$(suffix_shared)
-	endif
-	libname_shared_major_version = $(libname_shared).$(major_version)
-	lib_target                   = $(libname_shared_major_version).$(minor_version)
-	objdir                      := $(objdir)_shared
-	CXXFLAGS                    := $(CXXFLAGS) $(cxxflags_shared)
-else
-	lib_target                   = $(libname).$(suffix_static)
-	objdir                      := $(objdir)_static
-endif
-
-# Phony targets
-.PHONY: all banner installdirs install install_headers clean uninstall \
-        uninstall_headers
-
-# Targets
-all: $(lib_target)
-	@echo "============================================================"
-	@echo "Done"
-	@echo "============================================================"
-
-banner:
-	@echo "============================================================"
-	@echo "libwebsocketpp version: "$(major_version).$(minor_version) "target: "$(target) "OS: "$(OS)
-	@echo "============================================================"
-
-installdirs: banner
-	mkdir -p $(objdir)
-
-# Libraries
-ifeq ($(SHARED),1)
-$(lib_target): banner installdirs $(addprefix $(objdir)/, $(objects))
-	@echo "Link "
-	cd $(objdir) ; \
-	if test "$(OS)" = "Darwin" ; then \
-		$(CXX) -dynamiclib $(libs) -Wl,-dylib_install_name -Wl,$(libname_shared_major_version) -o $@ $(objects) ; \
-	else \
-		$(CXX) -shared $(libs) -Wl,-soname,$(libname_shared_major_version) -o $@ $(objects) ; \
-	fi ; \
-	mv -f $@ ../
-	@echo "Link: Done"
-else
-$(lib_target): banner installdirs $(addprefix $(objdir)/, $(objects))
-	@echo "Archive"
-	cd $(objdir) ; \
-	$(AR) -cvq $@ $(objects) ; \
-	mv -f $@ ../
-	@echo "Archive: Done"
-endif
-
-# Compile object files
-$(objdir)/sha1.o: $(srcdir)/sha1/sha1.cpp
-	$(CXX) $< -o $@ $(CXXFLAGS)
-	
-$(objdir)/base64.o: $(srcdir)/base64/base64.cpp
-	$(CXX) $< -o $@ $(CXXFLAGS)
-
-$(objdir)/%.o: $(srcdir)/%.cpp
-	$(CXX) $< -o $@ $(CXXFLAGS)
-
-ifeq ($(SHARED),1)
-install: banner install_headers $(lib_target)
-	@echo "Install shared library"
-	cp -f ./$(lib_target) $(inst_path)
-	cd $(inst_path) ; \
-	ln -sf $(lib_target) $(libname_shared_major_version) ; \
-	ln -sf $(libname_shared_major_version) $(libname_shared)
-	ifneq ($(OS),Darwin)
-		ldconfig
-	endif
-	@echo "Install shared library: Done."
-else
-install: banner install_headers $(lib_target)
-	@echo "Install static library"
-	cp -f ./$(lib_target) $(inst_path)
-	@echo "Install static library: Done."
-endif
-
-install_headers: banner
-	@echo "Install header files"
-	mkdir -p $(include_path)/$(libname_hdr)
-#	cp -f ./*.hpp $(include_path)/$(libname_hdr)
-	cp -f ./$(srcdir)/*.hpp $(include_path)/$(libname_hdr)
-	mkdir -p $(include_path)/$(libname_hdr)/base64
-	cp -f ./$(srcdir)/base64/base64.h $(include_path)/$(libname_hdr)/base64
-	mkdir -p $(include_path)/$(libname_hdr)/sha1
-	cp -f ./$(srcdir)/sha1/sha1.h $(include_path)/$(libname_hdr)/sha1
-	chmod -R a+r $(include_path)/$(libname_hdr)
-	find  $(include_path)/$(libname_hdr) -type d -exec chmod a+x {} \;
-	@echo "Install header files: Done."
-
-clean: banner
-	@echo "Clean library and object folder"
-	rm -rf $(objdir)
-	rm -f $(lib_target)
-	@echo "Clean library and object folder: Done"
-
-ifeq ($(SHARED),1)
-uninstall: banner uninstall_headers
-	@echo "Uninstall shared library"
-	rm -f $(inst_path)/$(libname_shared)
-	rm -f $(inst_path)/$(libname_shared_major_version)
-	rm -f $(inst_path)/$(lib_target)
-	ldconfig
-	@echo "Uninstall shared library: Done"
-else
-uninstall: banner uninstall_headers
-	@echo "Uninstall static library"
-	rm -f $(inst_path)/$(lib_target)
-	@echo "Uninstall static library: Done"
-endif
-
-uninstall_headers: banner
-	@echo "Uninstall header files"
-	rm -rf $(include_path)/$(libname)
-	@echo "Uninstall header files: Done"

SConstruct

@@ -0,0 +1,266 @@
+import os, sys, commands
+env = Environment(ENV = os.environ)
+
+# figure out a better way to configure this
+if os.environ.has_key('CXX'):
+    env['CXX'] = os.environ['CXX']
+
+if os.environ.has_key('DEBUG'):
+    env['DEBUG'] = os.environ['DEBUG']
+
+if os.environ.has_key('CXXFLAGS'):
+    #env['CXXFLAGS'] = os.environ['CXXFLAGS']
+    env.Append(CXXFLAGS = os.environ['CXXFLAGS'])
+
+if os.environ.has_key('LINKFLAGS'):
+    #env['LDFLAGS'] = os.environ['LDFLAGS']
+    env.Append(LINKFLAGS = os.environ['LINKFLAGS'])
+
+## Boost
+##
+## Note: You need to either set BOOSTROOT to the root of a stock Boost distribution
+## or set BOOST_INCLUDES and BOOST_LIBS if Boost comes with your OS distro e.g. and
+## needs BOOST_INCLUDES=/usr/include/boost and BOOST_LIBS=/usr/lib like Ubuntu.
+##
+if os.environ.has_key('BOOSTROOT'):
+    os.environ['BOOST_ROOT'] = os.environ['BOOSTROOT']
+
+if os.environ.has_key('BOOST_ROOT'):
+   env['BOOST_INCLUDES'] = os.environ['BOOST_ROOT']
+   env['BOOST_LIBS'] = os.path.join(os.environ['BOOST_ROOT'], 'stage', 'lib')
+elif os.environ.has_key('BOOST_INCLUDES') and os.environ.has_key('BOOST_LIBS'):
+   env['BOOST_INCLUDES'] = os.environ['BOOST_INCLUDES']
+   env['BOOST_LIBS'] = os.environ['BOOST_LIBS']
+else:
+   raise SCons.Errors.UserError, "Neither BOOST_ROOT, nor BOOST_INCLUDES + BOOST_LIBS was set!"
+
+if os.environ.has_key('WSPP_ENABLE_CPP11'):
+   env['WSPP_ENABLE_CPP11'] = True
+else:
+   env['WSPP_ENABLE_CPP11'] = False
+
+boost_linkshared = False
+
+def boostlibs(libnames,localenv):
+   if localenv['PLATFORM'].startswith('win'):
+      # Win/VC++ supports autolinking. nothing to do.
+      # http://www.boost.org/doc/libs/1_49_0/more/getting_started/windows.html#auto-linking
+      return []
+   else:
+      libs = []
+      prefix = localenv['SHLIBPREFIX'] if boost_linkshared else localenv['LIBPREFIX']
+      suffix = localenv['SHLIBSUFFIX'] if boost_linkshared else localenv['LIBSUFFIX']
+      for name in libnames:
+         lib = File(os.path.join(localenv['BOOST_LIBS'], '%sboost_%s%s' % (prefix, name, suffix)))
+         libs.append(lib)
+      return libs
+
+if env['PLATFORM'].startswith('win'):
+   env.Append(CPPDEFINES = ['WIN32',
+                            'NDEBUG',
+                            'WIN32_LEAN_AND_MEAN',
+                            '_WIN32_WINNT=0x0600',
+                            '_CONSOLE',
+                            'BOOST_TEST_DYN_LINK',
+                            'NOMINMAX',
+                            '_WEBSOCKETPP_CPP11_MEMORY_',
+                            '_WEBSOCKETPP_CPP11_FUNCTIONAL_'])
+   arch_flags  = '/arch:SSE2'
+   opt_flags   = '/Ox /Oi /fp:fast'
+   warn_flags  = '/W3 /wd4996 /wd4995 /wd4355'
+   env['CCFLAGS'] = '%s /EHsc /GR /GS- /MD /nologo %s %s' % (warn_flags, arch_flags, opt_flags)
+   env['LINKFLAGS'] = '/INCREMENTAL:NO /MANIFEST /NOLOGO /OPT:REF /OPT:ICF /MACHINE:X86'
+elif env['PLATFORM'] == 'posix':
+   if env.has_key('DEBUG'):
+      env.Append(CCFLAGS = ['-g', '-O0'])
+   else:
+      env.Append(CPPDEFINES = ['NDEBUG'])
+      env.Append(CCFLAGS = ['-O1', '-fomit-frame-pointer'])
+   env.Append(CCFLAGS = ['-Wall'])
+   #env['LINKFLAGS'] = ''
+elif env['PLATFORM'] == 'darwin':
+   if not os.environ.has_key('CXX'):
+      env['CXX'] = "clang++"
+   if env.has_key('DEBUG'):
+      env.Append(CCFLAGS = ['-g', '-O0'])
+   else:
+      env.Append(CPPDEFINES = ['NDEBUG'])
+      env.Append(CCFLAGS = ['-O1', '-fomit-frame-pointer'])
+   env.Append(CCFLAGS = ['-Wall'])
+   #env['LINKFLAGS'] = ''
+
+if env['PLATFORM'].startswith('win'):
+   #env['LIBPATH'] = env['BOOST_LIBS']
+   pass
+else:
+   env['LIBPATH'] = ['/usr/lib',
+                     '/usr/local/lib'] #, env['BOOST_LIBS']
+
+# Compiler specific warning flags
+if env['CXX'].startswith('g++'):
+   #env.Append(CCFLAGS = ['-Wconversion'])
+   env.Append(CCFLAGS = ['-Wcast-align'])
+   env.Append(CCFLAGS = ['-Wshadow'])
+   env.Append(CCFLAGS = ['-Wunused-parameter'])
+elif env['CXX'].startswith('clang++'):
+   #env.Append(CCFLAGS = ['-Wcast-align'])
+   #env.Append(CCFLAGS = ['-Wglobal-constructors'])
+   #env.Append(CCFLAGS = ['-Wconversion'])
+   env.Append(CCFLAGS = ['-Wno-padded'])
+   env.Append(CCFLAGS = ['-Wshadow'])
+   env.Append(CCFLAGS = ['-Wunused-parameter'])
+
+   env.Append(CCFLAGS = ['-Wsometimes-uninitialized'])
+   env.Append(CCFLAGS = ['-Wuninitialized'])
+
+   #env.Append(CCFLAGS = ['-Weverything'])
+   #env.Append(CCFLAGS = ['-Wno-documentation'])
+   #env.Append(CCFLAGS = ['-Wno-weak-vtables'])
+   #env.Append(CCFLAGS = ['-Wno-global-constructors'])
+   #env.Append(CCFLAGS = ['-Wno-sign-conversion'])
+   #env.Append(CCFLAGS = ['-Wno-exit-time-destructors'])
+
+
+
+
+   # Wpadded
+   # Wsign-conversion
+
+platform_libs = []
+tls_libs = []
+
+tls_build = False
+
+if env['PLATFORM'] == 'posix':
+   platform_libs = ['pthread', 'rt']
+   tls_libs = ['ssl', 'crypto']
+   tls_build = True
+elif env['PLATFORM'] == 'darwin':
+   tls_libs = ['ssl', 'crypto']
+   tls_build = True
+elif env['PLATFORM'].startswith('win'):
+   # Win/VC++ supports autolinking. nothing to do.
+   pass
+
+## Append WebSocket++ path
+env.Append(CPPPATH = ['#'])
+
+##### Set up C++11 environment
+polyfill_libs = [] # boost libraries used as drop in replacements for incomplete
+                   # C++11 STL implementations
+env_cpp11 = env.Clone ()
+
+if env_cpp11['CXX'].startswith('g++'):
+   # TODO: check g++ version
+   GCC_VERSION = commands.getoutput(env_cpp11['CXX'] + ' -dumpversion')
+
+   if GCC_VERSION > "4.4.0":
+      print "C++11 build environment partially enabled"
+      env_cpp11.Append(WSPP_CPP11_ENABLED = "true",CXXFLAGS = ['-std=c++0x'],TOOLSET = ['g++'],CPPDEFINES = ['_WEBSOCKETPP_CPP11_STL_'])
+   else:
+      print "C++11 build environment is not supported on this version of G++"
+elif env_cpp11['CXX'].startswith('clang++'):
+   print "C++11 build environment enabled"
+   env.Append(CXXFLANGS = ['-stdlib=libc++'],LINKFLAGS=['-stdlib=libc++'])
+   env_cpp11.Append(WSPP_CPP11_ENABLED = "true",CXXFLAGS = ['-std=c++0x','-stdlib=libc++'],LINKFLAGS = ['-stdlib=libc++'],TOOLSET = ['clang++'],CPPDEFINES = ['_WEBSOCKETPP_CPP11_STL_'])
+
+   # look for optional second boostroot compiled with clang's libc++ STL library
+   # this prevents warnings/errors when linking code built with two different
+   # incompatible STL libraries.
+   if os.environ.has_key('BOOST_ROOT_CPP11'):
+      env_cpp11['BOOST_INCLUDES'] = os.environ['BOOST_ROOT_CPP11']
+      env_cpp11['BOOST_LIBS'] = os.path.join(os.environ['BOOST_ROOT_CPP11'], 'stage', 'lib')
+   elif os.environ.has_key('BOOST_INCLUDES_CPP11') and os.environ.has_key('BOOST_LIBS_CPP11'):
+      env_cpp11['BOOST_INCLUDES'] = os.environ['BOOST_INCLUDES_CPP11']
+      env_cpp11['BOOST_LIBS'] = os.environ['BOOST_LIBS_CPP11']
+else:
+   print "C++11 build environment disabled"
+
+# if the build system is known to allow the isystem modifier for library include
+# values then use it for the boost libraries. Otherwise just add them to the
+# regular CPPPATH values.
+if env['CXX'].startswith('g++') or env['CXX'].startswith('clang'):
+    env.Append(CPPFLAGS = '-isystem ' + env['BOOST_INCLUDES'])
+else:
+    env.Append(CPPPATH = [env['BOOST_INCLUDES']])
+env.Append(LIBPATH = [env['BOOST_LIBS']])
+
+# if the build system is known to allow the isystem modifier for library include
+# values then use it for the boost libraries. Otherwise just add them to the
+# regular CPPPATH values.
+if env_cpp11['CXX'].startswith('g++') or env_cpp11['CXX'].startswith('clang'):
+    env_cpp11.Append(CPPFLAGS = '-isystem ' + env_cpp11['BOOST_INCLUDES'])
+else:
+    env_cpp11.Append(CPPPATH = [env_cpp11['BOOST_INCLUDES']])
+env_cpp11.Append(LIBPATH = [env_cpp11['BOOST_LIBS']])
+
+releasedir = 'build/release/'
+debugdir = 'build/debug/'
+testdir = 'build/test/'
+builddir = releasedir
+
+Export('env')
+Export('env_cpp11')
+Export('platform_libs')
+Export('boostlibs')
+Export('tls_libs')
+Export('polyfill_libs')
+
+## END OF CONFIG !!
+
+## TARGETS:
+
+if not env['PLATFORM'].startswith('win'):
+    # Unit tests, add test folders with SConscript files to to_test list.
+    to_test = ['utility','http','logger','random','processors','message_buffer','extension','transport/iostream','transport/asio','roles','endpoint','connection','transport'] #,'http','processors','connection'
+
+    for t in to_test:
+       new_tests = SConscript('#/test/'+t+'/SConscript',variant_dir = testdir + t, duplicate = 0)
+       for a in new_tests:
+          new_alias = Alias('test', [a], a.abspath)
+          AlwaysBuild(new_alias)
+
+# Main test application
+#main = SConscript('#/examples/dev/SConscript',variant_dir = builddir + 'dev',duplicate = 0)
+
+# echo_server
+echo_server = SConscript('#/examples/echo_server/SConscript',variant_dir = builddir + 'echo_server',duplicate = 0)
+
+# echo_server_tls
+if tls_build:
+    echo_server_tls = SConscript('#/examples/echo_server_tls/SConscript',variant_dir = builddir + 'echo_server_tls',duplicate = 0)
+    echo_server_both = SConscript('#/examples/echo_server_both/SConscript',variant_dir = builddir + 'echo_server_both',duplicate = 0)
+
+# broadcast_server
+broadcast_server = SConscript('#/examples/broadcast_server/SConscript',variant_dir = builddir + 'broadcast_server',duplicate = 0)
+
+# testee_server
+testee_server = SConscript('#/examples/testee_server/SConscript',variant_dir = builddir + 'testee_server',duplicate = 0)
+
+# testee_client
+testee_client = SConscript('#/examples/testee_client/SConscript',variant_dir = builddir + 'testee_client',duplicate = 0)
+
+# utility_client
+utility_client = SConscript('#/examples/utility_client/SConscript',variant_dir = builddir + 'utility_client',duplicate = 0)
+
+# debug_client
+debug_client = SConscript('#/examples/debug_client/SConscript',variant_dir = builddir + 'debug_client',duplicate = 0)
+
+# debug_server
+debug_server = SConscript('#/examples/debug_server/SConscript',variant_dir = builddir + 'debug_server',duplicate = 0)
+
+# subprotocol_server
+subprotocol_server = SConscript('#/examples/subprotocol_server/SConscript',variant_dir = builddir + 'subprotocol_server',duplicate = 0)
+
+# telemetry_server
+telemetry_server = SConscript('#/examples/telemetry_server/SConscript',variant_dir = builddir + 'telemetry_server',duplicate = 0)
+
+if not env['PLATFORM'].startswith('win'):
+    # iostream_server
+    iostream_server = SConscript('#/examples/iostream_server/SConscript',variant_dir = builddir + 'iostream_server',duplicate = 0)
+
+    # telemetry_client
+    telemetry_client = SConscript('#/examples/telemetry_client/SConscript',variant_dir = builddir + 'telemetry_client',duplicate = 0)
+
+    # print_server
+    print_server = SConscript('#/examples/print_server/SConscript',variant_dir = builddir + 'print_server',duplicate = 0)

changelog.md

@@ -0,0 +1,279 @@
+HEAD
+
+0.6.0
+- MINOR BREAKING TRANSPORT POLICY CHANGE: Custom transport policies will now be
+  required to include a new method `void set_uri(uri_ptr u)`. An implementation
+  is not required. The stub transport policy includes an example stub method
+  that can be added to any existing custom transport policy to fulfill this
+  requirement. This does not affect anyone using the bundled transports or
+  configs.
+- MINOR BREAKING SOCKET POLICY CHANGE: Custom asio transport socket policies 
+  will now be required to include a new method `void set_uri(uri_ptr u)`. Like
+  with the transport layer, an implementation is not required. This does not 
+  affect anyone using the bundled socket policies.
+- MINOR BREAKING DEPENDENCY CHANGE: When using Boost versions greater than or 
+  equal to 1.49 in C++03 mode, `libboost-chrono` is needed now instead of 
+  `libboost-date_time`. Users with C++11 compilers or using Boost versions 1.48
+  and earlier are not affected. Note: This change affects the bundled unit test
+  suite.
+- Feature: WebSocket++ Asio transport policy can now be used with the standalone
+  version of Asio (1.8.0+) when a C++11 compiler and standard library are 
+  present. This means that it is possible now to use WebSocket++'s Asio
+  transport entirely without Boost. Thank you Robert Seiler for proof of concept
+  code that was used as a guide for this implementation. Fixes #324 
+- Feature: Adds a vectored/scatter-gather write handler to the iostream
+  transport.
+- Feature: Adds the ability to defer sending an HTTP response until sometime
+  after the `http_handler` is run. This allows processing of long running http
+  handlers to defer their response until it is ready without blocking the
+  network thread. references #425
+- Improvement: `echo_server_tls` has been update to demonstrate how to configure
+  it for Mozilla's recommended intermediate and modern TLS security profiles.
+- Improvement: `endpoint::set_timer` now uses a steady clock provided by 
+  `boost::chrono` or `std::chrono` where available instead of the non-monotonic
+  system clock. Thank you breyed for reporting. fixes #241
+- Improvement: Outgoing TLS connections to servers using the SNI extension to
+  choose a certificate will now work. Thank you moozzyk for reporting. 
+  Fixes #400
+- Improvement: Removes an unnecessary mutex lock in `get_con_from_hdl`.
+- Cleanup: Asio transport policy has been refactored to remove many Boost
+  dependencies. On C++03 compilers the `boost::noncopyable` dependency has been
+  removed and the `boost::date_time` dependency has been replaced with the newer
+  `boost::chrono` when possible. On C++11 compilers the `boost::aligned_storage`
+  and `boost::date_time` dependencies are gone, replaced with equivalent C++11
+  standard library features.
+- Bug: Fixes a potential dangling pointer and inconsistent error message
+  handling in `websocketpp::exception`. #432 Thank you Tom Swirly for the fix.
+
+0.5.1 - 2015-02-27
+- Bug: Fixes an issue where some frame data was counted against the max header
+  size limit, resulting in connections that included a lot of frame data
+  immediately after the opening handshake to fail.
+- Bug: Fix a typo in the name of the set method for `max_http_body_size`. #406
+  Thank you jplatte for reporting.
+
+0.5.0 - 2015-01-22
+- BREAKING UTILITY CHANGE: Deprecated methods `http::parser::parse_headers`,
+  `http::response::parse_complete`, and `http::request::parse_complete` have
+  been removed.
+- Security: Disabled SSLv3 in example servers.
+- Feature: Adds basic support for accessing HTTP request bodies in the http
+  handler. #181
+- Feature: Adds the ability to register a shutdown handler when using the
+  iostream transport. This provides a clean interface for triggering the shut
+  down of external sockets and other cleanup without hooking in to higher level
+  WebSocket handlers.
+- Feature: Adds the ability to register a write handler when using the iostream
+  transport. This handler can be used to handle transport output in place of
+  registering an ostream to write to.
+- Feature: Adds a new logging policy that outputs to syslog. #386 Thank you Tom
+  Hughes for submitting the initial version of this policy.
+- Improvement: Message payload logging now prints text for text messages rather
+  than binary.
+- Improvement: Overhaul of handshake state machine. Should make it impossible
+  for exceptions to bubble out of transport methods like `io_service::run`.
+- Improvement: Overhaul of handshake error reporting. Fail handler error codes
+  will be more detailed and precise. Adds new [fail] and [http] logging channels
+  that log failed websocket connections and successful HTTP connections
+  respectively. A new aggregate channel package, `alevel::access_core`, allows
+  enabling connect, disconnect, fail, and http together. Successful HTTP
+  connections will no longer trigger a fail handler.
+- Improvement: Ability to terminate connection during an http handler to cleanly
+  suppress the default outgoing HTTP response.
+- Documentation: Add Sending & Receiving Messages step to chapter one of the
+  `utility_client` tutorial. Update `utility_client` example to match.
+- Cleanup: Removes unused files & STL includes. Adds required STL includes.
+  Normalizes include order.
+- Bug: Fixes a fatal state error when a handshake response is completed
+  immediately after that handshake times out. #389
+- Bug: MinGW fixes; C++11 feature detection, localtime use. #393 Thank you
+  Schebb for reporting, code, and testing.
+- Bug: Fixes an issue where `websocketpp::exception::what()` could return an out
+  of scope pointer. #397 Thank you fabioang for reporting.
+- Bug: Fixes an issue where endpoints were not reset properly after a call to
+  `endpoint::listen` failed. #390 Thank you wyyqyl for reporting.
+
+0.4.0 - 2014-11-04
+- BREAKING API CHANGE: All WebSocket++ methods now throw an exception of type
+  `websocketpp::exception` which derives from `std::exception`. This normalizes
+  all exception types under the standard exception hierarchy and allows
+  WebSocket++ exceptions to be caught in the same statement as others. The error
+  code that was previously thrown is wrapped in the exception object and can be
+  accessed via the `websocketpp::exception::code()` method.
+- BREAKING API CHANGE: Custom logging policies have some new required
+  constructors that take generic config settings rather than pointers to
+  std::ostreams. This allows writing logging policies that do not involve the
+  use of std::ostream. This does not affect anyone using the built in logging
+  policies.
+- BREAKING UTILITY CHANGE: `websocketpp::lib::net::htonll` and
+  `websocketpp::lib::net::ntohll` have been prefixed with an underscore to avoid
+  conflicts with similarly named macros in some operating systems. If you are
+  using the WebSocket++ provided 64 bit host/network byte order functions you
+  will need to switch to the prefixed versions.
+- BREAKING UTILITY CHANGE: The signature of `base64_encode` has changed from
+  `websocketpp::base64_encode(unsigned char const *, unsigned int)` to
+  `websocketpp::base64_encode(unsigned char const *, size_t)`.
+- BREAKING UTILITY CHANGE: The signature of `sha1::calc` has changed from
+  `websocketpp::sha1::calc(void const *, int, unsigned char *)` to
+  `websocketpp::sha1::calc(void const *, size_t, unsigned char *)`
+- Feature: Adds incomplete `minimal_server` and `minimal_client` configs that
+  can be used to build custom configs without pulling in the dependencies of
+  `core` or `core_client`. These configs will offer a stable base config to
+  future-proof custom configs.
+- Improvement: Core library no longer has std::iostream as a dependency.
+  std::iostream is still required for the optional iostream logging policy and
+  iostream transport.
+- Bug: C++11 Chrono support was being incorrectly detected by the `boost_config`
+  header. Thank you Max Dmitrichenko for reporting and a patch.
+- Bug: use of `std::put_time` is now guarded by a unique flag rather than a
+  chrono library flag. Thank you Max Dmitrichenko for reporting.
+- Bug: Fixes non-thread safe use of std::localtime. #347 #383
+- Compatibility: Adjust usage of std::min to be more compatible with systems
+  that define a min(...) macro.
+- Compatibility: Removes unused parameters from all library, test, and example
+  code. This assists with those developing with -Werror and -Wunused-parameter
+  #376
+- Compatibility: Renames ntohll and htonll methods to avoid conflicts with
+  platform specific macros. #358 #381, #382 Thank you logotype, unphased,
+  svendjo
+- Cleanup: Removes unused functions, fixes variable shadow warnings, normalizes
+  all whitespace in library, examples, and tests to 4 spaces. #376
+
+0.3.0 - 2014-08-10
+- Feature: Adds `start_perpetual` and `stop_perpetual` methods to asio transport
+  These may be used to replace manually managed `asio::io_service::work` objects
+- Feature: Allow setting pong and handshake timeouts at runtime.
+- Feature: Allows changing the listen backlog queue length.
+- Feature: Split tcp init into pre and post init.
+- Feature: Adds URI method to extract query string from URI. Thank you Banaan
+  for code. #298
+- Feature: Adds a compile time switch to asio transport config to disable
+  certain multithreading features (some locks, asio strands)
+- Feature: Adds the ability to pause reading on a connection. Paused connections
+  will not read more data from their socket, allowing TCP flow control to work
+  without blocking the main thread.
+- Feature: Adds the ability to specify whether or not to use the `SO_REUSEADDR`
+  TCP socket option. The default for this value has been changed from `true` to
+  `false`.
+- Feature: Adds the ability to specify a maximum message size.
+- Feature: Adds `close::status::get_string(...)` method to look up a human
+  readable string given a close code value.
+- Feature: Adds `connection::read_all(...)` method to iostream transport as a
+  convenience method for reading all data into the connection buffer without the
+  end user needing to manually loop on `read_some`.
+- Improvement: Open, close, and pong timeouts can be disabled entirely by
+  setting their duration to 0.
+- Improvement: Numerous performance improvements. Including: tuned default
+  buffer sizes based on profiling, caching of handler binding for async
+  reads/writes, non-malloc allocators for read/write handlers, disabling of a
+  number of questionably useful range sanity checks in tight inner loops.
+- Improvement: Cleaned up the handling of TLS related errors. TLS errors will
+  now be reported with more detail on the info channel rather than all being
+  `tls_short_read` or `pass_through`. In addition, many cases where a TLS short
+  read was in fact expected are no longer classified as errors. Expected TLS
+  short reads and quasi-expected socket shutdown related errors will no longer
+  be reported as unclean WebSocket shutdowns to the application. Information
+  about them will remain in the info error channel for debugging purposes.
+- Improvement: `start_accept` and `listen` errors are now reported to the caller
+  either via an exception or an ec parameter.
+- Improvement: Outgoing writes are now batched for improved message throughput
+  and reduced system call and TCP frame overhead.
+- Bug: Fix some cases of calls to empty lib::function objects.
+- Bug: Fix memory leak of connection objects due to cached handlers holding on to
+  reference counted pointers. #310 Thank you otaras for reporting.
+- Bug: Fix issue with const endpoint accessors (such as `get_user_agent`) not
+  compiling due to non-const mutex use. #292 Thank you logofive for reporting.
+- Bug: Fix handler allocation crash with multithreaded `io_service`.
+- Bug: Fixes incorrect whitespace handling in header parsing. #301 Thank you
+  Wolfram Schroers for reporting
+- Bug: Fix a crash when parsing empty HTTP headers. Thank you Thingol for
+  reporting.
+- Bug: Fix a crash following use of the `stop_listening` function. Thank you
+  Thingol for reporting.
+- Bug: Fix use of variable names that shadow function parameters. The library
+  should compile cleanly with -Wshadow now. Thank you giszo for reporting. #318
+- Bug: Fix an issue where `set_open_handshake_timeout` was ignored by server
+  code. Thank you Robin Rowe for reporting.
+- Bug: Fix an issue where custom timeout values weren't being propagated from
+  endpoints to new connections.
+- Bug: Fix a number of memory leaks related to server connection failures. #323
+  #333 #334 #335 Thank you droppy and aydany for reporting and patches.
+  reporting.
+- Compatibility: Fix compile time conflict with Visual Studio's MIN/MAX macros.
+  Thank you Robin Rowe for reporting.
+- Documentation: Examples and test suite build system now defaults to clang on
+  OS X
+
+0.3.0-alpha4 - 2013-10-11
+- HTTP requests ending normally are no longer logged as errors. Thank you Banaan
+  for reporting. #294
+- Eliminates spurious expired timers in certain error conditions. Thank you
+  Banaan for reporting. #295
+- Consolidates all bundled library licenses into the COPYING file. #294
+- Updates bundled sha1 library to one with a cleaner interface and more
+  straight-forward license. Thank you lotodore for reporting and Evgeni Golov
+  for reviewing. #294
+- Re-introduces strands to asio transport, allowing `io_service` thread pools to
+  be used (with some limitations).
+- Removes endpoint code that kept track of a connection list that was never used
+  anywhere. Removes a lock and reduces connection creation/deletion complexity
+  from O(log n) to O(1) in the number of connections.
+- A number of internal changes to transport APIs
+- Deprecates iostream transport `readsome` in favor of `read_some` which is more
+  consistent with the naming of the rest of the library.
+- Adds preliminary signaling to iostream transport of eof and fatal transport
+  errors
+- Updates transport code to use shared pointers rather than raw pointers to
+  prevent asio from retaining pointers to connection methods after the
+  connection goes out of scope. #293 Thank you otaras for reporting.
+- Fixes an issue where custom headers couldn't be set for client connections
+  Thank you Jerry Win and Wolfram Schroers for reporting.
+- Fixes a compile error on visual studio when using interrupts. Thank you Javier
+  Rey Neira for reporting this.
+- Adds new 1012 and 1013 close codes per IANA registry
+- Add `set_remote_endpoint` method to iostream transport.
+- Add `set_secure` method to iostream transport.
+- Fix typo in .gitattributes file. Thank you jstarasov for reporting this. #280
+- Add missing locale include. Thank you Toninoso for reporting this. #281
+- Refactors `asio_transport` endpoint and adds full documentation and exception
+  free varients of all methods.
+- Removes `asio_transport` endpoint method cancel(). Use `stop_listen()` instead
+- Wrap internal `io_service` `run_one()` method
+- Suppress error when trying to shut down a connection that was already closed
+
+0.3.0-alpha3 - 2013-07-16
+- Minor refactor to bundled sha1 library
+- HTTP header comparisons are now case insensitive. #220, #275
+- Refactors URI to be exception free and not use regular expressions. This
+  eliminates the dependency on boost or C++11 regex libraries allowing native
+  C++11 usage on GCC 4.4 and higher and significantly reduces staticly built
+  binary sizes.
+- Updates handling of Server and User-Agent headers to better handle custom
+  settings and allow suppression of these headers for security purposes.
+- Fix issue where pong timeout handler always fired. Thank you Steven Klassen
+  for reporting this bug.
+- Add ping and pong endpoint wrapper methods
+- Add `get_request()` pass through method to connection to allow calling methods
+  specific to the HTTP policy in use.
+- Fix issue compile error with `WEBSOCKETPP_STRICT_MASKING` enabled and another
+  issue where `WEBSOCKETPP_STRICT_MASKING` was not applied to incoming messages.
+  Thank you Petter Norby for reporting and testing these bugs. #264
+- Add additional macro guards for use with boost_config. Thank you breyed
+  for testing and code. #261
+
+0.3.0-alpha2 - 2013-06-09
+- Fix a regression that caused servers being sent two close frames in a row
+  to end a connection uncleanly. #259
+- Fix a regression that caused spurious frames following a legitimate close
+  frames to erroneously trigger handlers. #258
+- Change default HTTP response error code when no http_handler is defined from
+  500/Internal Server Error to 426/Upgrade Required
+- Remove timezone from logger timestamp to work around issues with the Windows
+  implementation of strftime. Thank you breyed for testing and code. #257
+- Switch integer literals to char literals to improve VCPP compatibility.
+  Thank you breyed for testing and code. #257
+- Add MSVCPP warning suppression for the bundled SHA1 library. Thank you breyed
+  for testing and code. #257
+
+0.3.0-alpha1 - 2013-06-09
+- Initial Release

cmake/CMakeHelpers.cmake

@@ -0,0 +1,78 @@
+
+# Print build configuration
+macro (print_used_build_config)
+    message ("\n=========== Used Build Configuration =============\n")
+    message (STATUS "ENABLE_CPP11        = " ${ENABLE_CPP11})
+    message (STATUS "BUILD_EXAMPLES      = " ${BUILD_EXAMPLES})
+    message (STATUS "BUILD_TESTS         = " ${BUILD_TESTS})
+    message ("")
+    message (STATUS "WEBSOCKETPP_ROOT    = " ${WEBSOCKETPP_ROOT})
+    message (STATUS "WEBSOCKETPP_BIN     = " ${WEBSOCKETPP_BIN})
+    message (STATUS "WEBSOCKETPP_LIB     = " ${WEBSOCKETPP_LIB})
+    message (STATUS "Install prefix      = " ${CMAKE_INSTALL_PREFIX})
+    message ("")
+    message (STATUS "WEBSOCKETPP_BOOST_LIBS        = ${WEBSOCKETPP_BOOST_LIBS}")
+    message (STATUS "WEBSOCKETPP_PLATFORM_LIBS     = ${WEBSOCKETPP_PLATFORM_LIBS}")
+    message (STATUS "WEBSOCKETPP_PLATFORM_TSL_LIBS = ${WEBSOCKETPP_PLATFORM_TSL_LIBS}")
+    message ("") 
+endmacro ()
+
+# Adds the given folder_name into the source files of the current project. 
+# Use this macro when your module contains .cpp and .h files in several subdirectories.
+# Your sources variable needs to be WSPP_SOURCE_FILES and headers variable WSPP_HEADER_FILES.
+macro(add_source_folder folder_name)
+    file(GLOB H_FILES_IN_FOLDER_${folder_name} ${folder_name}/*.hpp ${folder_name}/*.h)
+    file(GLOB CPP_FILES_IN_FOLDER_${folder_name} ${folder_name}/*.cpp ${folder_name}/*.c)
+    source_group("Header Files\\${folder_name}" FILES ${H_FILES_IN_FOLDER_${folder_name}})
+    source_group("Source Files\\${folder_name}" FILES ${CPP_FILES_IN_FOLDER_${folder_name}})
+    set(WSPP_HEADER_FILES ${WSPP_HEADER_FILES} ${H_FILES_IN_FOLDER_${folder_name}})
+    set(WSPP_SOURCE_FILES ${WSPP_SOURCE_FILES} ${CPP_FILES_IN_FOLDER_${folder_name}})
+endmacro()
+
+# Initialize target.
+macro (init_target NAME)
+    set (TARGET_NAME ${NAME})
+    message ("** " ${TARGET_NAME})
+
+    # Include our own module path. This makes #include "x.h" 
+    # work in project subfolders to include the main directory headers.
+    include_directories (${CMAKE_CURRENT_SOURCE_DIR})
+endmacro ()
+
+# Build executable for executables
+macro (build_executable TARGET_NAME)
+    set (TARGET_LIB_TYPE "EXECUTABLE")
+    message (STATUS "-- Build Type:")
+    message (STATUS "       " ${TARGET_LIB_TYPE})
+
+    add_executable (${TARGET_NAME} ${ARGN})
+
+    include_directories (${WEBSOCKETPP_ROOT} ${WEBSOCKETPP_INCLUDE})
+
+    set_target_properties (${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${WEBSOCKETPP_BIN})
+    set_target_properties (${TARGET_NAME} PROPERTIES DEBUG_POSTFIX d)
+endmacro ()
+
+# Finalize target for all types
+macro (final_target)
+    if ("${TARGET_LIB_TYPE}" STREQUAL "EXECUTABLE")
+        install (TARGETS ${TARGET_NAME} 
+                 RUNTIME DESTINATION "bin" 
+                 CONFIGURATIONS ${CMAKE_CONFIGURATION_TYPES})
+    endif ()
+
+    # install headers, directly from current source dir and look for subfolders with headers
+    file (GLOB_RECURSE TARGET_INSTALL_HEADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.hpp)
+    foreach (hppfile ${TARGET_INSTALL_HEADERS})
+      get_filename_component (currdir ${hppfile} PATH)
+      install (FILES ${hppfile} DESTINATION "include/${TARGET_NAME}/${currdir}")
+    endforeach()
+endmacro ()
+
+macro (link_boost)
+    target_link_libraries (${TARGET_NAME} ${Boost_LIBRARIES})
+endmacro ()
+
+macro (link_openssl)
+    target_link_libraries (${TARGET_NAME} ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY})
+endmacro ()

docs/simple_broadcast_server.cpp

@@ -0,0 +1,52 @@
+#include <set>
+
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+using websocketpp::connection_hdl;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+class broadcast_server {
+public:
+    broadcast_server() {
+        m_server.init_asio();
+                
+        m_server.set_open_handler(bind(&broadcast_server::on_open,this,::_1));
+        m_server.set_close_handler(bind(&broadcast_server::on_close,this,::_1));
+        m_server.set_message_handler(bind(&broadcast_server::on_message,this,::_1,::_2));
+    }
+    
+    void on_open(connection_hdl hdl) {
+        m_connections.insert(hdl);
+    }
+    
+    void on_close(connection_hdl hdl) {
+        m_connections.erase(hdl);
+    }
+    
+    void on_message(connection_hdl hdl, server::message_ptr msg) {
+        for (auto it : m_connections) {
+            m_server.send(it,msg);
+        }
+    }
+
+    void run(uint16_t port) {
+        m_server.listen(port);
+        m_server.start_accept();
+        m_server.run();
+    }
+private:
+    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
+
+    server m_server;
+    con_list m_connections;
+};
+
+int main() {
+    broadcast_server server;
+    server.run(9002);
+}

docs/simple_count_server_thread.cpp

@@ -0,0 +1,65 @@
+#include <functional>
+#include <mutex>
+#include <set>
+#include <thread>
+
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+using websocketpp::connection_hdl;
+
+class count_server {
+public:
+    count_server() : m_count(0) {
+        m_server.init_asio();
+                
+        m_server.set_open_handler(bind(&count_server::on_open,this,_1));
+        m_server.set_close_handler(bind(&count_server::on_close,this,_1));
+    }
+    
+    void on_open(connection_hdl hdl) {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_connections.insert(hdl);
+    }
+    
+    void on_close(connection_hdl hdl) {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_connections.erase(hdl);
+    }
+    
+    void count() {
+        while (1) {
+            sleep(1);
+            m_count++;
+            
+            std::stringstream ss;
+            ss << m_count;
+            
+            std::lock_guard<std::mutex> lock(m_mutex);    
+            for (auto it : m_connections) {
+                m_server.send(it,ss.str(),websocketpp::frame::opcode::text);
+            }
+        }
+    }
+    
+    void run(uint16_t port) {
+        m_server.listen(port);
+        m_server.start_accept();
+        m_server.run();
+    }
+private:
+    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
+    
+    int m_count;
+    server m_server;
+    con_list m_connections;
+    std::mutex m_mutex;
+};
+
+int main() {
+    count_server server;
+    std::thread t(std::bind(&count_server::count,&server));
+    server.run(9002);
+}

examples/CMakeLists.txt

@@ -0,0 +1,6 @@
+file (GLOB SDIRS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *)
+foreach (SUBDIR ${SDIRS})
+    if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIR}/CMakeLists.txt")
+        add_subdirectory (${SUBDIR})
+    endif ()
+endforeach ()

examples/associative_storage/associative_storage.cpp

@@ -0,0 +1,88 @@
+#include <iostream>
+#include <map>
+#include <exception>
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+using websocketpp::connection_hdl;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+struct connection_data {
+    int sessionid;
+    std::string name;
+};
+
+class print_server {
+public:
+    print_server() : m_next_sessionid(1) {
+        m_server.init_asio();
+
+        m_server.set_open_handler(bind(&print_server::on_open,this,::_1));
+        m_server.set_close_handler(bind(&print_server::on_close,this,::_1));
+        m_server.set_message_handler(bind(&print_server::on_message,this,::_1,::_2));
+    }
+
+    void on_open(connection_hdl hdl) {
+        connection_data data;
+
+        data.sessionid = m_next_sessionid++;
+        data.name = "";
+
+        m_connections[hdl] = data;
+    }
+
+    void on_close(connection_hdl hdl) {
+        connection_data& data = get_data_from_hdl(hdl);
+
+        std::cout << "Closing connection " << data.name
+                  << " with sessionid " << data.sessionid << std::endl;
+
+        m_connections.erase(hdl);
+    }
+
+    void on_message(connection_hdl hdl, server::message_ptr msg) {
+        connection_data& data = get_data_from_hdl(hdl);
+
+        if (data.name == "") {
+            data.name = msg->get_payload();
+            std::cout << "Setting name of connection with sessionid "
+                      << data.sessionid << " to " << data.name << std::endl;
+        } else {
+            std::cout << "Got a message from connection " << data.name
+                      << " with sessionid " << data.sessionid << std::endl;
+        }
+    }
+
+    connection_data& get_data_from_hdl(connection_hdl hdl) {
+        auto it = m_connections.find(hdl);
+
+        if (it == m_connections.end()) {
+            // this connection is not in the list. This really shouldn't happen
+            // and probably means something else is wrong.
+            throw std::invalid_argument("No data available for session");
+        }
+
+        return it->second;
+    }
+
+    void run(uint16_t port) {
+        m_server.listen(port);
+        m_server.start_accept();
+        m_server.run();
+    }
+private:
+    typedef std::map<connection_hdl,connection_data,std::owner_less<connection_hdl>> con_list;
+
+    int m_next_sessionid;
+    server m_server;
+    con_list m_connections;
+};
+
+int main() {
+    print_server server;
+    server.run(9002);
+}

examples/broadcast_server/SConscript

@@ -0,0 +1,23 @@
+## Broadcast Server example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('broadcast_server', ["broadcast_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system','thread'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('broadcast_server', ["broadcast_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/broadcast_server/broadcast_server.cpp

@@ -0,0 +1,156 @@
+#include <websocketpp/config/asio_no_tls.hpp>
+
+#include <websocketpp/server.hpp>
+
+#include <iostream>
+#include <set>
+
+/*#include <boost/thread.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>*/
+#include <websocketpp/common/thread.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+using websocketpp::connection_hdl;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+using websocketpp::lib::thread;
+using websocketpp::lib::mutex;
+using websocketpp::lib::unique_lock;
+using websocketpp::lib::condition_variable;
+
+/* on_open insert connection_hdl into channel
+ * on_close remove connection_hdl from channel
+ * on_message queue send to all channels
+ */
+
+enum action_type {
+    SUBSCRIBE,
+    UNSUBSCRIBE,
+    MESSAGE
+};
+
+struct action {
+    action(action_type t, connection_hdl h) : type(t), hdl(h) {}
+    action(action_type t, connection_hdl h, server::message_ptr m)
+      : type(t), hdl(h), msg(m) {}
+
+    action_type type;
+    websocketpp::connection_hdl hdl;
+    server::message_ptr msg;
+};
+
+class broadcast_server {
+public:
+    broadcast_server() {
+        // Initialize Asio Transport
+        m_server.init_asio();
+
+        // Register handler callbacks
+        m_server.set_open_handler(bind(&broadcast_server::on_open,this,::_1));
+        m_server.set_close_handler(bind(&broadcast_server::on_close,this,::_1));
+        m_server.set_message_handler(bind(&broadcast_server::on_message,this,::_1,::_2));
+    }
+
+    void run(uint16_t port) {
+        // listen on specified port
+        m_server.listen(port);
+
+        // Start the server accept loop
+        m_server.start_accept();
+
+        // Start the ASIO io_service run loop
+        try {
+            m_server.run();
+        } catch (const std::exception & e) {
+            std::cout << e.what() << std::endl;
+        }
+    }
+
+    void on_open(connection_hdl hdl) {
+        unique_lock<mutex> lock(m_action_lock);
+        //std::cout << "on_open" << std::endl;
+        m_actions.push(action(SUBSCRIBE,hdl));
+        lock.unlock();
+        m_action_cond.notify_one();
+    }
+
+    void on_close(connection_hdl hdl) {
+        unique_lock<mutex> lock(m_action_lock);
+        //std::cout << "on_close" << std::endl;
+        m_actions.push(action(UNSUBSCRIBE,hdl));
+        lock.unlock();
+        m_action_cond.notify_one();
+    }
+
+    void on_message(connection_hdl hdl, server::message_ptr msg) {
+        // queue message up for sending by processing thread
+        unique_lock<mutex> lock(m_action_lock);
+        //std::cout << "on_message" << std::endl;
+        m_actions.push(action(MESSAGE,hdl,msg));
+        lock.unlock();
+        m_action_cond.notify_one();
+    }
+
+    void process_messages() {
+        while(1) {
+            unique_lock<mutex> lock(m_action_lock);
+
+            while(m_actions.empty()) {
+                m_action_cond.wait(lock);
+            }
+
+            action a = m_actions.front();
+            m_actions.pop();
+
+            lock.unlock();
+
+            if (a.type == SUBSCRIBE) {
+                unique_lock<mutex> con_lock(m_connection_lock);
+                m_connections.insert(a.hdl);
+            } else if (a.type == UNSUBSCRIBE) {
+                unique_lock<mutex> con_lock(m_connection_lock);
+                m_connections.erase(a.hdl);
+            } else if (a.type == MESSAGE) {
+                unique_lock<mutex> con_lock(m_connection_lock);
+
+                con_list::iterator it;
+                for (it = m_connections.begin(); it != m_connections.end(); ++it) {
+                    m_server.send(*it,a.msg);
+                }
+            } else {
+                // undefined.
+            }
+        }
+    }
+private:
+    typedef std::set<connection_hdl,std::owner_less<connection_hdl> > con_list;
+
+    server m_server;
+    con_list m_connections;
+    std::queue<action> m_actions;
+
+    mutex m_action_lock;
+    mutex m_connection_lock;
+    condition_variable m_action_cond;
+};
+
+int main() {
+    try {
+    broadcast_server server_instance;
+
+    // Start a thread to run the processing loop
+    thread t(bind(&broadcast_server::process_messages,&server_instance));
+
+    // Run the asio loop with the main thread
+    server_instance.run(9002);
+
+    t.join();
+
+    } catch (websocketpp::exception const & e) {
+        std::cout << e.what() << std::endl;
+    }
+}

examples/chat_client/Makefile

@@ -1,23 +0,0 @@
-CFLAGS = -O2
-LDFLAGS = 
-
-CXX		?= c++
-SHARED  ?= "1"
-
-ifeq ($(SHARED), 1)
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_thread -lwebsocketpp
-else
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_thread -lboost_date_time -lboost_regex -lboost_random ../../libwebsocketpp.a
-endif
-
-chat_client: chat_client.o chat_client_handler.o
-	$(CXX) $(CFLAGS) $^ -o $@ $(LDFLAGS)
-
-%.o: %.cpp
-	$(CXX) -c $(CFLAGS) -o $@ $^
-
-# cleanup by removing generated files
-#
-.PHONY:		clean
-clean:
-		rm -f *.o chat_client

examples/chat_client/chat_client.cpp

@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "chat_client_handler.hpp"
-
-#include "../../src/websocketpp.hpp"
-#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/thread.hpp>
-
-#include <iostream>
-
-using boost::asio::ip::tcp;
-using namespace websocketchat;
-
-int main(int argc, char* argv[]) {
-	std::string uri;
-	
-	if (argc != 2) {
-		std::cout << "Usage: `chat_client ws_uri`" << std::endl;
-	} else {
-		uri = argv[1];
-	}
-	
-	chat_client_handler_ptr c(new chat_client_handler());
-	
-	try {
-		boost::asio::io_service io_service;
-		
-		websocketpp::client_ptr client(new websocketpp::client(io_service,c));
-		
-		client->init();
-
-		client->set_header("User Agent","WebSocket++/2011-09-25");
-		client->add_subprotocol("com.zaphoyd.websocketpp.chat");
-		
-		client->set_origin("http://zaphoyd.com");
-
-		client->connect(uri);
-		
-		boost::thread t(boost::bind(&boost::asio::io_service::run, &io_service));
-		
-		char line[512];
-		while (std::cin.getline(line, 512)) {
-			c->send(line);
-		}
-		
-		t.join();
-	} catch (std::exception& e) {
-		std::cerr << "Exception: " << e.what() << std::endl;
-	}
-	
-	return 0;
-}

examples/chat_client/chat_client.html

@@ -1,177 +0,0 @@
-<!doctype html>
-<html>
-<head>
-<script type="text/javascript" src="jquery-1.6.3.min.js"></script>
-</head>
-<body>
-
-<script type="text/javascript">
-var ws;
-var url;
-
-$(document).ready(init);
-
-function init() {
-	$(document).keypress(function(event) {
-		if ( event.which == 13 ) {
-			event.preventDefault();
-			send();
-		}
-	});
-}
-
-function connect() {
-	url = $("#server_url").val();
-	console.log(url);
-	
-	if ("WebSocket" in window) {
-		ws = new WebSocket(url);
-	} else if ("MozWebSocket" in window) {
-		ws = new MozWebSocket(url);
-	} else {
-		chat_message("This Browser does not support WebSockets");
-		return;
-	}
-	ws.onopen = function(e) {
-		chat_message("A connection to "+url+" has been opened.");
-		
-		$("#server_url").attr("disabled",true);
-		$("#toggle_connect").html("Disconnect");
-	};
-	
-	ws.onerror = function(e) {
-		chat_message("An error occured, see console log for more details.");
-		console.log(e);
-	};
-	
-	ws.onclose = function(e) {
-		chat_message("The connection to "+url+" was closed.");
-	};
-	
-	ws.onmessage = function(e) {
-		var message = JSON.parse(e.data);
-		
-		if (message.type == "msg") {
-			chat_message(message.value,message.sender);
-		} else if (message.type == "participants") {
-			var o = "<ul>";
-			for (var p in message.value) {
-				o += "<li>"+message.value[p]+"</li>";
-			}
-			o += "</ul>";
-			$("#participants").html(o);
-		}
-	};
-}
-
-function chat_message(message,sender) {
-	if (arguments.length == 1) {
-		sender = "";
-	}
-	
-	var style;
-	
-	if (sender == "") {
-		style = "client";
-	} else if (sender == "server") {
-		style = "server";
-		sender = "["+sender+"]";
-	} else {
-		style = "message";
-		sender = "["+sender+"]";
-	}
-	
-	$("#messages").append("<span class='"+style+"'><span class='sender'>"+sender+"</span> <span class='msg'>"+message+"</span></span><br />");
-	$("#messages").prop({ scrollTop: $("#messages").prop("scrollHeight")  });
-}
-
-function disconnect() {
-	ws.close();
-	$("#server_url").removeAttr("disabled");
-	$("#toggle_connect").html("Connect");
-	$("#participants").html("");
-}
-
-function toggle_connect() {
-	if ($("#server_url").attr("disabled") != "disabled") {
-		connect();
-	} else {
-		disconnect();
-	}
-}
-
-function send() {
-	if (ws === undefined || ws.readyState != 1) {
-		chat_message("Websocket is not avaliable for writing");
-		return;
-	}
-	
-	ws.send($("#msg").val());
-	$("#msg").val("");
-}
-
-
-
-
-</script>
-
-<style>
-body,html {
-	margin: 0px;
-	padding: 0px;
-	height: 100%;
-	background-color: #999;
-	font-family: sans-serif;
-	font-size: 14px;
-}
-
-h3 {
-
-}
-
-#controls {
-	padding: 4px;
-	float:right;
-	width: 300px;
-	
-}
-
-input {
-	width: 200px;
-}
-
-#messages {
-	height: 100%;
-	overflow: auto;
-	background-color: black;
-}
-
-#messages .client {
-	color: #ccc;
-}
-
-#messages .server {
-	color: yellow;
-}
-
-#messages .message {
-	color: white;
-}
-
-</style>
-
-<div id="controls">
-	<div id="server">
-	<input type="text" name="server_url" id="server_url" value="ws://thor-websocket.zaphoyd.net:9000/chat" />
-	<button id="toggle_connect" onclick="toggle_connect();">Connect</button>
-	</div>
-
-	<div id="message_input"><input type="text" name="msg" id="msg" value="Hello World!" />
-	<button onclick="send();">Send</button></div>
-	<h3>Chat Participants</h3>
-	<div id="participants"></div>
-</div>
-<div id="messages"></div>
-
-</body>
-</html>

examples/chat_client/chat_client_handler.cpp

@@ -1,171 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "chat_client_handler.hpp"
-
-#include <boost/algorithm/string/replace.hpp>
-
-using websocketchat::chat_client_handler;
-using websocketpp::client_session_ptr;
-
-void chat_client_handler::on_open(session_ptr s) {
-	// not sure if anything needs to happen here.
-	m_session = s;
-
-	std::cout << "Successfully connected" << std::endl;
-}
-
-void chat_client_handler::on_close(session_ptr s) {
-	// not sure if anything needs to happen here either.
-	
-	m_session = client_session_ptr();
-
-	std::cout << "client was disconnected" << std::endl;
-}
-
-void chat_client_handler::on_message(session_ptr s,const std::string &msg) {
-	//std::cout << "message from server: " << msg << std::endl;
-
-	decode_server_msg(msg);
-}
-
-// CLIENT API
-// client api methods will be called from outside the io_service.run thread
-//  they need to be careful to not touch unsyncronized member variables.
-
-void chat_client_handler::send(const std::string &msg) {
-	if (!m_session) {
-		std::cerr << "Error: no connected session" << std::endl;
-		return;
-	}
-	m_session->io_service().post(boost::bind(&chat_client_handler::do_send, this, msg));
-}
-
-void chat_client_handler::close() {
-	if (!m_session) {
-		std::cerr << "Error: no connected session" << std::endl;
-		return;
-	}
-	m_session->io_service().post(boost::bind(&chat_client_handler::do_close,this));
-}
-
-// END CLIENT API
-
-void chat_client_handler::do_send(const std::string &msg) {
-	if (!m_session) {
-		std::cerr << "Error: no connected session" << std::endl;
-		return;
-	}
-	
-	// check for local commands
-	if (msg == "/list") {
-		std::cout << "list all participants" << std::endl;
-	} else if (msg == "/close") {
-		do_close();
-	} else {
-		m_session->send(msg);
-	}
-}
-
-void chat_client_handler::do_close() {
-	if (!m_session) {
-		std::cerr << "Error: no connected session" << std::endl;
-		return;
-	}
-	m_session->close(websocketpp::session::CLOSE_STATUS_GOING_AWAY,"");
-}
-
-// {"type":"participants","value":[<participant>,...]}
-// {"type":"msg","sender":"<sender>","value":"<msg>" }
-void chat_client_handler::decode_server_msg(const std::string &msg) {
-	// for messages of type participants, erase and rebuild m_participants
-	// for messages of type msg, print out message
-	
-	// NOTE: The chat server was written with the intention of the client having a built in
-	// JSON parser. To keep external dependencies low for this demonstration chat client I am
-	// parsing the server messages by hand.
-	
-	std::string::size_type start = 9;
-	std::string::size_type end;
-	
-	if (msg.substr(0,start) != "{\"type\":\"") {
-		// ignore
-		std::cout << "invalid message" << std::endl;
-		return;
-	}
-	
-	
-
-	if (msg.substr(start,15) == "msg\",\"sender\":\"") {
-		// parse message
-		std::string sender;
-		std::string message;
-		
-		start += 15;
-
-		end = msg.find("\"",start);
-		while (end != std::string::npos) {
-			if (msg[end-1] == '\\') {
-				sender += msg.substr(start,end-start-1) + "\"";
-				start = end+1;
-				end = msg.find("\"",start);
-			} else {
-				sender += msg.substr(start,end-start);
-				start = end;
-				break;
-			}
-		}
-		
-		if (msg.substr(start,11) != "\",\"value\":\"") {
-			std::cout << "invalid message" << std::endl;
-			return;
-		}
-
-		start += 11;
-
-		end = msg.find("\"",start);
-		while (end != std::string::npos) {
-			if (msg[end-1] == '\\') {
-				message += msg.substr(start,end-start-1) + "\"";
-				start = end+1;
-				end = msg.find("\"",start);
-			} else {
-				message += msg.substr(start,end-start);
-				start = end;
-				break;
-			}
-		}
-
-		std::cout << "[" << sender << "] " << message << std::endl;
-	} else if (msg.substr(start,23) == "participants\",\"value\":[") {
-		// parse participants
-		std::cout << "participants message" << std::endl;
-	} else {
-		// unknown message type
-		std::cout << "unknown message" << std::endl;
-	}
-}

examples/chat_client/chat_client_handler.hpp

@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#ifndef CHAT_CLIENT_HANDLER_HPP
-#define CHAT_CLIENT_HANDLER_HPP
-
-// com.zaphoyd.websocketpp.chat protocol
-// 
-// client messages:
-// alias [UTF8 text, 16 characters max]
-// msg [UTF8 text]
-// 
-// server messages:
-// {"type":"msg","sender":"<sender>","value":"<msg>" }
-// {"type":"participants","value":[<participant>,...]}
-
-#include <boost/shared_ptr.hpp>
-
-#include "../../src/websocketpp.hpp"
-#include "../../src/websocket_connection_handler.hpp"
-
-#include <map>
-#include <string>
-#include <queue>
-
-using websocketpp::session_ptr;
-
-namespace websocketchat {
-
-class chat_client_handler : public websocketpp::connection_handler {
-public:
-	chat_client_handler() {}
-	virtual ~chat_client_handler() {}
-	
-	// ignored for clients?
-	void validate(session_ptr s) {} 
-	
-	// connection to chat room complete
-	void on_open(session_ptr s);
-
-	// connection to chat room closed
-	void on_close(session_ptr s);
-	
-	// got a new message from server
-	void on_message(session_ptr s,const std::string &msg);
-	
-	// ignore messages
-	void on_message(session_ptr s,const std::vector<unsigned char> &data) {}
-	
-	// CLIENT API
-	void send(const std::string &msg);
-	void close();
-
-private:
-	// Client API internal
-	void do_send(const std::string &msg);
-	void do_close();
-
-	void decode_server_msg(const std::string &msg);
-	
-	// list of other chat participants
-	std::set<std::string> m_participants;
-	std::queue<std::string> m_msg_queue;
-	session_ptr m_session;
-};
-
-typedef boost::shared_ptr<chat_client_handler> chat_client_handler_ptr;
-
-}
-#endif // CHAT_CLIENT_HANDLER_HPP

examples/chat_server/Makefile

@@ -1,23 +0,0 @@
-CFLAGS = -O2
-LDFLAGS = 
-
-CXX		?= c++
-SHARED  ?= "1"
-
-ifeq ($(SHARED), 1)
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_date_time -lwebsocketpp
-else
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_date_time -lboost_regex -lboost_random  -lboost_program_options ../../libwebsocketpp.a
-endif
-
-chat_server: chat_server.o chat.o
-	$(CXX) $(CFLAGS) $^ -o $@ $(LDFLAGS)
-
-%.o: %.cpp
-	$(CXX) -c $(CFLAGS) -o $@ $^
-
-# cleanup by removing generated files
-#
-.PHONY:		clean
-clean:
-		rm -f *.o chat_server

examples/chat_server/chat.cpp

@@ -1,192 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "chat.hpp"
-
-#include <boost/algorithm/string/replace.hpp>
-
-using websocketchat::chat_server_handler;
-using websocketpp::session_ptr;
-
-void chat_server_handler::validate(session_ptr client) {
-	std::stringstream err;
-	
-	// We only know about the chat resource
-	if (client->get_resource() != "/chat") {
-		err << "Request for unknown resource " << client->get_resource();
-		throw(websocketpp::handshake_error(err.str(),404));
-	}
-	
-	// Require specific origin example
-	if (client->get_origin() != "http://zaphoyd.com") {
-		err << "Request from unrecognized origin: " << client->get_origin();
-		throw(websocketpp::handshake_error(err.str(),403));
-	}
-}
-
-
-void chat_server_handler::on_open(session_ptr client) {
-	std::cout << "client " << client << " joined the lobby." << std::endl;
-	m_connections.insert(std::pair<session_ptr,std::string>(client,get_con_id(client)));
-
-	// send user list and signon message to all clients
-	send_to_all(serialize_state());
-	client->send(encode_message("server","Welcome, use the /alias command to set a name, /help for a list of other commands."));
-	send_to_all(encode_message("server",m_connections[client]+" has joined the chat."));
-}
-
-void chat_server_handler::on_close(session_ptr client) {
-	std::map<session_ptr,std::string>::iterator it = m_connections.find(client);
-	
-	if (it == m_connections.end()) {
-		// this client has already disconnected, we can ignore this.
-		// this happens during certain types of disconnect where there is a
-		// deliberate "soft" disconnection preceeding the "hard" socket read
-		// fail or disconnect ack message.
-		return;
-	}
-	
-	std::cout << "client " << client << " left the lobby." << std::endl;
-	
-	const std::string alias = it->second;
-	m_connections.erase(it);
-
-	// send user list and signoff message to all clients
-	send_to_all(serialize_state());
-	send_to_all(encode_message("server",alias+" has left the chat."));
-}
-
-void chat_server_handler::on_message(session_ptr client,const std::string &msg) {
-	std::cout << "message from client " << client << ": " << msg << std::endl;
-	
-	
-	
-	// check for special command messages
-	if (msg == "/help") {
-		// print command list
-		client->send(encode_message("server","avaliable commands:<br />&nbsp;&nbsp;&nbsp;&nbsp;/help - show this help<br />&nbsp;&nbsp;&nbsp;&nbsp;/alias foo - set alias to foo",false));
-		return;
-	}
-	
-	if (msg.substr(0,7) == "/alias ") {
-		std::string response;
-		std::string alias;
-		
-		if (msg.size() == 7) {
-			response = "You must enter an alias.";
-			client->send(encode_message("server",response));
-			return;
-		} else {
-			alias = msg.substr(7);
-		}
-		
-		response = m_connections[client] + " is now known as "+alias;
-
-		// store alias pre-escaped so we don't have to do this replacing every time this
-		// user sends a message
-		
-		// escape JSON characters
-		boost::algorithm::replace_all(alias,"\\","\\\\");
-		boost::algorithm::replace_all(alias,"\"","\\\"");
-		
-		// escape HTML characters
-		boost::algorithm::replace_all(alias,"&","&amp;");
-		boost::algorithm::replace_all(alias,"<","&lt;");
-		boost::algorithm::replace_all(alias,">","&gt;");
-		
-		m_connections[client] = alias;
-		
-		// set alias
-		send_to_all(serialize_state());
-		send_to_all(encode_message("server",response));
-		return;
-	}
-	
-	// catch other slash commands
-	if (msg[0] == '/') {
-		client->send(encode_message("server","unrecognized command"));
-		return;
-	}
-	
-	// create JSON message to send based on msg
-	send_to_all(encode_message(m_connections[client],msg));
-}
-
-// {"type":"participants","value":[<participant>,...]}
-std::string chat_server_handler::serialize_state() {
-	std::stringstream s;
-	
-	s << "{\"type\":\"participants\",\"value\":[";
-	
-	std::map<session_ptr,std::string>::iterator it;
-	
-	for (it = m_connections.begin(); it != m_connections.end(); it++) {
-		s << "\"" << (*it).second << "\"";
-		if (++it != m_connections.end()) {
-			s << ",";
-		}
-		it--;
-	}
-	
-	s << "]}";
-	
-	return s.str();
-}
-
-// {"type":"msg","sender":"<sender>","value":"<msg>" }
-std::string chat_server_handler::encode_message(std::string sender,std::string msg,bool escape) {
-	std::stringstream s;
-	
-	// escape JSON characters
-	boost::algorithm::replace_all(msg,"\\","\\\\");
-	boost::algorithm::replace_all(msg,"\"","\\\"");
-	
-	// escape HTML characters
-	if (escape) {
-		boost::algorithm::replace_all(msg,"&","&amp;");
-		boost::algorithm::replace_all(msg,"<","&lt;");
-		boost::algorithm::replace_all(msg,">","&gt;");
-	}
-	
-	s << "{\"type\":\"msg\",\"sender\":\"" << sender 
-	  << "\",\"value\":\"" << msg << "\"}";
-	
-	return s.str();
-}
-
-std::string chat_server_handler::get_con_id(session_ptr s) {
-	std::stringstream endpoint;
-	endpoint << s->socket().remote_endpoint();
-	return endpoint.str();
-}
-
-void chat_server_handler::send_to_all(std::string data) {
-	std::map<session_ptr,std::string>::iterator it;
-	for (it = m_connections.begin(); it != m_connections.end(); it++) {
-		(*it).first->send(data);
-	}
-}

examples/chat_server/chat.hpp

@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#ifndef CHAT_HPP
-#define CHAT_HPP
-
-// com.zaphoyd.websocketpp.chat protocol
-// 
-// client messages:
-// alias [UTF8 text, 16 characters max]
-// msg [UTF8 text]
-// 
-// server messages:
-// {"type":"msg","sender":"<sender>","value":"<msg>" }
-// {"type":"participants","value":[<participant>,...]}
-
-#include <boost/shared_ptr.hpp>
-#include "../../src/websocketpp.hpp"
-#include "../../src/websocket_connection_handler.hpp"
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace websocketchat {
-
-class chat_server_handler : public websocketpp::connection_handler {
-public:
-	chat_server_handler() {}
-	virtual ~chat_server_handler() {}
-	
-	void validate(websocketpp::session_ptr client); 
-	
-	// add new connection to the lobby
-	void on_open(websocketpp::session_ptr client);
-		
-	// someone disconnected from the lobby, remove them
-	void on_close(websocketpp::session_ptr client);
-	
-	void on_message(websocketpp::session_ptr client,const std::string &msg);
-	
-	// lobby will ignore binary messages
-	void on_message(websocketpp::session_ptr client,
-		const std::vector<unsigned char> &data) {}
-private:
-	std::string serialize_state();
-	std::string encode_message(std::string sender,std::string msg,bool escape = true);
-	std::string get_con_id(websocketpp::session_ptr s);
-	
-	void send_to_all(std::string data);
-	
-	// list of outstanding connections
-	std::map<websocketpp::session_ptr,std::string> m_connections;
-};
-
-typedef boost::shared_ptr<chat_server_handler> chat_server_handler_ptr;
-
-}
-#endif // CHAT_HPP

examples/chat_server/chat_client.html

@@ -1,177 +0,0 @@
-<!doctype html>
-<html>
-<head>
-<script type="text/javascript" src="jquery-1.6.3.min.js"></script>
-</head>
-<body>
-
-<script type="text/javascript">
-var ws;
-var url;
-
-$(document).ready(init);
-
-function init() {
-	$(document).keypress(function(event) {
-		if ( event.which == 13 ) {
-			event.preventDefault();
-			send();
-		}
-	});
-}
-
-function connect() {
-	url = $("#server_url").val();
-	console.log(url);
-	
-	if ("WebSocket" in window) {
-		ws = new WebSocket(url);
-	} else if ("MozWebSocket" in window) {
-		ws = new MozWebSocket(url);
-	} else {
-		chat_message("This Browser does not support WebSockets");
-		return;
-	}
-	ws.onopen = function(e) {
-		chat_message("A connection to "+url+" has been opened.");
-		
-		$("#server_url").attr("disabled",true);
-		$("#toggle_connect").html("Disconnect");
-	};
-	
-	ws.onerror = function(e) {
-		chat_message("An error occured, see console log for more details.");
-		console.log(e);
-	};
-	
-	ws.onclose = function(e) {
-		chat_message("The connection to "+url+" was closed.");
-	};
-	
-	ws.onmessage = function(e) {
-		var message = JSON.parse(e.data);
-		
-		if (message.type == "msg") {
-			chat_message(message.value,message.sender);
-		} else if (message.type == "participants") {
-			var o = "<ul>";
-			for (var p in message.value) {
-				o += "<li>"+message.value[p]+"</li>";
-			}
-			o += "</ul>";
-			$("#participants").html(o);
-		}
-	};
-}
-
-function chat_message(message,sender) {
-	if (arguments.length == 1) {
-		sender = "";
-	}
-	
-	var style;
-	
-	if (sender == "") {
-		style = "client";
-	} else if (sender == "server") {
-		style = "server";
-		sender = "["+sender+"]";
-	} else {
-		style = "message";
-		sender = "["+sender+"]";
-	}
-	
-	$("#messages").append("<span class='"+style+"'><span class='sender'>"+sender+"</span> <span class='msg'>"+message+"</span></span><br />");
-	$("#messages").prop({ scrollTop: $("#messages").prop("scrollHeight")  });
-}
-
-function disconnect() {
-	ws.close();
-	$("#server_url").removeAttr("disabled");
-	$("#toggle_connect").html("Connect");
-	$("#participants").html("");
-}
-
-function toggle_connect() {
-	if ($("#server_url").attr("disabled") != "disabled") {
-		connect();
-	} else {
-		disconnect();
-	}
-}
-
-function send() {
-	if (ws === undefined || ws.readyState != 1) {
-		chat_message("Websocket is not avaliable for writing");
-		return;
-	}
-	
-	ws.send($("#msg").val());
-	$("#msg").val("");
-}
-
-
-
-
-</script>
-
-<style>
-body,html {
-	margin: 0px;
-	padding: 0px;
-	height: 100%;
-	background-color: #999;
-	font-family: sans-serif;
-	font-size: 14px;
-}
-
-h3 {
-
-}
-
-#controls {
-	padding: 4px;
-	float:right;
-	width: 300px;
-	
-}
-
-input {
-	width: 200px;
-}
-
-#messages {
-	height: 100%;
-	overflow: auto;
-	background-color: black;
-}
-
-#messages .client {
-	color: #ccc;
-}
-
-#messages .server {
-	color: yellow;
-}
-
-#messages .message {
-	color: white;
-}
-
-</style>
-
-<div id="controls">
-	<div id="server">
-	<input type="text" name="server_url" id="server_url" value="ws://thor-websocket.zaphoyd.net:9000/chat" />
-	<button id="toggle_connect" onclick="toggle_connect();">Connect</button>
-	</div>
-
-	<div id="message_input"><input type="text" name="msg" id="msg" value="Hello World!" />
-	<button onclick="send();">Send</button></div>
-	<h3>Chat Participants</h3>
-	<div id="participants"></div>
-</div>
-<div id="messages"></div>
-
-</body>
-</html>

examples/chat_server/chat_server.cpp

@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "chat.hpp"
-
-#include "../../src/websocketpp.hpp"
-#include <boost/asio.hpp>
-
-#include <iostream>
-
-using boost::asio::ip::tcp;
-using namespace websocketchat;
-
-int main(int argc, char* argv[]) {
-	std::string host = "localhost";
-	short port = 9003;
-	std::string full_host;
-	
-	if (argc == 3) {
-		// TODO: input validation?
-		host = argv[1];
-		port = atoi(argv[2]);
-	}
-		
-	std::stringstream temp;
-	
-	temp << host << ":" << port;	
-	full_host = temp.str();
-	
-	
-	chat_server_handler_ptr chat_handler(new chat_server_handler());
-	
-	try {
-		boost::asio::io_service io_service;
-		tcp::endpoint endpoint(tcp::v6(), port);
-		
-		websocketpp::server_ptr server(
-			new websocketpp::server(io_service,endpoint,chat_handler)
-		);
-		
-		// setup server settings
-		server->add_host(host);
-		server->add_host(full_host);
-		// Chat server should only be receiving small text messages, reduce max
-		// message size limit slightly to save memory, improve performance, and 
-		// guard against DoS attacks.
-		server->set_max_message_size(0xFFFF); // 64KiB
-		
-		// start the server
-		server->start_accept();
-		
-		std::cout << "Starting chat server on " << full_host << std::endl;
-		
-		io_service.run();
-	} catch (std::exception& e) {
-		std::cerr << "Exception: " << e.what() << std::endl;
-	}
-	
-	return 0;
-}

examples/debug_client/SConscript

@@ -0,0 +1,24 @@
+## Debug client example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+Import('tls_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   prgs += env_cpp11.Program('debug_client', ["debug_client.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   prgs += env.Program('debug_client', ["debug_client.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/debug_client/debug_client.cpp

@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** ====== WARNING ========
+ * This example is presently used as a scratch space. It may or may not be broken
+ * at any given time.
+ */
+
+#include <websocketpp/config/asio_client.hpp>
+
+#include <websocketpp/client.hpp>
+
+#include <iostream>
+#include <chrono>
+
+typedef websocketpp::client<websocketpp::config::asio_client> client;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef websocketpp::config::asio_tls_client::message_type::ptr message_ptr;
+typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
+typedef client::connection_ptr connection_ptr;
+
+
+
+class perftest {
+public:
+    typedef perftest type;
+    typedef std::chrono::duration<int,std::micro> dur_type;
+
+    perftest () {
+        m_endpoint.set_access_channels(websocketpp::log::alevel::all);
+        m_endpoint.set_error_channels(websocketpp::log::elevel::all);
+
+        // Initialize ASIO
+        m_endpoint.init_asio();
+
+        // Register our handlers
+        m_endpoint.set_socket_init_handler(bind(&type::on_socket_init,this,::_1));
+        //m_endpoint.set_tls_init_handler(bind(&type::on_tls_init,this,::_1));
+        m_endpoint.set_message_handler(bind(&type::on_message,this,::_1,::_2));
+        m_endpoint.set_open_handler(bind(&type::on_open,this,::_1));
+        m_endpoint.set_close_handler(bind(&type::on_close,this,::_1));
+        m_endpoint.set_fail_handler(bind(&type::on_fail,this,::_1));
+    }
+
+    void start(std::string uri) {
+        websocketpp::lib::error_code ec;
+        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
+
+        if (ec) {
+            m_endpoint.get_alog().write(websocketpp::log::alevel::app,ec.message());
+        }
+
+        //con->set_proxy("http://humupdates.uchicago.edu:8443");
+
+        m_endpoint.connect(con);
+
+        // Start the ASIO io_service run loop
+        m_start = std::chrono::high_resolution_clock::now();
+        m_endpoint.run();
+    }
+
+    void on_socket_init(websocketpp::connection_hdl) {
+        m_socket_init = std::chrono::high_resolution_clock::now();
+    }
+
+    context_ptr on_tls_init(websocketpp::connection_hdl) {
+        m_tls_init = std::chrono::high_resolution_clock::now();
+        context_ptr ctx = websocketpp::lib::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::tlsv1);
+
+        try {
+            ctx->set_options(boost::asio::ssl::context::default_workarounds |
+                             boost::asio::ssl::context::no_sslv2 |
+                             boost::asio::ssl::context::no_sslv3 |
+                             boost::asio::ssl::context::single_dh_use);
+        } catch (std::exception& e) {
+            std::cout << e.what() << std::endl;
+        }
+        return ctx;
+    }
+
+    void on_fail(websocketpp::connection_hdl hdl) {
+        client::connection_ptr con = m_endpoint.get_con_from_hdl(hdl);
+        
+        std::cout << "Fail handler" << std::endl;
+        std::cout << con->get_state() << std::endl;
+        std::cout << con->get_local_close_code() << std::endl;
+        std::cout << con->get_local_close_reason() << std::endl;
+        std::cout << con->get_remote_close_code() << std::endl;
+        std::cout << con->get_remote_close_reason() << std::endl;
+        std::cout << con->get_ec() << " - " << con->get_ec().message() << std::endl;
+    }
+
+    void on_open(websocketpp::connection_hdl hdl) {
+        m_open = std::chrono::high_resolution_clock::now();
+        m_endpoint.send(hdl, "", websocketpp::frame::opcode::text);
+    }
+    void on_message(websocketpp::connection_hdl hdl, message_ptr) {
+        m_message = std::chrono::high_resolution_clock::now();
+        m_endpoint.close(hdl,websocketpp::close::status::going_away,"");
+    }
+    void on_close(websocketpp::connection_hdl) {
+        m_close = std::chrono::high_resolution_clock::now();
+
+        std::cout << "Socket Init: " << std::chrono::duration_cast<dur_type>(m_socket_init-m_start).count() << std::endl;
+        std::cout << "TLS Init: " << std::chrono::duration_cast<dur_type>(m_tls_init-m_start).count() << std::endl;
+        std::cout << "Open: " << std::chrono::duration_cast<dur_type>(m_open-m_start).count() << std::endl;
+        std::cout << "Message: " << std::chrono::duration_cast<dur_type>(m_message-m_start).count() << std::endl;
+        std::cout << "Close: " << std::chrono::duration_cast<dur_type>(m_close-m_start).count() << std::endl;
+    }
+private:
+    client m_endpoint;
+
+    std::chrono::high_resolution_clock::time_point m_start;
+    std::chrono::high_resolution_clock::time_point m_socket_init;
+    std::chrono::high_resolution_clock::time_point m_tls_init;
+    std::chrono::high_resolution_clock::time_point m_open;
+    std::chrono::high_resolution_clock::time_point m_message;
+    std::chrono::high_resolution_clock::time_point m_close;
+};
+
+int main(int argc, char* argv[]) {
+    std::string uri = "wss://echo.websocket.org";
+
+    if (argc == 2) {
+        uri = argv[1];
+    }
+
+    try {
+        perftest endpoint;
+        endpoint.start(uri);
+    } catch (const std::exception & e) {
+        std::cout << e.what() << std::endl;
+    } catch (websocketpp::lib::error_code e) {
+        std::cout << e.message() << std::endl;
+    } catch (...) {
+        std::cout << "other exception" << std::endl;
+    }
+}

examples/debug_server/CMakeLists.txt

@@ -0,0 +1,10 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (debug_server)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()

examples/debug_server/SConscript

@@ -0,0 +1,23 @@
+## Debug server example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('debug_server', ["debug_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('debug_server', ["debug_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/debug_server/debug_server.cpp

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** ====== WARNING ========
+ * This example is presently used as a scratch space. It may or may not be broken
+ * at any given time.
+ */
+
+#include <websocketpp/config/debug_asio_no_tls.hpp>
+
+// Custom logger
+#include <websocketpp/logger/syslog.hpp>
+
+#include <websocketpp/server.hpp>
+
+#include <iostream>
+
+////////////////////////////////////////////////////////////////////////////////
+///////////////// Custom Config for debugging custom policies //////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+struct debug_custom : public websocketpp::config::debug_asio {
+    typedef debug_custom type;
+    typedef debug_asio base;
+
+    typedef base::concurrency_type concurrency_type;
+
+    typedef base::request_type request_type;
+    typedef base::response_type response_type;
+
+    typedef base::message_type message_type;
+    typedef base::con_msg_manager_type con_msg_manager_type;
+    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    /// Custom Logging policies
+    /*typedef websocketpp::log::syslog<concurrency_type,
+        websocketpp::log::elevel> elog_type;
+    typedef websocketpp::log::syslog<concurrency_type,
+        websocketpp::log::alevel> alog_type;
+    */
+    typedef base::alog_type alog_type;
+    typedef base::elog_type elog_type;
+
+    typedef base::rng_type rng_type;
+
+    struct transport_config : public base::transport_config {
+        typedef type::concurrency_type concurrency_type;
+        typedef type::alog_type alog_type;
+        typedef type::elog_type elog_type;
+        typedef type::request_type request_type;
+        typedef type::response_type response_type;
+        typedef websocketpp::transport::asio::basic_socket::endpoint
+            socket_type;
+    };
+
+    typedef websocketpp::transport::asio::endpoint<transport_config>
+        transport_type;
+    
+    static const long timeout_open_handshake = 0;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+typedef websocketpp::server<debug_custom> server;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef server::message_ptr message_ptr;
+
+bool validate(server *, websocketpp::connection_hdl) {
+    //sleep(6);
+    return true;
+}
+
+void on_http(server* s, websocketpp::connection_hdl hdl) {
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+
+    std::string res = con->get_request_body();
+
+    std::stringstream ss;
+    ss << "got HTTP request with " << res.size() << " bytes of body data.";
+
+    con->set_body(ss.str());
+    con->set_status(websocketpp::http::status_code::ok);
+}
+
+void on_fail(server* s, websocketpp::connection_hdl hdl) {
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+    
+    std::cout << "Fail handler: " << con->get_ec() << " " << con->get_ec().message()  << std::endl;
+}
+
+void on_close(websocketpp::connection_hdl) {
+    std::cout << "Close handler" << std::endl;
+}
+
+// Define a callback to handle incoming messages
+void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    std::cout << "on_message called with hdl: " << hdl.lock().get()
+              << " and message: " << msg->get_payload()
+              << std::endl;
+
+    try {
+        s->send(hdl, msg->get_payload(), msg->get_opcode());
+    } catch (const websocketpp::lib::error_code& e) {
+        std::cout << "Echo failed because: " << e
+                  << "(" << e.message() << ")" << std::endl;
+    }
+}
+
+int main() {
+    // Create a server endpoint
+    server echo_server;
+
+    try {
+        // Set logging settings
+        echo_server.set_access_channels(websocketpp::log::alevel::all);
+        echo_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
+
+        // Initialize ASIO
+        echo_server.init_asio();
+        echo_server.set_reuse_addr(true);
+
+        // Register our message handler
+        echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));
+
+        echo_server.set_http_handler(bind(&on_http,&echo_server,::_1));
+        echo_server.set_fail_handler(bind(&on_fail,&echo_server,::_1));
+        echo_server.set_close_handler(&on_close);
+
+        echo_server.set_validate_handler(bind(&validate,&echo_server,::_1));
+
+        // Listen on port 9012
+        echo_server.listen(9012);
+
+        // Start the server accept loop
+        echo_server.start_accept();
+
+        // Start the ASIO io_service run loop
+        echo_server.run();
+    } catch (const std::exception & e) {
+        std::cout << e.what() << std::endl;
+    } catch (websocketpp::lib::error_code e) {
+        std::cout << e.message() << std::endl;
+    } catch (...) {
+        std::cout << "other exception" << std::endl;
+    }
+}

examples/dev/SConscript

@@ -0,0 +1,18 @@
+## Main development example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system','timer','chrono'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('main', ["main.cpp"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

examples/dev/main.cpp

@@ -0,0 +1,200 @@
+//#ifndef _WEBSOCKETPP_CPP11_STL_
+//    #define _WEBSOCKETPP_CPP11_STL_
+//#endif
+
+#include <random>
+#include <boost/timer/timer.hpp>
+
+#include <websocketpp/config/core.hpp>
+
+//#include <websocketpp/security/none.hpp>
+
+//#include <websocketpp/concurrency/none.hpp>
+//#include <websocketpp/concurrency/stl.hpp>
+
+//#include <websocketpp/transport/iostream.hpp>
+#include <websocketpp/server.hpp>
+
+#include <iostream>
+#include <sstream>
+
+//typedef websocketpp::concurrency::stl concurrency;
+//typedef websocketpp::transport::iostream<concurrency> transport;
+//typedef websocketpp::server<concurrency,transport> server;
+typedef websocketpp::server<websocketpp::config::core> server;
+
+/*class handler : public server::handler {
+    bool validate(connection_ptr con) {
+        std::cout << "handler validate" << std::endl;
+        if (con->get_origin() != "http://www.example.com") {
+            con->set_status(websocketpp::http::status_code::FORBIDDEN);
+            return false;
+        }
+        return true;
+    }
+
+    void http(connection_ptr con) {
+        std::cout << "handler http" << std::endl;
+    }
+
+    void on_load(connection_ptr con, ptr old_handler) {
+        std::cout << "handler on_load" << std::endl;
+    }
+    void on_unload(connection_ptr con, ptr new_handler) {
+        std::cout << "handler on_unload" << std::endl;
+    }
+
+    void on_open(connection_ptr con) {
+        std::cout << "handler on_open" << std::endl;
+    }
+    void on_fail(connection_ptr con) {
+        std::cout << "handler on_fail" << std::endl;
+    }
+
+    void on_message(connection_ptr con, message_ptr msg) {
+        std::cout << "handler on_message" << std::endl;
+
+
+    }
+
+    void on_close(connection_ptr con) {
+        std::cout << "handler on_close" << std::endl;
+    }
+};*/
+
+int main() {
+    typedef websocketpp::message_buffer::message<websocketpp::message_buffer::alloc::con_msg_manager>
+        message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_man_type;
+
+    con_msg_man_type::ptr manager = websocketpp::lib::make_shared<con_msg_man_type>();
+
+    size_t foo = 1024;
+
+    message_type::ptr input = manager->get_message(websocketpp::frame::opcode::TEXT,foo);
+    message_type::ptr output = manager->get_message(websocketpp::frame::opcode::TEXT,foo);
+    websocketpp::frame::masking_key_type key;
+
+    std::random_device dev;
+
+
+
+    key.i = 0x12345678;
+
+    double m = 18094238402394.0824923;
+
+    /*std::cout << "Some Math" << std::endl;
+    {
+        boost::timer::auto_cpu_timer t;
+
+        for (int i = 0; i < foo; i++) {
+            m /= 1.001;
+        }
+
+    }*/
+
+    std::cout << m << std::endl;
+
+    std::cout << "Random Gen" << std::endl;
+    {
+        boost::timer::auto_cpu_timer t;
+
+        input->get_raw_payload().replace(0,foo,foo,'\0');
+        output->get_raw_payload().replace(0,foo,foo,'\0');
+    }
+
+    std::cout << "Out of place accelerated" << std::endl;
+    {
+        boost::timer::auto_cpu_timer t;
+
+        websocketpp::frame::word_mask_exact(reinterpret_cast<uint8_t*>(const_cast<char*>(input->get_raw_payload().data())), reinterpret_cast<uint8_t*>(const_cast<char*>(output->get_raw_payload().data())), foo, key);
+    }
+
+    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
+    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
+
+    input->get_raw_payload().replace(0,foo,foo,'\0');
+    output->get_raw_payload().replace(0,foo,foo,'\0');
+
+    std::cout << "In place accelerated" << std::endl;
+    {
+        boost::timer::auto_cpu_timer t;
+
+        websocketpp::frame::word_mask_exact(reinterpret_cast<uint8_t*>(const_cast<char*>(input->get_raw_payload().data())), reinterpret_cast<uint8_t*>(const_cast<char*>(input->get_raw_payload().data())), foo, key);
+    }
+
+    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
+    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
+
+    input->get_raw_payload().replace(0,foo,foo,'\0');
+    output->get_raw_payload().replace(0,foo,foo,'\0');
+    std::cout << "Out of place byte by byte" << std::endl;
+    {
+        boost::timer::auto_cpu_timer t;
+
+        websocketpp::frame::byte_mask(input->get_raw_payload().begin(), input->get_raw_payload().end(), output->get_raw_payload().begin(), key);
+    }
+
+    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
+    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
+
+    input->get_raw_payload().replace(0,foo,foo,'\0');
+    output->get_raw_payload().replace(0,foo,foo,'\0');
+    std::cout << "In place byte by byte" << std::endl;
+    {
+        boost::timer::auto_cpu_timer t;
+
+        websocketpp::frame::byte_mask(input->get_raw_payload().begin(), input->get_raw_payload().end(), input->get_raw_payload().begin(), key);
+    }
+
+    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
+    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
+
+    input->get_raw_payload().replace(0,foo,foo,'a');
+    output->get_raw_payload().replace(0,foo,foo,'b');
+    std::cout << "Copy" << std::endl;
+    {
+        boost::timer::auto_cpu_timer t;
+
+        std::copy(input->get_raw_payload().begin(), input->get_raw_payload().end(), output->get_raw_payload().begin());
+    }
+
+    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
+    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
+
+    /*server::handler::ptr h(new handler());
+
+    server test_server(h);
+    server::connection_ptr con;
+
+    std::stringstream output;
+
+    test_server.register_ostream(&output);
+
+    con = test_server.get_connection();
+
+    con->start();
+
+    //foo.handle_accept(con,true);
+
+    std::stringstream input;
+    input << "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+    //input << "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
+    input >> *con;
+
+    std::stringstream input2;
+    input2 << "messageabc2";
+    input2 >> *con;
+
+    std::stringstream input3;
+    input3 << "messageabc3";
+    input3 >> *con;
+
+    std::stringstream input4;
+    input4 << "close";
+    input4 >> *con;
+
+    std::cout << "connection output:" << std::endl;
+    std::cout << output.str() << std::endl;*/
+}

examples/echo_client/Makefile

@@ -1,23 +0,0 @@
-CFLAGS = -O2
-LDFLAGS = 
-
-CXX		?= c++
-SHARED  ?= "1"
-
-ifeq ($(SHARED), 1)
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_thread -lwebsocketpp
-else
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_thread -lboost_date_time -lboost_regex -lboost_random -lboost_program_options ../../libwebsocketpp.a
-endif
-
-echo_client: echo_client.o echo_client_handler.o
-	$(CXX) $(CFLAGS) $^ -o $@ $(LDFLAGS)
-
-%.o: %.cpp
-	$(CXX) -c $(CFLAGS) -o $@ $^
-
-# cleanup by removing generated files
-#
-.PHONY:		clean
-clean:
-		rm -f *.o echo_client

examples/echo_client/echo_client.cpp

@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "echo_client_handler.hpp"
-
-#include "../../src/websocketpp.hpp"
-#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-#include <iostream>
-
-using boost::asio::ip::tcp;
-using namespace websocketecho;
-
-int main(int argc, char* argv[]) {
-	std::string uri;
-	
-	/*if (argc != 2) {
-		std::cout << "Usage: `echo_client test_url`" << std::endl;
-	} else {
-		uri = argv[1];
-	}*/
-	
-	echo_client_handler_ptr c(new echo_client_handler());
-	
-	try {
-		boost::asio::io_service io_service;
-		
-		websocketpp::client_ptr client(new websocketpp::client(io_service,c));
-		
-		client->init();
-		client->set_header("User Agent","WebSocket++/2011-10-27");
-		
-		client->connect("ws://localhost:9001/getCaseCount");
-		io_service.run();
-		
-		std::cout << "case count: " << c->m_case_count << std::endl;
-		
-		for (int i = 1; i <= c->m_case_count; i++) {
-			io_service.reset();
-						
-			client->set_alog_level(websocketpp::ALOG_OFF);
-			client->set_elog_level(websocketpp::LOG_OFF);
-			
-			client->init();
-			client->set_header("User Agent","WebSocket++/2011-10-27");
-			
-			
-			std::stringstream url;
-			
-			url << "ws://localhost:9001/runCase?case=" << i << "&agent=\"WebSocket++Snapshot/2011-10-27\"";
-			
-			client->connect(url.str());
-			
-			io_service.run();
-		}
-		
-		std::cout << "done" << std::endl;
-		
-	} catch (std::exception& e) {
-		std::cerr << "Exception: " << e.what() << std::endl;
-	}
-	
-	return 0;
-}

examples/echo_server/CMakeLists.txt

@@ -0,0 +1,10 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (echo_server)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()

examples/echo_server/Makefile

@@ -1,23 +0,0 @@
-CFLAGS = -O2
-LDFLAGS = 
-
-CXX		?= c++
-SHARED  ?= "1"
-
-ifeq ($(SHARED), 1)
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_date_time -lwebsocketpp
-else
-	LDFLAGS := $(LDFLAGS) -lboost_system -lboost_date_time -lboost_regex -lboost_random -lboost_program_options ../../libwebsocketpp.a
-endif
-
-echo_server: echo_server.o echo.o
-	$(CXX) $(CFLAGS) $^ -o $@ $(LDFLAGS)
-
-%.o: %.cpp
-	$(CXX) -c $(CFLAGS) -o $@ $^
-
-# cleanup by removing generated files
-#
-.PHONY:		clean
-clean:
-		rm -f *.o echo_server

examples/echo_server/SConscript

@@ -0,0 +1,23 @@
+## Main development example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('echo_server', ["echo_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('echo_server', ["echo_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/echo_server/echo_handler.hpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2012, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef WEBSOCKETPP_ECHO_SERVER_HANDLER_HPP
+#define WEBSOCKETPP_ECHO_SERVER_HANDLER_HPP
+
+class echo_handler : public server::handler {
+    void on_message(connection_ptr con, std::string msg) {
+        con->write(msg);
+    }
+};
+
+#endif // WEBSOCKETPP_ECHO_SERVER_HANDLER_HPP

examples/echo_server/echo_server.cpp

@@ -1,90 +1,65 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
+#include <websocketpp/config/asio_no_tls.hpp>
 
-#include "echo.hpp"
-
-#include "../../src/websocketpp.hpp"
-#include <boost/asio.hpp>
+#include <websocketpp/server.hpp>
 
 #include <iostream>
 
-using boost::asio::ip::tcp;
+typedef websocketpp::server<websocketpp::config::asio> server;
 
-int main(int argc, char* argv[]) {
-	std::string host = "localhost";
-	short port = 9002;
-	std::string full_host;
-	
-	if (argc == 3) {
-		// TODO: input validation?
-		host = argv[1];
-		port = atoi(argv[2]);
-	}
-	
-	std::stringstream temp;
-	
-	temp << host << ":" << port;
-	full_host = temp.str();
-	
-	websocketecho::echo_server_handler_ptr echo_handler(new websocketecho::echo_server_handler());
-	
-	try {
-		boost::asio::io_service io_service;
-		tcp::endpoint endpoint(tcp::v6(), port);
-		
-		websocketpp::server_ptr server(
-			new websocketpp::server(io_service,endpoint,echo_handler)
-		);
-		
-		//server->parse_command_line(argc, argv);
-		
-		
-		
-		// setup server settings
-		//server->set_alog_level(websocketpp::ALOG_OFF);
-		//server->set_elog_level(websocketpp::LOG_OFF);
-		
-		server->add_host(host);
-		server->add_host(full_host);
-		
-		// bump up max message size to maximum since we may be using the echo 
-		// server to test performance and protocol extremes.
-		server->set_max_message_size(websocketpp::frame::PAYLOAD_64BIT_LIMIT); 
-		
-		// start the server
-		server->start_accept();
-		
-		std::cout << "Starting echo server on " << full_host << std::endl;
-		
-		// start asio
-		io_service.run();
-	} catch (std::exception& e) {
-		std::cerr << "Exception: " << e.what() << std::endl;
-	}
-	
-	return 0;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef server::message_ptr message_ptr;
+
+// Define a callback to handle incoming messages
+void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    std::cout << "on_message called with hdl: " << hdl.lock().get()
+              << " and message: " << msg->get_payload()
+              << std::endl;
+
+    // check for a special command to instruct the server to stop listening so
+    // it can be cleanly exited.
+    if (msg->get_payload() == "stop-listening") {
+        s->stop_listening();
+        return;
+    }
+
+    try {
+        s->send(hdl, msg->get_payload(), msg->get_opcode());
+    } catch (const websocketpp::lib::error_code& e) {
+        std::cout << "Echo failed because: " << e
+                  << "(" << e.message() << ")" << std::endl;
+    }
+}
+
+int main() {
+    // Create a server endpoint
+    server echo_server;
+
+    try {
+        // Set logging settings
+        echo_server.set_access_channels(websocketpp::log::alevel::all);
+        echo_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
+
+        // Initialize ASIO
+        echo_server.init_asio();
+
+        // Register our message handler
+        echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));
+
+        // Listen on port 9002
+        echo_server.listen(9002);
+
+        // Start the server accept loop
+        echo_server.start_accept();
+
+        // Start the ASIO io_service run loop
+        echo_server.run();
+    } catch (websocketpp::exception const & e) {
+        std::cout << e.what() << std::endl;
+    } catch (...) {
+        std::cout << "other exception" << std::endl;
+    }
 }

examples/echo_server_both/CMakeLists.txt

@@ -0,0 +1,15 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+
+if (OPENSSL_FOUND)
+
+init_target (echo_server_both)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+link_openssl()
+final_target ()
+endif()

examples/echo_server_both/SConscript

@@ -0,0 +1,24 @@
+## Combo plain+tls echo server
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+Import('tls_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   prgs += env_cpp11.Program('echo_server_both', ["echo_server_both.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   prgs += env.Program('echo_server_both', ["echo_server_both.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/echo_server_both/echo_server_both.cpp

@@ -0,0 +1,87 @@
+#include <websocketpp/config/asio.hpp>
+#include <websocketpp/server.hpp>
+
+#include <iostream>
+
+// define types for two different server endpoints, one for each config we are
+// using
+typedef websocketpp::server<websocketpp::config::asio> server_plain;
+typedef websocketpp::server<websocketpp::config::asio_tls> server_tls;
+
+// alias some of the bind related functions as they are a bit long
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// type of the ssl context pointer is long so alias it
+typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
+
+// The shared on_message handler takes a template parameter so the function can
+// resolve any endpoint dependent types like message_ptr or connection_ptr
+template <typename EndpointType>
+void on_message(EndpointType* s, websocketpp::connection_hdl hdl,
+    typename EndpointType::message_ptr msg)
+{
+    std::cout << "on_message called with hdl: " << hdl.lock().get()
+              << " and message: " << msg->get_payload()
+              << std::endl;
+
+    try {
+        s->send(hdl, msg->get_payload(), msg->get_opcode());
+    } catch (const websocketpp::lib::error_code& e) {
+        std::cout << "Echo failed because: " << e
+                  << "(" << e.message() << ")" << std::endl;
+    }
+}
+
+// No change to TLS init methods from echo_server_tls
+std::string get_password() {
+    return "test";
+}
+
+context_ptr on_tls_init(websocketpp::connection_hdl hdl) {
+    std::cout << "on_tls_init called with hdl: " << hdl.lock().get() << std::endl;
+    context_ptr ctx(new boost::asio::ssl::context(boost::asio::ssl::context::tlsv1));
+
+    try {
+        ctx->set_options(boost::asio::ssl::context::default_workarounds |
+                         boost::asio::ssl::context::no_sslv2 |
+                         boost::asio::ssl::context::no_sslv3 |
+                         boost::asio::ssl::context::single_dh_use);
+        ctx->set_password_callback(bind(&get_password));
+        ctx->use_certificate_chain_file("server.pem");
+        ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem);
+    } catch (std::exception& e) {
+        std::cout << e.what() << std::endl;
+    }
+    return ctx;
+}
+
+int main() {
+    // set up an external io_service to run both endpoints on. This is not
+    // strictly necessary, but simplifies thread management a bit.
+    boost::asio::io_service ios;
+
+    // set up plain endpoint
+    server_plain endpoint_plain;
+    // initialize asio with our external io_service rather than an internal one
+    endpoint_plain.init_asio(&ios);
+    endpoint_plain.set_message_handler(
+        bind(&on_message<server_plain>,&endpoint_plain,::_1,::_2));
+    endpoint_plain.listen(80);
+    endpoint_plain.start_accept();
+
+    // set up tls endpoint
+    server_tls endpoint_tls;
+    endpoint_tls.init_asio(&ios);
+    endpoint_tls.set_message_handler(
+        bind(&on_message<server_tls>,&endpoint_tls,::_1,::_2));
+    // TLS endpoint has an extra handler for the tls init
+    endpoint_tls.set_tls_init_handler(bind(&on_tls_init,::_1));
+    // tls endpoint listens on a different port
+    endpoint_tls.listen(443);
+    endpoint_tls.start_accept();
+
+    // Start the ASIO io_service run loop running both endpoints
+    ios.run();
+}

examples/echo_server_both/server.pem

@@ -0,0 +1,58 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,A0ED66EF872A48A9
+
+gXuvKojXzApVhhPVNdRliiajbC4PtwQG5c8TA7JADLgwOR7o9t6KtXEr37bDRpvB
+9aO9P+SJaK5OOp3XKPGthOdqv+tvCRTlmzmC8GjPLBX389DWT2xoGu7JkGwDtdSm
+rnF49Rlp5bfjpACk5xKNiKeDo1CWfeEJzw9Kto0g+5eMaEdors64oPzjXs3geA2g
+TxCJSHv9qSX6++pCLKKCUTbyzidAxV/Zb0AAubt5V40QKqX4HhSwwstFnTaX3tlb
+3QOdY+y04VIkM6d7qN5W8M7NzRkMpZ1qBpQcUMpkhQcRzWP2wub5AAff9D2GntRd
+4Dz1vn3u41U3Okdr0CNj+iH7byCzuokoAhk6ZQEN6WB+GTpGgfBXdtUZrfpb0MKm
+UNYP5AF2AmUqJRXhViTDVtu/V2tHF3LGuNT+W2Dz+spFZEq0byEO0N858eR0dikc
+6jOASvNQbSwD0+mkgBC1gXKKU3ngj2gpJUwljeACdWFd8N2egrZfyI05CmX7vPNC
+NXbs7k2buWNdjP4/D8IM+HDVidWzQa/kG/qokXKqllem9Egg37lUucwnP3cX2/Hw
+U2mfaBWzeZtqc+GqRp08rYIql+Reai3sUYlQMnNk01prVY47UQb+dxuqjaxGV5Xx
+Xkx0s2mfQnNRjL4S7Hjhqelufi6GpkCQ2EGsPpA+6K1ztZ0ame9Q2BE1SXeM/6vU
+rxT5nRrCxueyXAyQSGcqMX9//gSeK8WWBqG/c1IAMVDa0NWrJeOJhSziE+ta3B0m
+bHAPBY6vh0iB3lLdRlbUOPbC6R1TpxMOs+6Vbs2+OTifFpvOVymEoZq/nroyg68P
+vn5uCKogwWA7o8EArf/UTlIwWJmH9bgILdZKld4wMel2HQg16RDzm+mEXAJi52a/
+FC+fgfphdxltmUJ+rqOyR4AHULjaTWUQqTIB6sdlzgmES1nXAiE71zX//KFqomar
+O60SPPk3C1bs0x5DsvmGJa8SIfDhyd+D7NPyqwEKqrZsaotYGklNkfqxa6pa8mrc
+ejxquW1PK4FvBk26+osu5a90Jih0PcQM7DUMMr2WHdTiMSXWAiK2ToYF8Itt25Qv
+Cd0CsSYw9CJkXNr1u1+mObheaY9QYOmztnSJLy4ZO2JsMhqNwuAueIcwmhXOREq7
+kzlnGMgJcuSeAS/OBNj8Zgx0c7QQ0kzc+YmnOCsqoMtPsu/CsXJ4iJiM3Tki/2jT
+bywrTiQwE6R3a/87GREOREX+WLicZBWX3k9/4tBL5XSe1p5wPpuIRQUDvAGNfNHP
+JN7kujDF4SehilF1qtvCygAwvxHFDj+EwhXKNDKJzoZZIM15rAk3k92n2j6nz1qH
+a3xOU05yydOlO6F6w51I1QoDddmkzCRNB0TeO3D6rekHsCK1aDWmC+qRcm2ZFtVz
+sY6fdZN2NEmMQokIh9Opi1f8CSYSizPESMzdu2SF0xVO9n/IGIkn1ksK04O2BZo0
+X3LBPHLfCRsQNY1eF17bj07fYU2oPZKs/XzJiwxkqK6LFvpeAVaYrtg9fqRO/UVe
+QhUIj3BL550ocEpa15xLehLrmwzYiW5zwGjSHQ4EgZluGLCwyKGTh4QswEJRA9Rt
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIE0DCCA7igAwIBAgIJAM5MuKJezXq0MA0GCSqGSIb3DQEBBQUAMIGgMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xGDAW
+BgNVBAoTD1phcGhveWQgU3R1ZGlvczEUMBIGA1UECxMLV2ViU29ja2V0KysxFjAU
+BgNVBAMTDVBldGVyIFRob3Jzb24xJDAiBgkqhkiG9w0BCQEWFXdlYm1hc3RlckB6
+YXBob3lkLmNvbTAeFw0xMTExMTUyMTIwMDZaFw0xMjExMTQyMTIwMDZaMIGgMQsw
+CQYDVQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28x
+GDAWBgNVBAoTD1phcGhveWQgU3R1ZGlvczEUMBIGA1UECxMLV2ViU29ja2V0Kysx
+FjAUBgNVBAMTDVBldGVyIFRob3Jzb24xJDAiBgkqhkiG9w0BCQEWFXdlYm1hc3Rl
+ckB6YXBob3lkLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANR0
+tdwAnIB8I9qRZ7QbzEWY95RpM7GIn0u/9oH90PzdHiE0rXSkKT+yw3XUzH0iw5t0
+5dEwSC+srSP5Vm4cA6kXc94agVVaPW89tGcdP4fHptCruSrzQsDXELCPl5UUvMpA
+YUcGisdXYPN/EeOoqb9wKWxoW5mREsyyeWWS89fYN5qU/d0QpbSvEWghqLbL/ZS2
+hOlXT9LufOeA+vHiV1/T/h5xC7ecIH02YDQw1EnqxbPmkLPcWThztLS9FiufNDRM
+Rhcoaj2b9VDHvDwdbeA0T5v5qNdG34LaapYOelxzQMOtM0f9Dgqehodyxl2qm9mR
+lq432dlOEzDnVCPNHwECAwEAAaOCAQkwggEFMB0GA1UdDgQWBBTTPKfNMnKOykhv
++vKS7vql5JsMyzCB1QYDVR0jBIHNMIHKgBTTPKfNMnKOykhv+vKS7vql5JsMy6GB
+pqSBozCBoDELMAkGA1UEBhMCVVMxETAPBgNVBAgTCElsbGlub2lzMRAwDgYDVQQH
+EwdDaGljYWdvMRgwFgYDVQQKEw9aYXBob3lkIFN0dWRpb3MxFDASBgNVBAsTC1dl
+YlNvY2tldCsrMRYwFAYDVQQDEw1QZXRlciBUaG9yc29uMSQwIgYJKoZIhvcNAQkB
+FhV3ZWJtYXN0ZXJAemFwaG95ZC5jb22CCQDOTLiiXs16tDAMBgNVHRMEBTADAQH/
+MA0GCSqGSIb3DQEBBQUAA4IBAQB+SH0s/hrv5VYqgX6SNLzxdSLvCVsUkCdTpxwY
+wOJ84XmYcXDMhKDtZqLtOtN6pfEwVusFlC9mkieuunztCnWNmsSG83RuljJPjFSi
+1d4Id4bKEQkQ4cfnjoHKivRrViWLnxuNnLzC6tpyGH/35kKWhhr6T58AXerFgVw3
+mHvLPTr1DuhdAZA0ZuvuseVAFFAjI3RetSySwHJE3ak8KswDVfLi6E3XxMVsIWTS
+/iFsC2WwoZQlljya2V/kRYIhu+uCdqJ01wunn2BvmURPSgr4GTBF0FQ9JGpNbXxM
+TAU7oQJgyFc5sCcuEgPTO0dWVQTvdZVgay4tkmduKDRkmJBF
+-----END CERTIFICATE-----

examples/echo_server_tls/CMakeLists.txt

@@ -0,0 +1,15 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+
+if (OPENSSL_FOUND)
+
+init_target (echo_server_tls)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+link_openssl()
+final_target ()
+endif()

examples/echo_server_tls/SConscript

@@ -0,0 +1,24 @@
+## Main development example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+Import('tls_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   prgs += env_cpp11.Program('echo_server_tls', ["echo_server_tls.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   prgs += env.Program('echo_server_tls', ["echo_server_tls.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/echo_server_tls/dh.pem

@@ -0,0 +1,8 @@
+-----BEGIN DH PARAMETERS-----
+MIIBCAKCAQEAqxMGKZB8YNV8WQnbJWwwwmifc+PfVRtd1FN5v5aQSsf6dpjX3Zlh
+N1NmgecsQyg4u2EWe4Umta10QzCgYaxf6QdTCg7iprLzFNw7IvWYbQ6du12NMGDr
+hmwA6KQKwbTgPL6mSlSlcK2wTP2FzxDTNffFu10cB/6Fj4kdQjPG0c1Koz/z7OOq
+BuDElJLClS8rjp3z1xvrc7gX95dFa2KaKgOAYDkpe8tfHRhHfJeIVS/whH9hzx6r
+OBg+E5K9JyvayrUoKgPeptRKCqo8A4YevtMLpRxMup0nMUgAIv6+BGTwPAFpwgl/
+8UIVcvjh1v95PwGDM/Q8yvIBJznBYk/e2wIBAg==
+-----END DH PARAMETERS-----

examples/echo_server_tls/echo_server_tls.cpp

@@ -0,0 +1,115 @@
+#include <websocketpp/config/asio.hpp>
+
+#include <websocketpp/server.hpp>
+
+#include <iostream>
+
+typedef websocketpp::server<websocketpp::config::asio_tls> server;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef websocketpp::config::asio::message_type::ptr message_ptr;
+typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
+
+void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    std::cout << "on_message called with hdl: " << hdl.lock().get()
+              << " and message: " << msg->get_payload()
+              << std::endl;
+
+    try {
+        s->send(hdl, msg->get_payload(), msg->get_opcode());
+    } catch (const websocketpp::lib::error_code& e) {
+        std::cout << "Echo failed because: " << e
+                  << "(" << e.message() << ")" << std::endl;
+    }
+}
+
+void on_http(server* s, websocketpp::connection_hdl hdl) {
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+    
+    con->set_body("Hello World!");
+    con->set_status(websocketpp::http::status_code::ok);
+}
+
+std::string get_password() {
+    return "test";
+}
+
+// See https://wiki.mozilla.org/Security/Server_Side_TLS for more details about
+// the TLS modes. The code below demonstrates how to implement both the modern
+enum tls_mode {
+    MOZILLA_INTERMEDIATE = 1,
+    MOZILLA_MODERN = 2
+};
+
+context_ptr on_tls_init(tls_mode mode, websocketpp::connection_hdl hdl) {
+    std::cout << "on_tls_init called with hdl: " << hdl.lock().get() << std::endl;
+    std::cout << "using TLS mode: " << (mode == MOZILLA_MODERN ? "Mozilla Modern" : "Mozilla Intermediate") << std::endl;
+    context_ptr ctx = websocketpp::lib::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);
+
+    try {
+        if (mode == MOZILLA_MODERN) {
+            // Modern disables TLSv1
+            ctx->set_options(boost::asio::ssl::context::default_workarounds |
+                             boost::asio::ssl::context::no_sslv2 |
+                             boost::asio::ssl::context::no_sslv3 |
+                             boost::asio::ssl::context::no_tlsv1 |
+                             boost::asio::ssl::context::single_dh_use);
+        } else {
+            ctx->set_options(boost::asio::ssl::context::default_workarounds |
+                             boost::asio::ssl::context::no_sslv2 |
+                             boost::asio::ssl::context::no_sslv3 |
+                             boost::asio::ssl::context::single_dh_use);
+        }
+        ctx->set_password_callback(bind(&get_password));
+        ctx->use_certificate_chain_file("server.pem");
+        ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem);
+        
+        // Example method of generating this file:
+        // `openssl dhparam -out dh.pem 2048`
+        // Mozilla Intermediate suggests 1024 as the minimum size to use
+        // Mozilla Modern suggests 2048 as the minimum size to use.
+        ctx->use_tmp_dh_file("dh.pem");
+        
+        std::string ciphers;
+        
+        if (mode == MOZILLA_MODERN) {
+            ciphers = "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK";
+        } else {
+            ciphers = "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA";
+        }
+        
+        if (SSL_CTX_set_cipher_list(ctx->native_handle() , ciphers.c_str()) != 1) {
+            std::cout << "Error setting cipher list" << std::endl;
+        }
+    } catch (std::exception& e) {
+        std::cout << "Exception: " << e.what() << std::endl;
+    }
+    return ctx;
+}
+
+int main() {
+    // Create a server endpoint
+    server echo_server;
+
+    // Initialize ASIO
+    echo_server.init_asio();
+
+    // Register our message handler
+    echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));
+    echo_server.set_http_handler(bind(&on_http,&echo_server,::_1));
+    echo_server.set_tls_init_handler(bind(&on_tls_init,MOZILLA_INTERMEDIATE,::_1));
+
+    // Listen on port 9002
+    echo_server.listen(9002);
+
+    // Start the server accept loop
+    echo_server.start_accept();
+
+    // Start the ASIO io_service run loop
+    echo_server.run();
+
+}

examples/echo_server_tls/server.pem

@@ -0,0 +1,55 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEA77v5VbFaq+geVd/RCLXoKTWj/LgXGjiOXBpJZca3o5edi7N1
+Ej41/13jfZ4OxgFIRFAALd+fU4NsObXzskth3rJLmJjUtGajRIPqF2IUVjFMmybQ
+9dUDSqPzd/bG+ul0DP7DNuiBcLC8XNC3/kchPUzVq9gNDk56jXn87kMoIkVXBWQS
+Rwk0yCtELSfwxxRCrGKgQDfXnRdwmkPe42DmKtdGksXJlUhP1UVTAXaSw1Nz64LV
+9bJje/eoDsSe4OxifVVToE6ZxIW+r1jVgrcupeYXQrSHIztl2U/rx2JkGMN0eS+P
+qrsJmkmRBN1cpgmvSV7WoM3hj6Eq71z4Dfv6EwIDAQABAoIBAEXAL19bZsI1mv3p
+TOx34MB8tuXEuhQK+ICbtVdDZhLW/iOzZxCTwSo3qwTVg/7gSKJ3lFXEhprJ1idE
+ZU8u157vyUbw0JJceoxoxSdghgI9/cf2lz2vaHHDGgeBaYt/eSB+z1WeeGrNQUDQ
+CXiWQXmQbWq+Ra4v70BSieDY8UhmzCTRhvfZV80vaY/4SnHxJ9C8Nu8/An7U3pwq
+ccfTaWMp3Q5ztmEnExF6/b1SUsnI8rzFovw/4C50AU09N/Z6zZVFsXgJAT2Kd1Tx
+HfP1vUkWZ/TJ6kcmVIV9U3uMcedBD8Rb/3M0Qdp+eymQ+1oYQ3K3/a2RlUQIeXzf
+hRbE4wECgYEA/WyULrwBsvSMPqK0K9pZpv921Yl6d4bGnpxKze7ltc9o5/LsU35q
+8u29Es7cPyhyUDOsPW8v2CNjw54t+eFGsu59bBvXZNz5gB7hTUEyLntB24cO5PmN
+kVExcMDFC6NgPaauBtUhODievKJ2C8P7sRJDAVKE9KkavDddU7nSEjMCgYEA8ivG
+AqwNXYsiIFjAo4uj3kuBFt8LU/q4m6GXI+9qyxfiJjuF1dROx5qaQGiE85VaBFUu
+gpbnjZH7s+BBgoaQhrB4i6mztljdN1KKuAlnjhB+Fywg8m8N9lAi3wIaxnIEqDkU
+vFiIFPTBCk0U7IZ/OyCrKPQTE9ApWHfBwA/vWKECgYBQixrJg61SkBCms5Vpvprx
+zY2aLniC1o33yRqpOr09PG9OENH1c19QWCjYenBbjmJOhS2/1L+zBQRnHrXkDion
+Ik8wdeTORMDzbF0U7ZyiU0BKIjGkqn/I6LI68LlvinxC+9+hgkltkek5cLTt5lrv
+Gyu6ltx02e4KVdpOiuduKwKBgQC3U0PWigCkK8ttyUIrjG5Evcu/UKH2tPpDdpQ/
+8+JYVIAyiSTLtqjcmcDjuTvMWeeHGCTZXvtzRGvSw5VUBiIqlDTtJU6SX7s3QhkZ
+MKVf+kQ5roJShJeBOzDquWEjkPTNlEiKPErn8lCgR7HrS/XNAPIRUpOOkCp8ekwF
+5Qo/gQKBgAue3TeCeIzxh4PxSAk39Uaj+AaLvlYg8C+ucEodCNQZnJ7jOO0hHkfT
+NvZBes0VukCGlBLOGRQtC3kgtyrerscnDiZOhdnJrhPIdNPC0k/p/uAfh7+C5Sxm
+rCEL0S7kORdEjlIGd5j6ZEN/HZe8FyOYSjbFAoJSlAId9WMSxycQ
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIEpzCCA4+gAwIBAgIJAMlCHvwnJ+F/MA0GCSqGSIb3DQEBCwUAMIGTMQswCQYD
+VQQGEwJVUzELMAkGA1UECBMCSUwxEDAOBgNVBAcTB0NoaWNhZ28xGTAXBgNVBAoT
+EFdlYlNvY2tldCsrIERlbW8xIjAgBgNVBAMTGXV0aWxpdGllcy53ZWJzb2NrZXRw
+cC5vcmcxJjAkBgkqhkiG9w0BCQEWF3dlYnNvY2tldHBwQHphcGhveWQuY29tMB4X
+DTE1MDQyNTE1NTk1M1oXDTE4MDMyODE1NTk1M1owgZMxCzAJBgNVBAYTAlVTMQsw
+CQYDVQQIEwJJTDEQMA4GA1UEBxMHQ2hpY2FnbzEZMBcGA1UEChMQV2ViU29ja2V0
+KysgRGVtbzEiMCAGA1UEAxMZdXRpbGl0aWVzLndlYnNvY2tldHBwLm9yZzEmMCQG
+CSqGSIb3DQEJARYXd2Vic29ja2V0cHBAemFwaG95ZC5jb20wggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDvu/lVsVqr6B5V39EItegpNaP8uBcaOI5cGkll
+xrejl52Ls3USPjX/XeN9ng7GAUhEUAAt359Tg2w5tfOyS2HeskuYmNS0ZqNEg+oX
+YhRWMUybJtD11QNKo/N39sb66XQM/sM26IFwsLxc0Lf+RyE9TNWr2A0OTnqNefzu
+QygiRVcFZBJHCTTIK0QtJ/DHFEKsYqBAN9edF3CaQ97jYOYq10aSxcmVSE/VRVMB
+dpLDU3PrgtX1smN796gOxJ7g7GJ9VVOgTpnEhb6vWNWCty6l5hdCtIcjO2XZT+vH
+YmQYw3R5L4+quwmaSZEE3VymCa9JXtagzeGPoSrvXPgN+/oTAgMBAAGjgfswgfgw
+HQYDVR0OBBYEFAWNBET93ZzSukXGkuGb93CfmUkDMIHIBgNVHSMEgcAwgb2AFAWN
+BET93ZzSukXGkuGb93CfmUkDoYGZpIGWMIGTMQswCQYDVQQGEwJVUzELMAkGA1UE
+CBMCSUwxEDAOBgNVBAcTB0NoaWNhZ28xGTAXBgNVBAoTEFdlYlNvY2tldCsrIERl
+bW8xIjAgBgNVBAMTGXV0aWxpdGllcy53ZWJzb2NrZXRwcC5vcmcxJjAkBgkqhkiG
+9w0BCQEWF3dlYnNvY2tldHBwQHphcGhveWQuY29tggkAyUIe/Ccn4X8wDAYDVR0T
+BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEA2DRQSDmo2Q5t8MEjp6jddRIFts5t
+BDBWPSwJ0qvmheFt53MuLds2hhvMn42WGrKtVJiLiDyOWuUZ41REJZb1uaissUuY
+r9pLuP5QLdibx7+/30iDEY0OGTgtSTfgwNx8bIApBSHoZEN3/HaikqplBng2+6u/
+kTe6UnRrBJ+8JOGl+duhCXNPeSyLa2NcrxE9XpWC/k1kC9MTUF+2NuqCtK3zO8ci
+p0mqARWDSrEBYISh3dAOgDFrcX6zj+0MK+iswu3ijEdItGAjxjlQ2t4XT1T/CDbc
+ysHg04TJw7v682+v124GrnrAPYUK34OK8kFVJ60SNYRUi7euOCdTM4Lwkw==
+-----END CERTIFICATE-----
+

examples/enriched_storage/enriched_storage.cpp

@@ -0,0 +1,87 @@
+#include <iostream>
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+struct connection_data {
+    int sessionid;
+    std::string name;
+};
+
+struct custom_config : public websocketpp::config::asio {
+    // pull default settings from our core config
+    typedef websocketpp::config::asio core;
+    
+    typedef core::concurrency_type concurrency_type;
+    typedef core::request_type request_type;
+    typedef core::response_type response_type;
+    typedef core::message_type message_type;
+    typedef core::con_msg_manager_type con_msg_manager_type;
+    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
+    typedef core::alog_type alog_type;
+    typedef core::elog_type elog_type;
+    typedef core::rng_type rng_type;
+    typedef core::transport_type transport_type;
+    typedef core::endpoint_base endpoint_base;
+    
+    // Set a custom connection_base class
+    typedef connection_data connection_base;
+};
+
+typedef websocketpp::server<custom_config> server;
+typedef server::connection_ptr connection_ptr;
+
+using websocketpp::connection_hdl;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+class print_server {
+public:
+    print_server() : m_next_sessionid(1) {
+        m_server.init_asio();
+                
+        m_server.set_open_handler(bind(&print_server::on_open,this,::_1));
+        m_server.set_close_handler(bind(&print_server::on_close,this,::_1));
+        m_server.set_message_handler(bind(&print_server::on_message,this,::_1,::_2));
+    }
+    
+    void on_open(connection_hdl hdl) {
+        connection_ptr con = m_server.get_con_from_hdl(hdl);
+        
+        con->sessionid = m_next_sessionid++;
+    }
+    
+    void on_close(connection_hdl hdl) {
+        connection_ptr con = m_server.get_con_from_hdl(hdl);
+        
+        std::cout << "Closing connection " << con->name 
+                  << " with sessionid " << con->sessionid << std::endl;
+    }
+    
+    void on_message(connection_hdl hdl, server::message_ptr msg) {
+        connection_ptr con = m_server.get_con_from_hdl(hdl);
+        
+        if (con->name == "") {
+            con->name = msg->get_payload();
+            std::cout << "Setting name of connection with sessionid " 
+                      << con->sessionid << " to " << con->name << std::endl;
+        } else {
+            std::cout << "Got a message from connection " << con->name 
+                      << " with sessionid " << con->sessionid << std::endl;
+        }
+    }
+    
+    void run(uint16_t port) {
+        m_server.listen(port);
+        m_server.start_accept();
+        m_server.run();
+    }
+private:
+    int m_next_sessionid;
+    server m_server;
+};
+
+int main() {
+    print_server server;
+    server.run(9002);
+}

examples/handler_switch/handler_switch.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+using websocketpp::connection_hdl;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+using websocketpp::lib::ref;
+
+void custom_on_msg(server & s, connection_hdl hdl, server::message_ptr msg) {
+        std::cout << "Message sent to custom handler" << std::endl;
+}
+
+void default_on_msg(server & s, connection_hdl hdl, server::message_ptr msg) {
+    std::cout << "Message sent to default handler" << std::endl;
+
+    if (msg->get_payload() == "upgrade") {
+        // Upgrade our connection_hdl to a full connection_ptr
+        server::connection_ptr con = s.get_con_from_hdl(hdl);
+
+        // Change the on message handler for this connection only to
+        // custom_on_mesage
+        con->set_message_handler(bind(&custom_on_msg,ref(s),::_1,::_2));
+        std::cout << "Upgrading connection to custom handler" << std::endl;
+    }
+}
+
+int main() {
+    server s;
+
+    s.set_message_handler(bind(&default_on_msg,ref(s),::_1,::_2));
+
+    s.init_asio();
+    s.listen(9002);
+    s.start_accept();
+
+    s.run();
+}

examples/iostream_server/SConscript

@@ -0,0 +1,23 @@
+## iostream server example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('iostream_server', ["iostream_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('iostream_server', ["iostream_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/iostream_server/iostream_server.cpp

@@ -0,0 +1,89 @@
+#include <websocketpp/config/core.hpp>
+
+#include <websocketpp/server.hpp>
+
+#include <iostream>
+#include <fstream>
+
+typedef websocketpp::server<websocketpp::config::core> server;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef server::message_ptr message_ptr;
+
+// Define a callback to handle incoming messages
+void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    if (msg->get_opcode() == websocketpp::frame::opcode::text) {
+        s->get_alog().write(websocketpp::log::alevel::app,
+                    "Text Message Received: "+msg->get_payload());
+    } else {
+        s->get_alog().write(websocketpp::log::alevel::app,
+                    "Binary Message Received: "+websocketpp::utility::to_hex(msg->get_payload()));
+    }
+
+    try {
+        s->send(hdl, msg->get_payload(), msg->get_opcode());
+    } catch (const websocketpp::lib::error_code& e) {
+        s->get_alog().write(websocketpp::log::alevel::app,
+                    "Echo Failed: "+e.message());
+    }
+}
+
+int main() {
+    server s;
+    std::ofstream log;
+
+    try {
+        // set up access channels to only log interesting things
+        s.clear_access_channels(websocketpp::log::alevel::all);
+        s.set_access_channels(websocketpp::log::alevel::connect);
+        s.set_access_channels(websocketpp::log::alevel::disconnect);
+        s.set_access_channels(websocketpp::log::alevel::app);
+
+        // Log to a file rather than stdout, as we are using stdout for real
+        // output
+        log.open("output.log");
+        s.get_alog().set_ostream(&log);
+        s.get_elog().set_ostream(&log);
+
+        // print all output to stdout
+        s.register_ostream(&std::cout);
+
+        // Register our message handler
+        s.set_message_handler(bind(&on_message,&s,::_1,::_2));
+
+        server::connection_ptr con = s.get_connection();
+
+        con->start();
+
+        // C++ iostream's don't support the idea of asynchronous i/o. As such
+        // there are two input strategies demonstrated here. Buffered I/O will
+        // read from stdin in chunks until EOF. This works very well for
+        // replaying canned connections as would be done in automated testing.
+        //
+        // If the server is being used live however, assuming input is being
+        // piped from elsewhere in realtime, this strategy will result in small
+        // messages being buffered forever. The non-buffered strategy below
+        // reads characters from stdin one at a time. This is inefficient and
+        // for more serious uses should be replaced with a platform specific
+        // asyncronous i/o technique like select, poll, IOCP, etc
+        bool buffered_io = false;
+
+        if (buffered_io) {
+            std::cin >> *con;
+            con->eof();
+        } else {
+            char a;
+            while(std::cin.get(a)) {
+                con->read_some(&a,1);
+            }
+            con->eof();
+        }
+    } catch (websocketpp::exception const & e) {
+        std::cout << e.what() << std::endl;
+    }
+    log.close();
+}

examples/print_server/CMakeLists.txt

@@ -0,0 +1,10 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (print_server)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()

examples/print_server/SConscript

@@ -0,0 +1,23 @@
+## Print server example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('print_server', ["print_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('print_server', ["print_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/print_server/print_server.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+void on_message(websocketpp::connection_hdl, server::message_ptr msg) {
+        std::cout << msg->get_payload() << std::endl;
+}
+
+int main() {
+    server print_server;
+
+    print_server.set_message_handler(&on_message);
+
+    print_server.init_asio();
+    print_server.listen(9002);
+    print_server.start_accept();
+
+    print_server.run();
+}

examples/simple_broadcast_server/simple_broadcast_server.cpp

@@ -0,0 +1,51 @@
+#include <set>
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+using websocketpp::connection_hdl;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+class broadcast_server {
+public:
+    broadcast_server() {
+        m_server.init_asio();
+
+        m_server.set_open_handler(bind(&broadcast_server::on_open,this,::_1));
+        m_server.set_close_handler(bind(&broadcast_server::on_close,this,::_1));
+        m_server.set_message_handler(bind(&broadcast_server::on_message,this,::_1,::_2));
+    }
+
+    void on_open(connection_hdl hdl) {
+        m_connections.insert(hdl);
+    }
+
+    void on_close(connection_hdl hdl) {
+        m_connections.erase(hdl);
+    }
+
+    void on_message(connection_hdl hdl, server::message_ptr msg) {
+        for (auto it : m_connections) {
+            m_server.send(it,msg);
+        }
+    }
+
+    void run(uint16_t port) {
+        m_server.listen(port);
+        m_server.start_accept();
+        m_server.run();
+    }
+private:
+    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
+
+    server m_server;
+    con_list m_connections;
+};
+
+int main() {
+    broadcast_server server;
+    server.run(9002);
+}

examples/sip_client/CMakeLists.txt

@@ -0,0 +1,11 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (sip_client)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()
+

examples/sip_client/README.txt

@@ -0,0 +1,22 @@
+
+
+Checkout the project from git
+
+At the top level, run cmake:
+
+  cmake -G 'Unix Makefiles' \
+     -D BUILD_EXAMPLES=ON \
+     -D WEBSOCKETPP_ROOT=/tmp/cm1 \
+     -D ENABLE_CPP11=OFF .
+
+and then make the example:
+
+  make -C examples/sip_client
+
+Now run it:
+
+  bin/sip_client ws://ws-server:80
+
+It has been tested against the repro SIP proxy from reSIProcate
+
+  http://www.resiprocate.org/WebRTC_and_SIP_Over_WebSockets

examples/sip_client/SConscript

@@ -0,0 +1,23 @@
+## SIP client example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is avaliable build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('sip_client', ["sip_client.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('sip_client', ["sip_client.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/sip_client/sip_client.cpp

@@ -0,0 +1,84 @@
+#include <condition_variable>
+
+#include <websocketpp/config/asio_no_tls_client.hpp>
+
+#include <websocketpp/client.hpp>
+
+#include <iostream>
+
+#include <boost/thread/thread.hpp>
+
+typedef websocketpp::client<websocketpp::config::asio_client> client;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
+
+// Create a server endpoint
+client sip_client;
+
+
+bool received;
+
+void on_open(client* c, websocketpp::connection_hdl hdl) {
+    // now it is safe to use the connection
+    std::cout << "connection ready" << std::endl;
+
+    received=false;
+    // Send a SIP OPTIONS message to the server:
+    std::string SIP_msg="OPTIONS sip:carol@chicago.com SIP/2.0\r\nVia: SIP/2.0/WS df7jal23ls0d.invalid;rport;branch=z9hG4bKhjhs8ass877\r\nMax-Forwards: 70\r\nTo: <sip:carol@chicago.com>\r\nFrom: Alice <sip:alice@atlanta.com>;tag=1928301774\r\nCall-ID: a84b4c76e66710\r\nCSeq: 63104 OPTIONS\r\nContact: <sip:alice@pc33.atlanta.com>\r\nAccept: application/sdp\r\nContent-Length: 0\r\n\r\n";
+    sip_client.send(hdl, SIP_msg.c_str(), websocketpp::frame::opcode::text);
+}
+
+void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
+    client::connection_ptr con = sip_client.get_con_from_hdl(hdl);
+
+    std::cout << "Received a reply:" << std::endl;
+    fwrite(msg->get_payload().c_str(), msg->get_payload().size(), 1, stdout);
+    received=true;
+}
+
+int main(int argc, char* argv[]) {
+
+    std::string uri = "ws://localhost:9001";
+
+    if (argc == 2) {
+        uri = argv[1];
+    }
+
+    try {
+        // We expect there to be a lot of errors, so suppress them
+        sip_client.clear_access_channels(websocketpp::log::alevel::all);
+        sip_client.clear_error_channels(websocketpp::log::elevel::all);
+
+        // Initialize ASIO
+        sip_client.init_asio();
+
+        // Register our handlers
+        sip_client.set_open_handler(bind(&on_open,&sip_client,::_1));
+        sip_client.set_message_handler(bind(&on_message,&sip_client,::_1,::_2));
+
+        websocketpp::lib::error_code ec;
+        client::connection_ptr con = sip_client.get_connection(uri, ec);
+
+        // Specify the SIP subprotocol:
+        con->add_subprotocol("sip");
+
+        sip_client.connect(con);
+
+        // Start the ASIO io_service run loop
+        sip_client.run();
+
+        while(!received) {
+            boost::this_thread::sleep(boost::posix_time::milliseconds(100));
+        }
+
+        std::cout << "done" << std::endl;
+
+    } catch (websocketpp::exception const & e) {
+        std::cout << e.what() << std::endl;
+    }
+}

examples/subprotocol_server/SConscript

@@ -0,0 +1,23 @@
+## Main development example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('subprotocol_server', ["subprotocol_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('subprotocol_server', ["subprotocol_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/subprotocol_server/subprotocol_server.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+
+using websocketpp::connection_hdl;
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+using websocketpp::lib::ref;
+
+
+bool validate(server & s, connection_hdl hdl) {
+    server::connection_ptr con = s.get_con_from_hdl(hdl);
+
+    std::cout << "Cache-Control: " << con->get_request_header("Cache-Control") << std::endl;
+
+    const std::vector<std::string> & subp_requests = con->get_requested_subprotocols();
+    std::vector<std::string>::const_iterator it;
+
+    for (it = subp_requests.begin(); it != subp_requests.end(); ++it) {
+        std::cout << "Requested: " << *it << std::endl;
+    }
+
+    if (subp_requests.size() > 0) {
+        con->select_subprotocol(subp_requests[0]);
+    }
+
+    return true;
+}
+
+int main() {
+    try {
+        server s;
+
+        s.set_validate_handler(bind(&validate,ref(s),::_1));
+
+        s.init_asio();
+        s.listen(9005);
+        s.start_accept();
+
+        s.run();
+    } catch (websocketpp::exception const & e) {
+        std::cout << e.what() << std::endl;
+    }
+}

examples/telemetry_client/CMakeLists.txt

@@ -0,0 +1,10 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (telemetry_client)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()

examples/telemetry_client/SConscript

@@ -0,0 +1,23 @@
+## Telemetry client example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('telemetry_client', ["telemetry_client.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('telemetry_client', ["telemetry_client.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/telemetry_client/telemetry_client.cpp

@@ -0,0 +1,156 @@
+#include <websocketpp/config/asio_no_tls_client.hpp>
+#include <websocketpp/client.hpp>
+
+// This header pulls in the WebSocket++ abstracted thread support that will
+// select between boost::thread and std::thread based on how the build system
+// is configured.
+#include <websocketpp/common/thread.hpp>
+
+/**
+ * The telemetry client connects to a WebSocket server and sends a message every
+ * second containing an integer count. This example can be used as the basis for
+ * programs where a client connects and pushes data for logging, stress/load
+ * testing, etc.
+ */
+class telemetry_client {
+public:
+    typedef websocketpp::client<websocketpp::config::asio_client> client;
+    typedef websocketpp::lib::lock_guard<websocketpp::lib::mutex> scoped_lock;
+
+    telemetry_client() : m_open(false),m_done(false) {
+        // set up access channels to only log interesting things
+        m_client.clear_access_channels(websocketpp::log::alevel::all);
+        m_client.set_access_channels(websocketpp::log::alevel::connect);
+        m_client.set_access_channels(websocketpp::log::alevel::disconnect);
+        m_client.set_access_channels(websocketpp::log::alevel::app);
+
+        // Initialize the Asio transport policy
+        m_client.init_asio();
+
+        // Bind the handlers we are using
+        using websocketpp::lib::placeholders::_1;
+        using websocketpp::lib::bind;
+        m_client.set_open_handler(bind(&telemetry_client::on_open,this,_1));
+        m_client.set_close_handler(bind(&telemetry_client::on_close,this,_1));
+        m_client.set_fail_handler(bind(&telemetry_client::on_fail,this,_1));
+    }
+
+    // This method will block until the connection is complete
+    void run(const std::string & uri) {
+        // Create a new connection to the given URI
+        websocketpp::lib::error_code ec;
+        client::connection_ptr con = m_client.get_connection(uri, ec);
+        if (ec) {
+            m_client.get_alog().write(websocketpp::log::alevel::app,
+                    "Get Connection Error: "+ec.message());
+            return;
+        }
+
+        // Grab a handle for this connection so we can talk to it in a thread
+        // safe manor after the event loop starts.
+        m_hdl = con->get_handle();
+
+        // Queue the connection. No DNS queries or network connections will be
+        // made until the io_service event loop is run.
+        m_client.connect(con);
+
+        // Create a thread to run the ASIO io_service event loop
+        websocketpp::lib::thread asio_thread(&client::run, &m_client);
+
+        // Create a thread to run the telemetry loop
+        websocketpp::lib::thread telemetry_thread(&telemetry_client::telemetry_loop,this);
+
+        asio_thread.join();
+        telemetry_thread.join();
+    }
+
+    // The open handler will signal that we are ready to start sending telemetry
+    void on_open(websocketpp::connection_hdl) {
+        m_client.get_alog().write(websocketpp::log::alevel::app,
+            "Connection opened, starting telemetry!");
+
+        scoped_lock guard(m_lock);
+        m_open = true;
+    }
+
+    // The close handler will signal that we should stop sending telemetry
+    void on_close(websocketpp::connection_hdl) {
+        m_client.get_alog().write(websocketpp::log::alevel::app,
+            "Connection closed, stopping telemetry!");
+
+        scoped_lock guard(m_lock);
+        m_done = true;
+    }
+
+    // The fail handler will signal that we should stop sending telemetry
+    void on_fail(websocketpp::connection_hdl) {
+        m_client.get_alog().write(websocketpp::log::alevel::app,
+            "Connection failed, stopping telemetry!");
+
+        scoped_lock guard(m_lock);
+        m_done = true;
+    }
+
+    void telemetry_loop() {
+        uint64_t count = 0;
+        std::stringstream val;
+        websocketpp::lib::error_code ec;
+
+        while(1) {
+            bool wait = false;
+
+            {
+                scoped_lock guard(m_lock);
+                // If the connection has been closed, stop generating telemetry
+                if (m_done) {break;}
+
+                // If the connection hasn't been opened yet wait a bit and retry
+                if (!m_open) {
+                    wait = true;
+                }
+            }
+
+            if (wait) {
+                sleep(1);
+                continue;
+            }
+
+            val.str("");
+            val << "count is " << count++;
+
+            m_client.get_alog().write(websocketpp::log::alevel::app, val.str());
+            m_client.send(m_hdl,val.str(),websocketpp::frame::opcode::text,ec);
+
+            // The most likely error that we will get is that the connection is
+            // not in the right state. Usually this means we tried to send a
+            // message to a connection that was closed or in the process of
+            // closing. While many errors here can be easily recovered from,
+            // in this simple example, we'll stop the telemetry loop.
+            if (ec) {
+                m_client.get_alog().write(websocketpp::log::alevel::app,
+                    "Send Error: "+ec.message());
+                break;
+            }
+
+            sleep(1);
+        }
+    }
+private:
+    client m_client;
+    websocketpp::connection_hdl m_hdl;
+    websocketpp::lib::mutex m_lock;
+    bool m_open;
+    bool m_done;
+};
+
+int main(int argc, char* argv[]) {
+    telemetry_client c;
+
+    std::string uri = "ws://localhost:9002";
+
+    if (argc == 2) {
+        uri = argv[1];
+    }
+
+    c.run(uri);
+}

examples/telemetry_server/CMakeLists.txt

@@ -0,0 +1,10 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (telemetry_server)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()

examples/telemetry_server/SConscript

@@ -0,0 +1,23 @@
+## Main development example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('telemetry_server', ["telemetry_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('telemetry_server', ["telemetry_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/telemetry_server/index.html

@@ -1,6 +1,7 @@
 <!doctype html>
 <html>
 <head>
+<title>WebSocket++ Telemetry Client</title>
 </head>
 <body>
 
@@ -10,7 +11,6 @@ var url;
 
 function connect() {
 	url = document.getElementById("server_url").value;
-	console.log(url);
 	
 	if ("WebSocket" in window) {
 		ws = new WebSocket(url);
@@ -21,7 +21,7 @@ function connect() {
 		return;
 	}
 	ws.onopen = function(e) {
-		document.getElementById("messages").innerHTML += "Client: A connection to "+ws.URL+" has been opened.<br />";
+		document.getElementById("messages").innerHTML += "Client: A connection to "+ws.url+" has been opened.<br />";
 		
 		document.getElementById("server_url").disabled = true;
 		document.getElementById("toggle_connect").innerHTML = "Disconnect";
@@ -33,7 +33,8 @@ function connect() {
 	};
 	
 	ws.onclose = function(e) {
-		document.getElementById("messages").innerHTML += "Client: The connection to "+url+" was closed.<br />";
+		document.getElementById("messages").innerHTML += "Client: The connection to "+url+" was closed. ["+e.code+(e.reason != "" ? ","+e.reason : "")+"]<br />";
+	    cleanup_disconnect();
 	};
 	
 	ws.onmessage = function(e) {
@@ -43,7 +44,11 @@ function connect() {
 
 function disconnect() {
 	ws.close();
-	document.getElementById("server_url").disabled = false;
+	cleanup_disconnect();
+}
+
+function cleanup_disconnect() {
+    document.getElementById("server_url").disabled = false;
 	document.getElementById("toggle_connect").innerHTML = "Connect";
 }
 
@@ -54,17 +59,6 @@ function toggle_connect() {
 		disconnect();
 	}
 }
-
-function send() {
-	if (ws === undefined || ws.readyState != 1) {
-		document.getElementById("messages").innerHTML += "Client: Websocket is not avaliable for writing<br />";
-		return;
-	}
-	
-	ws.send(document.getElementById("msg").value);
-	document.getElementById("msg").value = "";
-}
-
 </script>
 
 <style>
@@ -81,14 +75,11 @@ body,html {
 
 <div id="controls">
 	<div id="server">
-	<input type="text" name="server_url" id="server_url" value="ws://localhost:5000" />
+	<input type="text" name="server_url" id="server_url" value="ws://localhost:9002" /><br />
 	<button id="toggle_connect" onclick="toggle_connect();">Connect</button>
 	</div>
-
-	<div id="message_input"><input type="text" name="msg" id="msg" value="Hello World!" />
-	<button onclick="send();">Send</button></div>
 </div>
 <div id="messages"></div>
 
 </body>
-</html>
+</html>

examples/telemetry_server/telemetry_server.cpp

@@ -0,0 +1,204 @@
+#include <websocketpp/config/asio_no_tls.hpp>
+
+#include <websocketpp/server.hpp>
+
+#include <fstream>
+#include <iostream>
+#include <set>
+#include <streambuf>
+#include <string>
+
+/**
+ * The telemetry server accepts connections and sends a message every second to
+ * each client containing an integer count. This example can be used as the
+ * basis for programs that expose a stream of telemetry data for logging,
+ * dashboards, etc.
+ *
+ * This example uses the timer based concurrency method and is self contained
+ * and singled threaded. Refer to telemetry client for an example of a similar
+ * telemetry setup using threads rather than timers.
+ *
+ * This example also includes an example simple HTTP server that serves a web
+ * dashboard displaying the count. This simple design is suitable for use 
+ * delivering a small number of files to a small number of clients. It is ideal
+ * for cases like embedded dashboards that don't want the complexity of an extra
+ * HTTP server to serve static files.
+ *
+ * This design *will* fall over under high traffic or DoS conditions. In such
+ * cases you are much better off proxying to a real HTTP server for the http
+ * requests.
+ */
+class telemetry_server {
+public:
+    typedef websocketpp::connection_hdl connection_hdl;
+    typedef websocketpp::server<websocketpp::config::asio> server;
+    typedef websocketpp::lib::lock_guard<websocketpp::lib::mutex> scoped_lock;
+
+    telemetry_server() : m_count(0) {
+        // set up access channels to only log interesting things
+        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
+        m_endpoint.set_access_channels(websocketpp::log::alevel::access_core);
+        m_endpoint.set_access_channels(websocketpp::log::alevel::app);
+
+        // Initialize the Asio transport policy
+        m_endpoint.init_asio();
+
+        // Bind the handlers we are using
+        using websocketpp::lib::placeholders::_1;
+        using websocketpp::lib::bind;
+        m_endpoint.set_open_handler(bind(&telemetry_server::on_open,this,_1));
+        m_endpoint.set_close_handler(bind(&telemetry_server::on_close,this,_1));
+        m_endpoint.set_http_handler(bind(&telemetry_server::on_http,this,_1));
+    }
+
+    void run(std::string docroot, uint16_t port) {
+        std::stringstream ss;
+        ss << "Running telemetry server on port "<< port <<" using docroot=" << docroot;
+        m_endpoint.get_alog().write(websocketpp::log::alevel::app,ss.str());
+        
+        m_docroot = docroot;
+        
+        // listen on specified port
+        m_endpoint.listen(port);
+
+        // Start the server accept loop
+        m_endpoint.start_accept();
+
+        // Set the initial timer to start telemetry
+        set_timer();
+
+        // Start the ASIO io_service run loop
+        try {
+            m_endpoint.run();
+        } catch (websocketpp::exception const & e) {
+            std::cout << e.what() << std::endl;
+        }
+    }
+
+    void set_timer() {
+        m_timer = m_endpoint.set_timer(
+            1000,
+            websocketpp::lib::bind(
+                &telemetry_server::on_timer,
+                this,
+                websocketpp::lib::placeholders::_1
+            )
+        );
+    }
+
+    void on_timer(websocketpp::lib::error_code const & ec) {
+        if (ec) {
+            // there was an error, stop telemetry
+            m_endpoint.get_alog().write(websocketpp::log::alevel::app,
+                    "Timer Error: "+ec.message());
+            return;
+        }
+        
+        std::stringstream val;
+        val << "count is " << m_count++;
+        
+        // Broadcast count to all connections
+        con_list::iterator it;
+        for (it = m_connections.begin(); it != m_connections.end(); ++it) {
+            m_endpoint.send(*it,val.str(),websocketpp::frame::opcode::text);
+        }
+        
+        // set timer for next telemetry check
+        set_timer();
+    }
+
+    void on_http(connection_hdl hdl) {
+        // Upgrade our connection handle to a full connection_ptr
+        server::connection_ptr con = m_endpoint.get_con_from_hdl(hdl);
+    
+        std::ifstream file;
+        std::string filename = con->get_uri()->get_resource();
+        std::string response;
+    
+        m_endpoint.get_alog().write(websocketpp::log::alevel::app,
+            "http request1: "+filename);
+    
+        if (filename == "/") {
+            filename = m_docroot+"index.html";
+        } else {
+            filename = m_docroot+filename.substr(1);
+        }
+        
+        m_endpoint.get_alog().write(websocketpp::log::alevel::app,
+            "http request2: "+filename);
+    
+        file.open(filename.c_str(), std::ios::in);
+        if (!file) {
+            // 404 error
+            std::stringstream ss;
+        
+            ss << "<!doctype html><html><head>"
+               << "<title>Error 404 (Resource not found)</title><body>"
+               << "<h1>Error 404</h1>"
+               << "<p>The requested URL " << filename << " was not found on this server.</p>"
+               << "</body></head></html>";
+        
+            con->set_body(ss.str());
+            con->set_status(websocketpp::http::status_code::not_found);
+            return;
+        }
+    
+        file.seekg(0, std::ios::end);
+        response.reserve(file.tellg());
+        file.seekg(0, std::ios::beg);
+    
+        response.assign((std::istreambuf_iterator<char>(file)),
+                        std::istreambuf_iterator<char>());
+    
+        con->set_body(response);
+        con->set_status(websocketpp::http::status_code::ok);
+    }
+
+    void on_open(connection_hdl hdl) {
+        m_connections.insert(hdl);
+    }
+
+    void on_close(connection_hdl hdl) {
+        m_connections.erase(hdl);
+    }
+private:
+    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
+    
+    server m_endpoint;
+    con_list m_connections;
+    server::timer_ptr m_timer;
+    
+    std::string m_docroot;
+    
+    // Telemetry data
+    uint64_t m_count;
+};
+
+int main(int argc, char* argv[]) {
+    telemetry_server s;
+
+    std::string docroot;
+    uint16_t port = 9002;
+
+    if (argc == 1) {
+        std::cout << "Usage: telemetry_server [documentroot] [port]" << std::endl;
+        return 1;
+    }
+    
+    if (argc >= 2) {
+        docroot = std::string(argv[1]);
+    }
+        
+    if (argc >= 3) {
+        int i = atoi(argv[2]);
+        if (i <= 0 || i > 65535) {
+            std::cout << "invalid port" << std::endl;
+            return 1;
+        }
+        
+        port = uint16_t(i);
+    }
+
+    s.run(docroot, port);
+    return 0;
+}

examples/testee_client/CMakeLists.txt

@@ -0,0 +1,11 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (testee_client)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()
+

examples/testee_client/SConscript

@@ -0,0 +1,23 @@
+## Autobahn test client example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('testee_client', ["testee_client.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('testee_client', ["testee_client.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/testee_client/testee_client.cpp

@@ -0,0 +1,80 @@
+#include <websocketpp/config/asio_no_tls_client.hpp>
+
+#include <websocketpp/client.hpp>
+
+#include <iostream>
+
+typedef websocketpp::client<websocketpp::config::asio_client> client;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
+
+int case_count = 0;
+
+void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
+    client::connection_ptr con = c->get_con_from_hdl(hdl);
+
+    if (con->get_resource() == "/getCaseCount") {
+        std::cout << "Detected " << msg->get_payload() << " test cases."
+                  << std::endl;
+        case_count = atoi(msg->get_payload().c_str());
+    } else {
+        c->send(hdl, msg->get_payload(), msg->get_opcode());
+    }
+}
+
+int main(int argc, char* argv[]) {
+    // Create a server endpoint
+    client c;
+
+    std::string uri = "ws://localhost:9001";
+
+    if (argc == 2) {
+        uri = argv[1];
+    }
+
+    try {
+        // We expect there to be a lot of errors, so suppress them
+        c.clear_access_channels(websocketpp::log::alevel::all);
+        c.clear_error_channels(websocketpp::log::elevel::all);
+
+        // Initialize ASIO
+        c.init_asio();
+
+        // Register our handlers
+        c.set_message_handler(bind(&on_message,&c,::_1,::_2));
+
+        websocketpp::lib::error_code ec;
+        client::connection_ptr con = c.get_connection(uri+"/getCaseCount", ec);
+        c.connect(con);
+
+        // Start the ASIO io_service run loop
+        c.run();
+
+        std::cout << "case count: " << case_count << std::endl;
+
+        for (int i = 1; i <= case_count; i++) {
+            c.reset();
+
+            std::stringstream url;
+
+            url << uri << "/runCase?case=" << i << "&agent="
+                << websocketpp::user_agent;
+
+            con = c.get_connection(url.str(), ec);
+
+            c.connect(con);
+
+            c.run();
+        }
+
+        std::cout << "done" << std::endl;
+
+    } catch (websocketpp::exception const & e) {
+        std::cout << e.what() << std::endl;
+    }
+}

examples/testee_server/SConscript

@@ -0,0 +1,23 @@
+## Autobahn Testee Server
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('testee_server', ["testee_server.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('testee_server', ["testee_server.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/testee_server/testee_server.cpp

@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+#include <iostream>
+
+struct testee_config : public websocketpp::config::asio {
+    // pull default settings from our core config
+    typedef websocketpp::config::asio core;
+
+    typedef core::concurrency_type concurrency_type;
+    typedef core::request_type request_type;
+    typedef core::response_type response_type;
+    typedef core::message_type message_type;
+    typedef core::con_msg_manager_type con_msg_manager_type;
+    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    typedef core::alog_type alog_type;
+    typedef core::elog_type elog_type;
+    typedef core::rng_type rng_type;
+    typedef core::endpoint_base endpoint_base;
+
+    static bool const enable_multithreading = true;
+
+    struct transport_config : public core::transport_config {
+        typedef core::concurrency_type concurrency_type;
+        typedef core::elog_type elog_type;
+        typedef core::alog_type alog_type;
+        typedef core::request_type request_type;
+        typedef core::response_type response_type;
+
+        static bool const enable_multithreading = true;
+    };
+
+    typedef websocketpp::transport::asio::endpoint<transport_config>
+        transport_type;
+
+    static const websocketpp::log::level elog_level =
+        websocketpp::log::elevel::none;
+    static const websocketpp::log::level alog_level =
+        websocketpp::log::alevel::none;
+};
+
+typedef websocketpp::server<testee_config> server;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+// pull out the type of messages sent by our config
+typedef server::message_ptr message_ptr;
+
+// Define a callback to handle incoming messages
+void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    s->send(hdl, msg->get_payload(), msg->get_opcode());
+}
+
+void on_socket_init(websocketpp::connection_hdl, boost::asio::ip::tcp::socket & s) {
+    boost::asio::ip::tcp::no_delay option(true);
+    s.set_option(option);
+}
+
+int main(int argc, char * argv[]) {
+    // Create a server endpoint
+    server testee_server;
+
+    short port = 9002;
+    size_t num_threads = 1;
+
+    if (argc == 3) {
+        port = atoi(argv[1]);
+        num_threads = atoi(argv[2]);
+    }
+
+    try {
+        // Total silence
+        testee_server.clear_access_channels(websocketpp::log::alevel::all);
+        testee_server.clear_error_channels(websocketpp::log::alevel::all);
+
+        // Initialize ASIO
+        testee_server.init_asio();
+        testee_server.set_reuse_addr(true);
+
+        // Register our message handler
+        testee_server.set_message_handler(bind(&on_message,&testee_server,::_1,::_2));
+        testee_server.set_socket_init_handler(bind(&on_socket_init,::_1,::_2));
+
+        // Listen on specified port with extended listen backlog
+        testee_server.set_listen_backlog(8192);
+        testee_server.listen(port);
+
+        // Start the server accept loop
+        testee_server.start_accept();
+
+        // Start the ASIO io_service run loop
+        if (num_threads == 1) {
+            testee_server.run();
+        } else {
+            typedef websocketpp::lib::shared_ptr<websocketpp::lib::thread> thread_ptr;
+            std::vector<thread_ptr> ts;
+            for (size_t i = 0; i < num_threads; i++) {
+                ts.push_back(websocketpp::lib::make_shared<websocketpp::lib::thread>(&server::run, &testee_server));
+            }
+
+            for (size_t i = 0; i < num_threads; i++) {
+                ts[i]->join();
+            }
+        }
+
+    } catch (websocketpp::exception const & e) {
+        std::cout << "exception: " << e.what() << std::endl;
+    }
+}

examples/utility_client/CMakeLists.txt

@@ -0,0 +1,11 @@
+
+file (GLOB SOURCE_FILES *.cpp)
+file (GLOB HEADER_FILES *.hpp)
+
+init_target (utility_client)
+
+build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
+
+link_boost ()
+final_target ()
+

examples/utility_client/SConscript

@@ -0,0 +1,23 @@
+## Utility client example
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+prgs = []
+
+# if a C++11 environment is available build using that, otherwise use boost
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   prgs += env_cpp11.Program('utility_client', ["utility_client.cpp"], LIBS = ALL_LIBS)
+else:
+   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
+   prgs += env.Program('utility_client', ["utility_client.cpp"], LIBS = ALL_LIBS)
+
+Return('prgs')

examples/utility_client/utility_client.cpp

@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
+// Additional related material can be found in the tutorials/utility_client
+// directory of the WebSocket++ repository.
+
+#include <websocketpp/config/asio_no_tls_client.hpp>
+#include <websocketpp/client.hpp>
+
+#include <websocketpp/common/thread.hpp>
+#include <websocketpp/common/memory.hpp>
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <string>
+#include <sstream>
+
+typedef websocketpp::client<websocketpp::config::asio_client> client;
+
+class connection_metadata {
+public:
+    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
+
+    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
+      : m_id(id)
+      , m_hdl(hdl)
+      , m_status("Connecting")
+      , m_uri(uri)
+      , m_server("N/A")
+    {}
+
+    void on_open(client * c, websocketpp::connection_hdl hdl) {
+        m_status = "Open";
+
+        client::connection_ptr con = c->get_con_from_hdl(hdl);
+        m_server = con->get_response_header("Server");
+    }
+
+    void on_fail(client * c, websocketpp::connection_hdl hdl) {
+        m_status = "Failed";
+
+        client::connection_ptr con = c->get_con_from_hdl(hdl);
+        m_server = con->get_response_header("Server");
+        m_error_reason = con->get_ec().message();
+    }
+    
+    void on_close(client * c, websocketpp::connection_hdl hdl) {
+        m_status = "Closed";
+        client::connection_ptr con = c->get_con_from_hdl(hdl);
+        std::stringstream s;
+        s << "close code: " << con->get_remote_close_code() << " (" 
+          << websocketpp::close::status::get_string(con->get_remote_close_code()) 
+          << "), close reason: " << con->get_remote_close_reason();
+        m_error_reason = s.str();
+    }
+
+    void on_message(websocketpp::connection_hdl, client::message_ptr msg) {
+        if (msg->get_opcode() == websocketpp::frame::opcode::text) {
+            m_messages.push_back("<< " + msg->get_payload());
+        } else {
+            m_messages.push_back("<< " + websocketpp::utility::to_hex(msg->get_payload()));
+        }
+    }
+
+    websocketpp::connection_hdl get_hdl() const {
+        return m_hdl;
+    }
+    
+    int get_id() const {
+        return m_id;
+    }
+    
+    std::string get_status() const {
+        return m_status;
+    }
+
+    void record_sent_message(std::string message) {
+        m_messages.push_back(">> " + message);
+    }
+
+    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
+private:
+    int m_id;
+    websocketpp::connection_hdl m_hdl;
+    std::string m_status;
+    std::string m_uri;
+    std::string m_server;
+    std::string m_error_reason;
+    std::vector<std::string> m_messages;
+};
+
+std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
+    out << "> URI: " << data.m_uri << "\n"
+        << "> Status: " << data.m_status << "\n"
+        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
+        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason) << "\n";
+    out << "> Messages Processed: (" << data.m_messages.size() << ") \n";
+
+    std::vector<std::string>::const_iterator it;
+    for (it = data.m_messages.begin(); it != data.m_messages.end(); ++it) {
+        out << *it << "\n";
+    }
+
+    return out;
+}
+
+class websocket_endpoint {
+public:
+    websocket_endpoint () : m_next_id(0) {
+        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
+        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
+
+        m_endpoint.init_asio();
+        m_endpoint.start_perpetual();
+
+        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&client::run, &m_endpoint);
+    }
+
+    ~websocket_endpoint() {
+        m_endpoint.stop_perpetual();
+        
+        for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
+            if (it->second->get_status() != "Open") {
+                // Only close open connections
+                continue;
+            }
+            
+            std::cout << "> Closing connection " << it->second->get_id() << std::endl;
+            
+            websocketpp::lib::error_code ec;
+            m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
+            if (ec) {
+                std::cout << "> Error closing connection " << it->second->get_id() << ": "  
+                          << ec.message() << std::endl;
+            }
+        }
+        
+        m_thread->join();
+    }
+
+    int connect(std::string const & uri) {
+        websocketpp::lib::error_code ec;
+
+        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
+
+        if (ec) {
+            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
+            return -1;
+        }
+
+        int new_id = m_next_id++;
+        connection_metadata::ptr metadata_ptr = websocketpp::lib::make_shared<connection_metadata>(new_id, con->get_handle(), uri);
+        m_connection_list[new_id] = metadata_ptr;
+
+        con->set_open_handler(websocketpp::lib::bind(
+            &connection_metadata::on_open,
+            metadata_ptr,
+            &m_endpoint,
+            websocketpp::lib::placeholders::_1
+        ));
+        con->set_fail_handler(websocketpp::lib::bind(
+            &connection_metadata::on_fail,
+            metadata_ptr,
+            &m_endpoint,
+            websocketpp::lib::placeholders::_1
+        ));
+        con->set_close_handler(websocketpp::lib::bind(
+            &connection_metadata::on_close,
+            metadata_ptr,
+            &m_endpoint,
+            websocketpp::lib::placeholders::_1
+        ));
+        con->set_message_handler(websocketpp::lib::bind(
+            &connection_metadata::on_message,
+            metadata_ptr,
+            websocketpp::lib::placeholders::_1,
+            websocketpp::lib::placeholders::_2
+        ));
+
+        m_endpoint.connect(con);
+
+        return new_id;
+    }
+
+    void close(int id, websocketpp::close::status::value code, std::string reason) {
+        websocketpp::lib::error_code ec;
+        
+        con_list::iterator metadata_it = m_connection_list.find(id);
+        if (metadata_it == m_connection_list.end()) {
+            std::cout << "> No connection found with id " << id << std::endl;
+            return;
+        }
+        
+        m_endpoint.close(metadata_it->second->get_hdl(), code, reason, ec);
+        if (ec) {
+            std::cout << "> Error initiating close: " << ec.message() << std::endl;
+        }
+    }
+
+    void send(int id, std::string message) {
+        websocketpp::lib::error_code ec;
+        
+        con_list::iterator metadata_it = m_connection_list.find(id);
+        if (metadata_it == m_connection_list.end()) {
+            std::cout << "> No connection found with id " << id << std::endl;
+            return;
+        }
+        
+        m_endpoint.send(metadata_it->second->get_hdl(), message, websocketpp::frame::opcode::text, ec);
+        if (ec) {
+            std::cout << "> Error sending message: " << ec.message() << std::endl;
+            return;
+        }
+        
+        metadata_it->second->record_sent_message(message);
+    }
+
+    connection_metadata::ptr get_metadata(int id) const {
+        con_list::const_iterator metadata_it = m_connection_list.find(id);
+        if (metadata_it == m_connection_list.end()) {
+            return connection_metadata::ptr();
+        } else {
+            return metadata_it->second;
+        }
+    }
+private:
+    typedef std::map<int,connection_metadata::ptr> con_list;
+
+    client m_endpoint;
+    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
+
+    con_list m_connection_list;
+    int m_next_id;
+};
+
+int main() {
+    bool done = false;
+    std::string input;
+    websocket_endpoint endpoint;
+
+    while (!done) {
+        std::cout << "Enter Command: ";
+        std::getline(std::cin, input);
+
+        if (input == "quit") {
+            done = true;
+        } else if (input == "help") {
+            std::cout
+                << "\nCommand List:\n"
+                << "connect <ws uri>\n"
+                << "send <connection id> <message>\n"
+                << "close <connection id> [<close code:default=1000>] [<close reason>]\n"
+                << "show <connection id>\n"
+                << "help: Display this help text\n"
+                << "quit: Exit the program\n"
+                << std::endl;
+        } else if (input.substr(0,7) == "connect") {
+            int id = endpoint.connect(input.substr(8));
+            if (id != -1) {
+                std::cout << "> Created connection with id " << id << std::endl;
+            }
+        } else if (input.substr(0,4) == "send") {
+            std::stringstream ss(input);
+            
+            std::string cmd;
+            int id;
+            std::string message = "";
+            
+            ss >> cmd >> id;
+            std::getline(ss,message);
+            
+            endpoint.send(id, message);
+        } else if (input.substr(0,5) == "close") {
+            std::stringstream ss(input);
+            
+            std::string cmd;
+            int id;
+            int close_code = websocketpp::close::status::normal;
+            std::string reason = "";
+            
+            ss >> cmd >> id >> close_code;
+            std::getline(ss,reason);
+            
+            endpoint.close(id, close_code, reason);
+        } else if (input.substr(0,4) == "show") {
+            int id = atoi(input.substr(5).c_str());
+
+            connection_metadata::ptr metadata = endpoint.get_metadata(id);
+            if (metadata) {
+                std::cout << *metadata << std::endl;
+            } else {
+                std::cout << "> Unknown connection id " << id << std::endl;
+            }
+        } else {
+            std::cout << "> Unrecognized Command" << std::endl;
+        }
+    }
+
+    return 0;
+}

license.txt

@@ -1,23 +0,0 @@
-Copyright (c) 2011, Peter Thorson. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the WebSocket++ Project nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

readme.md

@@ -0,0 +1,49 @@
+WebSocket++ (0.6.0)
+==========================
+
+WebSocket++ is a header only C++ library that implements RFC6455 The WebSocket
+Protocol. It allows integrating WebSocket client and server functionality into
+C++ programs. It uses interchangeable network transport modules including one
+based on raw char buffers, one based on C++ iostreams, and one based on Asio 
+(either via Boost or standalone). End users can write additional transport
+policies to support other networking or event libraries as needed.
+
+Major Features
+==============
+* Full support for RFC6455
+* Partial support for Hixie 76 / Hybi 00, 07-17 draft specs (server only)
+* Message/event based interface
+* Supports secure WebSockets (TLS), IPv6, and explicit proxies.
+* Flexible dependency management (C++11 Standard Library or Boost)
+* Interchangeable network transport modules (raw, iostream, Asio, or custom)
+* Portable/cross platform (Posix/Windows, 32/64bit, Intel/ARM/PPC)
+* Thread-safe
+
+Get Involved
+============
+
+[![Build Status](https://travis-ci.org/zaphoyd/websocketpp.png)](https://travis-ci.org/zaphoyd/websocketpp)
+
+**Project Website**
+http://www.zaphoyd.com/websocketpp/
+
+**User Manual**
+http://www.zaphoyd.com/websocketpp/manual/
+
+**GitHub Repository**
+https://github.com/zaphoyd/websocketpp/
+
+GitHub pull requests should be submitted to the `develop` branch.
+
+**Announcements Mailing List**
+http://groups.google.com/group/websocketpp-announcements/
+
+**IRC Channel**
+ #websocketpp (freenode)
+
+**Discussion / Development / Support Mailing List / Forum**
+http://groups.google.com/group/websocketpp/
+
+Author
+======
+Peter Thorson - websocketpp@zaphoyd.com

readme.txt

@@ -1,299 +0,0 @@
-How to use this library
-
-WebSocket++ is a C++ websocket server library implimented using the Boost Asio networking stack. It is designed to provide a simple interface
-
-Built on Asio's proactor asyncronious event loop. 
-
-Building a program using WebSocket++ has two parts
-1. Impliment a connection handler.
-This is done by subclassing websocketpp::connection_handler. Each websocket connection is attached to a connection handler. The handler impliments the following methods:
-
-validate:
-Called after the client handshake is recieved but before the connection is accepted. Allows cookie authentication, origin checking, subprotocol negotiation, etc
-
-connect:
-Called when the connection has been established and writes are allowed.
-
-disconnect:
-Called when the connection has been disconnected
-
-message: text and binary variants
-Called when a new websocket message is recieved.
-
-The handler has access to the following websocket session api:
-get_header
-returns the value of an HTTP header sent by the client during the handshake
-
-get_request
-returns the resource requested by the client in the handshake
-
-set_handler:
-pass responsibility for this connection to another connection handler
-
-set_http_error:
-reject the connection with a specific HTTP error
-
-add_header
-adds an HTTP header to the server handshake
-
-set_subprotocol
-selects a subprotocol for the connection
-
-send: text and binary varients
-send a websocket message
-
-ping:
-send a ping
-
-2. Start Asio's event loop with a TCP endpoint and your connection handler
-
-There are two example programs in the examples directory that demonstrate this use pattern. One is a trivial stateless echo server, the other is a simple web based chat client. Both include example javascript clients. The echo server is suitable for use with automated testing suites such as the Autobahn test suite.
-
-By default, a single connection handler object is used for all connections. If needs require, that default handler can either store per-connection state itself or create new handlers and pass off responsibility for the connection to them.
-
-How to build this library
-
-Build static library
-make
-
-Build and install in system include directories
-make install
-
-Avaliable flags:
-- SHARED=1: build a shared instead of static library.
-- DEBUG=1: build library with no optimizations, suitable for debugging. Debug library
-	is called libwebsocketpp_dbg
-- CXX=*: uses * as the c++ compiler instead of system default
-
-Build tested on
-- Mac OS X 10.7 with apple gcc 4.2, macports gcc 4.6, apple llvm/clang, boost 1.47
-- Fedora 15, gcc 4.6, boost 1.46
-- Ubunutu server, gcc,  boost 1.42
-
-Outstanding issues
-- Acknowledgement details
-- Subprotocol negotiation interface
-- check draft 14 issues
-- session.cpp - add_header. Decide what should happen with multiple calls to 
-   add header with the same key
-- multiple headers of the same value
-- Better exception model
-- closing handshake reason/ error codes?
-- tests for opening/closing handshake
-- tests for utf8
-- utf8 streaming validation
-- more easily configurable frame size limit
-- Better system of handling server wide defaults (like hosts, frame limits, etc)
-
-To check
-- double check bugs in autobahn (sending wrong localhost:9000 header) not 
-- checking masking in the 9.x tests
-
-Unimplimented features
-- SSL
-- frame or streaming based api
-- client features
-- extension negotiation interface
-
-Acknowledgements
-- Boost Asio and other libraries
-- base64 library
-- sha1 library
-- htonll discussion
-- build/makefile from libjson
-
-- Autobahn test suite
-- testing by Keith Brisson
-
-
-
-API spec notes
-
-
-
-## Server API ##
-websocketpp.hpp
-
-create a websocketpp::server_ptr initialized to a new websocketpp::server object
-
-the server constructor will need three things.
-- A boost::asio::io_service object to use to manage its async operations
-- A boost::asio::ip::tcp::endpoint to listen to for new connections
-- An object that impliments the websocketpp::connection_handler interface to provide callback functions (See Handler API)
-
-After construction the server object will be in the initialization state. At this time you can set up server config options either via calling individual set option commands or by loading them in a batch from a config file.
-
-The only required option is that at least one host value must be set. Incoming websocket connections must specify a host value that they wish to connect to and if the server object does not have that host value in it's list of canonical hosts it will reject the connection.
-
-[note about settings that can be changed live?]
-
-Once the server has been configured the way you want, call the start_accept() method. This will add the first async call to your io_service. If your io_service was already running, the server will start accepting connections immediately. If not you will need to call io_service.run() to start it.
-
-Once the server has started it will accept new connections. A new session object will be created for each connection accepted. The session will perform the websocket handshake and if it is successful begin reading frames. The session will continue reading frames until an error occurs or a connection close frame is seen. The session will notify the handler that it was initilized with (see Handler API) as necessary. The Session API defines how a handler (or other part of the end application) can interact with the session (to get information about the session, send messages back to the client, etc)
-
-## Client API ##
-include websocketpp.hpp
-
-create a websocketpp::client_ptr initialized to a new websocketpp::client object
-
-the client constructor will need:
-- A boost::asio::io_service object to use to manage its async operations
-- An object that impliments the websocketpp::connection_handler interface to privde callback functions (See Handler API)
-
-After construction, the client object will be in the initialization state. At this time you can set up client config options either via calling individual set options commands or by loading them in a batch from a config file.
-
-Opening a new connection:
-Per the websocket spec, a client can only have one connection in the connecting state at a time. Client method new_session() will create a new session and return a shared pointer to it. After this point new_session will throw an exception if you attempt to call it again before the most recently created session has either successfully connected or failed to connect. new_session()
-- call websocketpp::client::new_session(). This will return a session_ptr
-
-
-## Handler API ##
-The handler API defines the interface that a websocketpp session will use to communicate information about the session state and new messages to your application.
-
-A client or server must be initialized with a default handler that will be used for all sessions. The default handler may pass a session off to another handler as necessary.
-
-A handler must impliment the following methods:
-- validate(session_ptr)
-- on_fail(session_ptr)
-- on_open(session_ptr)
-- on_close(session_ptr)
-- on_message(session_ptr,const std::vector<unsigned char> &)
-- on_message(session_ptr,const std::string &)
-
-validate will be called after a websocket handshake has been received and before it is accepted. It provides a handler the ability to refuse a connection based on application specific logic (ex: restrict domains or negotiate subprotocols). To reject the connection throw a handshake_error. Validate is never called for client sessions. To refuse a client session (ex: if you do not like the set of extensions/subprotocols the server chose) you can close the connection immediately in the on_open member function.
-
-on_fail is called whenever a session is terminated or failed before it was successfully established. This happens if there is an error during the handshake process or if the server refused the connection. 
-on_fail will be the last time a session calls its handler. If your application will need information from `session` after this function you should either save the session_ptr somewhere or copy the data out.
-
-on_open is called after the websocket session has been successfully established and is in the OPEN state. The session is now avaliable to send messages and will begin reading frames and calling the on_message/on_close/on_error callbacks. A client may reject the connection by closing the session at this point.
-
-on_close is called whenever an open session is closed for any reason. This can be due to either endpoint requesting a connection close or an error occuring. Information about why the session was closed can be extracted from the session itself.
-on_close will be the last time a session calls its handler. If your application will need information from `session` after this function you should either save the session_ptr somewhere or copy the data out.
-
-on_message (binary version) will be called when a binary message is recieved. Message data is passed as a vector of bytes (unsigned char). data will not be avaliable after this callback ends so the handler must either completely process the message or copy it somewhere else for processing later.
-
-TODO: Notes about thread safety
-
-
-## Session API ##
-The Session API allows a handler to look up information about a session as well as interact with that session (send messages, close the connection, etc)
-
-Session pointers are returned with every handler callback as well as every call to websocketpp::client::connect.
-
-
-Handler Interface:
-- set_handler(connection_handler_ptr)
-
-Handshake Interface:
-For the client these methods are valid after the server's handshake has been received. This is guaranteed to be the case by the time `on_open` is called.
-For the server these methods are valid after the client's handshake has been received. This is guaranteed to be the case by the time `validate` is called.
-
-- const std::string& get_subprotocol() const;
-- const std::string& get_resource() const;
-- const std::string& get_origin() const;
-- std::string get_client_header(const std::string&) const;
-- std::string get_server_header(const std::string&) const;
-- const std::vector<std::string>& get_extensions() const;
-- unsigned int get_version() const;
-
-Frame Interface
-- void send(const std::string &);
-- void send(const std::vector<unsigned char> &);
-- void ping(const std::string &);
-- void pong(const std::string &);
-
-These methods are valid only for open connections. They will throw an exception if called from any other state.
-
-WebSocket++ does not queue messages. As such only one send operation can be occuring at once. 
-TODO: failure behavior. OPTIONS:
-- send will throw a `session_busy` exception if busy
-- send will return true/false
-- a callback could be defined letting the handler know that it is safe to write again.
-
-Session Interface
-- void close(uint16_t status,const std::string &reason);
-- bool is_server() const;
-
-
-
-
---------------------------------
-screwing around with a policy based refactoring
---------------------------------
-
-template<class WebSocketRole,class Logger>
-class endpoint : public WebSocketRole, Logger {
-public:
-	endpoint(connection_handler_ptr);
-	
-	size_t get_connected_client_count() const;
-	
-	void set_endpoint(const tcp::endpoint& endpoint); // asio::bind
-	
-private:
-	std::list<session_ptr>	m_connections;
-	connection_handler_ptr	m_handler;
-	
-	boost::asio::io_service	m_io_service;
-	tcp::acceptor			m_acceptor;
-}
-
-class server_interface {
-public:
-	void add_host(const std::string &host);
-	void remove_host(const std::string &host);
-	bool validate_host(const std::string &host) const;
-	
-	void set_max_message_size(uint64_t size);
-	bool validate_message_size(uint64_t size) const;
-	
-	void start() {
-		// start_accept()
-		// io_service.run()
-	}
-private:
-	void start_accept();
-	void handle_accept(session_ptr session, const boost::system::error_code&)
-	
-	std::set<std::string>	m_hosts;
-	uint64_t				m_max_message_size;
-}
-
-class client_interface {
-public:
-	session_ptr connect(const std::string &url);
-protected:
-	
-private:
-
-}
-
-
-
-template<class HandshakePolicy>
-class session : public HandshakePolicy {
-public:
-	session();
-private:
-	
-}
-
-namespace websocketpp {
-namespace handshake {
-
-/* a handshake policy must define:
-void on_connect();
-bool is_server() const;
-
-*/
-
-class server {
-	
-}
-
-class client {
-	
-}
-
-} // handshake
-} // websocketpp

roadmap.md

@@ -0,0 +1,43 @@
+Complete & Tested:
+- Server and client roles pass all Autobahn v0.5.9 test suite tests strictly
+- Streaming UTF8 validation
+- random number generation
+- iostream based transport
+- C++11 support
+- LLVM/Clang support
+- GCC support
+- 64 bit support
+- 32 bit support
+- Logging
+- Client role
+- message_handler
+- ping_handler
+- pong_handler
+- open_handler
+- close_handler
+- echo_server & echo_server_tls
+- External io_service support
+- TLS support
+- exception/error handling
+- Timeouts
+- Subprotocol negotiation
+- validate_handler
+- Hybi 00/Hixie 76 legacy protocol support
+- Outgoing Proxy Support
+- socket_init_handler
+- tls_init_handler
+- tcp_init_handler
+
+Ongoing work
+- Performance tuning
+- PowerPC support
+- Visual Studio / Windows support
+- CMake build/install support
+- http_handler
+
+Future feature roadmap
+- Extension support
+- permessage_compress extension
+- Message buffer pool
+- flow control
+- tutorials & documentation

src/base64/base64.cpp

@@ -1,123 +0,0 @@
-/* 
-   base64.cpp and base64.h
-
-   Copyright (C) 2004-2008 René Nyffenegger
-
-   This source code is provided 'as-is', without any express or implied
-   warranty. In no event will the author be held liable for any damages
-   arising from the use of this software.
-
-   Permission is granted to anyone to use this software for any purpose,
-   including commercial applications, and to alter it and redistribute it
-   freely, subject to the following restrictions:
-
-   1. The origin of this source code must not be misrepresented; you must not
-      claim that you wrote the original source code. If you use this source code
-      in a product, an acknowledgment in the product documentation would be
-      appreciated but is not required.
-
-   2. Altered source versions must be plainly marked as such, and must not be
-      misrepresented as being the original source code.
-
-   3. This notice may not be removed or altered from any source distribution.
-
-   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-
-*/
-
-#include "base64.h"
-#include <iostream>
-
-static const std::string base64_chars = 
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789+/";
-
-
-static inline bool is_base64(unsigned char c) {
-  return (isalnum(c) || (c == '+') || (c == '/'));
-}
-
-std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
-  std::string ret;
-  int i = 0;
-  int j = 0;
-  unsigned char char_array_3[3];
-  unsigned char char_array_4[4];
-
-  while (in_len--) {
-    char_array_3[i++] = *(bytes_to_encode++);
-    if (i == 3) {
-      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
-      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
-      char_array_4[3] = char_array_3[2] & 0x3f;
-
-      for(i = 0; (i <4) ; i++)
-        ret += base64_chars[char_array_4[i]];
-      i = 0;
-    }
-  }
-
-  if (i)
-  {
-    for(j = i; j < 3; j++)
-      char_array_3[j] = '\0';
-
-    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
-    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
-    char_array_4[3] = char_array_3[2] & 0x3f;
-
-    for (j = 0; (j < i + 1); j++)
-      ret += base64_chars[char_array_4[j]];
-
-    while((i++ < 3))
-      ret += '=';
-
-  }
-
-  return ret;
-
-}
-
-std::string base64_decode(std::string const& encoded_string) {
-  size_t in_len = encoded_string.size();
-  int i = 0;
-  int j = 0;
-  int in_ = 0;
-  unsigned char char_array_4[4], char_array_3[3];
-  std::string ret;
-
-  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
-    char_array_4[i++] = encoded_string[in_]; in_++;
-    if (i ==4) {
-      for (i = 0; i <4; i++)
-        char_array_4[i] = base64_chars.find(char_array_4[i]);
-
-      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-      for (i = 0; (i < 3); i++)
-        ret += char_array_3[i];
-      i = 0;
-    }
-  }
-
-  if (i) {
-    for (j = i; j <4; j++)
-      char_array_4[j] = 0;
-
-    for (j = 0; j <4; j++)
-      char_array_4[j] = base64_chars.find(char_array_4[j]);
-
-    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
-  }
-
-  return ret;
-}

src/base64/base64.h

@@ -1,4 +0,0 @@
-#include <string>
-
-std::string base64_encode(unsigned char const* , unsigned int len);
-std::string base64_decode(std::string const& s);

src/network_utilities.cpp

@@ -1,175 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "network_utilities.hpp"
-
-uint64_t htonll(uint64_t src) { 
-	static int typ = TYP_INIT; 
-	unsigned char c; 
-	union { 
-		uint64_t ull; 
-		unsigned char c[8]; 
-	} x; 
-	if (typ == TYP_INIT) { 
-		x.ull = 0x01; 
-		typ = (x.c[7] == 0x01ULL) ? TYP_BIGE : TYP_SMLE; 
-	} 
-	if (typ == TYP_BIGE) 
-		return src; 
-	x.ull = src; 
-	c = x.c[0]; x.c[0] = x.c[7]; x.c[7] = c; 
-	c = x.c[1]; x.c[1] = x.c[6]; x.c[6] = c; 
-	c = x.c[2]; x.c[2] = x.c[5]; x.c[5] = c; 
-	c = x.c[3]; x.c[3] = x.c[4]; x.c[4] = c; 
-	return x.ull; 
-}
-
-uint64_t ntohll(uint64_t src) { 
-	return htonll(src);
-}
-
-std::string lookup_http_error_string(int code) {
-	switch (code) {
-		case 400:
-			return "Bad Request";
-		case 401:
-			return "Unauthorized";
-		case 403:
-			return "Forbidden";
-		case 404:
-			return "Not Found";
-		case 405:
-			return "Method Not Allowed";
-		case 406:
-			return "Not Acceptable";
-		case 407:
-			return "Proxy Authentication Required";
-		case 408:
-			return "Request Timeout";
-		case 409:
-			return "Conflict";
-		case 410:
-			return "Gone";
-		case 411:
-			return "Length Required";
-		case 412:
-			return "Precondition Failed";
-		case 413:
-			return "Request Entity Too Large";
-		case 414:
-			return "Request-URI Too Long";
-		case 415:
-			return "Unsupported Media Type";
-		case 416:
-			return "Requested Range Not Satisfiable";
-		case 417:
-			return "Expectation Failed";
-		case 500:
-			return "Internal Server Error";
-		case 501:
-			return "Not Implimented";
-		case 502:
-			return "Bad Gateway";
-		case 503:
-			return "Service Unavailable";
-		case 504:
-			return "Gateway Timeout";
-		case 505:
-			return "HTTP Version Not Supported";
-		default:
-			return "Unknown";
-	}
-}
-
-std::string lookup_ws_close_status_string(uint16_t code) {
-	switch (code) {
-		case 1000: 
-			return "Normal closure";
-		case 1001: 
-			return "Going away";
-		case 1002: 
-			return "Protocol error";
-		case 1003: 
-			return "Unacceptable data";
-		case 1004: 
-			return "Reserved";
-		case 1005: 
-			return "No status received";
-		case 1006: 
-			return "Abnormal closure";
-		case 1007: 
-			return "Invalid message data";
-		case 1008: 
-			return "Policy Violation";
-		case 1009: 
-			return "Message too large";
-		case 1010: 
-			return "Missing required extensions";
-		default:
-			return "Unknown";
-	}
-}
-
-bool websocketpp::ws_uri::parse(const std::string& uri) {
-	boost::cmatch what;
-	static const boost::regex expression("(ws|wss)://([^/:\\[]+|\\[[0-9:]+\\])(:\\d{1,5})?(/[^#]*)?");
-	
-	// TODO: should this split resource into path/query?
-	
-	if (boost::regex_match(uri.c_str(), what, expression)) {
-		if (what[1] == "wss") {
-			secure = true;
-		} else {
-			secure = false;
-		}
-		
-		host = what[2];
-
-		if (what[3] == "") {
-			port = (secure ? 443 : 80);
-		} else {
-			unsigned int t_port = atoi(std::string(what[3]).substr(1).c_str());
-
-			if (t_port > 65535) {
-				return false;
-			}
-
-			port = atoi(std::string(what[3]).substr(1).c_str());
-		}
-		
-		if (what[4] == "") {
-			resource = "/";
-		} else {
-			resource = what[4];
-		}
-
-		return true;
-	} else {
-		return false;
-	}
-
-}

src/sha1/Makefile

@@ -1,41 +0,0 @@
-#
-#  Makefile
-#  
-#  Copyright (C) 1998, 2009
-#  Paul E. Jones <paulej@packetizer.com>
-#  All Rights Reserved.
-#
-#############################################################################
-#  $Id: Makefile 12 2009-06-22 19:34:25Z paulej $
-#############################################################################
-#
-#  Description:
-#	This is a makefile for UNIX to build the programs sha, shacmp, and
-#	shatest
-#
-#
-
-CC	= g++
-
-CFLAGS	= -c -O2 -Wall -D_FILE_OFFSET_BITS=64
-
-LIBS	=
-
-OBJS	= sha1.o
-
-all: sha shacmp shatest
-
-sha: sha.o $(OBJS)
-	$(CC) -o $@ sha.o $(OBJS) $(LIBS)
-
-shacmp: shacmp.o $(OBJS)
-	$(CC) -o $@ shacmp.o $(OBJS) $(LIBS)
-
-shatest: shatest.o $(OBJS)
-	$(CC) -o $@ shatest.o $(OBJS) $(LIBS)
-
-%.o: %.cpp
-	$(CC) $(CFLAGS) -o $@ $<
-
-clean:
-	$(RM) *.o sha shacmp shatest

src/sha1/Makefile.nt

@@ -1,48 +0,0 @@
-#
-#  Makefile.nt
-#  
-#  Copyright (C) 1998, 2009
-#  Paul E. Jones <paulej@packetizer.com>
-#  All Rights Reserved.
-#
-#############################################################################
-#  $Id: Makefile.nt 13 2009-06-22 20:20:32Z paulej $
-#############################################################################
-#
-#  Description:
-#	This is a makefile for Win32 to build the programs sha, shacmp, and
-#	shatest
-#
-#  Portability Issues:
-#	Designed to work with Visual C++
-#
-#
-
-.silent:
-
-!include <win32.mak>
-
-RM	= del /q
-
-LIBS	= $(conlibs) setargv.obj
-
-CFLAGS	= -D _CRT_SECURE_NO_WARNINGS /EHsc /O2 /W3
-
-OBJS	= sha1.obj
-
-all: sha.exe shacmp.exe shatest.exe
-
-sha.exe: sha.obj $(OBJS)
-	$(link) $(conflags) -out:$@ sha.obj $(OBJS) $(LIBS)
-
-shacmp.exe: shacmp.obj $(OBJS)
-	$(link) $(conflags) -out:$@ shacmp.obj $(OBJS) $(LIBS)
-
-shatest.exe: shatest.obj $(OBJS)
-	$(link) $(conflags) -out:$@ shatest.obj $(OBJS) $(LIBS)
-
-.cpp.obj:
-	$(cc) $(CFLAGS) $(cflags) $(cvars) $<
-
-clean:
-	$(RM) *.obj sha.exe shacmp.exe shatest.exe

src/sha1/license.txt

@@ -1,14 +0,0 @@
-Copyright (C) 1998, 2009
-Paul E. Jones <paulej@packetizer.com>
-
-Freeware Public License (FPL)
-
-This software is licensed as "freeware."  Permission to distribute
-this software in source and binary forms, including incorporation 
-into other products, is hereby granted without a fee.  THIS SOFTWARE 
-IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESSED OR IMPLIED WARRANTIES, 
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
-AND FITNESS FOR A PARTICULAR PURPOSE.  THE AUTHOR SHALL NOT BE HELD 
-LIABLE FOR ANY DAMAGES RESULTING FROM THE USE OF THIS SOFTWARE, EITHER 
-DIRECTLY OR INDIRECTLY, INCLUDING, BUT NOT LIMITED TO, LOSS OF DATA 
-OR DATA BEING RENDERED INACCURATE.

src/sha1/sha.cpp

@@ -1,176 +0,0 @@
-/*
- *  sha.cpp
- *
- *  Copyright (C) 1998, 2009
- *  Paul E. Jones <paulej@packetizer.com>
- *  All Rights Reserved
- *
- *****************************************************************************
- *  $Id: sha.cpp 13 2009-06-22 20:20:32Z paulej $
- *****************************************************************************
- *
- *  Description:
- *      This utility will display the message digest (fingerprint) for
- *      the specified file(s).
- *
- *  Portability Issues:
- *      None.
- */
-
-#include <stdio.h>
-#include <string.h>
-#ifdef WIN32
-#include <io.h>
-#endif
-#include <fcntl.h>
-#include "sha1.h"
-
-/*
- *  Function prototype
- */
-void usage();
-
-
-/*  
- *  main
- *
- *  Description:
- *      This is the entry point for the program
- *
- *  Parameters:
- *      argc: [in]
- *          This is the count of arguments in the argv array
- *      argv: [in]
- *          This is an array of filenames for which to compute message digests
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-int main(int argc, char *argv[])
-{
-    SHA1        sha;                        // SHA-1 class
-    FILE        *fp;                        // File pointer for reading files
-    char        c;                          // Character read from file
-    unsigned    message_digest[5];          // Message digest from "sha"
-    int         i;                          // Counter
-    bool        reading_stdin;              // Are we reading standard in?
-    bool        read_stdin = false;         // Have we read stdin?
-
-    /*
-     *  Check the program arguments and print usage information if -?
-     *  or --help is passed as the first argument.
-     */
-    if (argc > 1 && (!strcmp(argv[1],"-?") || !strcmp(argv[1],"--help")))
-    {
-        usage();
-        return 1;
-    }
-
-    /*
-     *  For each filename passed in on the command line, calculate the
-     *  SHA-1 value and display it.
-     */
-    for(i = 0; i < argc; i++)
-    {
-        /*
-         *  We start the counter at 0 to guarantee entry into the for loop.
-         *  So if 'i' is zero, we will increment it now.  If there is no
-         *  argv[1], we will use STDIN below.
-         */
-        if (i == 0)
-        {
-            i++;
-        }
-
-        if (argc == 1 || !strcmp(argv[i],"-"))
-        {
-#ifdef WIN32
-            _setmode(_fileno(stdin), _O_BINARY);
-#endif
-            fp = stdin;
-            reading_stdin = true;
-        }
-        else
-        {
-            if (!(fp = fopen(argv[i],"rb")))
-            {
-                fprintf(stderr, "sha: unable to open file %s\n", argv[i]);
-                return 2;
-            }
-            reading_stdin = false;
-        }
-
-        /*
-         *  We do not want to read STDIN multiple times
-         */
-        if (reading_stdin)
-        {
-            if (read_stdin)
-            {
-                continue;
-            }
-
-            read_stdin = true;
-        }
-
-        /*
-         *  Reset the SHA1 object and process input
-         */
-        sha.Reset();
-
-        c = fgetc(fp);
-        while(!feof(fp))
-        {
-            sha.Input(c);
-            c = fgetc(fp);
-        }
-
-        if (!reading_stdin)
-        {
-            fclose(fp);
-        }
-
-        if (!sha.Result(message_digest))
-        {
-            fprintf(stderr,"sha: could not compute message digest for %s\n",
-                    reading_stdin?"STDIN":argv[i]);
-        }
-        else
-        {
-            printf( "%08X %08X %08X %08X %08X - %s\n",
-                    message_digest[0],
-                    message_digest[1],
-                    message_digest[2],
-                    message_digest[3],
-                    message_digest[4],
-                    reading_stdin?"STDIN":argv[i]);
-        }
-    }
-
-    return 0;
-}
-
-/*  
- *  usage
- *
- *  Description:
- *      This function will display program usage information to the user.
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void usage()
-{
-    printf("usage: sha <file> [<file> ...]\n");
-    printf("\tThis program will display the message digest (fingerprint)\n");
-    printf("\tfor files using the Secure Hashing Algorithm (SHA-1).\n");
-}

src/sha1/sha1.cpp

@@ -1,589 +0,0 @@
-/*
- *  sha1.cpp
- *
- *  Copyright (C) 1998, 2009
- *  Paul E. Jones <paulej@packetizer.com>
- *  All Rights Reserved.
- *
- *****************************************************************************
- *  $Id: sha1.cpp 12 2009-06-22 19:34:25Z paulej $
- *****************************************************************************
- *
- *  Description:
- *      This class implements the Secure Hashing Standard as defined
- *      in FIPS PUB 180-1 published April 17, 1995.
- *
- *      The Secure Hashing Standard, which uses the Secure Hashing
- *      Algorithm (SHA), produces a 160-bit message digest for a
- *      given data stream.  In theory, it is highly improbable that
- *      two messages will produce the same message digest.  Therefore,
- *      this algorithm can serve as a means of providing a "fingerprint"
- *      for a message.
- *
- *  Portability Issues:
- *      SHA-1 is defined in terms of 32-bit "words".  This code was
- *      written with the expectation that the processor has at least
- *      a 32-bit machine word size.  If the machine word size is larger,
- *      the code should still function properly.  One caveat to that
- *      is that the input functions taking characters and character arrays
- *      assume that only 8 bits of information are stored in each character.
- *
- *  Caveats:
- *      SHA-1 is designed to work with messages less than 2^64 bits long.
- *      Although SHA-1 allows a message digest to be generated for
- *      messages of any number of bits less than 2^64, this implementation
- *      only works with messages with a length that is a multiple of 8
- *      bits.
- *
- */
-
-
-#include "sha1.h"
-
-/*  
- *  SHA1
- *
- *  Description:
- *      This is the constructor for the sha1 class.
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-SHA1::SHA1()
-{
-    Reset();
-}
-
-/*  
- *  ~SHA1
- *
- *  Description:
- *      This is the destructor for the sha1 class
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-SHA1::~SHA1()
-{
-    // The destructor does nothing
-}
-
-/*  
- *  Reset
- *
- *  Description:
- *      This function will initialize the sha1 class member variables
- *      in preparation for computing a new message digest.
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void SHA1::Reset()
-{
-    Length_Low          = 0;
-    Length_High         = 0;
-    Message_Block_Index = 0;
-
-    H[0]        = 0x67452301;
-    H[1]        = 0xEFCDAB89;
-    H[2]        = 0x98BADCFE;
-    H[3]        = 0x10325476;
-    H[4]        = 0xC3D2E1F0;
-
-    Computed    = false;
-    Corrupted   = false;
-}
-
-/*  
- *  Result
- *
- *  Description:
- *      This function will return the 160-bit message digest into the
- *      array provided.
- *
- *  Parameters:
- *      message_digest_array: [out]
- *          This is an array of five unsigned integers which will be filled
- *          with the message digest that has been computed.
- *
- *  Returns:
- *      True if successful, false if it failed.
- *
- *  Comments:
- *
- */
-bool SHA1::Result(unsigned *message_digest_array)
-{
-    int i;                                  // Counter
-
-    if (Corrupted)
-    {
-        return false;
-    }
-
-    if (!Computed)
-    {
-        PadMessage();
-        Computed = true;
-    }
-
-    for(i = 0; i < 5; i++)
-    {
-        message_digest_array[i] = H[i];
-    }
-
-    return true;
-}
-
-/*  
- *  Input
- *
- *  Description:
- *      This function accepts an array of octets as the next portion of
- *      the message.
- *
- *  Parameters:
- *      message_array: [in]
- *          An array of characters representing the next portion of the
- *          message.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void SHA1::Input(   const unsigned char *message_array,
-                    unsigned            length)
-{
-    if (!length)
-    {
-        return;
-    }
-
-    if (Computed || Corrupted)
-    {
-        Corrupted = true;
-        return;
-    }
-
-    while(length-- && !Corrupted)
-    {
-        Message_Block[Message_Block_Index++] = (*message_array & 0xFF);
-
-        Length_Low += 8;
-        Length_Low &= 0xFFFFFFFF;               // Force it to 32 bits
-        if (Length_Low == 0)
-        {
-            Length_High++;
-            Length_High &= 0xFFFFFFFF;          // Force it to 32 bits
-            if (Length_High == 0)
-            {
-                Corrupted = true;               // Message is too long
-            }
-        }
-
-        if (Message_Block_Index == 64)
-        {
-            ProcessMessageBlock();
-        }
-
-        message_array++;
-    }
-}
-
-/*  
- *  Input
- *
- *  Description:
- *      This function accepts an array of octets as the next portion of
- *      the message.
- *
- *  Parameters:
- *      message_array: [in]
- *          An array of characters representing the next portion of the
- *          message.
- *      length: [in]
- *          The length of the message_array
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void SHA1::Input(   const char  *message_array,
-                    unsigned    length)
-{
-    Input((unsigned char *) message_array, length);
-}
-
-/*  
- *  Input
- *
- *  Description:
- *      This function accepts a single octets as the next message element.
- *
- *  Parameters:
- *      message_element: [in]
- *          The next octet in the message.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void SHA1::Input(unsigned char message_element)
-{
-    Input(&message_element, 1);
-}
-
-/*  
- *  Input
- *
- *  Description:
- *      This function accepts a single octet as the next message element.
- *
- *  Parameters:
- *      message_element: [in]
- *          The next octet in the message.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void SHA1::Input(char message_element)
-{
-    Input((unsigned char *) &message_element, 1);
-}
-
-/*  
- *  operator<<
- *
- *  Description:
- *      This operator makes it convenient to provide character strings to
- *      the SHA1 object for processing.
- *
- *  Parameters:
- *      message_array: [in]
- *          The character array to take as input.
- *
- *  Returns:
- *      A reference to the SHA1 object.
- *
- *  Comments:
- *      Each character is assumed to hold 8 bits of information.
- *
- */
-SHA1& SHA1::operator<<(const char *message_array)
-{
-    const char *p = message_array;
-
-    while(*p)
-    {
-        Input(*p);
-        p++;
-    }
-
-    return *this;
-}
-
-/*  
- *  operator<<
- *
- *  Description:
- *      This operator makes it convenient to provide character strings to
- *      the SHA1 object for processing.
- *
- *  Parameters:
- *      message_array: [in]
- *          The character array to take as input.
- *
- *  Returns:
- *      A reference to the SHA1 object.
- *
- *  Comments:
- *      Each character is assumed to hold 8 bits of information.
- *
- */
-SHA1& SHA1::operator<<(const unsigned char *message_array)
-{
-    const unsigned char *p = message_array;
-
-    while(*p)
-    {
-        Input(*p);
-        p++;
-    }
-
-    return *this;
-}
-
-/*  
- *  operator<<
- *
- *  Description:
- *      This function provides the next octet in the message.
- *
- *  Parameters:
- *      message_element: [in]
- *          The next octet in the message
- *
- *  Returns:
- *      A reference to the SHA1 object.
- *
- *  Comments:
- *      The character is assumed to hold 8 bits of information.
- *
- */
-SHA1& SHA1::operator<<(const char message_element)
-{
-    Input((unsigned char *) &message_element, 1);
-
-    return *this;
-}
-
-/*  
- *  operator<<
- *
- *  Description:
- *      This function provides the next octet in the message.
- *
- *  Parameters:
- *      message_element: [in]
- *          The next octet in the message
- *
- *  Returns:
- *      A reference to the SHA1 object.
- *
- *  Comments:
- *      The character is assumed to hold 8 bits of information.
- *
- */
-SHA1& SHA1::operator<<(const unsigned char message_element)
-{
-    Input(&message_element, 1);
-
-    return *this;
-}
-
-/*  
- *  ProcessMessageBlock
- *
- *  Description:
- *      This function will process the next 512 bits of the message
- *      stored in the Message_Block array.
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *      Many of the variable names in this function, especially the single
- *      character names, were used because those were the names used
- *      in the publication.
- *
- */
-void SHA1::ProcessMessageBlock()
-{
-    const unsigned K[] =    {               // Constants defined for SHA-1
-                                0x5A827999,
-                                0x6ED9EBA1,
-                                0x8F1BBCDC,
-                                0xCA62C1D6
-                            };
-    int         t;                          // Loop counter
-    unsigned    temp;                       // Temporary word value
-    unsigned    W[80];                      // Word sequence
-    unsigned    A, B, C, D, E;              // Word buffers
-
-    /*
-     *  Initialize the first 16 words in the array W
-     */
-    for(t = 0; t < 16; t++)
-    {
-        W[t] = ((unsigned) Message_Block[t * 4]) << 24;
-        W[t] |= ((unsigned) Message_Block[t * 4 + 1]) << 16;
-        W[t] |= ((unsigned) Message_Block[t * 4 + 2]) << 8;
-        W[t] |= ((unsigned) Message_Block[t * 4 + 3]);
-    }
-
-    for(t = 16; t < 80; t++)
-    {
-       W[t] = CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
-    }
-
-    A = H[0];
-    B = H[1];
-    C = H[2];
-    D = H[3];
-    E = H[4];
-
-    for(t = 0; t < 20; t++)
-    {
-        temp = CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
-        temp &= 0xFFFFFFFF;
-        E = D;
-        D = C;
-        C = CircularShift(30,B);
-        B = A;
-        A = temp;
-    }
-
-    for(t = 20; t < 40; t++)
-    {
-        temp = CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
-        temp &= 0xFFFFFFFF;
-        E = D;
-        D = C;
-        C = CircularShift(30,B);
-        B = A;
-        A = temp;
-    }
-
-    for(t = 40; t < 60; t++)
-    {
-        temp = CircularShift(5,A) +
-               ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
-        temp &= 0xFFFFFFFF;
-        E = D;
-        D = C;
-        C = CircularShift(30,B);
-        B = A;
-        A = temp;
-    }
-
-    for(t = 60; t < 80; t++)
-    {
-        temp = CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
-        temp &= 0xFFFFFFFF;
-        E = D;
-        D = C;
-        C = CircularShift(30,B);
-        B = A;
-        A = temp;
-    }
-
-    H[0] = (H[0] + A) & 0xFFFFFFFF;
-    H[1] = (H[1] + B) & 0xFFFFFFFF;
-    H[2] = (H[2] + C) & 0xFFFFFFFF;
-    H[3] = (H[3] + D) & 0xFFFFFFFF;
-    H[4] = (H[4] + E) & 0xFFFFFFFF;
-
-    Message_Block_Index = 0;
-}
-
-/*  
- *  PadMessage
- *
- *  Description:
- *      According to the standard, the message must be padded to an even
- *      512 bits.  The first padding bit must be a '1'.  The last 64 bits
- *      represent the length of the original message.  All bits in between
- *      should be 0.  This function will pad the message according to those
- *      rules by filling the message_block array accordingly.  It will also
- *      call ProcessMessageBlock() appropriately.  When it returns, it
- *      can be assumed that the message digest has been computed.
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void SHA1::PadMessage()
-{
-    /*
-     *  Check to see if the current message block is too small to hold
-     *  the initial padding bits and length.  If so, we will pad the
-     *  block, process it, and then continue padding into a second block.
-     */
-    if (Message_Block_Index > 55)
-    {
-        Message_Block[Message_Block_Index++] = 0x80;
-        while(Message_Block_Index < 64)
-        {
-            Message_Block[Message_Block_Index++] = 0;
-        }
-
-        ProcessMessageBlock();
-
-        while(Message_Block_Index < 56)
-        {
-            Message_Block[Message_Block_Index++] = 0;
-        }
-    }
-    else
-    {
-        Message_Block[Message_Block_Index++] = 0x80;
-        while(Message_Block_Index < 56)
-        {
-            Message_Block[Message_Block_Index++] = 0;
-        }
-
-    }
-
-    /*
-     *  Store the message length as the last 8 octets
-     */
-    Message_Block[56] = (Length_High >> 24) & 0xFF;
-    Message_Block[57] = (Length_High >> 16) & 0xFF;
-    Message_Block[58] = (Length_High >> 8) & 0xFF;
-    Message_Block[59] = (Length_High) & 0xFF;
-    Message_Block[60] = (Length_Low >> 24) & 0xFF;
-    Message_Block[61] = (Length_Low >> 16) & 0xFF;
-    Message_Block[62] = (Length_Low >> 8) & 0xFF;
-    Message_Block[63] = (Length_Low) & 0xFF;
-
-    ProcessMessageBlock();
-}
-
-
-/*  
- *  CircularShift
- *
- *  Description:
- *      This member function will perform a circular shifting operation.
- *
- *  Parameters:
- *      bits: [in]
- *          The number of bits to shift (1-31)
- *      word: [in]
- *          The value to shift (assumes a 32-bit integer)
- *
- *  Returns:
- *      The shifted value.
- *
- *  Comments:
- *
- */
-unsigned SHA1::CircularShift(int bits, unsigned word)
-{
-    return ((word << bits) & 0xFFFFFFFF) | ((word & 0xFFFFFFFF) >> (32-bits));
-}

src/sha1/sha1.h

@@ -1,89 +0,0 @@
-/*
- *  sha1.h
- *
- *  Copyright (C) 1998, 2009
- *  Paul E. Jones <paulej@packetizer.com>
- *  All Rights Reserved.
- *
- *****************************************************************************
- *  $Id: sha1.h 12 2009-06-22 19:34:25Z paulej $
- *****************************************************************************
- *
- *  Description:
- *      This class implements the Secure Hashing Standard as defined
- *      in FIPS PUB 180-1 published April 17, 1995.
- *
- *      Many of the variable names in this class, especially the single
- *      character names, were used because those were the names used
- *      in the publication.
- *
- *      Please read the file sha1.cpp for more information.
- *
- */
-
-#ifndef _SHA1_H_
-#define _SHA1_H_
-
-class SHA1
-{
-
-    public:
-
-        SHA1();
-        virtual ~SHA1();
-
-        /*
-         *  Re-initialize the class
-         */
-        void Reset();
-
-        /*
-         *  Returns the message digest
-         */
-        bool Result(unsigned *message_digest_array);
-
-        /*
-         *  Provide input to SHA1
-         */
-        void Input( const unsigned char *message_array,
-                    unsigned            length);
-        void Input( const char  *message_array,
-                    unsigned    length);
-        void Input(unsigned char message_element);
-        void Input(char message_element);
-        SHA1& operator<<(const char *message_array);
-        SHA1& operator<<(const unsigned char *message_array);
-        SHA1& operator<<(const char message_element);
-        SHA1& operator<<(const unsigned char message_element);
-
-    private:
-
-        /*
-         *  Process the next 512 bits of the message
-         */
-        void ProcessMessageBlock();
-
-        /*
-         *  Pads the current message block to 512 bits
-         */
-        void PadMessage();
-
-        /*
-         *  Performs a circular left shift operation
-         */
-        inline unsigned CircularShift(int bits, unsigned word);
-
-        unsigned H[5];                      // Message digest buffers
-
-        unsigned Length_Low;                // Message length in bits
-        unsigned Length_High;               // Message length in bits
-
-        unsigned char Message_Block[64];    // 512-bit message blocks
-        int Message_Block_Index;            // Index into message block array
-
-        bool Computed;                      // Is the digest computed?
-        bool Corrupted;                     // Is the message digest corruped?
-    
-};
-
-#endif

src/sha1/shacmp.cpp

@@ -1,169 +0,0 @@
-/*
- *  shacmp.cpp
- *
- *  Copyright (C) 1998, 2009
- *  Paul E. Jones <paulej@packetizer.com>
- *  All Rights Reserved
- *
- *****************************************************************************
- *  $Id: shacmp.cpp 12 2009-06-22 19:34:25Z paulej $
- *****************************************************************************
- *
- *  Description:
- *      This utility will compare two files by producing a message digest
- *      for each file using the Secure Hashing Algorithm and comparing
- *      the message digests.  This function will return 0 if they
- *      compare or 1 if they do not or if there is an error.
- *      Errors result in a return code higher than 1.
- *
- *  Portability Issues:
- *      none.
- *
- */
-
-#include <stdio.h>
-#include <string.h>
-#include "sha1.h"
-
-/*
- *  Return codes
- */
-#define SHA1_COMPARE        0
-#define SHA1_NO_COMPARE     1
-#define SHA1_USAGE_ERROR    2
-#define SHA1_FILE_ERROR     3
-
-/*
- *  Function prototype
- */
-void usage();
-
-/*  
- *  main
- *
- *  Description:
- *      This is the entry point for the program
- *
- *  Parameters:
- *      argc: [in]
- *          This is the count of arguments in the argv array
- *      argv: [in]
- *          This is an array of filenames for which to compute message digests
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-int main(int argc, char *argv[])
-{
-    SHA1        sha;                        // SHA-1 class
-    FILE        *fp;                        // File pointer for reading files
-    char        c;                          // Character read from file
-    unsigned    message_digest[2][5];       // Message digest for files
-    int         i;                          // Counter
-    bool        message_match;              // Message digest match flag
-    int         returncode;
-
-    /*
-     *  If we have two arguments, we will assume they are filenames.  If
-     *  we do not have to arguments, call usage() and exit.
-     */
-    if (argc != 3)
-    {
-        usage();
-        return SHA1_USAGE_ERROR;
-    }
-
-    /*
-     *  Get the message digests for each file
-     */
-    for(i = 1; i <= 2; i++)
-    {
-        sha.Reset();
-
-        if (!(fp = fopen(argv[i],"rb")))
-        {
-            fprintf(stderr, "sha: unable to open file %s\n", argv[i]);
-            return SHA1_FILE_ERROR;
-        }
-
-        c = fgetc(fp);
-        while(!feof(fp))
-        {
-            sha.Input(c);
-            c = fgetc(fp);
-        }
-
-        fclose(fp);
-
-        if (!sha.Result(message_digest[i-1]))
-        {
-            fprintf(stderr,"shacmp: could not compute message digest for %s\n",
-                    argv[i]);
-            return SHA1_FILE_ERROR;
-        }
-    }
-
-    /*
-     *  Compare the message digest values
-     */
-    message_match = true;
-    for(i = 0; i < 5; i++)
-    {
-        if (message_digest[0][i] != message_digest[1][i])
-        {
-            message_match = false;
-            break;
-        }
-    }
-
-    if (message_match)
-    {
-        printf("Fingerprints match:\n");
-        returncode = SHA1_COMPARE;
-    }
-    else
-    {
-        printf("Fingerprints do not match:\n");
-        returncode = SHA1_NO_COMPARE;
-    }
-
-    printf( "\t%08X %08X %08X %08X %08X\n",
-            message_digest[0][0],
-            message_digest[0][1],
-            message_digest[0][2],
-            message_digest[0][3],
-            message_digest[0][4]);
-    printf( "\t%08X %08X %08X %08X %08X\n",
-            message_digest[1][0],
-            message_digest[1][1],
-            message_digest[1][2],
-            message_digest[1][3],
-            message_digest[1][4]);
-
-    return returncode;
-}
-
-/*  
- *  usage
- *
- *  Description:
- *      This function will display program usage information to the user.
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void usage()
-{
-    printf("usage: shacmp <file> <file>\n");
-    printf("\tThis program will compare the message digests (fingerprints)\n");
-    printf("\tfor two files using the Secure Hashing Algorithm (SHA-1).\n");
-}

src/sha1/shatest.cpp

@@ -1,149 +0,0 @@
-/*
- *  shatest.cpp
- *
- *  Copyright (C) 1998, 2009
- *  Paul E. Jones <paulej@packetizer.com>
- *  All Rights Reserved
- *
- *****************************************************************************
- *  $Id: shatest.cpp 12 2009-06-22 19:34:25Z paulej $
- *****************************************************************************
- *
- *  Description:
- *      This file will exercise the SHA1 class and perform the three
- *      tests documented in FIPS PUB 180-1.
- *
- *  Portability Issues:
- *      None.
- *
- */
-
-#include <iostream>
-#include "sha1.h"
-
-using namespace std;
-
-/*
- *  Define patterns for testing
- */
-#define TESTA   "abc"
-#define TESTB   "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
-
-/*
- *  Function prototype
- */
-void DisplayMessageDigest(unsigned *message_digest);
-
-/*  
- *  main
- *
- *  Description:
- *      This is the entry point for the program
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-int main()
-{
-    SHA1        sha;
-    unsigned    message_digest[5];
-
-    /*
-     *  Perform test A
-     */
-    cout << endl << "Test A: 'abc'" << endl;
-
-    sha.Reset();
-    sha << TESTA;
-
-    if (!sha.Result(message_digest))
-    {
-        cerr << "ERROR-- could not compute message digest" << endl;
-    }
-    else
-    {
-        DisplayMessageDigest(message_digest);
-        cout << "Should match:" << endl;
-        cout << '\t' << "A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D" << endl;
-    }
-
-    /*
-     *  Perform test B
-     */
-    cout << endl << "Test B: " << TESTB << endl;
-
-    sha.Reset();
-    sha << TESTB;
-
-    if (!sha.Result(message_digest))
-    {
-        cerr << "ERROR-- could not compute message digest" << endl;
-    }
-    else
-    {
-        DisplayMessageDigest(message_digest);
-        cout << "Should match:" << endl;
-        cout << '\t' << "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1" << endl;
-    }
-
-    /*
-     *  Perform test C
-     */
-    cout << endl << "Test C: One million 'a' characters" << endl;
-
-    sha.Reset();
-    for(int i = 1; i <= 1000000; i++) sha.Input('a');
-
-    if (!sha.Result(message_digest))
-    {
-        cerr << "ERROR-- could not compute message digest" << endl;
-    }
-    else
-    {
-        DisplayMessageDigest(message_digest);
-        cout << "Should match:" << endl;
-        cout << '\t' << "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F" << endl;
-    }
-
-    return 0;
-}
-
-/*  
- *  DisplayMessageDigest
- *
- *  Description:
- *      Display Message Digest array
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *
- */
-void DisplayMessageDigest(unsigned *message_digest)
-{
-    ios::fmtflags   flags;
-
-    cout << '\t';
-
-    flags = cout.setf(ios::hex|ios::uppercase,ios::basefield);
-    cout.setf(ios::uppercase);
-
-    for(int i = 0; i < 5 ; i++)
-    {
-        cout << message_digest[i] << ' ';
-    }
-
-    cout << endl;
-
-    cout.setf(flags);
-}

src/utf8_validator/utf8_validator.hpp

@@ -1,40 +0,0 @@
-// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
-
-#include <stdint.h>
-
-namespace utf8_validator {
-
-static const int UTF8_ACCEPT = 0;
-static const int UTF8_REJECT = 1;
-
-static const uint8_t utf8d[] = {
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
-  8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
-  0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
-  0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
-  0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2
-  1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4
-  1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6
-  1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
-};
-
-uint32_t inline
-decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
-  uint32_t type = utf8d[byte];
-
-  *codep = (*state != UTF8_ACCEPT) ?
-    (byte & 0x3fu) | (*codep << 6) :
-    (0xff >> type) & (byte);
-
-  *state = utf8d[256 + *state*16 + type];
-  return *state;
-}
-
-} // namespace utf8_validator

src/websocket_client.cpp

@@ -1,200 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "websocket_client.hpp"
-
-#include <boost/bind.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-#include <iostream>
-
-using websocketpp::client;
-using boost::asio::ip::tcp;
-
-client::client(boost::asio::io_service& io_service,
-               websocketpp::connection_handler_ptr defc)
-	: m_elog_level(LOG_OFF),
-	  m_alog_level(ALOG_OFF),
-	  m_state(CLIENT_STATE_NULL),
-	  m_max_message_size(DEFAULT_MAX_MESSAGE_SIZE),
-	  m_io_service(io_service),
-	  m_resolver(io_service),
-	  m_def_con_handler(defc) {}
-
-void client::init() {
-	// TODO: sanity check whether the session buffer size bound could be reduced
-	m_client_session = client_session_ptr(
-		new client_session(
-	    	shared_from_this(),
-			m_io_service,
-			m_def_con_handler,
-			m_max_message_size*2
-		)
-	);
-	m_state = CLIENT_STATE_INITIALIZED;
-}
-
-void client::connect(const std::string& uri) {
-	if (m_state != CLIENT_STATE_INITIALIZED) {
-		throw client_error("connect can only be called after init and before a connection has been established");
-	}
-	
-	m_client_session->set_uri(uri);
-	
-	std::stringstream port;
-	port << m_client_session->get_port();
-
-
-	tcp::resolver::query query(m_client_session->get_host(),
-	                           port.str());
-	tcp::resolver::iterator iterator = m_resolver.resolve(query);
-	
-	boost::asio::async_connect(m_client_session->socket(),
-	                           iterator,boost::bind(&client::handle_connect,
-							   this,
-							   boost::asio::placeholders::error)); 
-	m_state = CLIENT_STATE_CONNECTING;
-}
-
-
-void client::add_subprotocol(const std::string& p) {
-	if (m_state != CLIENT_STATE_INITIALIZED) {
-		throw client_error("add_protocol can only be called after init and before connect");
-	}
-	m_client_session->add_subprotocol(p);
-}
-
-void client::set_header(const std::string& key,const std::string& val) {
-	if (m_state != CLIENT_STATE_INITIALIZED) {
-		throw client_error("set_header can only be called after init and before connect");
-	}
-	m_client_session->set_header(key,val);
-}
-
-void client::set_origin(const std::string& val) {
-	if (m_state != CLIENT_STATE_INITIALIZED) {
-		throw client_error("set_origin can only be called after init and before connect");
-	}
-	m_client_session->set_origin(val);
-}
-
-
-void client::set_max_message_size(uint64_t val) {
-	if (val > frame::PAYLOAD_64BIT_LIMIT) {
-		std::stringstream err;
-		err << "Invalid maximum message size: " << val;
-		
-		// TODO: Figure out what the ideal error behavior for this method.
-		// Options:
-		//   Throw exception
-		//   Log error and set value to maximum allowed
-		//   Log error and leave value at whatever it was before
-		log(err.str(),LOG_WARN);
-		//throw client_error(err.str());
-	}
-	m_max_message_size = val;
-}
-
-bool client::test_elog_level(uint16_t level) {
-	return (level >= m_elog_level);
-}
-void client::set_elog_level(uint16_t level) {
-	std::stringstream msg;
-	msg << "Error logging level changing from " 
-	    << m_elog_level << " to " << level;
-	log(msg.str(),LOG_INFO);
-
-	m_elog_level = level;
-}
-bool client::test_alog_level(uint16_t level) {
-	return ((level & m_alog_level) != 0);
-}
-void client::set_alog_level(uint16_t level) {
-	if (test_alog_level(level)) {
-		return;
-	}
-	std::stringstream msg;
-	msg << "Access logging level " << level << " being set"; 
-	access_log(msg.str(),ALOG_INFO);
-
-	m_alog_level |= level;
-}
-void client::unset_alog_level(uint16_t level) {
-	if (!test_alog_level(level)) {
-		return;
-	}
-	std::stringstream msg;
-	msg << "Access logging level " << level << " being unset"; 
-	access_log(msg.str(),ALOG_INFO);
-
-	m_alog_level &= ~level;
-}
-
-bool client::validate_message_size(uint64_t val) {
-	if (val > m_max_message_size) {
-		return false;
-	}
-	return true;
-}
-
-void client::log(std::string msg,uint16_t level) {
-	if (!test_elog_level(level)) {
-		return;
-	}
-	std::cerr << "[Error Log] "
-	          << boost::posix_time::to_iso_extended_string(
-			         boost::posix_time::second_clock::local_time())
-              << " " << msg << std::endl;
-}
-void client::access_log(std::string msg,uint16_t level) {
-	if (!test_alog_level(level)) {
-		return;
-	}
-	std::cout << "[Access Log] " 
-	          << boost::posix_time::to_iso_extended_string(
-			         boost::posix_time::second_clock::local_time())
-              << " " << msg << std::endl;
-}
-
-void client::handle_connect(const boost::system::error_code& error) {
-	if (!error) {
-		std::stringstream err;
-		err << "Successful Connection ";
-		log(err.str(),LOG_ERROR);
-		
-		std::cout << boost::posix_time::to_iso_extended_string(boost::posix_time::microsec_clock::local_time()) << " TCP established" << std::endl;
-		
-		m_state = CLIENT_STATE_CONNECTED;
-		m_client_session->on_connect();
-	} else {
-		std::stringstream err;
-		err << "An error occurred while establishing a connection: " << error;
-		
-		log(err.str(),LOG_ERROR);
-		throw client_error(err.str());
-	}
-}

src/websocket_client.hpp

@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#ifndef WEBSOCKET_CLIENT_HPP
-#define WEBSOCKET_CLIENT_HPP
-
-#include <boost/asio.hpp>
-#include <boost/shared_ptr.hpp>
-
-#include <set>
-
-namespace websocketpp {
-	class client;
-	typedef boost::shared_ptr<client> client_ptr;
-}
-
-#include "websocketpp.hpp"
-#include "websocket_client_session.hpp"
-#include "websocket_connection_handler.hpp"
-
-using boost::asio::ip::tcp;
-
-namespace websocketpp {
-
-class client_error : public std::exception {
-public:	
-	client_error(const std::string& msg)
-		: m_msg(msg) {}
-	~client_error() throw() {}
-	
-	virtual const char* what() const throw() {
-		return m_msg.c_str();
-	}
-private:
-	std::string m_msg;
-};
-
-class client : public boost::enable_shared_from_this<client> {
-	public:
-		static const uint16_t CLIENT_STATE_NULL = 0;
-		static const uint16_t CLIENT_STATE_INITIALIZED = 1;
-		static const uint16_t CLIENT_STATE_CONNECTING = 2;
-		static const uint16_t CLIENT_STATE_CONNECTED = 3;
-
-		client(boost::asio::io_service& io_service,
-			   connection_handler_ptr defc);
-
-		// INTERFACE FOR LOCAL APPLICATIONS
-		
-		// initializes the session. Methods that affect the opening handshake
-		// such as add_protocol and set_header must be called after init and
-		// before connect.
-		void init();
-
-		// starts the connection process. Should be called before 
-		// io_service.run(), connection process will not start until run() has
-		// been called.
-		void connect(const std::string& url);
-		
-		// Adds a protocol to the opening handshake.
-		// Must be called before connect
-		void add_subprotocol(const std::string& p);
-		
-		// Sets the value of the given HTTP header to be sent during the 
-		// opening handshake. Must be called before connect
-		void set_header(const std::string& key,const std::string& val);
-		
-		void set_origin(const std::string& val);
-
-		void set_max_message_size(uint64_t val);
-		
-		// Test methods determine if a message of the given level should be 
-		// written. elog shows all values above the level set. alog shows only
-		// the values explicitly set.
-		bool test_elog_level(uint16_t level);
-		void set_elog_level(uint16_t level);
-		
-		bool test_alog_level(uint16_t level);
-		void set_alog_level(uint16_t level);
-		void unset_alog_level(uint16_t level);
-
-		// INTERFACE FOR SESSIONS
-
-		// Check if message size is within server's acceptable parameters
-		bool validate_message_size(uint64_t val);
-		
-		// write to the server's logs
-		void log(std::string msg,uint16_t level = LOG_ERROR);
-		void access_log(std::string msg,uint16_t level);
-	private:
-		// if no errors starts the session's read loop and returns to the
-		// start_accept phase.
-		void handle_connect(const boost::system::error_code& error);
-		
-	private:
-		uint16_t					m_elog_level;
-		uint16_t					m_alog_level;
-		
-		uint16_t					m_state;
-
-		std::set<std::string>		m_hosts;
-		uint64_t					m_max_message_size;
-		boost::asio::io_service&	m_io_service;
-		tcp::resolver				m_resolver;
-		client_session_ptr			m_client_session;
-		connection_handler_ptr		m_def_con_handler;
-};
-
-}
-
-#endif // WEBSOCKET_CLIENT_HPP

src/websocket_client_session.cpp

@@ -1,350 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- */
-
-#include "websocketpp.hpp"
-#include "websocket_client_session.hpp"
-
-#include "websocket_frame.hpp"
-#include "utf8_validator/utf8_validator.hpp"
-
-#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/random.hpp>
-#include <boost/random/random_device.hpp>
-
-
-#include <cstdlib>
-#include <iostream>
-#include <sstream>
-#include <string>
-
-using websocketpp::client_session;
-
-client_session::client_session (websocketpp::client_ptr c,
-                                boost::asio::io_service& io_service,
-                                websocketpp::connection_handler_ptr defc,
-								uint64_t buf_size)
-	: session(io_service,defc,buf_size),m_client(c) {}
-
-void client_session::on_connect() {
-	// TODO: section 4.1: Figure out if we have another connection to this 
-	// host/port pending.
-	write_handshake();
-}
-
-void client_session::set_uri(const std::string& uri) {
-	if (!m_uri.parse(uri)) {
-		throw client_error("Invalid WebSocket URI");
-	}
-
-	if (m_uri.secure) {
-		throw client_error("wss / secure connections are not supported at this time");
-	}
-	
-	m_resource = m_uri.resource;
-	
-	std::stringstream l;
-	
-	l << "parsed websocket url: secure: " << m_uri.secure << " host: " << m_uri.host
-	  << " port (final): " << m_uri.port << " resource " << m_uri.resource;
-	
-	log(l.str(),LOG_DEBUG);
-}
-
-bool client_session::get_secure() const {
-	return m_uri.secure;
-}
-
-std::string client_session::get_host() const{
-	return m_uri.host;
-}
-
-uint16_t client_session::get_port() const {
-	return m_uri.port;
-}
-
-void client_session::set_header(const std::string &key,const std::string &val) {
-	// TODO: prevent use of reserved headers
-	m_client_headers[key] = val;
-}
-
-void client_session::set_origin(const std::string& val) {
-	// TODO: input validation
-	m_client_origin = val;
-}
-
-void client_session::add_subprotocol(const std::string &val) {
-	// TODO: input validation
-	m_client_subprotocols.push_back(val);
-}
-
-void client_session::add_extension(const std::string& val) {
-	// TODO: input validation
-	m_client_extensions.push_back(val);
-}
-
-void client_session::read_handshake() {
-	boost::asio::async_read_until(
-		m_socket,
-		m_buf,
-			"\r\n\r\n",
-		boost::bind(
-			&session::handle_read_handshake,
-			shared_from_this(),
-			boost::asio::placeholders::error,
-			boost::asio::placeholders::bytes_transferred
-		)
-	);
-}
-
-void client_session::handle_read_handshake(const boost::system::error_code& e,
-	std::size_t bytes_transferred) {
-	
-	if (e) {
-		log_error("Error reading server handshake",e);
-		drop_tcp();
-		return;
-	}
-	
-	// parse server handshake
-	std::istream response_stream(&m_buf);
-	std::string header;
-	std::string::size_type end;
-	
-	// get status line
-	std::getline(response_stream, header);
-	if (header[header.size()-1] == '\r') {
-		header.erase(header.end()-1);
-		m_server_http_request = header;
-		m_raw_server_handshake += header+"\n";
-	}
-	
-	// get headers
-	while (std::getline(response_stream, header) && header != "\r") {
-		if (header[header.size()-1] != '\r') {
-			continue; // ignore malformed header lines?
-		} else {
-			header.erase(header.end()-1);
-		}
-		
-		end = header.find(": ",0);
-		
-		if (end != std::string::npos) {			
-			std::string h = header.substr(0,end);
-			if (get_server_header(h) == "") {
-				m_server_headers[h] = header.substr(end+2);
-			} else {
-				m_server_headers[h] += ", " + header.substr(end+2);
-			}
-		}
-		
-		m_raw_server_handshake += header+"\n";
-	}
-	
-	// temporary debugging
-	if (m_buf.size() > 0) {
-		std::stringstream foo;
-		foo << "bytes left over: " << m_buf.size();
-		access_log(foo.str(), ALOG_HANDSHAKE);
-	}
-	
-	m_client->access_log(m_raw_server_handshake,ALOG_HANDSHAKE);
-	
-	// handshake error checking
-	try {
-		std::stringstream err;
-		std::string h;
-		
-		// TODO: allow versions greater than 1.1
-		if (m_server_http_request.substr(0,9) != "HTTP/1.1 ") {
-			err << "Websocket handshake has invalid HTTP version: "
-				<< m_server_http_request.substr(0,9);
-			
-			throw(handshake_error(err.str(),400));
-		}
-		
-		// check the HTTP version
-		if (m_server_http_request.substr(9,3) != "101") {
-			err << "Websocket handshake ended with status "
-			    << m_server_http_request.substr(9);
-			
-			// TODO: check version header for other supported versions.
-			
-			throw(handshake_error(err.str(),400));
-		}
-		
-		// verify the presence of required headers
-		h = get_server_header("Upgrade");
-		if (h == "") {
-			throw(handshake_error("Required Upgrade header is missing",400));
-		} else if (!boost::iequals(h,"websocket")) {
-			err << "Upgrade header was \"" << h << "\" instead of \"websocket\"";
-			throw(handshake_error(err.str(),400));
-		}
-		
-		h = get_server_header("Connection");
-		if (h == "") {
-			throw(handshake_error("Required Connection header is missing",400));
-		} else if (!boost::ifind_first(h,"upgrade")) {
-			err << "Connection header, \"" << h 
-				<< "\", does not contain required token \"upgrade\"";
-			throw(handshake_error(err.str(),400));
-		}
-			
-		if (get_server_header("Sec-WebSocket-Accept") == "") {
-			throw(handshake_error("Required Sec-WebSocket-Key header is missing",400));
-		} else {
-			// TODO: make a helper function for this.
-			std::string server_key = m_client_key;
-			server_key += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-			
-			SHA1		sha;
-			uint32_t	message_digest[5];
-			
-			sha.Reset();
-			sha << server_key.c_str();
-	
-			if (!sha.Result(message_digest)) {
-				m_client->log("Error computing handshake sha1 hash.",LOG_ERROR);
-				// TODO: close behavior
-				return;
-			}
-	
-			// convert sha1 hash bytes to network byte order because this sha1
-			//  library works on ints rather than bytes
-			for (int i = 0; i < 5; i++) {
-				message_digest[i] = htonl(message_digest[i]);
-			}
-	
-			server_key = base64_encode(
-					reinterpret_cast<const unsigned char*>(message_digest),20);
-			if (server_key != get_server_header("Sec-WebSocket-Accept")) {
-				m_client->log("Server key does not match",LOG_ERROR);
-				// TODO: close behavior
-				return;
-			}
-		}
-	} catch (const handshake_error& e) {
-		std::stringstream err;
-		err << "Caught handshake exception: " << e.what();
-		
-		m_client->access_log(e.what(),ALOG_HANDSHAKE);
-		m_client->log(err.str(),LOG_ERROR);
-		
-		// TODO: close behavior
-		return;
-	}
-	
-	log_open_result();
-
-	m_state = STATE_OPEN;
-
-	if (m_local_interface) {
-		m_local_interface->on_open(shared_from_this());
-	}
-	
-	reset_message();
-	read_frame();
-}
-
-void client_session::write_handshake() {
-	// generate client handshake.	
-	std::string client_handshake;
-	
-	client_handshake += "GET "+m_resource+" HTTP/1.1\r\n";
-	
-	set_header("Upgrade","websocket");
-	set_header("Connection","Upgrade");
-	set_header("Sec-WebSocket-Version","13");
-	
-	set_header("Host",m_uri.host);
-
-	if (m_client_origin != "") {
-		set_header("Origin",m_client_origin);
-	}
-	
-	// TODO: generate proper key
-	m_client_key = "XO4pxrIMLnK1CEVQP9untQ==";
-	
-	int32_t raw_key[4];
-	
-	boost::random::random_device rng;
-	boost::random::variate_generator<boost::random::random_device&, boost::random::uniform_int_distribution<> > gen(rng, boost::random::uniform_int_distribution<>(INT32_MIN,INT32_MAX));
-	
-	for (int i = 0; i < 4; i++) {
-		raw_key[i] = gen();
-	}
-	
-	m_client_key = base64_encode(reinterpret_cast<unsigned char const*>(raw_key), 16);
-	
-	m_client->access_log("Client key chosen: "+m_client_key, ALOG_HANDSHAKE);
-	
-	set_header("Sec-WebSocket-Key",m_client_key);
-	
-	
-
-	set_header("User Agent","WebSocket++/2011-09-25");
-
-	header_list::iterator it;
-	for (it = m_client_headers.begin(); it != m_client_headers.end(); it++) {
-		client_handshake += it->first + ": " + it->second + "\r\n";
-	}
-	
-	client_handshake += "\r\n";
-	
-	m_raw_client_handshake = client_handshake;
-
-	// start async write to handle_write_handshake
-	boost::asio::async_write(
-		m_socket,
-		boost::asio::buffer(m_raw_client_handshake),
-		boost::bind(
-			&session::handle_write_handshake,
-			shared_from_this(),
-			boost::asio::placeholders::error
-		)
-	);
-}
-
-void client_session::handle_write_handshake(const boost::system::error_code& error) {
-	if (error) {
-		log_error("Error writing handshake",error);
-		drop_tcp();
-		return;
-	}
-	
-	read_handshake();
-}
-
-void client_session::log(const std::string& msg, uint16_t level) const {
-	m_client->log(msg,level);
-}
-
-void client_session::access_log(const std::string& msg, uint16_t level) const {
-	m_client->access_log(msg,level);
-}