Page MenuHomePhabricator (Chris)
Files F118102

No OneTemporary
Actions

Authored By
Unknown
Size
242 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/.gitignore b/.gitignore
index 4558be37..2b862426 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,9 @@
.scon*
*.log
*.pyc
*.swp
build
lib
bin
config
+temp
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 00000000..3ec87adf
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,233 @@
+# -------------------------------------------------------
+# r-tech1 cmake build script. Creates makefiles for unix
+# based systems, cygwin(sp?) or mingw
+#
+# Written by: juvinious
+# -------------------------------------------------------
+
+# -------------------------------------------------------
+# Ensure that we are doing an out of source build
+# Prevents any mishaps
+# Also remove the makefile to regenerate the filelist
+# -------------------------------------------------------
+cmake_minimum_required(VERSION 2.6)
+if(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt)
+ file(REMOVE ${CMAKE_SOURCE_DIR}/CMakeCache.txt)
+ file(REMOVE_RECURSE ${CMAKE_SOURCE_DIR}/CMakeFiles)
+endif(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt)
+if(EXISTS ${CMAKE_BINARY_DIR}/Makefile)
+ file(REMOVE ${CMAKE_BINARY_DIR}/Makefile)
+endif(EXISTS ${CMAKE_BINARY_DIR}/Makefile)
+if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+ if(UNIX AND NOT CYGWIN)
+ message(FATAL_ERROR "Oops. Don't do an in-source build. Create an extra directory change into it and run cmake pointing to the base directory. IE: \nmkdir mybuild && cd mybuild && cmake ../ && make\nYou may need to remove CMakeCache.txt and the CMakeFiles directory in ${CMAKE_SOURCE_DIR} if you can't get rid of this error.")
+ else(UNIX AND NOT CYGWIN)
+ message(FATAL_ERROR "Oops. Don't do an in-source build. Create an extra directory change into it and run cmake pointing to the base directory. IE: \nmkdir mybuild; cd mybuild; cmakesetup ../\nYou may need to remove CMakeCache.txt and the CMakeFiles directory in ${CMAKE_SOURCE_DIR} if you can't get rid of this error.")
+ endif(UNIX AND NOT CYGWIN)
+endif(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+
+# -------------------------------------------------------
+# Directory in which extra macros can be found
+# -------------------------------------------------------
+set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
+set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
+
+# -------------------------------------------------------
+# Directory in which extra macros can be found
+# -------------------------------------------------------
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
+
+# -------------------------------------------------------
+# Add in uninstall target
+# -------------------------------------------------------
+configure_file(
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+ IMMEDIATE @ONLY)
+
+add_custom_target(uninstall
+ "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+
+# -------------------------------------------------------
+# project name
+# -------------------------------------------------------
+project (r-tech1 C CXX)
+
+# -------------------------------------------------------
+# Including needed macros
+# -------------------------------------------------------
+include(CheckCSourceCompiles)
+include(CheckCXXSourceCompiles)
+find_package(ZLIB)
+find_package(PNG)
+find_package(FREETYPE)
+find_package(Threads)
+#find_package(GNUREGEX)
+find_package(VORBIS)
+find_package(OGG)
+find_package(MPG123)
+
+# -------------------------------------------------------
+# Include Source
+# -------------------------------------------------------
+mark_as_advanced(CLEAR ZLIB_INCLUDE_DIR)
+mark_as_advanced(CLEAR ZLIB_LIBRARY)
+
+mark_as_advanced(CLEAR PNG_PNG_INCLUDE_DIR)
+mark_as_advanced(CLEAR PNG_LIBRARY)
+
+# -------------------------------------------------------
+# User setable options
+# -------------------------------------------------------
+option(DEBUG "Compile r-tech1 with debug information?" OFF)
+
+if($ENV{DEBUG})
+ set(DEBUG ON)
+elseif(NOT $ENV{DEBUG})
+ set(DEBUG OFF)
+endif($ENV{DEBUG})
+
+if(DEBUG)
+ add_definitions(-DDEBUG)
+ set(CMAKE_CXX_FLAGS "-Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations -Woverloaded-virtual -g3 -ggdb")
+ set(CMAKE_C_FLAGS "-Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations -g3 -ggdb")
+else(DEBUG)
+ set(CMAKE_CXX_FLAGS "-O2 -Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations -Woverloaded-virtual")
+ set(CMAKE_C_FLAGS "-O2 -Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations")
+endif(DEBUG)
+
+# FIXME: not sure if this is in the right place
+add_definitions(-DHAVE_NETWORKING)
+
+option(USE_ALLEGRO5 "Compile r-tech1 with ALLEGRO 5 instead of SDL or Allegro 4.x?" ON)
+
+if($ENV{ALLEGRO5})
+ set(USE_ALLEGRO5 ON)
+elseif(NOT $ENV{ALLEGRO5})
+ set(USE_ALLEGRO5 OFF)
+endif($ENV{ALLEGRO5})
+
+if(OGG_FOUND)
+ add_definitions(-DHAVE_OGG)
+ set(OGG_LIBS ${OGG_LIBRARY} ${VORBIS_LIBRARIES})
+ set(OGG_INCLUDES ${OGG_INCLUDE_DIR} ${VORBIS_INCLUDE_DIR})
+else(OGG_FOUND)
+ set(OGG_LIBS "")
+ set(OGG_INCLUDES "")
+endif(OGG_FOUND)
+
+# Allegro5
+find_package(ALLEGRO5)
+if(NOT ALLEGRO_FOUND)
+message(FATAL_ERROR "Couldn't find Allegro 5 and/or a required Allegro 5 module")
+endif(NOT ALLEGRO_FOUND)
+set(GRAPHICS_LIBRARIES ${ALLEGRO_LIBRARIES})
+set(GRAPHICS_INCLUDES ${ALLEGRO_INCLUDE_DIR})
+
+if(MPG123_FOUND)
+ add_definitions(-DHAVE_MP3_MPG123)
+ set(MP3_LIBS ${MPG123_LIBRARY})
+ set(MP3_INCLUDES ${MPG123_INCLUDE_DIR})
+else(MPG123_FOUND)
+ if (SDL_FOUND)
+ # Try looking for libmad instead only if SDL is available
+ find_package(MAD)
+ if (MAD_FOUND)
+ add_definitions(-DHAVE_MP3_MAD)
+ set(MP3_LIBS ${MAD_LIBRARY})
+ set(MP3_INCLUDES ${MAD_INCLUDE_DIR})
+ else(MAD_FOUND)
+ set(MP3_LIBS "")
+ set(MP3_INCLUDES "")
+ endif(MAD_FOUND)
+ endif (SDL_FOUND)
+endif(MPG123_FOUND)
+
+# freetype
+if(NOT FREETYPE_FOUND)
+ message(FATAL_ERROR "Couldn't find freetype")
+endif(NOT FREETYPE_FOUND)
+
+# -------------------------------------------------------
+# Paths and system setup
+# -------------------------------------------------------
+
+# -------------------------------------------------------
+# MINGW
+# -------------------------------------------------------
+
+if(MINGW OR CYGWIN)
+ # -------------------------------------------------------
+ # Take those user options and set the necessary compile time preprocessors
+ # -------------------------------------------------------
+ add_definitions(-DWINDOWS)
+ set(WIN_LIB -lgdi32 -luser32 -lwsock32)
+ set(CMAKE_THREAD_LIBS_INIT -lpthreadGC2)
+else(MINGW OR CYGWIN)
+ set(CMAKE_THREAD_LIBS_INIT -lpthread)
+endif(MINGW OR CYGWIN)
+
+# -------------------------------------------------------
+# Apple OSX
+# -------------------------------------------------------
+
+if(APPLE)
+ # -------------------------------------------------------
+ # Added stuff for osx
+ # -------------------------------------------------------
+ set(WIN_LIB "-framework Carbon")
+ add_definitions(-DMACOSX)
+
+ # Groups
+ set(GROUP_START "-Wl,-all_load")
+ set(GROUP_END "")
+else(APPLE)
+ # Groups
+ set(GROUP_START "-Wl,--start-group")
+ set(GROUP_END "-Wl,--end-group")
+endif(APPLE)
+
+# -------------------------------------------------------
+# Include directory
+# -------------------------------------------------------
+include_directories(src src/libs/hawknl src/libs/dumb/include include ${GRAPHICS_INCLUDES} ${FREETYPE_INCLUDE_DIR} ${OGG_INCLUDES} ${MP3_INCLUDES})
+
+# -------------------------------------------------------
+# Put the linked libraries together
+# -------------------------------------------------------
+set(REQUIRED_LIBS ${GRAPHICS_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${FREETYPE_LIBRARIES} ${PNG_LIBRARY} ${ZLIB_LIBRARY} ${OGG_LIBS} ${MP3_LIBS} ${WIN_LIB} ${WINSOCK})
+
+# -------------------------------------------------------
+# Source files
+# -------------------------------------------------------
+
+#Base Source
+add_subdirectory(${CMAKE_SOURCE_DIR}/src)
+
+# 7z
+add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/7z)
+
+#Dumb
+add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/dumb)
+
+#Hawknl
+add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/hawknl)
+
+#Minizip
+add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/zip)
+
+# SFL
+add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/sfl)
+
+# GME Library
+add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/gme)
+
+# PCRE
+add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/pcre)
+
+# Create r-tech1 library
+add_library(r-tech1 ${SFL_SRC} ${UTIL_SRC} ${PCRE_SRC} ${x7Z_SRC} ${DUMB_SRC} ${MINIZIP_SRC} ${HAWKNL_SRC} ${GME_SRC})
+
+# Init test
+add_executable(init-test tests/init/main.cpp)
+target_link_libraries(init-test r-tech1 ${REQUIRED_LIBS})
diff --git a/cmake/FileList.cmake b/cmake/FileList.cmake
new file mode 100644
index 00000000..96a60caa
--- /dev/null
+++ b/cmake/FileList.cmake
@@ -0,0 +1,20 @@
+set(BASE_SRC
+src/globals.cpp
+src/main-menu.cpp)
+
+set(FACTORY_SRC
+src/factory/font_render.cpp
+src/factory/collector.cpp)
+
+set(OPENBOR_SRC
+src/openbor/pack-reader.cpp
+src/openbor/animation.cpp
+src/openbor/display-character.cpp
+src/openbor/mod.cpp
+src/openbor/util.cpp
+src/openbor/data.cpp)
+
+#set(LOADPNG_SRC
+#src/util/graphics/allegro/loadpng/loadpng.c
+#src/util/graphics/allegro/loadpng/regpng.c
+#src/util/graphics/allegro/loadpng/savepng.c)
diff --git a/cmake/FindALLEGRO.cmake b/cmake/FindALLEGRO.cmake
new file mode 100644
index 00000000..34dc7ba8
--- /dev/null
+++ b/cmake/FindALLEGRO.cmake
@@ -0,0 +1,52 @@
+# - Find allegro
+# Find the native ALLEGRO includes and library
+#
+# ALLEGRO_INCLUDE_DIR - where to find allegro.h, etc.
+# ALLEGRO_LIBRARIES - List of libraries when using allegro.
+# ALLEGRO_FOUND - True if allegro found.
+
+
+IF (ALLEGRO_INCLUDE_DIR)
+ # Already in cache, be silent
+ SET(ALLEGRO_FIND_QUIETLY TRUE)
+ENDIF (ALLEGRO_INCLUDE_DIR)
+
+FIND_PATH(ALLEGRO_INCLUDE_DIR allegro.h
+ /usr/local/include
+ /usr/include
+ $ENV{MINGDIR}/include
+)
+
+if(UNIX AND NOT CYGWIN)
+ exec_program(allegro-config ARGS --libs OUTPUT_VARIABLE ALLEGRO_LIBRARY)
+else(UNIX AND NOT CYGWIN)
+ SET(ALLEGRO_NAMES alleg alleglib alleg41 alleg42 allegdll)
+ FIND_LIBRARY(ALLEGRO_LIBRARY
+ NAMES ${ALLEGRO_NAMES}
+ PATHS /usr/lib /usr/local/lib $ENV{MINGDIR}/lib)
+endif(UNIX AND NOT CYGWIN)
+
+IF (ALLEGRO_INCLUDE_DIR AND ALLEGRO_LIBRARY)
+ SET(ALLEGRO_FOUND TRUE)
+ SET( ALLEGRO_LIBRARIES ${ALLEGRO_LIBRARY} )
+ add_definitions(-DUSE_ALLEGRO)
+ELSE (ALLEGRO_INCLUDE_DIR AND ALLEGRO_LIBRARY)
+ SET(ALLEGRO_FOUND FALSE)
+ SET( ALLEGRO_LIBRARIES )
+ENDIF (ALLEGRO_INCLUDE_DIR AND ALLEGRO_LIBRARY)
+
+IF (ALLEGRO_FOUND)
+ IF (NOT ALLEGRO_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Allegro: ${ALLEGRO_LIBRARY}")
+ ENDIF (NOT ALLEGRO_FIND_QUIETLY)
+ELSE (ALLEGRO_FOUND)
+ IF (ALLEGRO_FIND_REQUIRED)
+ MESSAGE(STATUS "Looked for Allegro libraries named ${ALLEGRO_NAMES}.")
+ MESSAGE(FATAL_ERROR "Could NOT find Allegro library")
+ ENDIF (ALLEGRO_FIND_REQUIRED)
+ENDIF (ALLEGRO_FOUND)
+
+MARK_AS_ADVANCED(
+ ALLEGRO_LIBRARY
+ ALLEGRO_INCLUDE_DIR
+ )
diff --git a/cmake/FindALLEGRO5.cmake b/cmake/FindALLEGRO5.cmake
new file mode 100644
index 00000000..e56ab9e5
--- /dev/null
+++ b/cmake/FindALLEGRO5.cmake
@@ -0,0 +1,65 @@
+# - Find allegro 5
+# Find the native ALLEGRO 5 includes and library
+#
+# ALLEGRO_INCLUDE_DIR - where to find allegro.h, etc.
+# ALLEGRO_LIBRARIES - List of libraries when using allegro.
+# ALLEGRO_FOUND - True if allegro found.
+
+
+IF (ALLEGRO_INCLUDE_DIR)
+ # Already in cache, be silent
+ SET(ALLEGRO_FIND_QUIETLY TRUE)
+ENDIF (ALLEGRO_INCLUDE_DIR)
+
+FIND_PATH(ALLEGRO_INCLUDE_DIR allegro.h
+ /usr/local/include/allegro5
+ /usr/include/allegro5
+ $ENV{MINGDIR}/include/allegro5
+)
+
+set(VERSION_NUMBER "5")
+
+if(UNIX AND NOT CYGWIN)
+ exec_program(pkg-config ARGS "allegro-${VERSION_NUMBER} allegro_ttf-${VERSION_NUMBER} allegro_memfile-${VERSION_NUMBER} allegro_image-${VERSION_NUMBER} allegro_primitives-${VERSION_NUMBER} allegro_audio-${VERSION_NUMBER} allegro_acodec-${VERSION_NUMBER} --libs" OUTPUT_VARIABLE ALLEGRO_LIBRARY)
+ #IF (NOT ${ALLEGRO_LIBRARY})
+ # FALL BACK TO 5.0
+ # set(VERSION_NUMBER "5.0")
+ # exec_program(pkg-config ARGS "allegro-${VERSION_NUMBER} allegro_ttf-${VERSION_NUMBER} allegro_memfile-${VERSION_NUMBER} allegro_image-${VERSION_NUMBER} allegro_primitives-${VERSION_NUMBER} allegro_audio-${VERSION_NUMBER} allegro_acodec-${VERSION_NUMBER} --libs" OUTPUT_VARIABLE ALLEGRO_LIBRARY)
+ # ENDIF (NOT ${ALLEGRO_LIBRARY})
+ # Check if any of these checks have found if so then cause failure)
+ STRING(REGEX MATCH "not found" LIB_CHECK ${ALLEGRO_LIBRARY})
+ IF (${LIB_CHECK})
+ set(ALLEGRO_LIBRARY "")
+ ENDIF (${LIB_CHECK})
+# FIXME - Figure out what to do for windows
+#else(UNIX AND NOT CYGWIN)
+# SET(ALLEGRO_NAMES allegro allegrolib allegrodll)
+# FIND_LIBRARY(ALLEGRO_LIBRARY
+# NAMES ${ALLEGRO_NAMES}
+# PATHS /usr/lib /usr/local/lib $ENV{MINGDIR}/lib)
+endif(UNIX AND NOT CYGWIN)
+
+IF (ALLEGRO_INCLUDE_DIR AND ALLEGRO_LIBRARY)
+ SET(ALLEGRO_FOUND TRUE)
+ SET( ALLEGRO_LIBRARIES ${ALLEGRO_LIBRARY} )
+ add_definitions(-DUSE_ALLEGRO5)
+ELSE (ALLEGRO_INCLUDE_DIR AND ALLEGRO_LIBRARY)
+ SET(ALLEGRO_FOUND FALSE)
+ SET( ALLEGRO_LIBRARIES )
+ENDIF (ALLEGRO_INCLUDE_DIR AND ALLEGRO_LIBRARY)
+
+IF (ALLEGRO_FOUND)
+ IF (NOT ALLEGRO_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Allegro 5: ${ALLEGRO_LIBRARY}")
+ ENDIF (NOT ALLEGRO_FIND_QUIETLY)
+ELSE (ALLEGRO_FOUND)
+ IF (ALLEGRO_FIND_REQUIRED)
+ MESSAGE(STATUS "Looked for Allegro 5 libraries named ${ALLEGRO_NAMES}.")
+ MESSAGE(FATAL_ERROR "Could NOT find Allegro 5 library")
+ ENDIF (ALLEGRO_FIND_REQUIRED)
+ENDIF (ALLEGRO_FOUND)
+
+MARK_AS_ADVANCED(
+ ALLEGRO_LIBRARY
+ ALLEGRO_INCLUDE_DIR
+ )
diff --git a/cmake/FindALLEGROGL.cmake b/cmake/FindALLEGROGL.cmake
new file mode 100644
index 00000000..a3062f87
--- /dev/null
+++ b/cmake/FindALLEGROGL.cmake
@@ -0,0 +1,49 @@
+# - Find allegroGL
+# Find the native ALLEGROGL includes and library
+#
+# ALLEGROGL_INCLUDE_DIR - where to find alleggl.h, etc.
+# ALLEGROGL_LIBRARIES - List of libraries when using allegro.
+# ALLEGROGL_FOUND - True if allegro found.
+
+FIND_PACKAGE(ALLEGRO)
+FIND_PACKAGE(OpenGL)
+
+IF (ALLEGROGL_INCLUDE_DIR)
+ # Already in cache, be silent
+ SET(ALLEGROGL_FIND_QUIETLY TRUE)
+ENDIF (ALLEGROGL_INCLUDE_DIR)
+
+FIND_PATH(ALLEGROGL_INCLUDE_DIR alleggl.h
+ /usr/local/include
+ /usr/include
+ $ENV{MINGDIR}/include
+)
+
+SET(ALLEGROGL_NAMES agl alleggl agllib agldll)
+FIND_LIBRARY(ALLEGROGL_LIBRARY
+NAMES ${ALLEGROGL_NAMES}
+PATHS /usr/lib /usr/local/lib $ENV{MINGDIR}/lib)
+
+IF (ALLEGROGL_INCLUDE_DIR AND ALLEGROGL_LIBRARY)
+ SET(ALLEGROGL_FOUND TRUE)
+ SET( ALLEGROGL_LIBRARIES ${ALLEGROGL_LIBRARY} ${ALLEGRO_LIBRARIES} ${OPENGL_LIBRARIES})
+ELSE (ALLEGROGL_INCLUDE_DIR AND ALLEGROGL_LIBRARY)
+ SET(ALLEGROGL_FOUND FALSE)
+ SET( ALLEGROGL_LIBRARIES )
+ENDIF (ALLEGROGL_INCLUDE_DIR AND ALLEGROGL_LIBRARY)
+
+IF (ALLEGROGL_FOUND)
+ IF (NOT ALLEGROGL_FIND_QUIETLY)
+ MESSAGE(STATUS "Found AllegroGL: ${ALLEGROGL_LIBRARY}")
+ ENDIF (NOT ALLEGROGL_FIND_QUIETLY)
+ELSE (ALLEGROGL_FOUND)
+ IF (ALLEGROGL_FIND_REQUIRED)
+ MESSAGE(STATUS "Looked for AllegroGL libraries named ${ALLEGROGL_NAMES}.")
+ MESSAGE(FATAL_ERROR "Could NOT find AllegroGL library")
+ ENDIF (ALLEGROGL_FIND_REQUIRED)
+ENDIF (ALLEGROGL_FOUND)
+
+MARK_AS_ADVANCED(
+ ALLEGROGL_LIBRARY
+ ALLEGROGL_INCLUDE_DIR
+ )
\ No newline at end of file
diff --git a/cmake/FindFREETYPE.cmake b/cmake/FindFREETYPE.cmake
new file mode 100644
index 00000000..a1d006e9
--- /dev/null
+++ b/cmake/FindFREETYPE.cmake
@@ -0,0 +1,56 @@
+# - Find freetype
+# Find the native FREETYPE includes and library
+#
+# FREETYPE_INCLUDE_DIR - where to find ft2build.h, etc.
+# FREETYPE_LIBRARIES - List of libraries when using freetype.
+# FREETYPE_FOUND - True if freetype found.
+
+FIND_PACKAGE(ZLIB)
+
+IF (FREETYPE_INCLUDE_DIR)
+ # Already in cache, be silent
+ SET(FREETYPE_FIND_QUIETLY TRUE)
+ENDIF (FREETYPE_INCLUDE_DIR)
+
+FIND_PATH(FREETYPE_INCLUDE_DIR ft2build.h
+ /usr/local/include
+ /usr/include/freetype2
+ /usr/include
+ $ENV{MINGDIR}/include
+)
+
+# need to append the freetype2 dir wherever ft2build is found
+IF(FREETYPE_INCLUDE_DIR)
+ IF(NOT FREETYPE_INCLUDE_DIR MATCHES "^.*freetype2")
+ SET(FREETYPE_INCLUDE_DIR ${FREETYPE_INCLUDE_DIR}/freetype2)
+ ENDIF(NOT FREETYPE_INCLUDE_DIR MATCHES "^.*freetype2")
+ENDIF(FREETYPE_INCLUDE_DIR)
+
+SET(FREETYPE_NAMES ft ftlib ftdll freetype freetypelib freetypedll)
+FIND_LIBRARY(FREETYPE_LIBRARY
+NAMES ${FREETYPE_NAMES}
+PATHS /usr/lib /usr/local/lib $ENV{MINGDIR}/lib)
+
+IF (FREETYPE_INCLUDE_DIR AND FREETYPE_LIBRARY)
+ SET(FREETYPE_FOUND TRUE)
+ SET( FREETYPE_LIBRARIES ${FREETYPE_LIBRARY} ${ZLIB_LIBRARIES})
+ELSE (FREETYPE_INCLUDE_DIR AND FREETYPE_LIBRARY)
+ SET(FREETYPE_FOUND FALSE)
+ SET( FREETYPE_LIBRARIES )
+ENDIF (FREETYPE_INCLUDE_DIR AND FREETYPE_LIBRARY)
+
+IF (FREETYPE_FOUND)
+ IF (NOT FREETYPE_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Freetype: ${FREETYPE_LIBRARY}")
+ ENDIF (NOT FREETYPE_FIND_QUIETLY)
+ELSE (FREETYPE_FOUND)
+ IF (FREETYPE_FIND_REQUIRED)
+ MESSAGE(STATUS "Looked for Freetype libraries named ${FREETYPE_NAMES}.")
+ MESSAGE(FATAL_ERROR "Could NOT find Freetype library")
+ ENDIF (FREETYPE_FIND_REQUIRED)
+ENDIF (FREETYPE_FOUND)
+
+MARK_AS_ADVANCED(
+ FREETYPE_LIBRARY
+ FREETYPE_INCLUDE_DIR
+ )
diff --git a/cmake/FindGNUREGEX.cmake b/cmake/FindGNUREGEX.cmake
new file mode 100644
index 00000000..ab33655c
--- /dev/null
+++ b/cmake/FindGNUREGEX.cmake
@@ -0,0 +1,56 @@
+# - Find regex
+# Find the native GNU REGEX includes and library
+#
+# GNUREGEX_INCLUDE_DIR - where to find allegro.h, etc.
+# GNUREGEX_LIBRARIES - List of libraries when using allegro.
+# GNUREGEX_FOUND - True if allegro found.
+
+
+IF (GNUREGEX_INCLUDE_DIR)
+ # Already in cache, be silent
+ SET(GNUREGEX_FIND_QUIETLY TRUE)
+ENDIF (GNUREGEX_INCLUDE_DIR)
+
+FIND_PATH(GNUREGEX_INCLUDE_DIR regex.h
+ /usr/local/include
+ /usr/include
+ $ENV{MINGDIR}/include
+)
+
+IF(UNIX AND NOT CYGWIN)
+ # not needed
+ELSE(UNIX AND NOT CYGWIN)
+ SET(GNUREGEX_NAMES regex regexlib regexdll regex.dll regex-bcc)
+ FIND_LIBRARY(GNUREGEX_LIBRARY
+ NAMES ${GNUREGEX_NAMES}
+ PATHS /usr/lib /usr/local/lib $ENV{MINGDIR}/lib)
+ENDIF(UNIX AND NOT CYGWIN)
+
+IF(UNIX AND NOT CYGWIN)
+ SET(GNUREGEX_FOUND TRUE)
+ SET(GNUREGEX_LIBRARIES "")
+ELSE(UNIX AND NOT CYGWIN)
+ IF (GNUREGEX_INCLUDE_DIR AND GNUREGEX_LIBRARY)
+ SET(GNUREGEX_FOUND TRUE)
+ SET(GNUREGEX_LIBRARIES ${GNUREGEX_LIBRARY} )
+ ELSE (GNUREGEX_INCLUDE_DIR AND GNUREGEX_LIBRARY)
+ SET(GNUREGEX_FOUND FALSE)
+ SET(GNUREGEX_LIBRARIES )
+ ENDIF (GNUREGEX_INCLUDE_DIR AND GNUREGEX_LIBRARY)
+
+ IF (GNUREGEX_FOUND)
+ IF (NOT GNUREGEX_FIND_QUIETLY)
+ MESSAGE(STATUS "Found GNU Regex: ${GNUREGEX_LIBRARY}")
+ ENDIF (NOT GNUREGEX_FIND_QUIETLY)
+ ELSE (GNUREGEX_FOUND)
+ IF (GNUREGEX_FIND_REQUIRED)
+ MESSAGE(STATUS "Looked for GNU Regex libraries named ${GNUREGEX_NAMES}.")
+ MESSAGE(FATAL_ERROR "Could NOT find GNU Regex library")
+ ENDIF (GNUREGEX_FIND_REQUIRED)
+ ENDIF (GNUREGEX_FOUND)
+ENDIF(UNIX AND NOT CYGWIN)
+
+MARK_AS_ADVANCED(
+ GNUREGEX_LIBRARY
+ GNUREGEX_INCLUDE_DIR
+ )
diff --git a/cmake/FindMAD.cmake b/cmake/FindMAD.cmake
new file mode 100644
index 00000000..9a563a85
--- /dev/null
+++ b/cmake/FindMAD.cmake
@@ -0,0 +1,51 @@
+# - Locate mad (mpg1/2/3) library
+# This module defines
+# MAD_LIBRARY, the library to link against
+# MAD_FOUND, if false, do not try to link to libmad
+# MAD_INCLUDE_DIR, where to find headers.
+
+IF(MAD_LIBRARY AND MAD_INCLUDE_DIR)
+ # in cache already
+ SET(MAD_FIND_QUIETLY TRUE)
+ENDIF(MAD_LIBRARY AND MAD_INCLUDE_DIR)
+
+
+FIND_PATH(MAD_INCLUDE_DIR
+ mad.h
+ PATHS
+ $ENV{MAD_DIR}/include
+ /usr/local/include
+ /usr/include
+ /sw/include
+ /opt/local/include
+ /opt/csw/include
+ /opt/include
+ PATH_SUFFIXES ogg
+)
+
+FIND_LIBRARY(MAD_LIBRARY
+ NAMES mad libmad
+ PATHS
+ $ENV{MAD_DIR}/lib
+ /usr/local/lib
+ /usr/lib
+ /usr/local/X11R6/lib
+ /usr/X11R6/lib
+ /sw/lib
+ /opt/local/lib
+ /opt/csw/lib
+ /opt/lib
+ /usr/freeware/lib64
+)
+
+IF(MAD_LIBRARY AND MAD_INCLUDE_DIR)
+ SET(MAD_FOUND "YES")
+ IF(NOT MAD_FIND_QUIETLY)
+ MESSAGE(STATUS "Found libmad: ${MAD_LIBRARY}")
+ ENDIF(NOT MAD_FIND_QUIETLY)
+ELSE(MAD_LIBRARY AND MAD_INCLUDE_DIR)
+ IF(NOT MAD_FIND_QUIETLY)
+ MESSAGE(STATUS "Warning: Unable to find libmad!")
+ ENDIF(NOT MAD_FIND_QUIETLY)
+ENDIF(MAD_LIBRARY AND MAD_INCLUDE_DIR)
+
diff --git a/cmake/FindMPG123.cmake b/cmake/FindMPG123.cmake
new file mode 100644
index 00000000..94018733
--- /dev/null
+++ b/cmake/FindMPG123.cmake
@@ -0,0 +1,51 @@
+# - Locate mpg123 library
+# This module defines
+# MPG123_LIBRARY, the library to link against
+# MPG123_FOUND, if false, do not try to link to libmpg123
+# MPG123_INCLUDE_DIR, where to find headers.
+
+IF(MPG123_LIBRARY AND MPG123_INCLUDE_DIR)
+ # in cache already
+ SET(MPG123_FIND_QUIETLY TRUE)
+ENDIF(MPG123_LIBRARY AND MPG123_INCLUDE_DIR)
+
+
+FIND_PATH(MPG123_INCLUDE_DIR
+ mpg123.h
+ PATHS
+ $ENV{MPG123_DIR}/include
+ /usr/local/include
+ /usr/include
+ /sw/include
+ /opt/local/include
+ /opt/csw/include
+ /opt/include
+ PATH_SUFFIXES ogg
+)
+
+FIND_LIBRARY(MPG123_LIBRARY
+ NAMES mpg123 libmpg123
+ PATHS
+ $ENV{MPG123_DIR}/lib
+ /usr/local/lib
+ /usr/lib
+ /usr/local/X11R6/lib
+ /usr/X11R6/lib
+ /sw/lib
+ /opt/local/lib
+ /opt/csw/lib
+ /opt/lib
+ /usr/freeware/lib64
+)
+
+IF(MPG123_LIBRARY AND MPG123_INCLUDE_DIR)
+ SET(MPG123_FOUND "YES")
+ IF(NOT MPG123_FIND_QUIETLY)
+ MESSAGE(STATUS "Found libmpg123: ${MPG123_LIBRARY}")
+ ENDIF(NOT MPG123_FIND_QUIETLY)
+ELSE(MPG123_LIBRARY AND MPG123_INCLUDE_DIR)
+ IF(NOT MPG123_FIND_QUIETLY)
+ MESSAGE(STATUS "Warning: Unable to find libmpg123!")
+ ENDIF(NOT MPG123_FIND_QUIETLY)
+ENDIF(MPG123_LIBRARY AND MPG123_INCLUDE_DIR)
+
diff --git a/cmake/FindOGG.cmake b/cmake/FindOGG.cmake
new file mode 100644
index 00000000..9d324de6
--- /dev/null
+++ b/cmake/FindOGG.cmake
@@ -0,0 +1,51 @@
+# - Locate Ogg library
+# This module defines
+# OGG_LIBRARY, the library to link against
+# OGG_FOUND, if false, do not try to link to OGG
+# OGG_INCLUDE_DIR, where to find headers.
+
+IF(OGG_LIBRARY AND OGG_INCLUDE_DIR)
+ # in cache already
+ SET(OGG_FIND_QUIETLY TRUE)
+ENDIF(OGG_LIBRARY AND OGG_INCLUDE_DIR)
+
+
+FIND_PATH(OGG_INCLUDE_DIR
+ ogg.h
+ PATHS
+ $ENV{OGG_DIR}/include
+ /usr/local/include
+ /usr/include
+ /sw/include
+ /opt/local/include
+ /opt/csw/include
+ /opt/include
+ PATH_SUFFIXES ogg
+)
+
+FIND_LIBRARY(OGG_LIBRARY
+ NAMES ogg libogg
+ PATHS
+ $ENV{OGG_DIR}/lib
+ /usr/local/lib
+ /usr/lib
+ /usr/local/X11R6/lib
+ /usr/X11R6/lib
+ /sw/lib
+ /opt/local/lib
+ /opt/csw/lib
+ /opt/lib
+ /usr/freeware/lib64
+)
+
+IF(OGG_LIBRARY AND OGG_INCLUDE_DIR)
+ SET(OGG_FOUND "YES")
+ IF(NOT OGG_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Ogg: ${OGG_LIBRARY}")
+ ENDIF(NOT OGG_FIND_QUIETLY)
+ELSE(OGG_LIBRARY AND OGG_INCLUDE_DIR)
+ IF(NOT OGG_FIND_QUIETLY)
+ MESSAGE(STATUS "Warning: Unable to find Ogg!")
+ ENDIF(NOT OGG_FIND_QUIETLY)
+ENDIF(OGG_LIBRARY AND OGG_INCLUDE_DIR)
+
diff --git a/cmake/FindOPENLAYER.cmake b/cmake/FindOPENLAYER.cmake
new file mode 100644
index 00000000..9f4a3e1d
--- /dev/null
+++ b/cmake/FindOPENLAYER.cmake
@@ -0,0 +1,56 @@
+# - Find openlayer
+# Find the native OPENLAYER includes and library
+#
+# OPENLAYER_INCLUDE_DIR - where to find OpenLayer.h, etc.
+# OPENLAYER_INCLUDE_DIRS - where to find OpenLayer.h and the rest of its dependency includes
+# OPENLAYER_LIBRARIES - List of libraries when using OpenLayer.
+# OPENLAYER_FOUND - True if OpenLayer found.
+
+FIND_PACKAGE(ALLEGRO)
+FIND_PACKAGE(ALLEGROGL)
+FIND_PACKAGE(OpenGL)
+FIND_PACKAGE(PNG)
+FIND_PACKAGE(FREETYPE)
+FIND_PACKAGE(ZLIB)
+
+IF (OPENLAYER_INCLUDE_DIR)
+ # Already in cache, be silent
+ SET(OPENLAYER_FIND_QUIETLY TRUE)
+ENDIF (OPENLAYER_INCLUDE_DIR)
+
+FIND_PATH(OPENLAYER_INCLUDE_DIR OpenLayer.hpp
+ /usr/local/include
+ /usr/include
+ $ENV{MINGDIR}/include
+)
+
+SET(OPENLAYER_NAMES openlayer openlayerlib openlayerdll)
+FIND_LIBRARY(OPENLAYER_LIBRARY
+NAMES ${OPENLAYER_NAMES}
+PATHS /usr/lib /usr/local/lib $ENV{MINGDIR}/lib)
+
+IF (OPENLAYER_INCLUDE_DIR AND OPENLAYER_LIBRARY)
+ SET(OPENLAYER_FOUND TRUE)
+ SET( OPENLAYER_LIBRARIES ${OPENLAYER_LIBRARY} ${ALLEGROGL_LIBRARY} ${ALLEGRO_LIBRARY} ${PNG_LIBRARY} ${FREETYPE_LIBRARY} ${ZLIB_LIBRARY} ${OPENGL_LIBRARIES})
+ SET( OPENLAYER_INCLUDE_DIRS ${OPENLAYER_INCLUDE_DIR} ${FREETYPE_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR})
+ELSE (OPENLAYER_INCLUDE_DIR AND OPENLAYER_LIBRARY)
+ SET(OPENLAYER_FOUND FALSE)
+ SET( OPENLAYER_LIBRARIES )
+ENDIF (OPENLAYER_INCLUDE_DIR AND OPENLAYER_LIBRARY)
+
+IF (OPENLAYER_FOUND)
+ IF (NOT OPENLAYER_FIND_QUIETLY)
+ MESSAGE(STATUS "Found OpenLayer: ${OPENLAYER_LIBRARY}")
+ ENDIF (NOT OPENLAYER_FIND_QUIETLY)
+ELSE (OPENLAYER_FOUND)
+ IF (OPENLAYER_FIND_REQUIRED)
+ MESSAGE(STATUS "Looked for OpenLayer libraries named ${OPENLAYER_NAMES}.")
+ MESSAGE(FATAL_ERROR "Could NOT find OpenLayer library")
+ ENDIF (OPENLAYER_FIND_REQUIRED)
+ENDIF (OPENLAYER_FOUND)
+
+MARK_AS_ADVANCED(
+ OPENLAYER_LIBRARY
+ OPENLAYER_INCLUDE_DIR
+ OPENLAYER_INCLUDE_DIRS
+ )
\ No newline at end of file
diff --git a/cmake/FindVORBIS.cmake b/cmake/FindVORBIS.cmake
new file mode 100644
index 00000000..7b411455
--- /dev/null
+++ b/cmake/FindVORBIS.cmake
@@ -0,0 +1,67 @@
+# - Locate Vorbis library
+# This module defines
+# VORBIS_LIBRARY, the library to link against
+# VORBIS_FOUND, if false, do not try to link to VORBIS
+# VORBIS_INCLUDE_DIR, where to find headers.
+
+IF(VORBIS_LIBRARY AND VORBIS_INCLUDE_DIR)
+ # in cache already
+ SET(VORBIS_FIND_QUIETLY TRUE)
+ENDIF(VORBIS_LIBRARY AND VORBIS_INCLUDE_DIR)
+
+
+FIND_PATH(VORBIS_INCLUDE_DIR
+ vorbisfile.h
+ PATHS
+ $ENV{VORBIS_DIR}/include
+ /usr/local/include
+ /usr/include
+ /sw/include
+ /opt/local/include
+ /opt/csw/include
+ /opt/include
+ PATH_SUFFIXES vorbis
+)
+
+FIND_LIBRARY(VORBIS_LIBRARY
+ NAMES vorbis libvorbis
+ PATHS
+ $ENV{VORBIS_DIR}/lib
+ /usr/local/lib
+ /usr/lib
+ /usr/local/X11R6/lib
+ /usr/X11R6/lib
+ /sw/lib
+ /opt/local/lib
+ /opt/csw/lib
+ /opt/lib
+ /usr/freeware/lib64
+)
+
+FIND_LIBRARY(VORBISFILE_LIBRARY
+ NAMES vorbisfile libvorbisfile
+ PATHS
+ $ENV{VORBIS_DIR}/lib
+ /usr/local/lib
+ /usr/lib
+ /usr/local/X11R6/lib
+ /usr/X11R6/lib
+ /sw/lib
+ /opt/local/lib
+ /opt/csw/lib
+ /opt/lib
+ /usr/freeware/lib64
+)
+
+IF(VORBIS_LIBRARY AND VORBISFILE_LIBRARY AND VORBIS_INCLUDE_DIR)
+ SET(VORBIS_FOUND "YES")
+ SET(VORBIS_LIBRARIES ${VORBIS_LIBRARY} ${VORBISFILE_LIBRARY})
+ IF(NOT VORBIS_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Vorbis: ${VORBIS_LIBRARY}")
+ ENDIF(NOT VORBIS_FIND_QUIETLY)
+ELSE(VORBIS_LIBRARY AND VORBISFILE_LIBRARY AND VORBIS_INCLUDE_DIR)
+ IF(NOT VORBIS_FIND_QUIETLY)
+ MESSAGE(STATUS "Warning: Unable to find Vorbis!")
+ ENDIF(NOT VORBIS_FIND_QUIETLY)
+ENDIF(VORBIS_LIBRARY AND VORBISFILE_LIBRARY AND VORBIS_INCLUDE_DIR)
+
diff --git a/cmake/TestForPythonEmbed.cmake b/cmake/TestForPythonEmbed.cmake
new file mode 100644
index 00000000..c1348a39
--- /dev/null
+++ b/cmake/TestForPythonEmbed.cmake
@@ -0,0 +1,41 @@
+# - Test if Python is embedable
+# Facilitate python within paintown
+#
+# PYTHON_EMBEDABLE - True if embedable
+
+set(PythonLibs_FIND_VERSION "2")
+find_package(PythonLibs)
+if(UNIX OR LINUX)
+ # Some systems require these libs to be added explicitly
+ find_library(DL dl)
+ find_library(MATH m)
+ find_library(PTHREAD pthread)
+ find_library(UTIL util)
+endif(UNIX OR LINUX)
+
+if(PYTHONLIBS_FOUND)
+ MESSAGE(STATUS "Checking if Python is Embedable")
+ SET(CMAKE_REQUIRED_INCLUDES ${PYTHON_INCLUDE_PATH})
+ # ensure the libs are included with python
+ SET(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} ${DL} ${MATH} ${PTHREAD} ${UTIL})
+ SET(CMAKE_REQUIRED_LIBRARIES ${PYTHON_LIBRARIES})
+ CHECK_C_SOURCE_COMPILES(
+"#include <Python.h>
+int main(int argc, char *argv[]) {
+ Py_Initialize();
+ return 0;
+}
+
+" PY_EMBED)
+ IF(PY_EMBED)
+ MESSAGE(STATUS "Python is embedable")
+ SET(PYTHON_EMBEDABLE TRUE)
+ ELSE(PY_EMBED)
+ MESSAGE(STATUS "Python is not embedable")
+ SET(PYTHON_EMBEDABLE FALSE)
+ ENDIF(PY_EMBED)
+ELSE(PYTHONLIBS_FOUND)
+ MESSAGE(STATUS "Python is not embedable")
+ SET(PYTHON_EMBEDABLE FALSE)
+ENDIF(PYTHONLIBS_FOUND)
+
diff --git a/cmake/cmake_uninstall.cmake.in b/cmake/cmake_uninstall.cmake.in
new file mode 100644
index 00000000..bcf2437c
--- /dev/null
+++ b/cmake/cmake_uninstall.cmake.in
@@ -0,0 +1,22 @@
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+ MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+FOREACH(file ${files})
+ MESSAGE(STATUS "Uninstalling \"${file}\"")
+ IF(EXISTS "${file}")
+ EXEC_PROGRAM(
+ "@CMAKE_COMMAND@" ARGS "-E remove \"${file}\""
+ OUTPUT_VARIABLE rm_out
+ RETURN_VALUE rm_retval
+ )
+ IF("${rm_retval}" STREQUAL 0)
+ ELSE("${rm_retval}" STREQUAL 0)
+ MESSAGE(FATAL_ERROR "Problem when removing \"${file}\"")
+ ENDIF("${rm_retval}" STREQUAL 0)
+ ELSE(EXISTS "${file}")
+ MESSAGE(STATUS "File \"${file}\" does not exist.")
+ ENDIF(EXISTS "${file}")
+ENDFOREACH(file)
\ No newline at end of file
diff --git a/scons_rtech1/helpers.py b/scons_rtech1/helpers.py
index b3ce49e6..0c91cdf8 100644
--- a/scons_rtech1/helpers.py
+++ b/scons_rtech1/helpers.py
@@ -1,43 +1,44 @@
import SCons
def read_cmake_list(name):
"""
Read a cmake files list and return a dictionary with each cmake variable
matched to a list of filenames.
This makes it easy to add/remove files, as only the cmake list needs to be
modified and scons will automatically pick up the changes.
"""
lists = {}
current = []
reading = False
for line in open(name):
if line.startswith("set("):
current = []
name = line[4:].strip()
lists[name] = current
reading = True
else:
if reading:
# Stop reading files once we hit a line like 'file.cpp)'
if line.strip("\t\r\n").endswith(")"):
reading = False
path = line.strip("( )\t\r\n")
- if path:
- current.append(path)
+ if path and path != 'PARENT_SCOPE':
+ current.append(path.replace("${CMAKE_CURRENT_SOURCE_DIR}/", ""))
+
return lists
def findFile(root, name):
path = SCons.Script.File(name, SCons.Script.Dir(".").rel_path(SCons.Script.Dir("#%s" % root)))
return path.abspath
#return findDirectory(name)
def findDirectory(name):
import os.path
where = '.'
# just try 5 directories
for i in xrange(0, 6):
if os.path.exists("%s/%s" % (where, name)):
return "%s/%s" % (where, name)
where = os.path.join(where, '..')
raise Exception("Could not find the %s directory" % name)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 31e561c7..d54616ed 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,104 +1,106 @@
# -------------------------------------------------------
# util cmake build script for r-tech1.
# Written by: juvinious
# Modified by: kazzmir
# -------------------------------------------------------
+project (util C CXX)
# -------------------------------------------------------
# Source directories containing all the necessary .cpp files
# -------------------------------------------------------
set(UTIL_SRC
-argument.cpp
-configuration.cpp
-network/network.cpp
-network/chat.cpp
-network/irc.cpp
-token.cpp
-resource.cpp
-tokenreader.cpp
-timedifference.cpp
-debug.cpp
-timer.cpp
-init.cpp
-utf.cpp
-console.cpp
-input/keyboard.cpp
-loading.cpp
-messages.cpp
-graphics/bitmap.cpp
-graphics/image.cpp
-events.cpp
-font.cpp
-font_factory.cpp
-graphics/fire.cpp
-ftalleg.cpp
-funcs.cpp
-directory.cpp
-file-system.cpp
-graphics/gradient.cpp
-ebox.cpp
-regex.cpp
-language-string.cpp
-thread.cpp
-input/text-input.cpp
-input/input-manager.cpp
-input/input-source.cpp
-input/joystick.cpp
-input/allegro5/joystick.cpp
-input/touch.cpp
-input/allegro5/touch.cpp
-xenon/xenon.cpp
-libs/lz4/lz4.c
-system.cpp
-version.cpp
-compress.cpp
-message-queue.cpp
-input/linux_joystick.cpp
-exceptions/load_exception.cpp
-windows/system.cpp
-nacl/module.cpp
-nacl/network-system.cpp
-exceptions/exception.cpp
-menu/actionfactory.cpp
-menu/action_speed.cpp
-menu/menu.cpp
-menu/font-info.cpp
-menu/menu_action.cpp
-menu/menu_option.cpp
-menu/options.cpp
-menu/optionfactory.cpp
-gui/animation.cpp
-gui/box.cpp
-gui/container.cpp
-gui/context-box.cpp
-gui/coordinate.cpp
-gui/cutscene.cpp
-gui/fadetool.cpp
-gui/lineedit.cpp
-gui/list.cpp
-gui/rectarea.cpp
-gui/popup-box.cpp
-gui/scroll-list.cpp
-gui/select-list.cpp
-gui/tab-container.cpp
-gui/tabbed-box.cpp
-gui/timer.cpp
-gui/widget.cpp
-sound/sound.cpp
-sound/audio.cpp
-sound/music-player.cpp
-sound/music-renderer.cpp
-sound/music.cpp
-system/timer.cpp
-system/allegro5/timer.cpp
-system/allegro5/init.cpp)
+${CMAKE_CURRENT_SOURCE_DIR}/argument.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/configuration.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/network/network.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/network/chat.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/network/irc.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/token.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/resource.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/tokenreader.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/timedifference.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/debug.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/timer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/init.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/utf.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/console.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/keyboard.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/loading.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/messages.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/graphics/bitmap.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/graphics/image.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/events.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/font.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/font_factory.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/graphics/fire.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/ftalleg.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/funcs.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/directory.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/file-system.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/graphics/gradient.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/ebox.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/regex.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/language-string.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/thread.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/text-input.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/input-manager.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/input-source.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/joystick.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/allegro5/joystick.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/touch.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/allegro5/touch.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/xenon/xenon.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/libs/lz4/lz4.c
+${CMAKE_CURRENT_SOURCE_DIR}/system.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/version.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/compress.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/message-queue.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/input/linux_joystick.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/exceptions/load_exception.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/windows/system.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/nacl/module.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/nacl/network-system.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/exceptions/exception.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/actionfactory.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/action_speed.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/menu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/font-info.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/menu_action.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/menu_option.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/options.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/menu/optionfactory.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/animation.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/box.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/container.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/context-box.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/coordinate.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/cutscene.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/fadetool.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/lineedit.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/list.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/rectarea.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/popup-box.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/scroll-list.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/select-list.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/tab-container.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/tabbed-box.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/timer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gui/widget.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/sound/sound.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/sound/audio.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/sound/music-player.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/sound/music-renderer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/sound/music.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/system/timer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/system/allegro5/timer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/system/allegro5/init.cpp
+PARENT_SCOPE)
# -------------------------------------------------------
# Include directory
# -------------------------------------------------------
#include_directories(include include/internal)
# -------------------------------------------------------
# module
# -------------------------------------------------------
-add_library (util_module ${UTIL_SRC})
+# add_library (util_module ${UTIL_SRC})
diff --git a/src/libs/7z/CMakeLists.txt b/src/libs/7z/CMakeLists.txt
index 5e3a7981..c6db7f5a 100644
--- a/src/libs/7z/CMakeLists.txt
+++ b/src/libs/7z/CMakeLists.txt
@@ -1,35 +1,38 @@
# -------------------------------------------------------
# util cmake build script for r-tech1.
# Written by: juvinious
# Modified by: kazzmir
# -------------------------------------------------------
+project (x7z C CXX)
+
# -------------------------------------------------------
# Source directories containing all the necessary .cpp files
# -------------------------------------------------------
set(x7Z_SRC
-7zAlloc.c
-7zBuf.c
-7zBuf2.c
-7zCrc.c
-7zCrcOpt.c
-7zDec.c
-7zIn.c
-CpuArch.c
-LzmaDec.c
-Lzma2Dec.c
-Bra.c
-Bra86.c
-Bcj2.c
-7zFile.c
-7zStream.c)
+${CMAKE_CURRENT_SOURCE_DIR}/7zAlloc.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zBuf.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zBuf2.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zCrc.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zCrcOpt.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zDec.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zIn.c
+${CMAKE_CURRENT_SOURCE_DIR}/CpuArch.c
+${CMAKE_CURRENT_SOURCE_DIR}/LzmaDec.c
+${CMAKE_CURRENT_SOURCE_DIR}/Lzma2Dec.c
+${CMAKE_CURRENT_SOURCE_DIR}/Bra.c
+${CMAKE_CURRENT_SOURCE_DIR}/Bra86.c
+${CMAKE_CURRENT_SOURCE_DIR}/Bcj2.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zFile.c
+${CMAKE_CURRENT_SOURCE_DIR}/7zStream.c
+PARENT_SCOPE)
# -------------------------------------------------------
# Include directory
# -------------------------------------------------------
#include_directories(include include/internal)
# -------------------------------------------------------
# module
# -------------------------------------------------------
-add_library (x7z_module ${x7Z_SRC})
+#add_library (x7z_module ${x7Z_SRC})
diff --git a/src/libs/dumb/CMakeLists.txt b/src/libs/dumb/CMakeLists.txt
index abf1b825..2763cd97 100644
--- a/src/libs/dumb/CMakeLists.txt
+++ b/src/libs/dumb/CMakeLists.txt
@@ -1,92 +1,96 @@
# -------------------------------------------------------
# dumb cmake build script for r-tech1.
# Written by: juvinious
# -------------------------------------------------------
-
+project (dumb C)
# -------------------------------------------------------
# Set some specific stuff for dumb
# -------------------------------------------------------
if(NOT MSVC)
set(CFLAGS "-W -O2 -Wwrite-strings -Wstrict-prototypes -Wall -funroll-loops -Wmissing-declarations -fomit-frame-pointer -Wno-missing-declarations")
else(NOT MSVC)
set(CFLAGS "-O2")
endif(NOT MSVC)
remove_definitions(${CXXFLAGS})
add_definitions(${CFLAGS})
if(MSVC)
add_definitions("/DDUMB_DECLARE_DEPRECATED")
else(MSVC)
add_definitions(-DDUMB_DECLARE_DEPRECATED)
endif(MSVC)
# -------------------------------------------------------
# Source directories containing all the necessary .cpp files
# -------------------------------------------------------
set(DUMB_SRC
-src/it/itorder.c
-src/it/xmeffect.c
-src/it/itrender.c
-src/it/itread2.c
-src/it/itunload.c
-src/it/loadmod.c
-src/it/loads3m.c
-src/it/loadxm2.c
-src/it/itload2.c
-src/it/readmod2.c
-src/it/reads3m2.c
-src/it/loadmod2.c
-src/it/loadxm.c
-src/it/loads3m2.c
-src/it/itload.c
-src/it/itmisc.c
-src/it/itread.c
-src/it/readxm.c
-src/it/readmod.c
-src/it/reads3m.c
-src/it/readxm2.c
-src/core/makeduh.c
-src/core/unload.c
-src/core/loadduh.c
-src/core/rawsig.c
-src/core/rendduh.c
-src/core/rendsig.c
-src/core/duhlen.c
-src/core/duhtag.c
-src/core/atexit.c
-src/core/readduh.c
-src/core/register.c
-src/core/dumbfile.c
-src/helpers/sampbuf.c
-src/helpers/stdfile.c
-src/helpers/resample.inc
-src/helpers/clickrem.c
-src/helpers/silence.c
-src/helpers/resamp2.inc
-src/helpers/resamp3.inc
-src/helpers/memfile.c
-src/helpers/resample.c
-src/allegro/datit.c
-src/allegro/datxm.c
-src/allegro/datduh.c
-src/allegro/datitq.c
-src/allegro/datmod.c
-src/allegro/dats3m.c
-src/allegro/datxmq.c
-src/allegro/datmodq.c
-src/allegro/dats3mq.c
-src/allegro/datunld.c
-src/allegro/alplay.c
-src/allegro/packfile.c)
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itorder.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/xmeffect.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itrender.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itread2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itunload.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/loadmod.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/loads3m.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/loadxm2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itload2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/readmod2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/reads3m2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/loadmod2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/loadxm.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/loads3m2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itload.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itmisc.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/itread.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/readxm.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/readmod.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/reads3m.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/it/readxm2.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/makeduh.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/unload.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/loadduh.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/rawsig.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/rendduh.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/rendsig.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/duhlen.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/duhtag.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/atexit.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/readduh.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/register.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/core/dumbfile.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/sampbuf.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/stdfile.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/resample.inc
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/clickrem.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/silence.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/resamp2.inc
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/resamp3.inc
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/memfile.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/helpers/resample.c
+PARENT_SCOPE)
+
+set(UNUSED_DUMB_SRC
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datit.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datxm.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datduh.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datitq.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datmod.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/dats3m.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datxmq.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datmodq.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/dats3mq.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/datunld.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/alplay.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/allegro/packfile.c
+PARENT_SCOPE)
# -------------------------------------------------------
# Include directory
# -------------------------------------------------------
include_directories(include include/internal)
# -------------------------------------------------------
# module
# -------------------------------------------------------
-add_library (dumb_module ${DUMB_SRC})
+#add_library (dumb_module ${DUMB_SRC})
diff --git a/src/libs/dumb/SConscript b/src/libs/dumb/SConscript
index 790e3459..6404aee0 100644
--- a/src/libs/dumb/SConscript
+++ b/src/libs/dumb/SConscript
@@ -1,76 +1,76 @@
import os
Import( 'env' )
# env = Environment( ENV = os.environ )
source = Split("""
it/itorder.c
it/xmeffect.c
it/itrender.c
it/itread2.c
it/itunload.c
it/loadmod.c
it/loads3m.c
it/loadxm2.c
it/itload2.c
it/readmod2.c
it/reads3m2.c
it/loadmod2.c
it/loadxm.c
it/loads3m2.c
it/itload.c
it/itmisc.c
it/itread.c
it/readxm.c
it/readmod.c
it/reads3m.c
it/readxm2.c
core/makeduh.c
core/unload.c
core/loadduh.c
core/rawsig.c
core/rendduh.c
core/rendsig.c
core/duhlen.c
core/duhtag.c
core/atexit.c
core/readduh.c
core/register.c
core/dumbfile.c
helpers/sampbuf.c
helpers/stdfile.c
helpers/clickrem.c
helpers/silence.c
helpers/memfile.c
helpers/resample.c
-allegro/alplay.c
""");
unused = Split("""
+allegro/alplay.c
allegro/datit.c
allegro/datxm.c
allegro/datduh.c
allegro/datitq.c
allegro/datmod.c
allegro/dats3m.c
allegro/datxmq.c
allegro/datmodq.c
allegro/dats3mq.c
allegro/datunld.c
allegro/packfile.c
""")
# helpers/resample.inc
# helpers/resamp2.inc
# helpers/resamp3.inc
env.Prepend(CPPPATH = ['include','include/internal'])
# env.Append( CCFLAGS = ['-Wall','-W','-Wwrite-strings','-Wstrict-prototypes','-Wmissing-declarations', '-O2', '-ffast-math', '-fomit-frame-pointer', '-Wno-missing-declarations'] )
env.Append(CCFLAGS = ['-Wall','-W','-Wwrite-strings','-Wstrict-prototypes','-Wmissing-declarations', '-ffast-math', '-Wno-missing-declarations'] )
env.Append(CPPDEFINES = 'DUMB_DECLARE_DEPRECATED')
x = []
for s in map( lambda x: 'src/%s' % x, source ):
x.append(env.Object(s))
Return( 'x' )
diff --git a/src/libs/gme/CMakeLists.txt b/src/libs/gme/CMakeLists.txt
new file mode 100644
index 00000000..9b6f8c4a
--- /dev/null
+++ b/src/libs/gme/CMakeLists.txt
@@ -0,0 +1,63 @@
+# -------------------------------------------------------
+# GME cmake build script for r-tech1.
+# Written by: juvinious
+# -------------------------------------------------------
+project (gme C CXX)
+
+# -------------------------------------------------------
+# Source directories containing all the necessary .cpp files
+# -------------------------------------------------------
+# GME Library
+set(GME_SRC
+${CMAKE_CURRENT_SOURCE_DIR}/Ay_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Ay_Cpu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Ay_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Blip_Buffer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Classic_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Data_Reader.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Dual_Resampler.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Effects_Buffer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Fir_Resampler.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Gb_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Gb_Cpu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Gb_Oscs.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Gbs_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/gme.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Gme_File.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Gym_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Hes_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Hes_Cpu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Hes_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Kss_Cpu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Kss_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Kss_Scc_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/M3u_Playlist.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Multi_Buffer.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Music_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nes_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nes_Cpu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nes_Fme7_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nes_Namco_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nes_Oscs.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nes_Vrc6_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nsfe_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Nsf_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Sap_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Sap_Cpu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Sap_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Sms_Apu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Snes_Spc.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Spc_Cpu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Spc_Dsp.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Spc_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Spc_Filter.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Vgm_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Vgm_Emu_Impl.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Ym2413_Emu.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/Ym2612_Emu.cpp
+PARENT_SCOPE)
+
+# -------------------------------------------------------
+# module
+# -------------------------------------------------------
+#add_library (gme_module ${GME_SRC})
diff --git a/src/libs/hawknl/CMakeLists.txt b/src/libs/hawknl/CMakeLists.txt
index 086918a1..a05fc114 100644
--- a/src/libs/hawknl/CMakeLists.txt
+++ b/src/libs/hawknl/CMakeLists.txt
@@ -1,45 +1,46 @@
# -------------------------------------------------------
# hawknl cmake build script for r-tech1.
# Written by: juvinious
# -------------------------------------------------------
-
+project (hawknl C CXX)
# -------------------------------------------------------
# Set some specific stuff for hawknl
# -------------------------------------------------------
if(NOT MSVC)
set(CFLAGS "-W -O2 -Wwrite-strings -Wstrict-prototypes -Wall -funroll-loops -Wmissing-declarations -fomit-frame-pointer -Wno-missing-declarations")
else(NOT MSVC)
set(CFLAGS "-O2")
endif(NOT MSVC)
remove_definitions(${CXXFLAGS})
add_definitions(${CFLAGS})
# -------------------------------------------------------
# Source directories containing all the necessary .cpp files
# -------------------------------------------------------
-set(SRC
-src/crc.cpp
-src/err.cpp
-src/errorstr.cpp
-src/group.cpp
-src/ipx.cpp
-src/loopback.cpp
-src/nl.cpp
-src/nltime.cpp
-src/sock.cpp)
+set(HAWKNL_SRC
+${CMAKE_CURRENT_SOURCE_DIR}/src/crc.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/err.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/errorstr.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/group.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/ipx.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/loopback.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/nl.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/nltime.cpp
+${CMAKE_CURRENT_SOURCE_DIR}/src/sock.cpp
+PARENT_SCOPE)
-#src/htcondition.cpp
-#src/hthread.cpp
-#src/htmutex.cpp
+#${CMAKE_CURRENT_SOURCE_DIR}/src/htcondition.cpp
+#${CMAKE_CURRENT_SOURCE_DIR}/src/hthread.cpp
+#${CMAKE_CURRENT_SOURCE_DIR}/src/htmutex.cpp
# -------------------------------------------------------
# Include directory
# -------------------------------------------------------
#include_directories(include hawknl)
# -------------------------------------------------------
# module
# -------------------------------------------------------
-add_library (hawknl_module ${SRC})
+#add_library (hawknl_module ${HAWKNL_SRC})
diff --git a/src/libs/hawknl/hawknl/nlinternal.h b/src/libs/hawknl/hawknl/nlinternal.h
index 96182826..3a20f97c 100644
--- a/src/libs/hawknl/hawknl/nlinternal.h
+++ b/src/libs/hawknl/hawknl/nlinternal.h
@@ -1,270 +1,270 @@
/*
HawkNL cross platform network library
Copyright (C) 2000-2004 Phil Frisbie, Jr. (phil@hawksoft.com)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#ifndef INTERNAL_H
#define INTERNAL_H
#include "nl.h"
// #include "hawkthreads.h"
-#include "util/thread.h"
+#include "r-tech1/thread.h"
/* for malloc and free */
#include <stdlib.h>
#if !defined(MACOSX) && !defined(__FreeBSD__)
#include <malloc.h>
#endif
/* Windows CE does not have time.h functions */
#if defined (_WIN32_WCE)
extern time_t time(time_t *timer);
#else
#include <time.h>
#endif
#ifdef NL_LITTLE_ENDIAN
#define NL_SWAP_TRUE (nlState.nl_big_endian_data == NL_TRUE)
#else
#define NL_SWAP_TRUE (nlState.nl_big_endian_data != NL_TRUE)
#endif /* NL_LITTLE_ENDIAN */
#ifdef HL_WINDOWS_APP
/* Windows systems */
#ifdef _MSC_VER
#pragma warning (disable:4201)
#pragma warning (disable:4214)
#endif /* _MSC_VER */
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tchar.h>
#ifdef _MSC_VER
#pragma warning (default:4201)
#pragma warning (default:4214)
#endif /* _MSC_VER */
#endif
/* part of portable unicode support */
#if !defined _TCHAR_DEFINED && !(defined _WCHAR_T_DEFINED && defined (__LCC__))
#ifdef _UNICODE
#define TEXT(x) L##x
#define _tcsncat wcsncat
#define _stprintf swprintf
#define _sntprintf snwprintf
#define _stscanf swscanf
#define _tcsncpy wcsncpy
#define _tcscspn wcscspn
#define _tcschr wcschr
#define _tcslen wcslen
#define _tcsrchr wcsrchr
#ifdef HL_WINDOWS_APP
#define _ttoi _wtoi
#else /* !HL_WINDOWS_APP*/
#define _ttoi wtoi
#endif /* !HL_WINDOWS_APP*/
#else /* !UNICODE */
#define TEXT(x) x
#define _tcsncat strncat
#define _stprintf sprintf
#define _sntprintf snprintf
#define _stscanf sscanf
#define _tcsncpy strncpy
#define _tcscspn strcspn
#define _tcschr strchr
#define _tcslen strlen
#define _ttoi atoi
#define _tcsrchr strrchr
#endif /* !UNICODE */
#endif /* _INC_TCHAR */
/* internally for TCP packets and UDP connections, all data is big endien,
so we force it so here using these macros */
#undef writeShort
#define writeShort(x, y, z) {*((NLushort *)((NLbyte *)&x[y])) = htons(z); y += 2;}
#undef readShort
#define readShort(x, y, z) {z = ntohs(*(NLushort *)((NLbyte *)&x[y])); y += 2;}
#define NL_FIRST_GROUP (200000 + 1)
/* the minumum number of sockets that will be allocated */
#define NL_MIN_SOCKETS 16
/* number of buckets for average bytes/second */
#define NL_NUM_BUCKETS 8
/* number of packets stored for NL_LOOP_BACK */
#define NL_NUM_PACKETS 8
#define NL_MAX_ACCEPT 10
/* for nlLockSocket and nlUnlockSocket */
#define NL_READ 0x0001
#define NL_WRITE 0x0002
#define NL_BOTH (NL_READ|NL_WRITE)
/* time in milliseconds that unreliable connect/accepts sleep while waiting */
#define NL_CONNECT_SLEEP 50
#ifdef __cplusplus
extern "C" {
#endif
/* the driver object */
typedef struct
{
const NLchar /*@observer@*/*name;
const NLchar /*@observer@*/*socktypes;
NLenum type;
NLboolean initialized;
NLboolean (*Init)(void);
void (*Shutdown)(void);
NLboolean (*Listen)(NLsocket socket);
NLsocket (*AcceptConnection)(NLsocket socket);
NLsocket (*Open)(NLushort port, NLenum type);
NLboolean (*Connect)(NLsocket socket, const NLaddress *address);
void (*Close)(NLsocket socket);
NLint (*Read)(NLsocket socket, /*@out@*/ NLvoid *buffer, NLint nbytes);
NLint (*Write)(NLsocket socket, const NLvoid *buffer, NLint nbytes);
NLchar *(*AddrToString)(const NLaddress *address, /*@returned@*/ /*@out@*/ NLchar *string);
NLboolean (*StringToAddr)(const NLchar *string, /*@out@*/ NLaddress *address);
NLboolean (*GetLocalAddr)(NLsocket socket, /*@out@*/ NLaddress *address);
NLaddress *(*GetAllLocalAddr)(/*@out@*/ NLint *count);
NLboolean (*SetLocalAddr)(const NLaddress *address);
NLchar *(*GetNameFromAddr)(const NLaddress *address, /*@returned@*/ /*@out@*/ NLchar *name);
NLboolean (*GetNameFromAddrAsync)(const NLaddress *address, /*@out@*/ NLchar *name);
NLboolean (*GetAddrFromName)(const NLchar *name, /*@out@*/ NLaddress *address);
NLboolean (*GetAddrFromNameAsync)(const NLchar *name, /*@out@*/ NLaddress *address);
NLboolean (*AddrCompare)(const NLaddress *address1, const NLaddress *address2);
NLushort (*GetPortFromAddr)(const NLaddress *address);
void (*SetAddrPort)(NLaddress *address, NLushort port);
NLint (*GetSystemError)(void);
NLint (*PollGroup)(NLint group, NLenum name, /*@out@*/ NLsocket *sockets,
NLint number, NLint timeout);
NLboolean (*PollSocket)(NLsocket socket, NLenum name, NLint timeout);
NLboolean (*Hint)(NLenum name, NLint arg);
NLboolean (*SetSocketOpt)(NLsocket socket, NLenum name, NLint arg);
NLint (*GetSocketOpt)(NLsocket socket, NLenum name);
} nl_netdriver_t;
typedef struct
{
NLlong bytes; /* bytes sent/received */
NLlong packets; /* packets sent/received */
NLlong highest; /* highest bytes/sec sent/received */
NLlong average; /* average bytes/sec sent/received */
time_t stime; /* the last time stats were updated */
NLint lastbucket; /* the last bucket that was used */
NLlong curbytes; /* current bytes sent/received */
NLlong bucket[NL_NUM_BUCKETS];/* buckets for sent/received counts */
NLboolean firstround; /* is this the first round through the buckets? */
} nl_stats_t;
typedef struct
{
/* info for NL_LOOP_BACK, NL_SERIAL, and NL_PARALLEL */
NLbyte *outpacket[NL_NUM_PACKETS];/* temp storage for packet data */
NLbyte *inpacket[NL_NUM_PACKETS];/* temp storage for packet data */
NLint outlen[NL_NUM_PACKETS];/* the length of each packet */
NLint inlen[NL_NUM_PACKETS];/* the length of each packet */
NLint nextoutused; /* the next used packet */
NLint nextinused; /* the next used packet */
NLint nextoutfree; /* the next free packet */
NLint nextinfree; /* the next free packet */
NLsocket accept[NL_MAX_ACCEPT];/* pending connects */
NLsocket consock; /* the socket this socket is connected to */
} nl_extra_t;
/* the internal socket object */
typedef struct
{
/* the current status of the socket */
NLenum driver; /* the driver used with this socket */
NLenum type; /* type of socket */
NLboolean inuse; /* is in use */
NLboolean connecting; /* a non-blocking TCP or UDP connection is in process */
NLboolean conerror; /* an error occured on a UDP connect */
NLboolean connected; /* is connected */
NLboolean reliable; /* do we use reliable */
NLboolean blocking; /* is set to blocking */
NLboolean listen; /* can receive an incoming connection */
NLboolean reuseaddr; /* can we reuse the address */
NLboolean TCPNoDelay; /* disable Nagle on TCP */
NLint TTL; /* TTL for multicast */
NLint realsocket; /* the real socket number */
NLushort localport; /* local port number */
NLushort remoteport; /* remote port number */
NLaddress addressin; /* address of remote system, same as the socket sockaddr_in structure */
NLaddress addressout; /* the multicast address set by nlConnect or the remote address for unconnected UDP */
Util::Thread::Lock readlock; /* socket is locked to update data */
Util::Thread::Lock writelock; /* socket is locked to update data */
/* the current read/write statistics for the socket */
nl_stats_t instats; /* stats for received */
nl_stats_t outstats; /* stats for sent */
/* NL_RELIABLE_PACKETS info and storage */
NLbyte *outbuf; /* temp storage for partially sent reliable packet data */
NLint outbuflen; /* the length of outbuf */
NLint sendlen; /* how much still needs to be sent */
NLbyte *inbuf; /* temp storage for partially received reliable packet data */
NLint inbuflen; /* the length of inbuf */
NLint reclen; /* how much of the reliable packet we have received */
NLboolean readable; /* a complete packet is in inbuf */
NLboolean message_end; /* a message end error ocured but was not yet reported */
NLboolean packetsync; /* is the reliable packet stream in sync */
/* pointer to extra info needed for NL_LOOP_BACK, NL_SERIAL, and NL_PARALLEL */
nl_extra_t *ext;
} nl_socket_t;
typedef struct
{
NLboolean socketStats; /* enable collection of socket read/write statistics, default disabled */
NLboolean nl_big_endian_data; /* is the packet data big endian? */
} nl_state_t;
/* used by the drivers to allocate and free socket objects */
NLsocket nlGetNewSocket(void);
/* other functions */
NLboolean nlGroupInit(void);
void nlGroupShutdown(void);
void nlGroupLock(void);
void nlGroupUnlock(void);
NLboolean nlGroupGetSocketsINT(NLint group, /*@out@*/ NLsocket *socket, /*@in@*/ NLint *number);
NLboolean nlIsValidSocket(NLsocket socket);
NLboolean nlLockSocket(NLsocket socket, NLint which);
void nlUnlockSocket(NLsocket socket, NLint which);
void nlSetError(NLenum err);
/* globals (as few as possible) */
extern volatile nl_state_t nlState;
typedef /*@only@*/ nl_socket_t *pnl_socket_t;
extern /*@only@*/ pnl_socket_t *nlSockets;
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* INTERNAL_H */
diff --git a/src/libs/hawknl/src/loopback.cpp b/src/libs/hawknl/src/loopback.cpp
index 32dccf9a..f58209ee 100644
--- a/src/libs/hawknl/src/loopback.cpp
+++ b/src/libs/hawknl/src/loopback.cpp
@@ -1,1050 +1,1050 @@
/*
HawkNL cross platform network library
Copyright (C) 2000-2004 Phil Frisbie, Jr. (phil@hawksoft.com)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#include <string.h>
#include <stdio.h>
#if defined (_WIN32_WCE)
#define errno GetLastError()
#else
#include <errno.h>
#endif
#include "hawknl/nlinternal.h"
-#include "util/funcs.h"
+#include "r-tech1/funcs.h"
#ifdef HL_WINDOWS_APP
/* Windows systems */
#include "hawknl/wsock.h"
#else
/* Unix-style systems or macs with posix support */
#ifndef WII
#include <netinet/in.h> /* for ntohs and htons */
#else
#include <network.h>
#endif
#endif
#ifdef NL_INCLUDE_LOOPBACK
#include "hawknl/loopback.h"
static NLaddress loopback_ouraddress;
static NLint loopgroup;
static volatile NLboolean reuseaddress = NL_FALSE;
static Util::Thread::Lock portlock; /* In memory of my step-father, Don Portlock,
who passed away Jan 12, 2001 - Phil */
static volatile NLushort newport = 1024;
static NLushort loopback_getNextPort(void)
{
Util::Thread::acquireLock(&portlock);
newport += 1;
if (newport < 1024){
newport = 1024;
}
Util::Thread::releaseLock(&portlock);
return newport;
}
static NLboolean loopback_ScanPort(NLushort port, NLenum type)
{
NLint numsockets = NL_MAX_GROUP_SOCKETS;
NLsocket temp[NL_MAX_GROUP_SOCKETS];
if(reuseaddress == NL_TRUE)
{
return NL_TRUE;
}
if(nlGroupGetSockets(loopgroup, (NLsocket *)&temp, &numsockets) == NL_FALSE)
{
return NL_FALSE;
}
if(numsockets == 0)
{
return NL_TRUE;
}
while(numsockets-- > 0)
{
nl_socket_t *sock = nlSockets[temp[numsockets]];
if(sock->type == type && sock->localport == port)
{
return NL_FALSE;
}
}
return NL_TRUE;
}
static NLushort loopback_TryPort(NLushort port, NLenum type)
{
NLint ntries = 500; /* this is to prevent an infinite loop */
if(port > 0)
{
if(loopback_ScanPort(port, type) == NL_TRUE)
{
return port;
}
else
{
return 0;
}
}
/* let's find our own port number */
while(ntries-- > 0)
{
port = loopback_getNextPort();
if(loopback_ScanPort(port, type) == NL_TRUE)
{
return port;
}
}
return 0;
}
NLboolean loopback_Init(void)
{
loopgroup = nlGroupCreate();
if(loopgroup == NL_INVALID)
{
return NL_FALSE;
}
return NL_TRUE;
}
void loopback_Shutdown(void)
{
(void)nlGroupDestroy(loopgroup);
}
NLboolean loopback_Listen(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
NLint i = NL_MAX_ACCEPT;
if(sock->type == NL_BROADCAST)
{
nlSetError(NL_WRONG_TYPE);
return NL_FALSE;
}
sock->listen = NL_TRUE;
while(i-- > 0)
{
sock->ext->accept[i] = NL_INVALID;
}
return NL_TRUE;
}
NLsocket loopback_AcceptConnection(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
if(sock->listen == NL_FALSE)
{
nlSetError(NL_NOT_LISTEN);
return NL_INVALID;
}
if(sock->inuse == NL_FALSE)
{
/* socket was closed by nlShutdown */
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
if(sock->ext == NULL)
{
/* socket was closed on another thread */
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
if(sock->ext->accept[0] != NL_INVALID)
{
NLsocket newsocket;
NLsocket osock = sock->ext->accept[0];
nl_socket_t *othersock = nlSockets[osock];
/* make sure the other socket is valid */
if(nlIsValidSocket(osock) == NL_FALSE)
{
NLint i;
for(i=1;i<NL_MAX_ACCEPT;i++)
{
sock->ext->accept[i-1] = sock->ext->accept[i];
}
sock->ext->accept[NL_MAX_ACCEPT-1] = NL_INVALID;
return loopback_AcceptConnection(socket);
}
newsocket = loopback_Open(0, sock->type);
if(newsocket != NL_INVALID)
{
NLint i;
nl_socket_t *newsock = nlSockets[newsocket];
/* we must unlock the socket briefly or else nlConnect will deadlock */
nlUnlockSocket(socket, NL_BOTH);
if(nlLockSocket(osock, NL_READ) == NL_FALSE)
{
return NL_INVALID;
}
(void)nlLockSocket(socket, NL_BOTH);
/* do the connecting */
newsock->ext->consock = osock;
newsock->remoteport = othersock->localport;
othersock->ext->consock = newsocket;
othersock->remoteport = newsock->localport;
newsock->connected = NL_TRUE;
loopback_SetAddrPort(&othersock->addressin, othersock->remoteport);
loopback_SetAddrPort(&newsock->addressin, newsock->remoteport);
othersock->connected = NL_TRUE;
othersock->connecting = NL_FALSE;
/* move the accept que down one */
for(i=1;i<NL_MAX_ACCEPT;i++)
{
sock->ext->accept[i-1] = sock->ext->accept[i];
}
sock->ext->accept[NL_MAX_ACCEPT-1] = NL_INVALID;
nlUnlockSocket(socket, NL_BOTH);
nlUnlockSocket(osock, NL_READ);
(void)nlLockSocket(socket, NL_BOTH);
return newsocket;
}
}
nlSetError(NL_NO_PENDING);
return NL_INVALID;
}
NLsocket loopback_Open(NLushort port, NLenum type)
{
nl_socket_t *newsock;
NLsocket newsocket;
NLint i;
NLushort lport;
switch (type) {
case NL_RELIABLE:
case NL_UNRELIABLE:
case NL_RELIABLE_PACKETS:
case NL_BROADCAST:
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_INVALID;
}
lport = loopback_TryPort(port, type);
if(lport == 0)
{
nlSetError(NL_INVALID_PORT);
return NL_INVALID;
}
newsocket = nlGetNewSocket();
if(newsocket == NL_INVALID)
{
return NL_INVALID;
}
if(nlLockSocket(newsocket, NL_BOTH) == NL_FALSE)
{
return NL_INVALID;
}
newsock = nlSockets[newsocket];
newsock->type = type;
newsock->localport = lport;
if(type == NL_BROADCAST)
{
newsock->remoteport = lport;
}
if((newsock->ext = (nl_extra_t *)malloc(sizeof(nl_extra_t))) == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
nlUnlockSocket(newsocket, NL_BOTH);
loopback_Close(newsocket);
return NL_INVALID;
}
/* clear out the structure */
memset(newsock->ext, 0, sizeof(nl_extra_t));
for(i=0;i<NL_NUM_PACKETS;i++)
{
NLboolean err = NL_FALSE;
/* malloc the max packet length plus two bytes for the port number */
if((newsock->ext->inpacket[i] = (NLbyte *)malloc((size_t)(NL_MAX_PACKET_LENGTH + 2))) == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
err = NL_TRUE;
}
if(err == NL_TRUE)
{
while(i-- > 0)
{
free(newsock->ext->inpacket[i]);
}
nlUnlockSocket(newsocket, NL_BOTH);
loopback_Close(newsocket);
return NL_INVALID;
}
}
(void)nlGroupAddSocket(loopgroup, newsocket);
nlUnlockSocket(newsocket, NL_BOTH);
return newsocket;
}
NLboolean loopback_Connect(NLsocket socket, const NLaddress *address)
{
nl_socket_t *sock = nlSockets[socket];
NLushort port;
NLint numsockets = NL_MAX_GROUP_SOCKETS;
NLsocket temp[NL_MAX_GROUP_SOCKETS];
/* no need to connect a broadcast socket */
if(sock->type == NL_BROADCAST)
{
nlSetError(NL_WRONG_TYPE);
}
port = loopback_GetPortFromAddr(address);
/* make sure socket is not already connected */
if(sock->connected == NL_TRUE)
{
nlSetError(NL_CONNECTED);
return NL_FALSE;
}
if(sock->connecting == NL_TRUE)
{
nlSetError(NL_CON_PENDING);
return NL_FALSE;
}
if(nlGroupGetSockets(loopgroup, (NLsocket *)&temp, &numsockets) == NL_FALSE)
{
return NL_FALSE;
}
if(numsockets == 0)
{
return NL_FALSE;
}
while(numsockets-- > 0)
{
NLsocket s = temp[numsockets];
nl_socket_t *othersock = nlSockets[s];
if(sock->type == othersock->type && port == othersock->localport
&& othersock->listen == NL_TRUE && othersock->connected == NL_FALSE
&& othersock->connecting == NL_FALSE)
{
/* we found the right socket, so connect */
NLint i;
if(nlLockSocket(s, NL_BOTH) == NL_FALSE)
{
return NL_FALSE;
}
for(i=0;i<NL_MAX_ACCEPT;i++)
{
if(othersock->ext->accept[i] == NL_INVALID)
{
othersock->ext->accept[i] = socket;
sock->connecting = NL_TRUE;
sock->ext->consock = s;
nlUnlockSocket(s, NL_BOTH);
if(sock->blocking == NL_TRUE)
{
nlUnlockSocket(socket, NL_BOTH);
/* wait for nlAccept to be called */
while(sock->connecting == NL_TRUE)
{
if(sock->inuse == NL_FALSE)
{
/* nlShutdown has been called */
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
Util::rest(NL_CONNECT_SLEEP);
}
(void)nlLockSocket(socket, NL_BOTH);
}
return NL_TRUE;
}
}
nlUnlockSocket(s, NL_BOTH);
}
}
nlSetError(NL_CON_REFUSED);
return NL_FALSE;
}
void loopback_Close(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
int i;
if(sock->connected == NL_TRUE || sock->connecting == NL_TRUE)
{
/* break the connection */
nl_socket_t *othersock = nlSockets[sock->ext->consock];
if(othersock->ext != NULL)
{
othersock->ext->consock = NL_INVALID;
}
othersock->connected = NL_FALSE;
sock->connected = NL_FALSE;
sock->listen = NL_FALSE;
if(sock->type != NL_BROADCAST)
{
/* this allows nlPollGroup to report socket is readable */
/* so that the app can get the NL_SOCK_DISCONNECT message*/
if(othersock->ext != NULL)
{
othersock->ext->inlen[othersock->ext->nextinused] = -1;
}
}
}
for(i=0;i<NL_NUM_PACKETS;i++)
{
void /*@owned@*/*t = sock->ext->inpacket[i];
free(t);
sock->ext->inpacket[i] = NULL;
}
free(sock->ext);
sock->ext = NULL;
}
NLint loopback_Read(NLsocket socket, NLvoid *buffer, NLint nbytes)
{
nl_socket_t *sock = nlSockets[socket];
NLint len = sock->ext->inlen[sock->ext->nextinused];
NLint c = 0;
NLushort port;
if(sock->blocking == NL_TRUE)
{
while(len == 0)
{
nlUnlockSocket(socket, NL_READ);
Util::rest(NL_CONNECT_SLEEP);
(void)nlLockSocket(socket, NL_READ);
if(sock->inuse == NL_FALSE)
{
/* nlShutdown has been called */
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
len = sock->ext->inlen[sock->ext->nextinused];
}
}
if(len > 0)
{
if(len > nbytes)
{
nlSetError(NL_BUFFER_SIZE);
return NL_INVALID;
}
if(sock->connecting == NL_TRUE)
{
nlSetError(NL_CON_PENDING);
return NL_INVALID;
}
/* get the port number */
readShort(sock->ext->inpacket[sock->ext->nextinused], c, port);
loopback_SetAddrPort(&sock->addressin, port);
/* copy the packet */
memcpy(buffer, sock->ext->inpacket[sock->ext->nextinused] + 2, (size_t)len);
/* zero out length and set up for next packet */
sock->ext->inlen[sock->ext->nextinused] = 0;
sock->ext->nextinused++;
if(sock->ext->nextinused >= NL_NUM_PACKETS)
{
sock->ext->nextinused = 0;
}
}
/* check for broken connection */
else if((len == -1) || (sock->connected == NL_TRUE && sock->ext->consock == NL_INVALID)
|| (sock->connected == NL_FALSE && sock->type != NL_BROADCAST))
{
nlSetError(NL_SOCK_DISCONNECT);
return NL_INVALID;
}
return len;
}
static NLint loopback_WritePacket(NLsocket to, const NLvoid *buffer, NLint nbytes, NLushort fromport)
{
nl_socket_t *sock = nlSockets[to];
NLint i, j;
NLint c = 0;
/* check the packet size */
if(nbytes > NL_MAX_PACKET_LENGTH)
{
nlSetError(NL_PACKET_SIZE);
return NL_INVALID;
}
if(nlLockSocket(to, NL_READ) == NL_FALSE)
{
return NL_INVALID;
}
/* make sure we have an empty packet buffer */
if(sock->ext->nextinfree == NL_INVALID)
{
/* all buffers were filled by last write */
/* check to see if any were emptied by a read */
i = NL_NUM_PACKETS;
j = sock->ext->nextinused;
while(i-- > 0)
{
if(sock->ext->inlen[j] == 0)
{
/* found the first free */
sock->ext->nextinfree = j;
break;
}
j++;
if(j >= NL_NUM_PACKETS)
{
j = 0;
}
}
if(sock->ext->nextinfree == NL_INVALID)
{
nlUnlockSocket(to, NL_READ);
/* none are free */
if(sock->type == NL_RELIABLE || sock->type == NL_RELIABLE_PACKETS)
{
return 0;
}
else
{
/* silently fail */
return nbytes;
}
}
}
/* write the port number */
writeShort(sock->ext->inpacket[sock->ext->nextinfree], c, fromport);
/* copy the packet buffer */
memcpy(sock->ext->inpacket[sock->ext->nextinfree] + 2, buffer, (size_t)nbytes);
sock->ext->inlen[sock->ext->nextinfree] = nbytes;
sock->ext->nextinfree++;
if(sock->ext->nextinfree >= NL_NUM_PACKETS)
{
sock->ext->nextinfree = 0;
}
/* check for full packet buffers */
if(sock->ext->inlen[sock->ext->nextinfree] != 0)
{
sock->ext->nextinfree = NL_INVALID;
}
nlUnlockSocket(to, NL_READ);
return nbytes;
}
NLint loopback_Write(NLsocket socket, const NLvoid *buffer, NLint nbytes)
{
nl_socket_t *sock = nlSockets[socket];
nl_socket_t *othersock;
NLsocket s[NL_MAX_GROUP_SOCKETS];
NLint number = NL_MAX_GROUP_SOCKETS;
NLint i;
NLint count;
switch (sock->type) {
case NL_RELIABLE:
case NL_RELIABLE_PACKETS:
default:
{
if(sock->connected == NL_TRUE)
{
/* check for broken connection */
if(sock->ext->consock == NL_INVALID)
{
nlSetError(NL_SOCK_DISCONNECT);
return NL_INVALID;
}
count = loopback_WritePacket(sock->ext->consock, buffer, nbytes, sock->localport);
}
else if(sock->connecting == NL_TRUE)
{
nlSetError(NL_CON_PENDING);
return NL_INVALID;
}
else
{
nlSetError(NL_SOCK_DISCONNECT);
return NL_INVALID;
}
}
break;
case NL_UNRELIABLE:
{
if(sock->connected == NL_TRUE)
{
/* check for broken connection */
if(sock->ext->consock == NL_INVALID)
{
nlSetError(NL_SOCK_DISCONNECT);
return NL_INVALID;
}
count = loopback_WritePacket(sock->ext->consock, buffer, nbytes, sock->localport);
}
else if(sock->connecting == NL_TRUE)
{
nlSetError(NL_CON_PENDING);
return NL_INVALID;
}
/* unconnected UDP emulation */
count = nbytes;
(void)nlGroupGetSockets(loopgroup, (NLsocket *)s, &number);
for(i=0;i<number;i++)
{
if(nlIsValidSocket(s[i]) == NL_TRUE)
{
othersock = nlSockets[s[i]];
if(sock->remoteport == othersock->localport &&
othersock->connected == NL_FALSE &&
sock->type == othersock->type)
{
(void)loopback_WritePacket(s[i], buffer, nbytes, sock->localport);
}
}
}
}
break;
case NL_BROADCAST:
{
count = nbytes;
(void)nlGroupGetSockets(loopgroup, (NLsocket *)s, &number);
for(i=0;i<number;i++)
{
if(nlIsValidSocket(s[i]) == NL_TRUE)
{
othersock = nlSockets[s[i]];
if(sock->localport == othersock->localport &&
sock->type == othersock->type)
{
(void)loopback_WritePacket(s[i], buffer, nbytes, sock->localport);
}
}
}
}
}
return count;
}
NLchar *loopback_AddrToString(const NLaddress *address, NLchar *string)
{
_stprintf(string, TEXT("127.0.0.1:%u"), loopback_GetPortFromAddr(address));
return string;
}
NLboolean loopback_StringToAddr(const NLchar *string, NLaddress *address)
{
NLchar *st;
NLint port;
memset(address, 0, sizeof(NLaddress));
address->valid = NL_TRUE;
/* check for a port number */
st = _tcschr((NLchar*) string, TEXT(':'));
if(st != NULL)
{
st++;
port = _ttoi(st);
if(port < 0 || port > 65535)
{
nlSetError(NL_BAD_ADDR);
address->valid = NL_FALSE;
return NL_FALSE;
}
loopback_SetAddrPort(address, (NLushort)port);
}
return NL_TRUE;
}
NLboolean loopback_GetLocalAddr(NLsocket socket, NLaddress *address)
{
nl_socket_t *sock = nlSockets[socket];
memset(address, 0, sizeof(NLaddress));
loopback_SetAddrPort(address, sock->localport);
address->valid = NL_TRUE;
return NL_TRUE;
}
NLaddress *loopback_GetAllLocalAddr(NLint *count)
{
*count = 1;
memset(&loopback_ouraddress, 0, sizeof(NLaddress));
loopback_ouraddress.valid = NL_TRUE;
return &loopback_ouraddress;
}
NLboolean loopback_SetLocalAddr(const NLaddress *address)
{
/* this is just to keep compilers happy */
if(address == NULL)
{
return NL_FALSE;
}
return NL_TRUE;
}
NLchar *loopback_GetNameFromAddr(const NLaddress *address, NLchar *name)
{
_stprintf(name, TEXT("%s:%u"), TEXT("localhost"), loopback_GetPortFromAddr(address));
return name;
}
NLboolean loopback_GetNameFromAddrAsync(const NLaddress *address, NLchar *name)
{
(void)loopback_GetNameFromAddr(address, name);
return NL_TRUE;
}
NLboolean loopback_GetAddrFromName(const NLchar *name, NLaddress *address)
{
return loopback_StringToAddr(name, address);
}
NLboolean loopback_GetAddrFromNameAsync(const NLchar *name, NLaddress *address)
{
return loopback_GetAddrFromName(name, address);
}
NLboolean loopback_AddrCompare(const NLaddress *address1, const NLaddress *address2)
{
if(*(NLushort *)(&address1->addr[0]) == *(NLushort *)(&address2->addr[0]))
{
return NL_TRUE;
}
return NL_FALSE;
}
NLushort loopback_GetPortFromAddr(const NLaddress *address)
{
return *(NLushort *)(&address->addr[0]);
}
void loopback_SetAddrPort(NLaddress *address, NLushort port)
{
*(NLushort *)(&address->addr[0]) = port;
}
NLint loopback_GetSystemError(void)
{
return errno;
}
NLint loopback_PollGroup(NLint group, NLenum name, NLsocket *sockets, NLint number, NLint timeout)
{
NLint count = 0;
NLint numsockets = NL_MAX_GROUP_SOCKETS;
NLsocket temp[NL_MAX_GROUP_SOCKETS];
NLtime end, now;
nlGroupLock();
if(nlGroupGetSocketsINT(group, (NLsocket *)&temp, &numsockets) == NL_FALSE)
{
/* any error is set by nlGroupGetSockets */
nlGroupUnlock();
return NL_INVALID;
}
nlGroupUnlock();
if(numsockets == 0)
{
return 0;
}
(void)nlTime(&now);
end.seconds = now.seconds;
end.mseconds = now.mseconds;
if(timeout > 0)
{
end.mseconds += timeout;
while(end.mseconds > 999)
{
end.mseconds -= 1000;
end.seconds++;
}
}
while(count == 0)
{
switch(name) {
case NL_READ_STATUS:
{
NLint i = 0;
NLint j = numsockets;
while(j-- > 0)
{
/* check for a packet */
nl_socket_t *sock;
if(nlIsValidSocket(temp[i]) != NL_TRUE)
{
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
sock = nlSockets[temp[i]];
if(sock->ext->inlen[sock->ext->nextinused] != 0)
{
*sockets = temp[i];
sockets++;
count++;
if(count > number)
{
nlSetError(NL_BUFFER_SIZE);
return NL_INVALID;
}
}
i++;
}
}
break;
case NL_WRITE_STATUS:
{
NLint i = 0;
NLint j = numsockets;
while(j-- > 0)
{
nl_socket_t *sock;
if(nlIsValidSocket(temp[i]) != NL_TRUE)
{
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
sock = nlSockets[temp[i]];
/* check for a free packet if reliable and connected */
if((sock->type == NL_TCP || sock->type == NL_TCP_PACKETS)
&& (sock->connecting == NL_TRUE || sock->connected == NL_TRUE))
{
nl_socket_t *othersock = nlSockets[sock->ext->consock];
if(othersock->ext->nextinfree == NL_INVALID)
{
continue;
}
}
/* add the socket to the list */
*sockets = temp[i];
sockets++;
count++;
if(count > number)
{
nlSetError(NL_BUFFER_SIZE);
return NL_INVALID;
}
i++;
}
}
break;
case NL_ERROR_STATUS:
{
NLint i = 0;
NLint j = numsockets;
while(j-- > 0)
{
nl_socket_t *sock;
if(nlIsValidSocket(temp[i]) != NL_TRUE)
{
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
sock = nlSockets[temp[i]];
if(sock->connected == NL_FALSE && sock->type != NL_UDP_BROADCAST)
{
/* add the socket to the list */
*sockets = temp[i];
sockets++;
count++;
if(count > number)
{
nlSetError(NL_BUFFER_SIZE);
return NL_INVALID;
}
i++;
}
}
}
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_INVALID;
}
if(timeout != 0)
{
Util::rest(1);
(void)nlTime(&now);
if(timeout > 0 && (now.seconds > end.seconds || (now.seconds == end.seconds && now.mseconds > end.mseconds)))
break;
}
else
{
break;
}
}
return count;
}
NLboolean loopback_PollSocket(NLsocket socket, NLenum name, NLint timeout)
{
nl_socket_t *sock = nlSockets[socket];
NLtime end, now;
nlSetError(NL_NO_ERROR);
(void)nlTime(&now);
end.seconds = now.seconds;
end.mseconds = now.mseconds;
if(timeout > 0)
{
end.mseconds += timeout;
while(end.mseconds > 999)
{
end.mseconds -= 1000;
end.seconds++;
}
}
while(!(timeout > 0 && (now.seconds > end.seconds || (now.seconds == end.seconds && now.mseconds > end.mseconds))))
{
switch(name) {
case NL_READ_STATUS:
if(sock->ext->inlen[sock->ext->nextinused] > 0)
return NL_TRUE;
break;
case NL_WRITE_STATUS:
/* check for a free packet if reliable and connected */
if((sock->type == NL_TCP || sock->type == NL_TCP_PACKETS)
&& (sock->connecting == NL_TRUE || sock->connected == NL_TRUE))
{
nl_socket_t *othersock = nlSockets[sock->ext->consock];
if(othersock->ext->nextinfree != NL_INVALID)
{
return NL_TRUE;
}
}
else
{
return NL_TRUE;
}
break;
case NL_ERROR_STATUS:
if(sock->connected == NL_FALSE && sock->type != NL_UDP_BROADCAST)
return NL_TRUE;
break;
default:
nlSetError(NL_INVALID_ENUM);
}
if(timeout != 0)
{
Util::rest(1);
(void)nlTime(&now);
}
else
{
break;
}
}
return NL_FALSE;
}
NLboolean loopback_Hint(NLenum name, NLint arg)
{
switch (name) {
case NL_REUSE_ADDRESS:
reuseaddress = (NLboolean)(arg != 0 ? NL_TRUE : NL_FALSE);
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
return NL_TRUE;
}
NLboolean loopback_SetSocketOpt(NLsocket socket, NLenum name, NLint arg)
{
nl_socket_t *sock = nlSockets[socket];
switch (name) {
case NL_BLOCKING_IO:
sock->blocking = (NLboolean)((NLboolean)arg != NL_FALSE ? NL_FALSE : NL_TRUE);
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
return NL_TRUE;
}
NLint loopback_GetSocketOpt(NLsocket socket, NLenum name)
{
nl_socket_t *sock = nlSockets[socket];
switch (name) {
case NL_BLOCKING_IO:
return (NLint)sock->blocking;
default:
nlSetError(NL_INVALID_ENUM);
return NL_INVALID;
}
}
#endif /* NL_INCLUDE_LOOPBACK */
diff --git a/src/libs/hawknl/src/nl.cpp b/src/libs/hawknl/src/nl.cpp
index 75ef4d23..d001a5f5 100644
--- a/src/libs/hawknl/src/nl.cpp
+++ b/src/libs/hawknl/src/nl.cpp
@@ -1,1959 +1,1959 @@
/*
HawkNL cross platform network library
Copyright (C) 2000-2004 Phil Frisbie, Jr. (phil@hawksoft.com)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#include <string.h>
#include "hawknl/nlinternal.h"
#include "hawknl/sock.h"
#include "hawknl/serial.h"
#include "hawknl/parallel.h"
-#include "util/funcs.h"
+#include "r-tech1/funcs.h"
#ifdef PS3
#include <net/net.h>
#endif
#ifdef WII
#include <network.h>
#endif
#ifdef NL_INCLUDE_LOOPBACK
#include "hawknl/loopback.h"
#endif
#if defined HL_WINDOWS_APP && defined NL_INCLUDE_IPX
#include "hawknl/ipx.h"
#endif
#define MAX_NET_DRIVERS 6
volatile nl_state_t nlState = {NL_FALSE, NL_TRUE};
/* mutexes for global variables */
static Util::Thread::Lock socklock, instatlock, outstatlock;
static volatile NLboolean nlBlocking = NL_FALSE;
static volatile nl_stats_t nlInstats;
static volatile nl_stats_t nlOutstats;
static volatile NLsocket nlNextsocket = 0;
static volatile NLint nlNumsockets = 0;
static volatile NLint nlMaxNumsockets = NL_MIN_SOCKETS; /* this is dynamic, and can grow as needed */
static volatile NLint nlInitCount = 0;
pnl_socket_t *nlSockets = NULL;
/* the current selected driver */
static nl_netdriver_t /*@null@*/*driver = NULL;
static nl_netdriver_t netdrivers[] =
{
{
(NLchar*)TEXT("NL_IP"),
(NLchar*)TEXT("NL_RELIABLE NL_UNRELIABLE NL_RELIABLE_PACKETS NL_BROADCAST NL_UDP_MULTICAST NL_MULTICAST"),
NL_IP,
NL_FALSE,
sock_Init,
sock_Shutdown,
sock_Listen,
sock_AcceptConnection,
sock_Open,
sock_Connect,
sock_Close,
sock_Read,
sock_Write,
sock_AddrToString,
sock_StringToAddr,
sock_GetLocalAddr,
sock_GetAllLocalAddr,
sock_SetLocalAddr,
sock_GetNameFromAddr,
sock_GetNameFromAddrAsync,
sock_GetAddrFromName,
sock_GetAddrFromNameAsync,
sock_AddrCompare,
sock_GetPortFromAddr,
sock_SetAddrPort,
sock_GetSystemError,
sock_PollGroup,
sock_PollSocket,
sock_Hint,
sock_SetSocketOpt,
sock_GetSocketOpt
}
#ifdef NL_INCLUDE_LOOPBACK
,
{
(NLchar*)TEXT("NL_LOOP_BACK"),
(NLchar*)TEXT("NL_RELIABLE NL_UNRELIABLE NL_RELIABLE_PACKETS NL_BROADCAST"),
NL_LOOP_BACK,
NL_FALSE,
loopback_Init,
loopback_Shutdown,
loopback_Listen,
loopback_AcceptConnection,
loopback_Open,
loopback_Connect,
loopback_Close,
loopback_Read,
loopback_Write,
loopback_AddrToString,
loopback_StringToAddr,
loopback_GetLocalAddr,
loopback_GetAllLocalAddr,
loopback_SetLocalAddr,
loopback_GetNameFromAddr,
loopback_GetNameFromAddrAsync,
loopback_GetAddrFromName,
loopback_GetAddrFromNameAsync,
loopback_AddrCompare,
loopback_GetPortFromAddr,
loopback_SetAddrPort,
loopback_GetSystemError,
loopback_PollGroup,
loopback_PollSocket,
loopback_Hint,
loopback_SetSocketOpt,
loopback_GetSocketOpt
}
#endif /* NL_INCLUDE_LOOPBACK */
#if defined HL_WINDOWS_APP && defined NL_INCLUDE_IPX
,
{
(NLchar*)TEXT("NL_IPX"),
(NLchar*)TEXT("NL_RELIABLE NL_UNRELIABLE NL_RELIABLE_PACKETS NL_BROADCAST"),
NL_IPX,
NL_FALSE,
ipx_Init,
ipx_Shutdown,
sock_Listen,
ipx_AcceptConnection,
ipx_Open,
sock_Connect,
sock_Close,
sock_Read,
sock_Write,
ipx_AddrToString,
ipx_StringToAddr,
ipx_GetLocalAddr,
ipx_GetAllLocalAddr,
ipx_SetLocalAddr,
ipx_GetNameFromAddr,
ipx_GetNameFromAddrAsync,
ipx_GetAddrFromName,
ipx_GetAddrFromNameAsync,
ipx_AddrCompare,
ipx_GetPortFromAddr,
ipx_SetAddrPort,
sock_GetSystemError,
sock_PollGroup,
sock_PollSocket,
ipx_Hint,
ipx_SetSocketOpt,
ipx_GetSocketOpt
}
#endif /* HL_WINDOWS_APP && NL_INCLUDE_IPX */
,
{
(NLchar*)NULL,
}
};
/*
Internal helper functions.
*/
static NLboolean isSafeString(const NLchar *string)
{
int i;
NLboolean nullfound = NL_FALSE;
/* make sure string is null terminated at less than NL_MAX_STRING_LENGTH */
for(i=0;i<NL_MAX_STRING_LENGTH;i++)
{
if(string[i] == (NLchar)'\0')
{
nullfound = NL_TRUE;
break;
}
}
if(nullfound == NL_FALSE)
{
return NL_FALSE;
}
/* check for formating characters */
if(_tcsrchr(string, '%') != NULL)
{
return NL_FALSE;
}
return NL_TRUE;
}
static void safecat(NLchar *dest, const NLchar *src)
{
int len;
if(isSafeString(dest) != NL_TRUE || isSafeString(src) != NL_TRUE)
{
/* don't do anything */
return;
}
len = (int)_tcslen(dest);
if( len < (NL_MAX_STRING_LENGTH - 1))
{
_tcsncat(dest, src, (size_t)(NL_MAX_STRING_LENGTH - len));
dest[NL_MAX_STRING_LENGTH - 1] = (NLchar)'\0';
}
}
NLsocket nlGetNewSocket(void)
{
NLsocket newsocket = NL_INVALID;
nl_socket_t *sock = NULL;
if(Util::Thread::acquireLock(&socklock) != 0)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_INVALID;
}
if(nlNumsockets == nlMaxNumsockets)
{
nl_socket_t **temp;
NLint tempmaxnumsockets = nlMaxNumsockets;
/* expand the list of sockets pointers */
tempmaxnumsockets *= 2;
temp = (nl_socket_t **)realloc((void *)nlSockets, tempmaxnumsockets * sizeof(nl_socket_t *));
if(temp == NULL)
{
Util::Thread::releaseLock(&socklock);
nlSetError(NL_OUT_OF_MEMORY);
return NL_INVALID;
}
nlSockets = temp;
nlMaxNumsockets = tempmaxnumsockets;
}
/* get a socket number */
if(nlNumsockets == (NLint)nlNextsocket)
{
newsocket = nlNextsocket++;
/* allocate the memory */
sock = (nl_socket_t *)malloc(sizeof(nl_socket_t));
if(sock == NULL)
{
Util::Thread::releaseLock(&socklock);
nlSetError(NL_OUT_OF_MEMORY);
return NL_INVALID;
}
else
{
nlSockets[newsocket] = sock;
}
/* clear the structure */
memset(sock, 0, sizeof(nl_socket_t));
if(Util::Thread::initializeLock(&sock->readlock) != true || Util::Thread::initializeLock(&sock->writelock) != true)
{
nlSetError(NL_SYSTEM_ERROR);
Util::Thread::releaseLock(&socklock);
return NL_INVALID;
}
}
else
/* there is an open socket slot somewhere below nlNextsocket */
{
NLsocket i;
Util::Thread::Lock readlock, writelock;
for(i=0;i<nlNextsocket;i++)
{
if(nlSockets[i]->inuse == NL_FALSE)
{
/* found an open socket slot */
newsocket = i;
sock = nlSockets[i];
break;
}
}
/* let's check just to make sure we did find a socket */
if(sock == NULL)
{
Util::Thread::releaseLock(&socklock);
nlSetError(NL_OUT_OF_MEMORY);
return NL_INVALID;
}
readlock = sock->readlock;
writelock = sock->writelock;
/* clear the structure */
memset(sock, 0, sizeof(nl_socket_t));
sock->readlock = readlock;
sock->writelock = writelock;
}
/* sockets are blocking until set for non-blocking */
sock->blocking = nlBlocking;
sock->inuse = NL_TRUE;
nlNumsockets++;
Util::Thread::releaseLock(&socklock);
return newsocket;
}
static void nlReturnSocket(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
if((sock != NULL) && (sock->inuse == NL_TRUE))
{
sock->inuse = NL_FALSE;
if(sock->inbuf != NULL)
{
free(sock->inbuf);
sock->inbuf = NULL;
}
if(sock->outbuf != NULL)
{
free(sock->outbuf);
sock->outbuf = NULL;
}
nlNumsockets--;
}
}
void nlFreeSocket(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
if(sock != NULL)
{
if(sock->inbuf != NULL)
{
free(sock->inbuf);
}
if(sock->outbuf != NULL)
{
free(sock->outbuf);
}
Util::Thread::destroyLock(&sock->readlock);
Util::Thread::destroyLock(&sock->writelock);
free(sock);
}
}
NLboolean nlIsValidSocket(NLsocket socket)
{
nl_socket_t *sock;
if(socket < 0 || socket > nlMaxNumsockets)
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
sock = nlSockets[socket];
if(sock == NULL)
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
if(sock->inuse == NL_FALSE)
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
return NL_TRUE;
}
NLboolean nlLockSocket(NLsocket socket, NLint which)
{
nl_socket_t *sock = nlSockets[socket];
if((which&NL_READ) > 0)
{
if(Util::Thread::acquireLock(&sock->readlock) != 0)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
}
if((which&NL_WRITE) > 0)
{
if(Util::Thread::acquireLock(&sock->writelock) != 0)
{
if((which&NL_READ) > 0)
{
Util::Thread::releaseLock(&sock->readlock);
}
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
}
return NL_TRUE;
}
void nlUnlockSocket(NLsocket socket, NLint which)
{
nl_socket_t *sock = nlSockets[socket];
if((which&NL_WRITE) > 0){
Util::Thread::releaseLock(&sock->writelock);
}
if((which&NL_READ) > 0)
{
Util::Thread::releaseLock(&sock->readlock);
}
}
static void nlUpdateStats(volatile nl_stats_t *stats, NLint nbytes, NLint npackets)
{
time_t t;
(void)time(&t);
if(stats->stime == 0)
{
/* must be the first time through */
stats->stime = t;
stats->lastbucket = -1;
stats->firstround = NL_TRUE;
}
/* do the basic update */
stats->packets += npackets;
stats->bytes += nbytes;
/* check to see if we need to do the full update */
if(stats->stime != t)
{
NLint i;
NLlong count = 0;
time_t diff = t - stats->stime;
stats->stime = t;
if(stats->curbytes > stats->highest)
{
stats->highest = stats->curbytes;
}
if(diff >= NL_NUM_BUCKETS)
{
diff = NL_NUM_BUCKETS;
}
while(diff > 1)
{
/* we need to zero out skipped over buckets */
stats->lastbucket++;
if(stats->lastbucket == NL_NUM_BUCKETS)
{
stats->lastbucket = 0;
}
stats->bucket[stats->lastbucket] = 0;
diff--;
}
stats->lastbucket++;
if(stats->lastbucket == NL_NUM_BUCKETS)
{
stats->lastbucket = 0;
stats->firstround = NL_FALSE;
}
stats->bucket[stats->lastbucket] = stats->curbytes;
if(stats->firstround == NL_TRUE)
{
/* this corrects the stats for the first second */
for(i=stats->lastbucket + 1;i<NL_NUM_BUCKETS;i++)
{
stats->bucket[i] = stats->curbytes;
}
}
stats->curbytes = 0;
for(i=0;i<NL_NUM_BUCKETS;i++)
{
count += stats->bucket[i];
}
stats->average = count / NL_NUM_BUCKETS;
}
stats->curbytes += nbytes;
}
static void nlUpdateInStats(NLint nbytes, NLint npackets)
{
if(nlState.socketStats == NL_FALSE)
{
return;
}
Util::Thread::acquireLock(&instatlock);
nlUpdateStats(&nlInstats, nbytes, npackets);
Util::Thread::releaseLock(&instatlock);
}
static void nlUpdateOutStats(NLint nbytes, NLint npackets)
{
if(nlState.socketStats == NL_FALSE)
{
return;
}
Util::Thread::acquireLock(&outstatlock);
nlUpdateStats(&nlOutstats, nbytes, npackets);
Util::Thread::releaseLock(&outstatlock);
}
static void nlUpdateSocketInStats(NLsocket socket, NLint nbytes, NLint npackets)
{
nl_socket_t *sock = nlSockets[socket];
if(nlState.socketStats == NL_FALSE)
{
return;
}
nlUpdateStats(&sock->instats, nbytes, npackets);
}
static void nlUpdateSocketOutStats(NLsocket socket, NLint nbytes, NLint npackets)
{
nl_socket_t *sock = nlSockets[socket];
if(nlState.socketStats == NL_FALSE)
{
return;
}
nlUpdateStats(&sock->outstats, nbytes, npackets);
}
/*
Low level functions, a thin layer over Sockets.
*/
/*
Trys to init all drivers, BUT DOES NOT SELECT A DRIVER
*/
HL_EXP NLboolean HL_APIENTRY nlInit(void)
{
int i, numdrivers = 0;
#ifdef PS3
netInitialize();
#endif
#ifdef WII
net_init();
#endif
nlSetError(NL_NO_ERROR);
/* init socket memory, mutexes, and global variables */
if(nlInitCount == 0)
{
nlMaxNumsockets = NL_MIN_SOCKETS;
if(nlSockets == NULL)
{
nlSockets = (nl_socket_t **)malloc(nlMaxNumsockets * sizeof(nl_socket_t *));
}
if(nlSockets == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
nlShutdown();
return NL_FALSE;
}
if(nlGroupInit() == NL_FALSE)
{
nlShutdown();
return NL_FALSE;
}
if(Util::Thread::initializeLock(&socklock) != true || Util::Thread::initializeLock(&instatlock) != true ||
Util::Thread::initializeLock(&outstatlock) != true)
{
nlSetError(NL_SYSTEM_ERROR);
nlShutdown();
return NL_FALSE;
}
nlNumsockets = 0;
nlNextsocket = 0;
nlBlocking = NL_FALSE;
nlState.socketStats = NL_FALSE;
nlState.nl_big_endian_data = NL_TRUE;
for(i=0;i<MAX_NET_DRIVERS;i++)
{
if(netdrivers[i].name == NULL)
{
break;
}
if(netdrivers[i].initialized == NL_TRUE)
{
numdrivers++;
}
else if(netdrivers[i].Init() == NL_TRUE)
{
netdrivers[i].initialized = NL_TRUE;
numdrivers++;
}
}
if(numdrivers == 0)
{
nlSetError(NL_NO_NETWORK);
nlShutdown();
return NL_FALSE;
}
}
nlInitCount++;
return NL_TRUE;
}
/*
Called at the end of your program, shuts down the active driver and frees memory
*/
HL_EXP void HL_APIENTRY nlShutdown(void)
{
--nlInitCount;
if(nlInitCount > 0)
{
return;
}
if(driver != NULL)
{
/* close any open sockets */
Util::Thread::acquireLock(&socklock);
if(nlSockets != NULL)
{
NLsocket s;
for(s=0;s<nlNextsocket;s++)
{
if(nlSockets[s] != NULL)
{
if(nlIsValidSocket(s) == NL_TRUE)
{
driver->Close(s);
Util::rest(0);
}
}
}
}
/* now we can shutdown the driver */
driver->Shutdown();
driver->initialized = NL_FALSE;
driver = NULL;
}
else
{
nlSetError(NL_NO_NETWORK);
}
Util::rest(1);
/* now free all the socket structures */
if(nlSockets != NULL)
{
NLsocket s;
for(s=0;s<nlNextsocket;s++)
{
if(nlSockets[s] != NULL)
{
if(nlIsValidSocket(s) == NL_TRUE)
{
(void)nlLockSocket(s, NL_BOTH);
nlReturnSocket(s);
nlUnlockSocket(s, NL_BOTH);
Util::rest(0);
}
nlFreeSocket(s);
}
}
free(nlSockets);
nlSockets = NULL;
}
Util::Thread::releaseLock(&socklock);
nlGroupShutdown();
/* destroy the mutexes */
Util::Thread::destroyLock(&socklock);
Util::Thread::destroyLock(&instatlock);
Util::Thread::destroyLock(&outstatlock);
}
/*
Enables a socket to listen for incomming connections
*/
HL_EXP NLboolean HL_APIENTRY nlListen(NLsocket socket)
{
if(driver != NULL)
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
NLboolean result;
if(nlLockSocket(socket, NL_BOTH) == NL_FALSE)
{
return NL_FALSE;
}
result = driver->Listen(socket);
nlUnlockSocket(socket, NL_BOTH);
return result;
}
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Accepts a pending connection.
Creates a new socket object for this connection.
*/
HL_EXP NLsocket HL_APIENTRY nlAcceptConnection(NLsocket socket)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
NLsocket newsocket;
if(nlLockSocket(socket, NL_BOTH) == NL_FALSE)
{
return NL_INVALID;
}
newsocket = driver->AcceptConnection(socket);
nlUnlockSocket(socket, NL_BOTH);
if(newsocket != NL_INVALID)
{
/* the new socket was locked when it is created */
nlUnlockSocket(newsocket, NL_BOTH);
}
return newsocket;
}
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
nlSetError(NL_NO_NETWORK);
return NL_INVALID;
}
/*
Creates a new socket object.
Can be used for reading or broadcast as is.
For non-broadcast use, call nlConnectSocket to connect to a remote address.
*/
HL_EXP NLsocket HL_APIENTRY nlOpen(NLushort port, NLenum type)
{
if(driver)
{
return (driver->Open(port, type));
}
nlSetError(NL_NO_NETWORK);
return NL_INVALID;
}
/*
Connect a socket to a remote address.
*/
HL_EXP NLboolean HL_APIENTRY nlConnect(NLsocket socket, const NLaddress *address)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
if(address == NULL)
{
nlSetError(NL_NULL_POINTER);
}
else
{
NLboolean result;
if(nlLockSocket(socket, NL_BOTH) == NL_FALSE)
{
return NL_FALSE;
}
result = driver->Connect(socket, address);
nlUnlockSocket(socket, NL_BOTH);
return result;
}
}
else
{
nlSetError(NL_INVALID_SOCKET);
}
return NL_FALSE;
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Close the socket.
*/
HL_EXP NLboolean HL_APIENTRY nlClose(NLsocket socket)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
if(Util::Thread::acquireLock(&socklock) != 0)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
/*
if(nlLockSocket(socket, NL_BOTH) == NL_FALSE)
{
return NL_FALSE;
}
*/
driver->Close(socket);
/* return the socket for reuse */
nlReturnSocket(socket);
// nlUnlockSocket(socket, NL_BOTH);
if(Util::Thread::releaseLock(&socklock) != 0)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
return NL_TRUE;
}
else
{
nlSetError(NL_INVALID_SOCKET);
return NL_TRUE;
}
}
#ifdef WII
net_deinit();
#endif
#ifdef PS3
netDeinitialize();
#endif
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Reads from a socket.
*/
HL_EXP NLint HL_APIENTRY nlRead(NLsocket socket, NLvoid *buffer, NLint nbytes)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
if(buffer == NULL)
{
nlSetError(NL_NULL_POINTER);
}
else
{
NLint received;
if(nlLockSocket(socket, NL_READ) == NL_FALSE)
{
return NL_INVALID;
}
received = driver->Read(socket, buffer, nbytes);
if(received > 0)
{
nlUpdateSocketInStats(socket, received, 1);
nlUpdateInStats(received, 1);
}
nlUnlockSocket(socket, NL_READ);
return received;
}
}
else
{
nlSetError(NL_INVALID_SOCKET);
}
return NL_INVALID;
}
nlSetError(NL_NO_NETWORK);
return NL_INVALID;
}
/*
Writes to a socket.
*/
HL_EXP NLint HL_APIENTRY nlWrite(NLsocket socket, const NLvoid *buffer, NLint nbytes)
{
if(driver)
{
/* check for group */
if(socket >= NL_FIRST_GROUP)
{
NLint number = NL_MAX_GROUP_SOCKETS;
NLsocket s[NL_MAX_GROUP_SOCKETS];
NLint i;
NLint sent = nbytes;
if(nlGroupGetSockets((NLint)socket, (NLsocket *)s, &number) == NL_FALSE)
{
return NL_INVALID;
}
for(i=0;i<number;i++)
{
NLint result;
if(nlIsValidSocket(s[i]) == NL_TRUE)
{
result = nlWrite(s[i], buffer, nbytes);
if(result < sent)
{
sent = result;
}
}
}
return sent;
}
else
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
if(buffer == NULL)
{
nlSetError(NL_NULL_POINTER);
}
else
{
NLint sent;
if(nlLockSocket(socket, NL_WRITE) == NL_FALSE)
{
return NL_INVALID;
}
sent = driver->Write(socket, buffer, nbytes);
if(sent > 0)
{
nlUpdateSocketOutStats(socket, sent, 1);
nlUpdateOutStats(sent, 1);
}
nlUnlockSocket(socket, NL_WRITE);
return sent;
}
}
else
{
nlSetError(NL_INVALID_SOCKET);
}
return NL_INVALID;
}
}
nlSetError(NL_NO_NETWORK);
return NL_INVALID;
}
/*
Polls all sockets in the group to see which have data waiting to be read.
nlPollGroup uses select() on TCP or UDP sockets.
Returns number of sockets waiting, and a list of those sockets, or NL_INVALID
on an error.
*/
HL_EXP NLint HL_APIENTRY nlPollGroup(NLint group, NLenum name, /*@out@*/ NLsocket *sockets, NLint number, NLint timeout)
{
if(driver)
{
if(sockets == NULL )
{
nlSetError(NL_NULL_POINTER);
return 0;
}
return (driver->PollGroup(group, name, sockets, number, timeout));
}
nlSetError(NL_NO_NETWORK);
return 0;
}
HL_EXP NLboolean HL_APIENTRY nlPollSocket(NLsocket socket, NLenum name, NLint timeout)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE )
{
return (driver->PollSocket(socket, name, timeout));
}
else
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
HL_EXP NLboolean HL_APIENTRY nlHint(NLenum name, NLint arg)
{
if(driver)
{
return driver->Hint(name, arg);
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
HL_EXP NLboolean HL_APIENTRY nlSetSocketOpt(NLsocket socket, NLenum name, NLint arg)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE )
{
return driver->SetSocketOpt(socket, name, arg);
}
else
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
HL_EXP NLint HL_APIENTRY nlGetSocketOpt(NLsocket socket, NLenum name)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE )
{
return driver->GetSocketOpt(socket, name);
}
else
{
nlSetError(NL_INVALID_SOCKET);
return NL_INVALID;
}
}
nlSetError(NL_NO_NETWORK);
return NL_INVALID;
}
/*
Converts the numeric address in the NLaddress structure to a string.
*/
HL_EXP /*@null@*/ NLchar* HL_APIENTRY nlAddrToString(const NLaddress *address, NLchar *string)
{
if(driver)
{
if((string == NULL) || (address == NULL))
{
nlSetError(NL_NULL_POINTER);
return NULL;
}
return (driver->AddrToString(address, string));
}
nlSetError(NL_NO_NETWORK);
return NULL;
}
/*
Takes a string that contains a full network address (ie, for IP 192.168.0.1:27000),
and adds it to the NLaddress structure.
*/
HL_EXP NLboolean HL_APIENTRY nlStringToAddr(const NLchar *string, NLaddress *address)
{
if(driver)
{
if((string == NULL) || (address == NULL))
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
if(isSafeString(string) == NL_FALSE)
{
nlSetError(NL_STRING_OVER_RUN);
return NL_FALSE;
}
return driver->StringToAddr(string, address);
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Gets the remote address of the socket if connected to a remote host,
or the local address if not connected.
*/
/* Note: the drivers put a copy of address in nl_socket_t, so we just need to copy it */
HL_EXP NLboolean HL_APIENTRY nlGetRemoteAddr(NLsocket socket, NLaddress *address)
{
if(driver)
{
if(address == NULL)
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
if(nlIsValidSocket(socket) == NL_TRUE)
{
nl_socket_t *sock = nlSockets[socket];
if(nlLockSocket(socket, NL_READ) == NL_FALSE)
{
return NL_FALSE;
}
memcpy(address, &sock->addressin, sizeof(NLaddress));
address->valid = NL_TRUE;
nlUnlockSocket(socket, NL_READ);
}
else
{
nlSetError(NL_INVALID_SOCKET);
memset(address, 0, sizeof(NLaddress));
return NL_FALSE;
}
return NL_TRUE;
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Sets the remote address of an unconnected UDP socket.
*/
HL_EXP NLboolean HL_APIENTRY nlSetRemoteAddr(NLsocket socket, const NLaddress *address)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
if(address == NULL)
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
else
{
nl_socket_t *sock = nlSockets[socket];
if(nlLockSocket(socket, NL_WRITE) == NL_FALSE)
{
return NL_FALSE;
}
memcpy(&sock->addressout, address, sizeof(NLaddress));
nlUnlockSocket(socket, NL_WRITE);
}
}
else
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
return NL_TRUE;
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Gets the local address.
*/
HL_EXP NLboolean HL_APIENTRY nlGetLocalAddr(NLsocket socket, NLaddress *address)
{
if(driver)
{
if(nlIsValidSocket(socket) == NL_TRUE)
{
if(address == NULL)
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
if(nlLockSocket(socket, NL_READ) == NL_FALSE)
{
return NL_FALSE;
}
if(driver->GetLocalAddr(socket, address) != NL_TRUE)
{
nlUnlockSocket(socket, NL_READ);
return NL_FALSE;
}
nlUnlockSocket(socket, NL_READ);
}
else
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
return NL_TRUE;
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
HL_EXP NLaddress * HL_APIENTRY nlGetAllLocalAddr(/*@out@*/ NLint *count)
{
if(driver)
{
if(count == NULL)
{
nlSetError(NL_NULL_POINTER);
return NULL;
}
return driver->GetAllLocalAddr(count);
}
nlSetError(NL_NO_NETWORK);
return NULL;
}
HL_EXP NLboolean HL_APIENTRY nlSetLocalAddr(const NLaddress *address)
{
if(driver)
{
if(address == NULL)
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
return driver->SetLocalAddr(address);
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Resolves the name from the address.
*/
HL_EXP /*@null@*/ NLchar* HL_APIENTRY nlGetNameFromAddr(const NLaddress *address, NLchar *name)
{
if(driver)
{
if((name == NULL) || (address == NULL))
{
nlSetError(NL_NULL_POINTER);
return NULL;
}
return (driver->GetNameFromAddr(address, name));
}
nlSetError(NL_NO_NETWORK);
return NULL;
}
/*
Resolves the name from the address asynchronously.
*/
HL_EXP NLboolean HL_APIENTRY nlGetNameFromAddrAsync(const NLaddress *address, NLchar *name)
{
if(driver)
{
if((name == NULL) || (address == NULL))
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
return driver->GetNameFromAddrAsync(address, name);
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Get the address from a host name.
*/
HL_EXP NLboolean HL_APIENTRY nlGetAddrFromName(const NLchar *name, NLaddress *address)
{
if(driver)
{
if((name == NULL) || (address == NULL))
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
if(isSafeString(name) == NL_FALSE)
{
nlSetError(NL_STRING_OVER_RUN);
return NL_FALSE;
}
return driver->GetAddrFromName(name, address);
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Get the address from a host name asynchronously.
*/
HL_EXP NLboolean HL_APIENTRY nlGetAddrFromNameAsync(const NLchar *name, NLaddress *address)
{
if(driver)
{
if((name == NULL) || (address == NULL))
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
if(isSafeString(name) == NL_FALSE)
{
nlSetError(NL_STRING_OVER_RUN);
return NL_FALSE;
}
return driver->GetAddrFromNameAsync(name, address);
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Compare two addresses.
*/
HL_EXP NLboolean HL_APIENTRY nlAddrCompare(const NLaddress *address1, const NLaddress *address2)
{
if(driver)
{
if((address1 == NULL) || (address2 == NULL))
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
return driver->AddrCompare(address1, address2);
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Get the port number from an address.
*/
HL_EXP NLushort HL_APIENTRY nlGetPortFromAddr(const NLaddress *address)
{
if(driver)
{
if(address == NULL)
{
nlSetError(NL_NULL_POINTER);
return 0;
}
return driver->GetPortFromAddr(address);
}
nlSetError(NL_NO_NETWORK);
return 0;
}
/*
Set the port number in the address.
*/
HL_EXP NLboolean HL_APIENTRY nlSetAddrPort(NLaddress *address, NLushort port)
{
if(driver)
{
if(address == NULL)
{
nlSetError(NL_NULL_POINTER);
return NL_FALSE;
}
driver->SetAddrPort(address, port);
return NL_TRUE;
}
nlSetError(NL_NO_NETWORK);
return NL_FALSE;
}
/*
Non-socket functions
*/
/*
Select the network to use.
*/
HL_EXP NLboolean HL_APIENTRY nlSelectNetwork(NLenum network)
{
int i, found = 0;
if(driver != NULL)
{
/* we cannot select a new network without shutting down first */
nlSetError(NL_SELECT_NET_ERROR);
return NL_FALSE;
}
for(i=0;i<MAX_NET_DRIVERS;i++)
{
if(netdrivers[i].name == NULL)
{
break;
}
if(netdrivers[i].type == network)
{
found++;
if(netdrivers[i].initialized == NL_TRUE)
{
driver = &netdrivers[i];
return NL_TRUE;
}
}
}
if(found > 0)
{
nlSetError(NL_INVALID_TYPE);
}
else
{
nlSetError(NL_INVALID_ENUM);
}
return NL_FALSE;
}
/*
Returns a string corresponding to the NLenum.
*/
HL_EXP const /*@observer@*//*@null@*/ NLchar* HL_APIENTRY nlGetString(NLenum name)
{
/* use seperate strings for thread safety */
static NLchar vstring[NL_MAX_STRING_LENGTH];
static NLchar tstring[NL_MAX_STRING_LENGTH];
NLint i;
nlSetError(NL_NO_ERROR);
/* intitialize the version string */
_tcsncpy(vstring, (NLchar *)TEXT(NL_VERSION_STRING), (size_t)NL_MAX_STRING_LENGTH);
vstring[NL_MAX_STRING_LENGTH - 1] = (NLchar) '\0';
#ifdef _UNICODE
/* add the UNICODE string */
safecat(vstring, (NLchar *)TEXT(" UNICODE version"));
#endif
/* intitialize the network types string */
memset(tstring, 0, sizeof(NLchar) * NL_MAX_STRING_LENGTH);
for(i=0;i<MAX_NET_DRIVERS;i++)
{
if(netdrivers[i].name == NULL)
{
break;
}
if(netdrivers[i].initialized == NL_TRUE)
{
safecat((NLchar *)tstring, (const NLchar *)netdrivers[i].name);
safecat((NLchar *)tstring, (NLchar *)TEXT(" "));
}
}
switch (name) {
case NL_VERSION:
return (const NLchar*)vstring;
case NL_NETWORK_TYPES:
return (const NLchar*)tstring;
case NL_SOCKET_TYPES:
if(driver != NULL)
{
return (const NLchar*)(driver->socktypes);
}
else
{
nlSetError(NL_NO_NETWORK);
}
break;
default:
nlSetError(NL_INVALID_ENUM);
}
return NULL;
}
/*
Returns an integer corresponding to the NLenum.
*/
HL_EXP NLlong HL_APIENTRY nlGetInteger(NLenum name)
{
switch (name) {
case NL_PACKETS_SENT:
return nlOutstats.packets;
case NL_BYTES_SENT:
return nlOutstats.bytes;
case NL_AVE_BYTES_SENT:
nlUpdateOutStats(0, 0);
return nlOutstats.average;
case NL_HIGH_BYTES_SENT:
return nlOutstats.highest;
case NL_PACKETS_RECEIVED:
return nlInstats.packets;
case NL_BYTES_RECEIVED:
return nlInstats.bytes;
case NL_AVE_BYTES_RECEIVED:
nlUpdateInStats(0, 0);
return nlInstats.average;
case NL_HIGH_BYTES_RECEIVED:
return nlInstats.highest;
case NL_OPEN_SOCKETS:
return nlNumsockets;
default:
nlSetError(NL_INVALID_ENUM);
}
return 0;
}
/*
Clears the stat corresponding to the NLenum.
*/
HL_EXP NLboolean HL_APIENTRY nlClear(NLenum name)
{
switch (name) {
case NL_PACKETS_SENT:
if(Util::Thread::acquireLock(&outstatlock) != 0){
Util::Thread::releaseLock(&outstatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlOutstats.packets = 0;
Util::Thread::releaseLock(&outstatlock);
break;
case NL_BYTES_SENT:
if(Util::Thread::acquireLock(&outstatlock) != 0){
Util::Thread::releaseLock(&outstatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlOutstats.bytes = 0;
Util::Thread::releaseLock(&outstatlock);
break;
case NL_AVE_BYTES_SENT:
if(Util::Thread::acquireLock(&outstatlock) != 0){
Util::Thread::releaseLock(&outstatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlOutstats.average = 0;
memset((NLbyte *)nlOutstats.bucket, 0, sizeof(NLlong) * NL_NUM_BUCKETS);
Util::Thread::releaseLock(&outstatlock);
break;
case NL_HIGH_BYTES_SENT:
if(Util::Thread::acquireLock(&outstatlock) != 0){
Util::Thread::releaseLock(&outstatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlOutstats.highest = 0;
Util::Thread::releaseLock(&outstatlock);
break;
case NL_PACKETS_RECEIVED:
if(Util::Thread::acquireLock(&instatlock) != 0){
Util::Thread::releaseLock(&instatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlInstats.packets = 0;
Util::Thread::releaseLock(&instatlock);
break;
case NL_BYTES_RECEIVED:
if(Util::Thread::acquireLock(&instatlock) != 0){
Util::Thread::releaseLock(&instatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlInstats.bytes = 0;
Util::Thread::releaseLock(&instatlock);
break;
case NL_AVE_BYTES_RECEIVED:
if(Util::Thread::acquireLock(&instatlock) != 0){
Util::Thread::releaseLock(&instatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlInstats.average = 0;
memset((NLbyte *)nlInstats.bucket, 0, sizeof(NLlong) * NL_NUM_BUCKETS);
Util::Thread::releaseLock(&instatlock);
break;
case NL_HIGH_BYTES_RECEIVED:
if(Util::Thread::acquireLock(&instatlock) != 0){
Util::Thread::releaseLock(&instatlock);
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
nlInstats.highest = 0;
Util::Thread::releaseLock(&instatlock);
break;
case NL_ALL_STATS:
(void)nlClear(NL_PACKETS_SENT);
(void)nlClear(NL_BYTES_SENT);
(void)nlClear(NL_AVE_BYTES_SENT);
(void)nlClear(NL_HIGH_BYTES_SENT);
(void)nlClear(NL_PACKETS_RECEIVED);
(void)nlClear(NL_BYTES_RECEIVED);
(void)nlClear(NL_AVE_BYTES_RECEIVED);
(void)nlClear(NL_HIGH_BYTES_RECEIVED);
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
return NL_TRUE;
}
/*
Get the socket or system error.
*/
HL_EXP NLint HL_APIENTRY nlGetSystemError(void)
{
if(driver)
{
return driver->GetSystemError();
}
return NL_NO_NETWORK;
}
HL_EXP NLboolean HL_APIENTRY nlEnable(NLenum name)
{
switch (name) {
case NL_BLOCKING_IO:
nlBlocking = NL_TRUE;
break;
case NL_REUSE_ADDRESS:
return nlHint(NL_REUSE_ADDRESS, (NLint) NL_TRUE);
case NL_TCP_NO_DELAY:
return nlHint(NL_TCP_NO_DELAY, (NLint)NL_TRUE);
case NL_SOCKET_STATS:
nlState.socketStats = NL_TRUE;
break;
case NL_BIG_ENDIAN_DATA:
nlState.nl_big_endian_data = NL_TRUE;
break;
case NL_LITTLE_ENDIAN_DATA:
nlState.nl_big_endian_data = NL_FALSE;
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
return NL_TRUE;
}
HL_EXP NLboolean HL_APIENTRY nlDisable(NLenum name)
{
switch (name) {
case NL_BLOCKING_IO:
nlBlocking = NL_FALSE;
break;
case NL_REUSE_ADDRESS:
return nlHint(NL_REUSE_ADDRESS, (NLint) NL_FALSE);
case NL_TCP_NO_DELAY:
return nlHint(NL_TCP_NO_DELAY, NL_FALSE);
case NL_SOCKET_STATS:
nlState.socketStats = NL_FALSE;
break;
case NL_BIG_ENDIAN_DATA:
nlState.nl_big_endian_data = NL_FALSE;
break;
case NL_LITTLE_ENDIAN_DATA:
nlState.nl_big_endian_data = NL_TRUE;
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
return NL_TRUE;
}
HL_EXP NLboolean HL_APIENTRY nlGetBoolean(NLenum name)
{
switch (name) {
case NL_BLOCKING_IO:
return nlBlocking;
case NL_SOCKET_STATS:
return nlState.socketStats;
case NL_BIG_ENDIAN_DATA:
return nlState.nl_big_endian_data;
case NL_LITTLE_ENDIAN_DATA:
return (NLboolean)(nlState.nl_big_endian_data == NL_TRUE ? NL_FALSE:NL_TRUE);
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
}
HL_EXP NLlong HL_APIENTRY nlGetSocketStat(NLsocket socket, NLenum name)
{
nl_socket_t *sock;
NLlong result = 0;
if(nlIsValidSocket(socket) == NL_FALSE)
{
nlSetError(NL_INVALID_SOCKET);
return 0;
}
if(nlLockSocket(socket, NL_BOTH) == NL_FALSE)
{
return 0;
}
sock = nlSockets[socket];
switch (name) {
case NL_PACKETS_SENT:
result = sock->outstats.packets;
break;
case NL_BYTES_SENT:
result = sock->outstats.bytes;
break;
case NL_AVE_BYTES_SENT:
nlUpdateSocketOutStats(socket, 0, 0);
result = sock->outstats.average;
if(result == 0)
{
/* this corrects the stats for the first second */
result = sock->outstats.curbytes;
}
break;
case NL_HIGH_BYTES_SENT:
result = sock->outstats.highest;
break;
case NL_PACKETS_RECEIVED:
result = sock->instats.packets;
break;
case NL_BYTES_RECEIVED:
result = sock->instats.bytes;
break;
case NL_AVE_BYTES_RECEIVED:
nlUpdateSocketInStats(socket, 0, 0);
result = sock->instats.average;
if(result == 0)
{
/* this corrects the stats for the first second */
result = sock->instats.curbytes;
}
break;
case NL_HIGH_BYTES_RECEIVED:
result = sock->instats.highest;
break;
default:
nlSetError(NL_INVALID_ENUM);
}
nlUnlockSocket(socket, NL_BOTH);
return result;
}
HL_EXP NLboolean HL_APIENTRY nlClearSocketStat(NLsocket socket, NLenum name)
{
nl_socket_t *sock;
if(nlIsValidSocket(socket) == NL_FALSE)
{
nlSetError(NL_INVALID_SOCKET);
return NL_FALSE;
}
if(nlLockSocket(socket, NL_BOTH) == NL_FALSE)
{
return NL_FALSE;
}
sock = nlSockets[socket];
switch (name) {
case NL_PACKETS_SENT:
sock->outstats.packets = 0;
break;
case NL_BYTES_SENT:
sock->outstats.bytes = 0;
break;
case NL_AVE_BYTES_SENT:
sock->outstats.average = 0;
memset((NLbyte *)sock->outstats.bucket, 0, sizeof(NLlong) * NL_NUM_BUCKETS);
break;
case NL_HIGH_BYTES_SENT:
sock->outstats.highest = 0;
break;
case NL_PACKETS_RECEIVED:
sock->instats.packets = 0;
break;
case NL_BYTES_RECEIVED:
sock->instats.bytes = 0;
break;
case NL_AVE_BYTES_RECEIVED:
sock->instats.average = 0;
memset((NLbyte *)sock->instats.bucket, 0, sizeof(NLlong) * NL_NUM_BUCKETS);
break;
case NL_HIGH_BYTES_RECEIVED:
sock->instats.highest = 0;
break;
case NL_ALL_STATS:
sock->outstats.packets = 0;
sock->outstats.bytes = 0;
sock->outstats.average = 0;
memset((NLbyte *)sock->outstats.bucket, 0, sizeof(NLlong) * NL_NUM_BUCKETS);
sock->outstats.highest = 0;
sock->instats.packets = 0;
sock->instats.bytes = 0;
sock->instats.average = 0;
memset((NLbyte *)sock->instats.bucket, 0, sizeof(NLlong) * NL_NUM_BUCKETS);
sock->instats.highest = 0;
break;
default:
nlSetError(NL_INVALID_ENUM);
nlUnlockSocket(socket, NL_BOTH);
return NL_FALSE;
}
nlUnlockSocket(socket, NL_BOTH);
return NL_TRUE;
}
HL_EXP NLushort HL_APIENTRY nlSwaps(NLushort x)
{
if(NL_SWAP_TRUE)
{
return (NLushort)(((((NLushort)x) & 0x00ff) << 8) | ((((NLushort)x) & 0xff00) >> 8));
}
else
{
return x;
}
}
HL_EXP NLulong HL_APIENTRY nlSwapl(NLulong x)
{
if(NL_SWAP_TRUE)
{
return (NLulong)(((((NLulong)x) & 0x000000ff) << 24) | ((((NLulong)x) & 0x0000ff00) << 8) | ((((NLulong)x) & 0x00ff0000) >> 8) | ((((NLulong)x) & 0xff000000) >> 24));
}
else
{
return x;
}
}
HL_EXP NLfloat HL_APIENTRY nlSwapf(NLfloat f)
{
if(NL_SWAP_TRUE)
{
NLulong temp = (NLulong)nlSwapl(*(NLulong *)&f);
return *((float *)&temp);
}
else
{
return f;
}
}
HL_EXP NLdouble HL_APIENTRY nlSwapd(NLdouble d)
{
if(NL_SWAP_TRUE)
{
union {NLulong l[2]; NLdouble d;} in, out;
in.d = d;
out.l[0] = nlSwapl(in.l[1]);
out.l[1] = nlSwapl(in.l[0]);
return out.d;
}
else
{
return d;
}
}
#if defined (__LCC__)
BOOL WINAPI __declspec(dllexport) LibMain(/*@unused@*/HINSTANCE hinstDLL, /*@unused@*/DWORD fdwReason, /*@unused@*/LPVOID lpvReserved)
{
return TRUE;
}
#endif /* WINDOWS APP */
diff --git a/src/libs/hawknl/src/sock.cpp b/src/libs/hawknl/src/sock.cpp
index 6fbd782f..a2fc4e5c 100644
--- a/src/libs/hawknl/src/sock.cpp
+++ b/src/libs/hawknl/src/sock.cpp
@@ -1,2783 +1,2783 @@
/*
HawkNL cross platform network library
Copyright (C) 2000-2004 Phil Frisbie, Jr. (phil@hawksoft.com)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#ifndef FD_SETSIZE
#define FD_SETSIZE 8192
#endif
#if !defined(PS3) && !defined(WII)
#include <memory.h>
#endif
#include <stdio.h>
#include <string.h>
#if defined (_WIN32_WCE)
#define EAGAIN 11
#define errno GetLastError()
#else
#include <errno.h>
#endif
#if defined WIN32 || defined WIN64 || defined (_WIN32_WCE)
#include "hawknl/wsock.h"
#elif defined Macintosh
#include <Types.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <sys/time.h>
#include <LowMem.h>
#define closesocket close
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define SOCKET int
#define sockerrno errno
/* define INADDR_NONE if not already */
#ifndef INADDR_NONE
#define INADDR_NONE ((unsigned long) -1)
#endif
#else
/* Unix-style systems */
#ifdef SOLARIS
#include <sys/filio.h> /* for FIONBIO */
#endif
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#ifndef WII
#include <sys/socket.h>
#include <netinet/in.h>
#ifndef PS3
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#else
#include <net/select.h>
#endif
#include <arpa/inet.h>
#ifdef PS3
#include <net/netdb.h>
#else
#include <netdb.h>
#endif
#else
#include <network.h>
/* FIXME: BAAARFFFF at least move these things to a different header */
#define send net_send
#define sendto net_sendto
#define gethostbyname net_gethostbyname
#define recv net_recv
#define recvfrom net_recvfrom
#define bind net_bind
#define listen net_listen
#define socket net_socket
#define connect net_connect
#define accept net_accept
#define shutdown net_shutdown
#define select net_select
#define setsockopt net_setsockopt
int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen){
return -1;
}
struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type){
return NULL;
}
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen){
return -1;
}
#endif
#define closesocket close
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define SOCKET int
#define SD_RECEIVE 0
#define SD_SEND 1
#define SD_BOTH 2
#define sockerrno errno
/* define INADDR_NONE if not already */
#ifndef INADDR_NONE
#define INADDR_NONE ((unsigned long) -1)
#endif
/* SGI and MacOS X do not include socklen_t */
// #if defined __sgi || defined MACOSX
#if defined __sgi
typedef int socklen_t;
#endif
#endif /* HL_WINDOWS_APP*/
/* Uncomment if multicast should be used */
// #define WANT_MULTICAST
#include "hawknl/nlinternal.h"
#include "hawknl/group.h"
#include "hawknl/sock.h"
-#include "util/funcs.h"
+#include "r-tech1/funcs.h"
#ifndef IN_MULTICAST
#define IN_MULTICAST(i) (((unsigned long)(i) & 0xF0000000) == (unsigned long)0xE0000000)
#endif
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN NL_MAX_STRING_LENGTH
#endif
#define NL_CONNECT_STRING "HawkNL request connection."
#define NL_REPLY_STRING "HawkNL connection OK."
#define NL_HEADER_LEN 4
/*
* Portable NLMAX() function macro
*/
#define NLMAX( a, b ) ( ( a ) > ( b ) ? ( a ) : ( b ) )
#define NLMIN( a, b ) ( ( a ) < ( b ) ? ( a ) : ( b ) )
static volatile NLuint ouraddress, bindaddress;
#if defined(PS3) || defined(WII)
int backlog = 10;
#else
int backlog = SOMAXCONN;
#endif
static volatile int multicastTTL = 1;
NLboolean reuseaddress = NL_FALSE;
static volatile NLboolean nlTCPNoDelay = NL_FALSE;
static NLaddress *alladdr = NULL;
typedef struct
{
NLaddress /*@temp@*/*address;
NLchar /*@temp@*/*name;
NLsocket socket;
} NLaddress_ex_t;
extern SOCKET nlGroupGetFdset(NLint group, /*@out@*/ fd_set *fd);
extern NLushort ipx_GetPort(SOCKET socket);
extern NLushort ipx_GetPortFromAddr(const NLaddress *address);
/*
This is a Winsock work around to be able to bind() to more than 3976 ports
*/
#ifdef HL_WINDOWS_APP
/* In memory of my step-father, Don Portlock,
* who passed away Jan 12, 2001 - Phil
*/
static Util::Thread::Lock portlock;
static volatile NLushort nextport = 1024;
static NLushort sock_getNextPort(void)
{
NLlong temp;
Util::Thread::acquireLock(&portlock);
temp = (NLlong)nextport;
if(++temp > 65535)
{
/* skip the well known ports */
temp = 1024;
}
nextport = (NLushort)temp;
Util::Thread::releaseLock(&portlock);
return nextport;
}
static NLint sock_bind(SOCKET socket, const struct sockaddr *a, int len)
{
struct sockaddr_in *addr = (struct sockaddr_in *)a;
int ntries = 500; /* this is to prevent an infinite loop */
NLboolean found = NL_FALSE;
/* check to see if the port is already specified */
if(addr->sin_port != 0)
{
/* do the normal bind */
return bind(socket, a, len);
}
/* let's find our own port number */
while(ntries-- > 0)
{
addr->sin_port = htons(sock_getNextPort());
if(bind(socket, (struct sockaddr *)addr, len) != SOCKET_ERROR)
{
found = NL_TRUE;
break;
}
}
if(found == NL_TRUE)
{
return 0;
}
/* could not find a port, restore the port number back to 0 */
addr->sin_port = 0;
/* return error */
return SOCKET_ERROR;
}
static int sock_connect(SOCKET socket, const struct sockaddr* a, int len )
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = 0;
if(sock_bind(socket, (struct sockaddr *)&addr, (int)sizeof(addr)) == SOCKET_ERROR)
{
return SOCKET_ERROR;
}
return connect(socket, a, len);
}
void nlFD_CLR(SOCKET fd, fd_set *set)
{
u_int i;
for(i=0;i<set->fd_count;i++)
{
if(set->fd_array[i] == fd)
{
while(i < set->fd_count-1)
{
set->fd_array[i] = set->fd_array[i+1];
i++;
}
set->fd_count--;
break;
}
}
}
void nlFD_SET(SOCKET fd, /*@out@*/ fd_set *set)
{
if(set->fd_count < FD_SETSIZE)
set->fd_array[set->fd_count++]=fd;
}
/* This function is inlined for speed over the Winsock function */
int nlWSAFDIsSet(SOCKET fd, fd_set *set)
{
int i = (int)set->fd_count;
while(i-- != 0)
{
if (set->fd_array[i] == fd)
return 1;
}
return 0;
}
#else
#define sock_bind bind
#define sock_connect connect
#endif /* HL_WINDOWS_APP */
/*
helper functions for NL_RELIABLE_PACKETS
*/
static NLint rpGroup; /* the group to hold all the NL_RELIABLE_PACKETS sockets */
static Util::Thread::Lock rpMutex; /* mutex to lock the functions */
static NLboolean needThread = NL_TRUE; /* do we need to spawn a thread? */
static NLint rpSocketCount = 0; /* total count of NL_RELIABLE_PACKETS sockets */
static volatile NLint rpBufferedCount = 0;/* count of sockets that are buffering data */
static void sock_WritePacketCheckPending(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
/* first check for data waiting to be sent */
if(sock->sendlen > 0)
{
NLint count, size = NL_MAX_PACKET_LENGTH + NL_HEADER_LEN;
if(size > sock->sendlen)
{
size = sock->sendlen;
}
count = send((SOCKET)sock->realsocket, (char *)sock->outbuf, size, 0);
if(count > 0)
{
sock->sendlen -= count;
if(sock->sendlen > 0)
{
/* move remaining data to beginning of outbuf */
memmove(sock->outbuf, (sock->outbuf + count), (size_t)sock->sendlen);
}
else
{
rpBufferedCount--;
}
}
}
}
static void *sock_rpThread(void *p)
{
static NLsocket *sockets = NULL;
static NLint maxsockets = 0;
/* allocate memory */
if(sockets == NULL)
{
sockets = (NLsocket *)malloc(sizeof(NLsocket *) * 16);
if(sockets == NULL)
{
needThread = NL_TRUE;
return NULL;
}
maxsockets = 16;
}
while(rpGroup != NL_INVALID)
{
NLint count = maxsockets;
/* make sure there is something to do */
if(rpSocketCount == 0 || rpBufferedCount == 0)
{
goto loopend;
}
/* see if we need to allocate more memory */
if(maxsockets < rpSocketCount)
{
NLsocket *temp;
while(maxsockets < rpSocketCount)
{
maxsockets *= 2;
}
temp = (NLsocket *)realloc((void *)sockets, sizeof(NLsocket *) * maxsockets);
if(temp == NULL)
{
goto cleanup;
}
sockets = temp;
}
/* we can now get the sockets */
if(nlGroupGetSockets(rpGroup, sockets, &count) == NL_FALSE)
{
goto cleanup;
}
while(count-- > 0 && rpBufferedCount > 0)
{
NLsocket socket = sockets[count];
(void)nlLockSocket(socket, NL_WRITE);
sock_WritePacketCheckPending(socket);
nlUnlockSocket(socket, NL_WRITE);
}
loopend:
Util::rest(50);
}
cleanup:
free(sockets);
sockets = NULL;
maxsockets = 0;
needThread = NL_TRUE;
return p;
}
static void sock_AddSocket(NLsocket socket)
{
Util::Thread::acquireLock(&rpMutex);
(void)nlGroupAddSocket(rpGroup, socket);
rpSocketCount++;
if(needThread == NL_TRUE){
Util::Thread::Id thread;
/* the thread was initially made in a detached state which
* is why the thread is it not stored -- because it wasn't
* ever joined later on.
*/
Util::Thread::createThread(&thread, NULL, (Util::Thread::ThreadFunction) sock_rpThread, NULL);
needThread = NL_FALSE;
}
Util::Thread::releaseLock(&rpMutex);
}
static void sock_DeleteSocket(NLsocket socket)
{
Util::Thread::acquireLock(&rpMutex);
(void)nlGroupDeleteSocket(rpGroup, socket);
rpSocketCount--;
Util::Thread::releaseLock(&rpMutex);
}
/*
handle some common connection errors so the app knows when a connection has been dropped
*/
NLint sock_Error(void)
{
switch (sockerrno) {
#ifdef HL_WINDOWS_APP
case WSABASEERR:
return 0;
#endif
case EWOULDBLOCK:
return 0;
case ENETRESET:
case EHOSTUNREACH:
case ECONNABORTED:
case ECONNRESET:
case ENETUNREACH:
case ETIMEDOUT:
nlSetError(NL_SOCK_DISCONNECT);
break;
default:
nlSetError(NL_SYSTEM_ERROR);
break;
}
return NL_INVALID;
}
NLboolean sock_SetBlocking(SOCKET socket, NLboolean arg)
{
int rc;
unsigned long i = 1;
if(arg == NL_TRUE){
i = 0;
}
#if defined(PS3) || defined(WII)
/* FIXME: set sockets to blocking or not */
return NL_TRUE;
#else
rc = ioctl(socket, FIONBIO, &i);
if(rc == SOCKET_ERROR){
return NL_FALSE;
}
return NL_TRUE;
#endif
}
NLboolean sock_SetBroadcast(SOCKET socket)
{
int i = 1;
if(setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&i, (int)sizeof(i)) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
return NL_TRUE;
}
NLboolean sock_SetReuseAddr(nl_socket_t *sock)
{
int i = 1;
if(setsockopt((SOCKET)sock->realsocket, SOL_SOCKET, SO_REUSEADDR, (char *)&i, (int)sizeof(i)) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
sock->reuseaddr = NL_TRUE;
return NL_TRUE;
}
static NLboolean sock_SetTCPNoDelay(nl_socket_t *sock, NLboolean arg)
{
NLenum type = sock->type;
SOCKET realsocket = (SOCKET)sock->realsocket;
int i;
if(type == NL_TCP || type == NL_TCP_PACKETS)
{
arg = (NLboolean)(arg != (NLboolean)0 ? NL_TRUE : NL_FALSE);
i = (int)arg;
#ifdef PS3
/* FIXME: maybe use SO_SNDTIMEO? */
#else
if(setsockopt(realsocket, IPPROTO_TCP, TCP_NODELAY, (char *)&i, (int)sizeof(i)) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
#endif
}
sock->TCPNoDelay = arg;
return NL_TRUE;
}
static NLboolean sock_SetMulticastTTL(nl_socket_t *sock, NLint ttl)
{
SOCKET realsocket = (SOCKET)sock->realsocket;
unsigned char cttl;
/* make sure we have a valid TTL */
if(ttl > 255) ttl = 255;
if(ttl < 1) ttl = 1;
cttl = (unsigned char)ttl;
#ifdef WANT_MULTICAST
/* first try setsockopt by passing a 'char', the Unix standard */
if(setsockopt(realsocket, IPPROTO_IP, IP_MULTICAST_TTL,
(char *)&cttl, (int)sizeof(cttl)) == SOCKET_ERROR)
{
/* if that failed, we might be on a Windows system
that requires an 'int' */
if(setsockopt(realsocket, IPPROTO_IP, IP_MULTICAST_TTL,
(char *)&ttl, (int)sizeof(ttl)) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
}
sock->TTL = ttl;
return NL_TRUE;
#else
return NL_FALSE;
#endif
}
static NLsocket sock_SetSocketOptions(NLsocket s)
{
nl_socket_t *sock = nlSockets[s];
NLenum type = sock->type;
SOCKET realsocket = (SOCKET)sock->realsocket;
if(type == NL_RELIABLE || type == NL_RELIABLE_PACKETS)
{
sock->reliable = NL_TRUE;
if(type == NL_RELIABLE_PACKETS)
{
sock->packetsync = NL_TRUE;
}
}
else
{
sock->reliable = NL_FALSE;
}
if(sock->driver == NL_IP)
{
if(sock_SetTCPNoDelay(sock, sock->TCPNoDelay) == NL_FALSE)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_INVALID;
}
}
if(reuseaddress == NL_TRUE)
{
if(sock_SetReuseAddr(sock) == NL_FALSE)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_INVALID;
}
}
if(sock_SetBlocking(realsocket, sock->blocking) == NL_FALSE)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_INVALID;
}
return s;
}
#if defined(PS3) || defined(WII)
static int gethostname(char * name, size_t length){
snprintf(name, length, "host");
}
#endif
static NLuint sock_GetHostAddress(void)
{
struct hostent *local;
char buff[MAXHOSTNAMELEN];
if(gethostname(buff, MAXHOSTNAMELEN) == SOCKET_ERROR){
return INADDR_NONE;
}
buff[MAXHOSTNAMELEN - 1] = '\0';
local = gethostbyname(buff);
if(!local)
return (NLuint)htonl(0x7f000001);
return *(NLuint *)local->h_addr_list[0];
}
static NLushort sock_GetPort(SOCKET socket)
{
struct sockaddr_in addr;
socklen_t len;
len = (socklen_t)sizeof(struct sockaddr_in);
if(getsockname(socket, (struct sockaddr *) &addr, &len) == SOCKET_ERROR)
{
return 0;
}
return ntohs(addr.sin_port);
}
NLboolean sock_Init(void)
{
#ifdef HL_WINDOWS_APP
WSADATA libmibWSAdata;
/* We must have Winsock 2.0 */
if(WSAStartup(MAKEWORD(2, 0),&libmibWSAdata) != 0)
{
return NL_FALSE;
}
if(Util::Thread::initializeLock(&portlock) != true)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
#endif
if(Util::Thread::initializeLock(&rpMutex) != true)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
if((rpGroup = nlGroupCreate()) == NL_INVALID)
{
return NL_FALSE;
}
ouraddress = sock_GetHostAddress();
if(ouraddress == (NLuint)INADDR_NONE)
{
return NL_FALSE;
}
bindaddress = INADDR_ANY;
return NL_TRUE;
}
void sock_Shutdown(void)
{
#ifdef HL_WINDOWS_APP
(void)WSACleanup();
Util::Thread::destroyLock(&portlock);
Util::Thread::destroyLock(&rpMutex);
(void)nlGroupDestroy(rpGroup);
rpGroup = NL_INVALID;
#endif
if(alladdr != NULL)
{
free(alladdr);
alladdr = NULL;
}
}
NLboolean sock_Listen(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
if(sock->listen == NL_TRUE)
{
return NL_TRUE;
}
if(sock->reliable == NL_TRUE) /* TCP */
{
/* check for unbound socket */
if(sock->localport == 0)
{
NLint result;
/* bind socket */
#ifdef NL_INCLUDE_IPX
if(sock->driver == NL_IPX)
{
((struct sockaddr_ipx *)&sock->addressin)->sa_family = AF_IPX;
memset(((struct sockaddr_ipx *)&sock->addressin)->sa_netnum, 0, 4);
memset(((struct sockaddr_ipx *)&sock->addressin)->sa_nodenum, 0, 6);
((struct sockaddr_ipx *)&sock->addressin)->sa_socket = 0;
result = bind((SOCKET)sock->realsocket, (struct sockaddr *)&sock->addressin,
(int)sizeof(struct sockaddr_ipx));
}
else
#endif
{
((struct sockaddr_in *)&sock->addressin)->sin_family = AF_INET;
((struct sockaddr_in *)&sock->addressin)->sin_addr.s_addr = bindaddress;
((struct sockaddr_in *)&sock->addressin)->sin_port = 0;
result = sock_bind((SOCKET)sock->realsocket, (struct sockaddr *)&sock->addressin,
(int)sizeof(struct sockaddr_in));
}
if(result == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
}
if(listen((SOCKET)sock->realsocket, backlog) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
}
sock->listen = NL_TRUE;
return NL_TRUE;
}
static SOCKET sock_AcceptUDP(NLsocket nlsocket, /*@out@*/struct sockaddr_in *newaddr)
{
nl_socket_t *sock = nlSockets[nlsocket];
struct sockaddr_in ouraddr;
SOCKET newsocket;
NLushort localport;
NLbyte buffer[NL_MAX_STRING_LENGTH];
socklen_t len = (socklen_t)sizeof(struct sockaddr_in);
NLint slen = (NLint)sizeof(NL_CONNECT_STRING);
NLbyte reply = (NLbyte)0x00;
NLint count = 0;
/* Get the packet and remote host address */
if(recvfrom((SOCKET)sock->realsocket, buffer, (int)sizeof(buffer), 0,
(struct sockaddr *)newaddr, &len) < (int)sizeof(NL_CONNECT_STRING))
{
nlSetError(NL_NO_PENDING);
return INVALID_SOCKET;
}
/* Let's check for the connection string */
buffer[slen - 1] = (NLbyte)0; /* null terminate for peace of mind */
if(strcmp(buffer, NL_CONNECT_STRING) != 0)
{
nlSetError(NL_NO_PENDING);
return INVALID_SOCKET;
}
/* open up a new socket on this end */
newsocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(newsocket == INVALID_SOCKET)
{
nlSetError(NL_SYSTEM_ERROR);
(void)closesocket(newsocket);
return INVALID_SOCKET;
}
ouraddr.sin_family = AF_INET;
ouraddr.sin_addr.s_addr = bindaddress;
/* system assigned port number */
ouraddr.sin_port = 0;
if(sock_bind(newsocket, (struct sockaddr *)&ouraddr, len) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
(void)closesocket(newsocket);
return INVALID_SOCKET;
}
/* get the new port */
localport = sock_GetPort(newsocket);
/* create the return message */
writeShort(buffer, count, localport);
writeString(buffer, count, (NLchar *)TEXT(NL_REPLY_STRING));
/* send back the reply with our new port */
if(sendto((SOCKET)sock->realsocket, buffer, count, 0, (struct sockaddr *)newaddr,
(int)sizeof(struct sockaddr_in)) < count)
{
nlSetError(NL_SYSTEM_ERROR);
(void)closesocket(newsocket);
return INVALID_SOCKET;
}
/* send back a 0 length packet from our new port, needed for firewalls */
if(sendto(newsocket, &reply, 0, 0,
(struct sockaddr *)newaddr,
(int)sizeof(struct sockaddr_in)) < 0)
{
nlSetError(NL_SYSTEM_ERROR);
(void)closesocket(newsocket);
return INVALID_SOCKET;
}
/* connect the socket */
if(connect(newsocket, (struct sockaddr *)newaddr,
(int)sizeof(struct sockaddr_in)) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
(void)closesocket(newsocket);
return INVALID_SOCKET;
}
return newsocket;
}
NLsocket sock_AcceptConnection(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
nl_socket_t *newsock = NULL;
NLsocket newsocket = NL_INVALID;
SOCKET realsocket = INVALID_SOCKET;
struct sockaddr_in newaddr;
socklen_t len = (socklen_t)sizeof(newaddr);
memset(&newaddr, 0, sizeof(newaddr));
if(sock->listen != NL_TRUE)
{
nlSetError(NL_NOT_LISTEN);
return NL_INVALID;
}
if(sock->type == NL_RELIABLE || sock->type == NL_RELIABLE_PACKETS) /* TCP */
{
SOCKET s = 101;
/* !@#$% metrowerks compiler, try to get it to actually produce some code */
s = accept((SOCKET)(sock->realsocket), (struct sockaddr *)&newaddr, &len);
realsocket = s;
if(realsocket == INVALID_SOCKET)
{
if(sockerrno == (int)EWOULDBLOCK || errno == EAGAIN)/* yes, we need to use errno here */
{
nlSetError(NL_NO_PENDING);
}
else
{
nlSetError(NL_SYSTEM_ERROR);
}
return NL_INVALID;
}
}
else if(sock->type == NL_UNRELIABLE)/* UDP*/
{
realsocket = sock_AcceptUDP(socket, &newaddr);
if(realsocket == INVALID_SOCKET)
{
/* error is already set in sock_AcceptUDP */
return NL_INVALID;
}
}
else /* broadcast or multicast */
{
nlSetError(NL_WRONG_TYPE);
return NL_INVALID;
}
newsocket = nlGetNewSocket();
if(newsocket == NL_INVALID)
{
return NL_INVALID;
}
if(nlLockSocket(newsocket, NL_BOTH) == NL_FALSE)
{
return NL_INVALID;
}
newsock = nlSockets[newsocket];
/* update the remote address */
memcpy((char *)&newsock->addressin, (char *)&newaddr, sizeof(struct sockaddr_in));
newsock->realsocket = (NLint)realsocket;
newsock->localport = sock_GetPort(realsocket);
newsock->remoteport = sock_GetPortFromAddr((NLaddress *)&newsock->addressin);
newsock->type = sock->type;
newsock->TCPNoDelay = sock->TCPNoDelay;
newsock->connected = NL_TRUE;
newsock->blocking = sock->blocking;
if(newsock->type == NL_RELIABLE_PACKETS)
{
sock_AddSocket(newsocket);
}
return sock_SetSocketOptions(newsocket);
}
NLsocket sock_OpenINT(NLushort port, NLenum type, NLenum driver)
{
nl_socket_t *newsock;
NLsocket newsocket;
SOCKET realsocket;
switch (type) {
case NL_RELIABLE: /* TCP/SPX */
case NL_RELIABLE_PACKETS:
#ifdef NL_INCLUDE_IPX
if(driver == NL_IPX)
{
realsocket = socket(PF_IPX, SOCK_SEQPACKET, NSPROTO_SPXII);
type = NL_RELIABLE;
}
else
#endif
{
realsocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
}
break;
case NL_UNRELIABLE: /* UDP/IPX */
case NL_BROADCAST: /* UDP/IPX broadcast */
case NL_UDP_MULTICAST: /* UDP multicast */
#ifdef NL_INCLUDE_IPX
if(driver == NL_IPX)
{
if(type == NL_UDP_MULTICAST)
{
nlSetError(NL_INVALID_ENUM);
return NL_INVALID;
}
realsocket = socket(PF_IPX, SOCK_DGRAM, NSPROTO_IPX);
}
else
#endif
{
realsocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
}
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_INVALID;
}
if(realsocket == INVALID_SOCKET)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_INVALID;
}
newsocket = nlGetNewSocket();
if(newsocket == NL_INVALID)
{
return NL_INVALID;
}
if(nlLockSocket(newsocket, NL_BOTH) == NL_FALSE)
{
return NL_INVALID;
}
newsock = nlSockets[newsocket];
newsock->realsocket = (NLint)realsocket;
newsock->type = type;
newsock->TCPNoDelay = nlTCPNoDelay;
if(sock_SetSocketOptions(newsocket) == NL_INVALID)
{
nlUnlockSocket(newsocket, NL_BOTH);
(void)sock_Close(newsocket);
return NL_INVALID;
}
/* do not bind a TCP/SPX socket here if the port is 0; let connect assign the port */
if((type == NL_RELIABLE || type == NL_RELIABLE_PACKETS) && port == 0)
{
newsock->localport = 0;
}
else
{
NLint result;
#ifdef NL_INCLUDE_IPX
if(driver == NL_IPX)
{
((struct sockaddr_ipx *)&newsock->addressin)->sa_family = AF_IPX;
memset(((struct sockaddr_ipx *)&newsock->addressin)->sa_netnum, 0, 4);
memset(((struct sockaddr_ipx *)&newsock->addressin)->sa_nodenum, 0, 6);
((struct sockaddr_ipx *)&newsock->addressin)->sa_socket = htons((unsigned short)port);
result = bind((SOCKET)realsocket, (struct sockaddr *)&newsock->addressin,
(int)sizeof(struct sockaddr_ipx));
}
else
#endif
{
((struct sockaddr_in *)&newsock->addressin)->sin_family = AF_INET;
((struct sockaddr_in *)&newsock->addressin)->sin_addr.s_addr = bindaddress;
((struct sockaddr_in *)&newsock->addressin)->sin_port = htons((unsigned short)port);
result = sock_bind(realsocket, (struct sockaddr *)&newsock->addressin,
(int)sizeof(struct sockaddr_in));
}
if(result == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
nlUnlockSocket(newsocket, NL_BOTH);
(void)sock_Close(newsocket);
return NL_INVALID;
}
if(type == NL_BROADCAST)
{
if(sock_SetBroadcast(realsocket) == NL_FALSE)
{
nlSetError(NL_SYSTEM_ERROR);
nlUnlockSocket(newsocket, NL_BOTH);
(void)sock_Close(newsocket);
return NL_INVALID;
}
#ifdef NL_INCLUDE_IPX
if(driver == NL_IPX)
{
((struct sockaddr_ipx *)&newsock->addressout)->sa_family = AF_IPX;
memset(((struct sockaddr_ipx *)&newsock->addressout)->sa_netnum, 0, 4);
memset(((struct sockaddr_ipx *)&newsock->addressout)->sa_nodenum, 0xff, 6);
((struct sockaddr_ipx *)&newsock->addressout)->sa_socket = htons((unsigned short)port);
}
else
#endif
{
((struct sockaddr_in *)&newsock->addressout)->sin_family = AF_INET;
((struct sockaddr_in *)&newsock->addressout)->sin_addr.s_addr = INADDR_BROADCAST;
((struct sockaddr_in *)&newsock->addressout)->sin_port = htons((unsigned short)port);
}
}
#ifdef NL_INCLUDE_IPX
if(driver == NL_IPX)
{
newsock->localport = ipx_GetPort(realsocket);
}
else
#endif
{
newsock->localport = sock_GetPort(realsocket);
}
}
if(type == NL_RELIABLE_PACKETS)
{
sock_AddSocket(newsocket);
}
newsock->driver = driver;
nlUnlockSocket(newsocket, NL_BOTH);
return newsocket;
}
NLsocket sock_Open(NLushort port, NLenum type)
{
return sock_OpenINT(port, type, NL_IP);
}
static NLboolean sock_ConnectUDP(NLsocket socket, const NLaddress *address)
{
nl_socket_t *sock = nlSockets[socket];
time_t begin, t;
socklen_t len = (socklen_t)sizeof(struct sockaddr_in);
sock->conerror = NL_FALSE;
#ifdef NL_INCLUDE_IPX
if(sock->driver == NL_IPX)
{
len = (socklen_t)sizeof(struct sockaddr_ipx);
}
#endif
if(sendto((SOCKET)sock->realsocket, (char *)NL_CONNECT_STRING, (NLint)sizeof(NL_CONNECT_STRING),
0, (struct sockaddr *)address, len)
== SOCKET_ERROR)
{
if(sock->blocking == NL_TRUE)
{
nlSetError(NL_SYSTEM_ERROR);
}
else
{
sock->conerror = NL_TRUE;
}
return NL_FALSE;
}
(void)time(&begin);
/* FIXME! If the udp server is not open then recvfrom will hang forever. Use
* select or something here to truly test if 6 seconds is up.
*/
/* try for six seconds */
while((time(&t) - begin) < 6)
{
NLbyte buffer[NL_MAX_STRING_LENGTH];
NLbyte *pbuffer = buffer;
NLushort newport;
NLint slen = (NLint)(sizeof(NL_REPLY_STRING) + sizeof(newport));
NLint received;
NLbyte reply = (NLbyte)0;
received = recvfrom((SOCKET)sock->realsocket, (char *)buffer, (int)sizeof(buffer), 0,
(struct sockaddr *)&sock->addressin, &len);
if(received == SOCKET_ERROR)
{
if(sockerrno != (int)EWOULDBLOCK)
{
if(sock->blocking == NL_TRUE)
{
nlSetError(NL_CON_REFUSED);
}
else
{
sock->conerror = NL_TRUE;
}
return NL_FALSE;
}
}
if(received >= slen)
{
NLint count = 0;
/* retrieve the port number */
readShort(buffer, count, newport);
#ifdef NL_INCLUDE_IPX
if(sock->driver == NL_IPX)
{
((struct sockaddr_ipx *)&sock->addressin)->sa_socket = htons(newport);
}
else
#endif
{
((struct sockaddr_in *)&sock->addressin)->sin_port = htons(newport);
}
/* Lets check for the reply string */
pbuffer[slen - 1] = (NLbyte)0; /* null terminate for peace of mind */
pbuffer += sizeof(newport);
if(strcmp(pbuffer, NL_REPLY_STRING) == 0)
{
if(connect((SOCKET)sock->realsocket, (struct sockaddr *)&sock->addressin, len)
== SOCKET_ERROR)
{
if(sock->blocking == NL_TRUE)
{
nlSetError(NL_SYSTEM_ERROR);
}
else
{
sock->conerror = NL_TRUE;
}
return NL_FALSE;
}
/* send back a 0 length packet to the new port, needed for firewalls */
if(send((SOCKET)sock->realsocket, &reply, 0, 0) == SOCKET_ERROR)
{
if(sock->blocking == NL_TRUE)
{
nlSetError(NL_SYSTEM_ERROR);
}
else
{
sock->conerror = NL_TRUE;
}
return NL_FALSE;
}
/* success! */
#ifdef NL_INCLUDE_IPX
if(sock->driver == NL_IPX)
{
sock->localport = ipx_GetPort((SOCKET)sock->realsocket);
sock->remoteport = ipx_GetPortFromAddr((NLaddress *)&sock->addressin);
}
else
#endif
{
sock->localport = sock_GetPort((SOCKET)sock->realsocket);
sock->remoteport = sock_GetPortFromAddr((NLaddress *)&sock->addressin);
}
sock->connected = NL_TRUE;
sock->connecting = NL_FALSE;
return NL_TRUE;
}
}
Util::rest(NL_CONNECT_SLEEP);
}
if(sock->blocking == NL_TRUE)
{
nlSetError(NL_CON_REFUSED);
}
else
{
sock->conerror = NL_TRUE;
}
sock->connecting = NL_FALSE;
return NL_FALSE;
}
static void *sock_ConnectUDPAsynchInt(void /*@owned@*/*addr)
{
NLaddress_ex_t *address = (NLaddress_ex_t *)addr;
(void)sock_ConnectUDP(address->socket, address->address);
free(addr);
return NULL;
}
static NLboolean sock_ConnectUDPAsynch(NLsocket socket, const NLaddress *address)
{
NLaddress_ex_t /*@dependent@*/*addr;
nl_socket_t *sock = nlSockets[socket];
addr = (NLaddress_ex_t *)malloc(sizeof(NLaddress_ex_t));
if(addr == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
return NL_FALSE;
}
addr->address = (NLaddress *)address;
addr->socket = socket;
sock->connecting = NL_TRUE;
sock->conerror = NL_FALSE;
Util::Thread::Id thread;
if (!Util::Thread::createThread(&thread, NULL, (Util::Thread::ThreadFunction) sock_ConnectUDPAsynchInt, (void *)addr)){
return NL_FALSE;
}
return NL_TRUE;
}
static NLboolean sock_ConnectMulticast(NLsocket socket, const NLaddress *address)
{
#ifdef WANT_MULTICAST
struct ip_mreq mreq;
nl_socket_t *sock = nlSockets[socket];
if(sock->reliable == NL_TRUE)
{
nlSetError(NL_WRONG_TYPE);
return NL_FALSE;
}
if(!IN_MULTICAST(ntohl(((struct sockaddr_in *)address)->sin_addr.s_addr)))
{
nlSetError(NL_BAD_ADDR);
return NL_FALSE;
}
memcpy((char *)&sock->addressin, (char *)address, sizeof(NLaddress));
memcpy((char *)&sock->addressout, (char *)address, sizeof(NLaddress));
/* join the multicast group */
mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)address)->sin_addr.s_addr;
mreq.imr_interface.s_addr = bindaddress;
if(setsockopt((SOCKET)sock->realsocket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
(char *)&mreq, (int)sizeof(mreq)) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
sock->localport = sock_GetPort((SOCKET)sock->realsocket);
sock->remoteport = sock_GetPortFromAddr((NLaddress *)&sock->addressout);
return sock_SetMulticastTTL(sock, multicastTTL);
#else
return NL_FALSE;
#endif
}
NLboolean sock_Connect(NLsocket socket, const NLaddress *address)
{
nl_socket_t *sock = nlSockets[socket];
memcpy((char *)&sock->addressin, (char *)address, sizeof(NLaddress));
if(sock->connected == NL_TRUE)
{
nlSetError(NL_CONNECTED);
return NL_FALSE;
}
if(sock->connecting == NL_TRUE)
{
nlSetError(NL_CON_PENDING);
return NL_FALSE;
}
if(sock->type == NL_RELIABLE || sock->type == NL_RELIABLE_PACKETS)
{
socklen_t len = (socklen_t)sizeof(struct sockaddr_in);
#ifdef NL_INCLUDE_IPX
if(sock->driver == NL_IPX)
{
len = (socklen_t)sizeof(struct sockaddr_ipx);
if(connect((SOCKET)sock->realsocket, (struct sockaddr *)&sock->addressin, len)
== SOCKET_ERROR)
{
if(sock->blocking == NL_FALSE &&
(sockerrno == (int)EWOULDBLOCK || sockerrno == (int)EINPROGRESS))
{
sock->connecting = NL_TRUE;
}
else
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
}
sock->localport = ipx_GetPort((SOCKET)sock->realsocket);
sock->remoteport = ipx_GetPortFromAddr((NLaddress *)&sock->addressin);
}
else
#endif
{
if(sock_connect((SOCKET)sock->realsocket, (struct sockaddr *)&sock->addressin, len)
== SOCKET_ERROR)
{
if(sock->blocking == NL_FALSE &&
(sockerrno == (int)EWOULDBLOCK || sockerrno == (int)EINPROGRESS))
{
sock->connecting = NL_TRUE;
}
else
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
}
sock->localport = sock_GetPort((SOCKET)sock->realsocket);
sock->remoteport = sock_GetPortFromAddr((NLaddress *)&sock->addressin);
}
if(sock->connecting == NL_FALSE)
{
sock->connected = NL_TRUE;
}
return NL_TRUE;
}
else if(sock->type == NL_UDP_MULTICAST)
{
return sock_ConnectMulticast(socket, &sock->addressin);
}
else if(sock->type == NL_UNRELIABLE)
{
if(sock->blocking == NL_TRUE)
{
return sock_ConnectUDP(socket, &sock->addressin);
}
else
{
return sock_ConnectUDPAsynch(socket, &sock->addressin);
}
}
else
{
nlSetError(NL_WRONG_TYPE);
}
return NL_FALSE;
}
void sock_Close(NLsocket socket)
{
nl_socket_t *sock = nlSockets[socket];
if(sock->type == NL_UDP_MULTICAST)
{
#ifdef WANT_MULTICAST
struct ip_mreq mreq;
/* leave the multicast group */
mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)&sock->addressout)->sin_addr.s_addr;
mreq.imr_interface.s_addr = bindaddress;
(void)setsockopt((SOCKET)sock->realsocket, IPPROTO_IP, IP_DROP_MEMBERSHIP,
(char *)&mreq, (int)sizeof(mreq));
#endif
}
if(sock->type == NL_RELIABLE_PACKETS)
{
/* check for unsent data */
if(sock->sendlen > 0)
{
int tries = 200;
/* 200 * 50 ms = up to a 10 second delay to allow data to be sent */
while(tries-- > 0 && sock->sendlen > 0)
{
Util::rest(50);
}
}
sock_DeleteSocket(socket);
}
if((sock->type == NL_RELIABLE_PACKETS || sock->type == NL_RELIABLE) && sock->listen == NL_FALSE)
{
struct linger l = {1, 1};
(void)setsockopt((SOCKET)sock->realsocket, SOL_SOCKET, SO_LINGER, (const char *)&l, (int)sizeof(l));
(void)shutdown((SOCKET)sock->realsocket, SD_RECEIVE);
}
else
{
(void)shutdown((SOCKET)sock->realsocket, SD_BOTH);
}
(void)closesocket((SOCKET)sock->realsocket);
}
/* internal function to read reliable packets from TCP stream */
static NLint sock_ReadPacket(NLsocket socket, NLvoid /*@out@*/ *buffer, NLint nbytes,
NLboolean checkonly)
{
nl_socket_t *sock = nlSockets[socket];
/* skip error reporting if checkonly is TRUE */
/* check for sync */
if(sock->packetsync == NL_FALSE)
{
if(checkonly == NL_FALSE)
{
nlSetError(NL_PACKET_SYNC);
}
else
{
sock->readable = NL_TRUE;
}
return NL_INVALID;
}
if(sock->message_end == NL_TRUE && checkonly == NL_FALSE && sock->reclen == 0)
{
sock->message_end = NL_FALSE;
nlSetError(NL_MESSAGE_END);
return NL_INVALID;
}
/* allocate some temp storage the first time through */
if(sock->inbuf == NULL)
{
sock->inbuflen = (nbytes + nbytes / 4 + NL_HEADER_LEN);
if(sock->inbuflen < 1024)
{
sock->inbuflen = 1024;
}
else if(sock->inbuflen > NL_MAX_PACKET_LENGTH + NL_MAX_PACKET_LENGTH/4)
{
sock->inbuflen = NL_MAX_PACKET_LENGTH + NL_MAX_PACKET_LENGTH/4;
}
sock->inbuf = (NLbyte *)malloc((size_t)sock->inbuflen);
if(sock->inbuf == NULL)
{
if(checkonly == NL_FALSE)
{
sock->inbuflen = 0;
nlSetError(NL_OUT_OF_MEMORY);
}
return NL_INVALID;
}
}
/* if inbuf is empty, get some data */
if(sock->reclen < NL_HEADER_LEN)
{
NLint count;
count = recv((SOCKET)sock->realsocket, (char *)(sock->inbuf + sock->reclen), (sock->inbuflen - sock->reclen), 0);
if(count == SOCKET_ERROR)
{
if(checkonly == NL_FALSE)
{
return sock_Error();
}
else
{
sock->readable = NL_TRUE;
return NL_INVALID;
}
}
if(count == 0)
{
if(checkonly == NL_FALSE)
{
nlSetError(NL_MESSAGE_END);
}
else
{
sock->message_end = NL_TRUE;
sock->readable = NL_TRUE;
}
return NL_INVALID;
}
sock->reclen += count;
}
/* start parsing the packet */
if(sock->reclen >= NL_HEADER_LEN)
{
NLboolean done = NL_FALSE;
NLushort len;
NLint c = 2;
/* check for valid packet */
if(sock->inbuf[0] != 'N' || sock->inbuf[1] != 'L')
{
/* packet is not valid, we are somehow out of sync,
or we are talking to a regular TCP stream */
if(checkonly == NL_FALSE)
{
nlSetError(NL_PACKET_SYNC);
}
else
{
sock->readable = NL_TRUE;
}
sock->packetsync = NL_FALSE;
return NL_INVALID;
}
/* read the length of the packet */
readShort(sock->inbuf, c, len);
if(len > NL_MAX_PACKET_LENGTH)
{
/* packet is not valid, or we are talking to a regular TCP stream */
if(checkonly == NL_FALSE)
{
nlSetError(NL_PACKET_SYNC);
}
else
{
sock->readable = NL_TRUE;
}
sock->packetsync = NL_FALSE;
return NL_INVALID;
}
/* check to see if we need to make the inbuf storage larger */
if((NLint)len > sock->inbuflen)
{
NLint newbuflen;
NLbyte *temp;
newbuflen = (len + len / 4 + NL_HEADER_LEN);
temp = (NLbyte *)realloc(sock->inbuf, (size_t)newbuflen);
if(temp == NULL)
{
if(checkonly == NL_FALSE)
{
nlSetError(NL_OUT_OF_MEMORY);
}
return NL_INVALID;
}
sock->inbuf = temp;
sock->inbuflen = newbuflen;
}
if(checkonly == NL_FALSE)
{
if(len > (NLushort)nbytes)
{
nlSetError(NL_BUFFER_SIZE);
return NL_INVALID;
}
}
/* see if we need to get more of the packet */
if(len > (NLushort)(sock->reclen - c))
{
done = NL_FALSE;
while(done == NL_FALSE)
{
NLint count;
if(checkonly == NL_FALSE)
{
count = recv((SOCKET)sock->realsocket,
(char *)(sock->inbuf + sock->reclen),
(sock->inbuflen - sock->reclen), 0);
}
else
{
/* we are calling this from PollGroup, so it cannot block */
fd_set fdset;
struct timeval t = {0,0};
FD_ZERO(&fdset);
FD_SET((SOCKET)sock->realsocket, &fdset);
if(select(sock->realsocket + 1, &fdset, NULL, NULL, &t) == 1)
{
count = recv((SOCKET)sock->realsocket,
(char *)(sock->inbuf + sock->reclen),
(sock->inbuflen - sock->reclen), 0);
}
else
{
/* socket would block, so break */
break;
}
}
if(count == SOCKET_ERROR)
{
if(checkonly == NL_FALSE)
{
/* check to see if we already have all the packet */
if(len <= (NLushort)(sock->reclen - c))
{
done = NL_TRUE;
}
else
{
/* report the error */
return sock_Error();
}
}
else
{
done = NL_TRUE;
}
}
else if(count == 0)
{
sock->message_end = NL_TRUE;
sock->readable = NL_TRUE;
done = NL_TRUE;
}
else
{
sock->reclen += count;
if(len <= (NLushort)(sock->reclen - c))
{
done = NL_TRUE;
}
}
}
}
/* see if we now have all of the packet */
if(len <= (NLushort)(sock->reclen - c))
{
sock->readable = NL_TRUE;
if(checkonly == NL_FALSE)
{
/* copy the packet */
memcpy(buffer, (sock->inbuf + c), (size_t)len);
/* check for another packet */
sock->reclen -= (len + c);
if(sock->reclen > 0)
{
/* move it down to the beginning of inbuf */
memmove(sock->inbuf, (sock->inbuf + c + len), (size_t)sock->reclen);
}
/* quick check to see if we have another complete packet buffered */
if(sock->reclen >= NL_HEADER_LEN)
{
NLushort templen;
/* read the length of the packet */
c = 2;
readShort(sock->inbuf, c, templen);
/* check the length */
if(templen <= (NLushort)(sock->reclen - c))
{
/* we have another complete packet, so mark as readable for PollGroup */
sock->readable = NL_TRUE;
}
else
{
sock->readable = NL_FALSE;
}
}
else
{
sock->readable = NL_FALSE;
}
return (NLint)len;
}
}
else
{
return 0;
}
}
return 0;
}
NLint sock_Read(NLsocket socket, NLvoid *buffer, NLint nbytes)
{
nl_socket_t *sock = nlSockets[socket];
NLint count;
if(nbytes < 0)
{
return 0;
}
if(sock->type == NL_RELIABLE || sock->type == NL_RELIABLE_PACKETS) /* TCP */
{
/* check for a non-blocking connection pending */
if(sock->connecting == NL_TRUE)
{
fd_set fdset;
struct timeval t = {0,0};
int serrval = -1;
socklen_t serrsize = (socklen_t)sizeof(serrval);
FD_ZERO(&fdset);
FD_SET((SOCKET)sock->realsocket, &fdset);
if(select(sock->realsocket + 1, NULL, &fdset, NULL, &t) == 1)
{
/* Check the socket status */
(void)getsockopt((SOCKET)sock->realsocket, SOL_SOCKET, SO_ERROR, (char *)&serrval, &serrsize );
if(serrval != 0)
{
if(serrval == (int)ECONNREFUSED)
{
nlSetError(NL_CON_REFUSED);
}
else if(serrval == (int)EINPROGRESS || serrval == (int)EWOULDBLOCK)
{
nlSetError(NL_CON_PENDING);
}
return NL_INVALID;
}
/* the connect has completed */
sock->connected = NL_TRUE;
sock->connecting = NL_FALSE;
}
else
{
/* check for a failed connect */
FD_ZERO(&fdset);
FD_SET((SOCKET)sock->realsocket, &fdset);
if(select(sock->realsocket + 1, NULL, NULL, &fdset, &t) == 1)
{
nlSetError(NL_CON_REFUSED);
}
else
{
nlSetError(NL_CON_PENDING);
}
return NL_INVALID;
}
}
/* check for reliable packets */
if(sock->type == NL_RELIABLE_PACKETS)
{
return sock_ReadPacket(socket, buffer, nbytes, NL_FALSE);
}
count = recv((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0);
if(count == 0)
{
/* end of message */
nlSetError(NL_MESSAGE_END);
return NL_INVALID;
}
}
else /* UDP */
{
/* check for a non-blocking connection pending */
if(sock->connecting == NL_TRUE)
{
nlSetError(NL_CON_PENDING);
return NL_INVALID;
}
/* check for a connection error */
if(sock->conerror == NL_TRUE)
{
nlSetError(NL_CON_REFUSED);
return NL_INVALID;
}
if(sock->connected == NL_TRUE)
{
count = recv((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0);
}
else
{
socklen_t len = (socklen_t)sizeof(struct sockaddr_in);
count = recvfrom((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0,
(struct sockaddr *)&sock->addressin, &len);
}
}
if(count == SOCKET_ERROR)
{
return sock_Error();
}
return count;
}
static NLboolean allocateBuffer(nl_socket_t *sock, NLint nbytes)
{
NLint size = NLMIN(NLMAX((nbytes + NL_HEADER_LEN) * 2, 1024), (NL_MAX_PACKET_LENGTH + NL_HEADER_LEN));
/* first call */
if(sock->outbuf == NULL)
{
sock->outbuf = (NLbyte *)malloc((size_t)size);
if(sock->outbuf == NULL)
{
sock->outbuflen = 0;
nlSetError(NL_OUT_OF_MEMORY);
return NL_FALSE;
}
sock->outbuflen = size;
}
else
{
if(size > sock->outbuflen)
{
NLbyte *temp;
temp = (NLbyte *)realloc(sock->outbuf, (size_t)size);
if(temp == NULL)
{
sock->outbuflen = 0;
nlSetError(NL_OUT_OF_MEMORY);
return NL_FALSE;
}
sock->outbuf = temp;
sock->outbuflen = size;
}
}
return NL_TRUE;
}
static NLint sock_WritePacket(NLsocket socket, const NLvoid *buffer, NLint nbytes)
{
nl_socket_t *sock = nlSockets[socket];
NLint count;
NLbyte temp[NL_HEADER_LEN];
NLint c = 0;
/* allocate memory for outbuf */
if(sock->outbuf == NULL)
{
if(allocateBuffer(sock, nbytes) == NL_FALSE)
{
return NL_INVALID;
}
}
else
{
/* send any unsent data from last packet */
sock_WritePacketCheckPending(socket);
}
/* check to see if we already have some pending data */
if(sock->sendlen > 0)
{
/* to comply with the way UDP packets act */
/* if the send buffer has unsent data return 0 */
return 0;
}
/* ID for packets is 'NL'*/
writeByte(temp, c, 'N');
writeByte(temp, c, 'L');
/* add the packet length */
writeShort(temp, c, (NLushort)nbytes);
count = send((SOCKET)sock->realsocket, (char *)temp, c, 0);
if(count == SOCKET_ERROR)
{
if(sockerrno == (int)EWOULDBLOCK)
{
count = 0;
}
else
{
return sock_Error();
}
}
if(count < c)
{
int dif = c - count;
/* check outbuf size */
if(allocateBuffer(sock, nbytes) == NL_FALSE)
{
return NL_INVALID;
}
/* store it */
memcpy((sock->outbuf + sock->sendlen), (temp + count), (size_t)(dif));
sock->sendlen += (dif);
memcpy((sock->outbuf + sock->sendlen), ((NLbyte *)buffer), (size_t)(nbytes));
sock->sendlen += (nbytes);
rpBufferedCount++;
}
else
{
count = send((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0);
if(count == SOCKET_ERROR)
{
if(sockerrno == (int)EWOULDBLOCK)
{
count = 0;
}
else
{
return sock_Error();
}
}
/* make sure all was sent */
if(count < nbytes)
{
int dif = nbytes - count;
/* check outbuf size */
if(allocateBuffer(sock, nbytes) == NL_FALSE)
{
return NL_INVALID;
}
/* store it */
memcpy((sock->outbuf + sock->sendlen), ((NLbyte *)buffer + count), (size_t)(dif));
sock->sendlen += dif;
rpBufferedCount++;
}
}
count = nbytes;
return count;
}
NLint sock_Write(NLsocket socket, const NLvoid *buffer, NLint nbytes)
{
nl_socket_t *sock = nlSockets[socket];
NLint count;
if(nbytes < 0)
{
return 0;
}
if((sock->type == NL_RELIABLE) || (sock->type == NL_RELIABLE_PACKETS)) /* TCP */
{
if(sock->connecting == NL_TRUE)
{
fd_set fdset;
struct timeval t = {0,0};
int serrval = -1;
socklen_t serrsize = (socklen_t)sizeof(serrval);
FD_ZERO(&fdset);
FD_SET((SOCKET)sock->realsocket, &fdset);
if(select(sock->realsocket + 1, NULL, &fdset, NULL, &t) == 1)
{
/* Check the socket status */
(void)getsockopt((SOCKET)sock->realsocket, SOL_SOCKET, SO_ERROR, (char *)&serrval, &serrsize );
if(serrval != 0)
{
if(serrval == (int)ECONNREFUSED)
{
nlSetError(NL_CON_REFUSED);
}
else if(serrval == (int)EINPROGRESS || serrval == (int)EWOULDBLOCK)
{
nlSetError(NL_CON_PENDING);
}
return NL_INVALID;
}
/* the connect has completed */
sock->connected = NL_TRUE;
sock->connecting = NL_FALSE;
}
else
{
/* check for a failed connect */
FD_ZERO(&fdset);
FD_SET((SOCKET)sock->realsocket, &fdset);
if(select(sock->realsocket + 1, NULL, NULL, &fdset, &t) == 1)
{
nlSetError(NL_CON_REFUSED);
}
else
{
nlSetError(NL_CON_PENDING);
}
return NL_INVALID;
}
}
/* check for reliable packets */
if(sock->type == NL_RELIABLE_PACKETS)
{
if(nbytes > NL_MAX_PACKET_LENGTH)
{
nlSetError(NL_PACKET_SIZE);
return NL_INVALID;
}
return sock_WritePacket(socket, buffer, nbytes);
}
count = send((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0);
}
else /* unconnected UDP */
{
int maxpacket = NL_MAX_PACKET_LENGTH;
int sizesockaddr = (int)sizeof(struct sockaddr_in);
/* check for a non-blocking connection pending */
if(sock->connecting == NL_TRUE)
{
nlSetError(NL_CON_PENDING);
return NL_INVALID;
}
/* check for a connection error */
if(sock->conerror == NL_TRUE)
{
nlSetError(NL_CON_REFUSED);
return NL_INVALID;
}
#ifdef NL_INCLUDE_IPX
if(sock->driver == NL_IPX)
{
maxpacket = 1466;
sizesockaddr = (int)sizeof(struct sockaddr_ipx);
}
#endif
if(nbytes > maxpacket)
{
nlSetError(NL_PACKET_SIZE);
return NL_INVALID;
}
if(sock->type == NL_UDP_MULTICAST)
{
count = sendto((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0,
(struct sockaddr *)&sock->addressout,
(int)sizeof(struct sockaddr_in));
}
else if(sock->connected == NL_TRUE)
{
count = send((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0);
}
else
{
count = sendto((SOCKET)sock->realsocket, (char *)buffer, nbytes, 0,
(struct sockaddr *)&sock->addressout, sizesockaddr);
}
}
if(count == SOCKET_ERROR)
{
return sock_Error();
}
return count;
}
NLchar *sock_AddrToString(const NLaddress *address, NLchar *string)
{
NLulong addr;
NLushort port;
addr = ntohl(((struct sockaddr_in *)address)->sin_addr.s_addr);
port = ntohs(((struct sockaddr_in *)address)->sin_port);
if(port == 0)
{
_stprintf(string, TEXT("%lu.%lu.%lu.%lu"), (addr >> 24) & 0xff, (addr >> 16)
& 0xff, (addr >> 8) & 0xff, addr & 0xff);
}
else
{
_stprintf(string, TEXT("%lu.%lu.%lu.%lu:%u"), (addr >> 24) & 0xff, (addr >> 16)
& 0xff, (addr >> 8) & 0xff, addr & 0xff, port);
}
return string;
}
NLboolean sock_StringToAddr(const NLchar *string, NLaddress *address)
{
NLulong a1, a2, a3, a4;
NLulong ipaddress, port = 0;
int ret;
ret = _stscanf((const NLchar *)string, (const NLchar *)TEXT("%lu.%lu.%lu.%lu:%lu"), &a1, &a2, &a3, &a4, &port);
if(a1 > 255 || a2 > 255 || a3 > 255 || a4 > 255 || port > 65535 || ret < 4)
{
/* bad address */
((struct sockaddr_in *)address)->sin_family = AF_INET;
((struct sockaddr_in *)address)->sin_addr.s_addr = INADDR_NONE;
((struct sockaddr_in *)address)->sin_port = 0;
nlSetError(NL_BAD_ADDR);
address->valid = NL_FALSE;
return NL_FALSE;
}
else
{
ipaddress = (a1 << 24) | (a2 << 16) | (a3 << 8) | a4;
((struct sockaddr_in *)address)->sin_family = AF_INET;
((struct sockaddr_in *)address)->sin_addr.s_addr = htonl(ipaddress);
((struct sockaddr_in *)address)->sin_port = htons((NLushort)port);
address->valid = NL_TRUE;
return NL_TRUE;
}
}
NLboolean sock_GetLocalAddr(NLsocket socket, NLaddress *address)
{
nl_socket_t *sock = nlSockets[socket];
socklen_t len;
memset(address, 0, sizeof(NLaddress));
((struct sockaddr_in *)address)->sin_family = AF_INET;
address->valid = NL_TRUE;
len = (socklen_t)sizeof(struct sockaddr_in);
/* if the socket is connected, this will get us
the correct address on a multihomed system*/
if(getsockname((SOCKET)sock->realsocket, (struct sockaddr *)address, &len) == SOCKET_ERROR)
{
/* ignore error if socket has not been bound or connected yet */
if(sockerrno != (int)EINVAL)
{
nlSetError(NL_SYSTEM_ERROR);
address->valid = NL_FALSE;
return NL_FALSE;
}
}
/* if not connected, substitute the NIC address */
if(((struct sockaddr_in *)address)->sin_addr.s_addr == INADDR_ANY)
{
((struct sockaddr_in *)address)->sin_addr.s_addr = ouraddress;
}
sock_SetAddrPort(address, sock->localport);
return NL_TRUE;
}
NLaddress *sock_GetAllLocalAddr(NLint *count)
{
struct hostent *local;
char buff[MAXHOSTNAMELEN];
int i = 0;
if(gethostname(buff, MAXHOSTNAMELEN) == SOCKET_ERROR)
{
nlSetError(NL_SYSTEM_ERROR);
return NULL;
}
buff[MAXHOSTNAMELEN - 1] = '\0';
local = gethostbyname(buff);
if(local == NULL)
{
if(sockerrno == (int)ENETDOWN)
{
nlSetError(NL_SYSTEM_ERROR);
return NULL;
}
}
/* count the number of returned IP addresses */
*count = 0;
if(local != NULL)
{
while(local->h_addr_list[i++] != NULL)
{
(*count)++;
}
}
/* allocate storage for address */
if(alladdr != NULL)
{
free(alladdr);
}
if(*count == 0)
{
*count = 1;
alladdr = (NLaddress *)malloc(sizeof(NLaddress));
memset(alladdr, 0, sizeof(NLaddress));
/* fill in the localhost address */
((struct sockaddr_in *)alladdr)->sin_family = AF_INET;
((struct sockaddr_in *)alladdr)->sin_addr.s_addr = (NLuint)htonl(0x7f000001);
alladdr->valid = NL_TRUE;
}
else
{
alladdr = (NLaddress *)malloc(sizeof(NLaddress) * *count);
memset(alladdr, 0, sizeof(NLaddress) * *count);
/* fill in the addresses */
i = 0;
while(local->h_addr_list[i] != NULL)
{
NLaddress *addr = &alladdr[i];
((struct sockaddr_in *)addr)->sin_family = AF_INET;
((struct sockaddr_in *)addr)->sin_addr.s_addr = *(NLuint *)local->h_addr_list[i];
addr->valid = NL_TRUE;
i++;
}
}
return alladdr;
}
NLboolean sock_SetLocalAddr(const NLaddress *address)
{
/* should we check against all the local addresses? */
bindaddress = ouraddress = (NLuint)((struct sockaddr_in *)address)->sin_addr.s_addr;
return NL_TRUE;
}
NLchar *sock_GetNameFromAddr(const NLaddress *address, NLchar *name)
{
struct hostent *hostentry;
NLchar tempname[MAXHOSTNAMELEN];
hostentry = gethostbyaddr((char *)&((struct sockaddr_in *)address)->sin_addr,
(int)sizeof(struct in_addr), AF_INET);
if(hostentry != NULL)
{
NLushort port = sock_GetPortFromAddr(address);
#ifdef _UNICODE
NLchar temp[MAXHOSTNAMELEN];
/* convert from multibyte char string to wide char string */
mbstowcs(temp, (const char *)hostentry->h_name, MAXHOSTNAMELEN);
temp[MAXHOSTNAMELEN - 1] = '\0';
#else
NLchar *temp = (NLchar *)hostentry->h_name;
#endif
if(port != 0)
{
_sntprintf(tempname, (size_t)(NL_MAX_STRING_LENGTH), (const NLchar *)TEXT("%s:%hu"), (const NLchar *)temp, port);
}
else
{
_tcsncpy(tempname, (const NLchar *)temp, (size_t)(NL_MAX_STRING_LENGTH));
}
tempname[NL_MAX_STRING_LENGTH - 1] = (NLchar)'\0';
}
else
{
if(((struct sockaddr_in *)address)->sin_addr.s_addr == (unsigned long)INADDR_NONE)
{
_tcsncpy(tempname, (const NLchar *)TEXT("Bad address"), (size_t)(NL_MAX_STRING_LENGTH));
}
else
{
(void)sock_AddrToString(address, tempname);
}
}
/* special copy in case this was called as sock_GetNameFromAddrAsync */
name[0] = (NLchar)'\0';
_tcsncpy(&name[1], (const NLchar *)&tempname[1], (size_t)(NL_MAX_STRING_LENGTH - 1));
name[0] = tempname[0];
return name;
}
static void *sock_GetNameFromAddrAsyncInt(void /*@owned@*/ * addr)
{
NLaddress_ex_t *address = (NLaddress_ex_t *)addr;
(void)sock_GetNameFromAddr(address->address, address->name);
free(address->address);
free(address);
return NULL;
}
NLboolean sock_GetNameFromAddrAsync(const NLaddress *address, NLchar *name)
{
NLaddress_ex_t *addr;
memset(name, 0, sizeof(NLchar) * NL_MAX_STRING_LENGTH);
addr = (NLaddress_ex_t *)malloc(sizeof(NLaddress_ex_t));
if(addr == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
return NL_FALSE;
}
addr->address = (NLaddress *)malloc(sizeof(NLaddress));
if(addr->address == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
free(addr);
return NL_FALSE;
}
memcpy(addr->address, address, sizeof(NLaddress));
addr->name = name;
Util::Thread::Id thread;
if (!Util::Thread::createThread(&thread, NULL, (Util::Thread::ThreadFunction) sock_GetNameFromAddrAsyncInt, (void *)addr)){
return NL_FALSE;
}
return NL_TRUE;
}
NLboolean sock_GetAddrFromName(const NLchar *name, NLaddress *address)
{
struct hostent *hostentry;
NLushort port = 0;
int pos;
NLbyte temp[NL_MAX_STRING_LENGTH];
address->valid = NL_FALSE;
/* first check to see if we have a numeric address already */
(void)sock_StringToAddr(name, address);
/* clear out an NL_BAD_ADDR error */
if(nlGetError() == NL_BAD_ADDR)
{
nlSetError(NL_NO_ERROR);
}
if(((struct sockaddr_in *)address)->sin_addr.s_addr != (unsigned long)INADDR_NONE)
{
/* we are already done! */
address->valid = NL_TRUE;
return NL_TRUE;
}
#ifdef _UNICODE
/* convert from wide char string to multibyte char string */
(void)wcstombs(temp, (const NLchar *)name, NL_MAX_STRING_LENGTH);
#else
strncpy(temp, name, NL_MAX_STRING_LENGTH);
#endif
temp[NL_MAX_STRING_LENGTH - 1] = (NLbyte)'\0';
pos = (int)strcspn(temp, (const char *)":");
if(pos > 0)
{
NLbyte *p = &temp[pos+1];
temp[pos] = (NLbyte)'\0';
(void)sscanf(p, "%hu", &port);
}
hostentry = gethostbyname((const char *)temp);
if(hostentry != NULL)
{
((struct sockaddr_in *)address)->sin_family = AF_INET;
((struct sockaddr_in *)address)->sin_port = htons(port);
((struct sockaddr_in *)address)->sin_addr.s_addr = *(NLulong *)hostentry->h_addr_list[0];
address->valid = NL_TRUE;
}
else
{
((struct sockaddr_in *)address)->sin_family = AF_INET;
((struct sockaddr_in *)address)->sin_addr.s_addr = INADDR_NONE;
((struct sockaddr_in *)address)->sin_port = 0;
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
return NL_TRUE;
}
static void *sock_GetAddrFromNameAsyncInt(void /*@owned@*/ *addr)
{
NLaddress_ex_t *address = (NLaddress_ex_t *)addr;
(void)sock_GetAddrFromName(address->name, address->address);
address->address->valid = NL_TRUE;
free(address->name);
free(address);
return NULL;
}
NLboolean sock_GetAddrFromNameAsync(const NLchar *name, NLaddress *address)
{
NLaddress_ex_t *addr;
address->valid = NL_FALSE;
addr = (NLaddress_ex_t *)malloc(sizeof(NLaddress_ex_t));
if(addr == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
return NL_FALSE;
}
addr->name = (NLchar *)malloc(NL_MAX_STRING_LENGTH);
if(addr->name == NULL)
{
nlSetError(NL_OUT_OF_MEMORY);
free(addr);
return NL_FALSE;
}
_tcsncpy(addr->name, name, (size_t)NL_MAX_STRING_LENGTH);
addr->name[NL_MAX_STRING_LENGTH - 1] = '\0';
addr->address = address;
Util::Thread::Id thread;
if (!Util::Thread::createThread(&thread, NULL, (Util::Thread::ThreadFunction) sock_GetAddrFromNameAsyncInt, (void *)addr)){
return NL_FALSE;
}
return NL_TRUE;
}
NLboolean sock_AddrCompare(const NLaddress *address1, const NLaddress *address2)
{
if(((struct sockaddr_in *)address1)->sin_family != ((struct sockaddr_in *)address2)->sin_family)
return NL_FALSE;
if(((struct sockaddr_in *)address1)->sin_addr.s_addr
!= ((struct sockaddr_in *)address2)->sin_addr.s_addr)
return NL_FALSE;
if(((struct sockaddr_in *)address1)->sin_port
!= ((struct sockaddr_in *)address2)->sin_port)
return NL_FALSE;
return NL_TRUE;
}
NLushort sock_GetPortFromAddr(const NLaddress *address)
{
return ntohs(((struct sockaddr_in *)address)->sin_port);
}
void sock_SetAddrPort(NLaddress *address, NLushort port)
{
((struct sockaddr_in *)address)->sin_port = htons((NLushort)port);
}
NLint sock_GetSystemError(void)
{
NLint err = sockerrno;
#ifdef HL_WINDOWS_APP
if(err < WSABASEERR)
{
if(errno > 0)
{
err = errno;
}
}
#endif
return err;
}
NLint sock_PollGroup(NLint group, NLenum name, NLsocket *sockets, NLint number, NLint timeout)
{
NLint numselect, count = 0;
NLint numsockets = NL_MAX_GROUP_SOCKETS;
NLsocket temp[NL_MAX_GROUP_SOCKETS];
NLboolean reliable[NL_MAX_GROUP_SOCKETS];
NLboolean result;
NLsocket *ptemp = temp;
int i, found = 0;
fd_set fdset;
SOCKET highest;
struct timeval t = {0,0}; /* {seconds, useconds}*/
struct timeval *tp = &t;
nlGroupLock();
highest = nlGroupGetFdset(group, &fdset);
if(highest == INVALID_SOCKET)
{
/* error is set by nlGroupGetFdset */
nlGroupUnlock();
return NL_INVALID;
}
result = nlGroupGetSocketsINT(group, ptemp, &numsockets);
nlGroupUnlock();
if(result == NL_FALSE)
{
/* any error is set by nlGroupGetSockets */
return NL_INVALID;
}
if(numsockets == 0)
{
return 0;
}
if(name == NL_READ_STATUS)
{
/* check for buffered reliable packets */
for(i=0;i<numsockets;i++)
{
nl_socket_t *s = nlSockets[ptemp[i]];
if(s->type == NL_RELIABLE_PACKETS && s->readable == NL_TRUE)
{
/* mark as readable */
reliable[i] = NL_TRUE;
found++;
/* change the timeout to 0, or non-blocking since we */
/* have at least one reliable packet to read */
timeout = 0;
}
else
{
reliable[i] = NL_FALSE;
}
}
}
/* check for full blocking call */
if(timeout < 0)
{
tp = NULL;
}
else /* set t values */
{
t.tv_sec = timeout/1000;
t.tv_usec = (timeout%1000) * 1000;
}
/* call select to check the status */
switch(name) {
case NL_READ_STATUS:
numselect = select((int)highest, &fdset, NULL, NULL, tp);
break;
case NL_WRITE_STATUS:
numselect = select((int)highest, NULL, &fdset, NULL, tp);
break;
case NL_ERROR_STATUS:
numselect = select((int)highest, NULL, NULL, &fdset, tp);
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_INVALID;
}
if(numselect == SOCKET_ERROR)
{
if(sockerrno == (int)ENOTSOCK)
{
/* one of the sockets has been closed */
nlSetError(NL_INVALID_SOCKET);
}
else if(sockerrno == (int)EINTR)
{
/* select was interrupted by the system, maybe because the app is exiting */
return 0;
}
else
{
nlSetError(NL_SYSTEM_ERROR);
}
return NL_INVALID;
}
if(numselect > number)
{
nlSetError(NL_BUFFER_SIZE);
return NL_INVALID;
}
/* fill *sockets with a list of the sockets ready to be read */
numselect += found;
i = 0;
while(numsockets-- > 0 && numselect > count)
{
nl_socket_t *s = nlSockets[*ptemp];
if((reliable[i] == NL_TRUE ) || (FD_ISSET(s->realsocket, &fdset) != 0))
{
/* if checking for read status, must check for a complete packet */
if(s->type == NL_RELIABLE_PACKETS && s->listen == NL_FALSE && name == NL_READ_STATUS)
{
(void)nlLockSocket(*ptemp, NL_READ);
if(s->readable != NL_TRUE)
{
if(s->inuse == NL_TRUE)
{
(void)sock_ReadPacket(*ptemp, NULL, 0, NL_TRUE);
}
else
{
s->readable = NL_FALSE;
}
}
if(s->readable == NL_TRUE)
{
/* we do have a complete packet */
*sockets = *ptemp;
sockets++;
count++;
}
nlUnlockSocket(*ptemp, NL_READ);
}
else
{
*sockets = *ptemp;
sockets++;
count ++;
}
}
i++;
ptemp++;
}
return count;
}
NLboolean sock_PollSocket(NLsocket socket, NLenum name, NLint timeout)
{
NLint numselect;
nl_socket_t *sock = nlSockets[socket];
fd_set fdset;
struct timeval t = {0,0}; /* {seconds, useconds}*/
struct timeval *tp = &t;
nlSetError(NL_NO_ERROR);
if(name == NL_READ_STATUS)
{
/* check for buffered reliable packets */
nl_socket_t *s = nlSockets[socket];
if(s->type == NL_TCP_PACKETS && s->readable == NL_TRUE)
{
return NL_TRUE;
}
}
/* check for full blocking call */
if(timeout < 0)
{
tp = NULL;
}
else /* set t values */
{
t.tv_sec = timeout/1000;
t.tv_usec = (timeout%1000) * 1000;
}
FD_ZERO(&fdset);
FD_SET((SOCKET)(sock->realsocket), &fdset);
/* call select to check the status */
switch(name) {
case NL_READ_STATUS:
numselect = select((int)(sock->realsocket + 1), &fdset, NULL, NULL, tp);
break;
case NL_WRITE_STATUS:
numselect = select((int)(sock->realsocket + 1), NULL, &fdset, NULL, tp);
break;
case NL_ERROR_STATUS:
numselect = select((int)(sock->realsocket + 1), NULL, NULL, &fdset, tp);
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
if(numselect == SOCKET_ERROR)
{
if(sockerrno == (int)ENOTSOCK)
{
/* the socket has been closed */
nlSetError(NL_INVALID_SOCKET);
}
else if(sockerrno == (int)EINTR)
{
/* select was interrupted by the system, maybe because the app is exiting */
return NL_FALSE;
}
else
{
nlSetError(NL_SYSTEM_ERROR);
}
}
else if(numselect == 1)
{
return NL_TRUE;
}
return NL_FALSE;
}
NLboolean sock_Hint(NLenum name, NLint arg)
{
switch(name) {
case NL_LISTEN_BACKLOG:
backlog = arg;
break;
case NL_MULTICAST_TTL:
if(arg < 1)
{
arg = 1;
}
else if(arg > 255)
{
arg = 255;
}
multicastTTL = arg;
break;
case NL_REUSE_ADDRESS:
reuseaddress = (NLboolean)(arg != 0 ? NL_TRUE : NL_FALSE);
break;
case NL_TCP_NO_DELAY:
nlTCPNoDelay = (NLboolean)(arg != 0 ? NL_TRUE : NL_FALSE);
break;
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
return NL_TRUE;
}
NLboolean sock_SetSocketOpt(NLsocket socket, NLenum name, NLint arg)
{
nl_socket_t *sock = nlSockets[socket];
switch (name) {
case NL_BLOCKING_IO:
sock->blocking = (NLboolean)(arg != 0 ? NL_TRUE : NL_FALSE);
if(sock_SetBlocking((SOCKET)sock->realsocket, sock->blocking) == NL_FALSE)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
break;
case NL_MULTICAST_TTL:
if(sock->type == NL_UDP_MULTICAST)
{
return(sock_SetMulticastTTL(sock, multicastTTL));
}
else
{
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
case NL_REUSE_ADDRESS:
if(sock_SetReuseAddr(sock) == NL_FALSE)
{
nlSetError(NL_SYSTEM_ERROR);
return NL_FALSE;
}
break;
case NL_TCP_NO_DELAY:
return (sock_SetTCPNoDelay(sock, (NLboolean)(arg != 0 ? NL_TRUE : NL_FALSE)));
default:
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
return NL_TRUE;
}
NLint sock_GetSocketOpt(NLsocket socket, NLenum name)
{
nl_socket_t *sock = nlSockets[socket];
switch (name) {
case NL_BLOCKING_IO:
return (NLint)sock->blocking;
case NL_MULTICAST_TTL:
if(sock->type == NL_UDP_MULTICAST)
{
return sock->TTL;
}
else
{
nlSetError(NL_INVALID_ENUM);
return NL_FALSE;
}
case NL_REUSE_ADDRESS:
return (NLint)sock->reuseaddr;
case NL_TCP_NO_DELAY:
return (NLint)sock->TCPNoDelay;
default:
nlSetError(NL_INVALID_ENUM);
return NL_INVALID;
}
}
diff --git a/src/libs/pcre/CMakeLists.txt b/src/libs/pcre/CMakeLists.txt
new file mode 100644
index 00000000..376e350b
--- /dev/null
+++ b/src/libs/pcre/CMakeLists.txt
@@ -0,0 +1,38 @@
+# -------------------------------------------------------
+# PCRE cmake build script for r-tech1.
+# Written by: juvinious
+# -------------------------------------------------------
+project (pcre C CXX)
+
+# -------------------------------------------------------
+# Source directories containing all the necessary .c files
+# -------------------------------------------------------
+# PCRE Library
+set(PCRE_SRC
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_chartables.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_compile.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_config.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_dfa_exec.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_exec.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_fullinfo.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_get.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_globals.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_info.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_maketables.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_newline.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_ord2utf8.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcreposix.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_refcount.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_study.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_tables.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_try_flipped.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_ucd.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_valid_utf8.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_version.c
+${CMAKE_CURRENT_SOURCE_DIR}/pcre_xclass.c
+PARENT_SCOPE)
+
+# -------------------------------------------------------
+# module
+# -------------------------------------------------------
+#add_library (pcre_module ${PCRE_SRC})
diff --git a/src/libs/sfl/CMakeLists.txt b/src/libs/sfl/CMakeLists.txt
index d0d0796c..d2a53101 100644
--- a/src/libs/sfl/CMakeLists.txt
+++ b/src/libs/sfl/CMakeLists.txt
@@ -1,74 +1,75 @@
# -------------------------------------------------------
# SFL cmake build script for r-tech1.
# Written by: juvinious
# -------------------------------------------------------
-
+project (sfl C)
# -------------------------------------------------------
# Set some specific stuff for hawknl
# -------------------------------------------------------
if(NOT MSVC)
set(CFLAGS "-W -O2 -Wwrite-strings -Wstrict-prototypes -Wall -funroll-loops -Wmissing-declarations -fomit-frame-pointer -Wno-missing-declarations")
else(NOT MSVC)
set(CFLAGS "-O2")
endif(NOT MSVC)
remove_definitions(${CXXFLAGS})
add_definitions(${CFLAGS})
# -------------------------------------------------------
# Source directories containing all the necessary .cpp files
# -------------------------------------------------------
-set(SRC
-sflbits.c
-sflcomp.c
-sflcons.c
-sflconv.c
-sflcryp.c
-sflcvbs.c
-sflcvdp.c
-sflcvds.c
-sflcvns.c
-sflcvsb.c
-sflcvsd.c
-sflcvsn.c
-sflcvtp.c
-sflcvts.c
-sfldbio.c
-sfldir.c
-sflenv.c
-sflexdr.c
-sflfile.c
-sflfind.c
-sflfort.c
-sflhttp.c
-sflini.c
-sfllang.c
-sfllbuf.c
-sfllist.c
-sflmath.c
-sflmem.c
-sflmesg.c
-sflmime.c
-sflnode.c
-sflprint.c
-sflslot.c
-sflstr.c
-sflsymb.c
-sflsyst.c
-sfltok.c
-sfltree.c
-sfltron.c
-sfluid.c
-sflxml.c
-sfldate.c)
+set(SFL_SRC
+${CMAKE_CURRENT_SOURCE_DIR}/sflbits.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcomp.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcons.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflconv.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcryp.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvbs.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvdp.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvds.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvns.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvsb.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvsd.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvsn.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvtp.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflcvts.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfldbio.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfldir.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflenv.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflexdr.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflfile.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflfind.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflfort.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflhttp.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflini.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfllang.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfllbuf.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfllist.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflmath.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflmem.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflmesg.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflmime.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflnode.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflprint.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflslot.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflstr.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflsymb.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflsyst.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfltok.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfltree.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfltron.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfluid.c
+${CMAKE_CURRENT_SOURCE_DIR}/sflxml.c
+${CMAKE_CURRENT_SOURCE_DIR}/sfldate.c
+PARENT_SCOPE)
# -------------------------------------------------------
# Include directory
# -------------------------------------------------------
include_directories(include ./)
# -------------------------------------------------------
# module
# -------------------------------------------------------
-add_library (sfl_module ${SRC})
+#add_library (sfl_module ${SFL_SRC})
diff --git a/src/libs/zip/CMakeLists.txt b/src/libs/zip/CMakeLists.txt
index 17149d5f..d0445c5e 100644
--- a/src/libs/zip/CMakeLists.txt
+++ b/src/libs/zip/CMakeLists.txt
@@ -1,14 +1,16 @@
+project(minizip C)
+
set(MINIZIP_SRC
-ioapi.c
-unzip.c
-zip.c)
+${CMAKE_CURRENT_SOURCE_DIR}/ioapi.c
+${CMAKE_CURRENT_SOURCE_DIR}/unzip.c
+${CMAKE_CURRENT_SOURCE_DIR}/zip.c PARENT_SCOPE)
# -------------------------------------------------------
# Include directory
# -------------------------------------------------------
# include_directories(include include/internal)
# -------------------------------------------------------
# module
# -------------------------------------------------------
-add_library (minizip_module ${MINIZIP_SRC})
+#add_library (minizip_module ${MINIZIP_SRC})
diff --git a/src/network/network.cpp b/src/network/network.cpp
index 7c3ba7c0..77d6b8c2 100644
--- a/src/network/network.cpp
+++ b/src/network/network.cpp
@@ -1,401 +1,401 @@
#ifdef HAVE_NETWORKING
-#include "libs/hawknl/nl.h"
+#include "libs/hawknl/hawknl/nl.h"
#endif
#include "r-tech1/network/network.h"
#include "r-tech1/debug.h"
#include <string>
#include <sstream>
#include <string.h>
#include "r-tech1/system.h"
#include "r-tech1/compress.h"
#include "r-tech1/thread.h"
#ifdef HAVE_NETWORKING
#ifdef WII
#include <network.h>
#elif defined(WINDOWS)
#include <winsock.h>
#else
#include <arpa/inet.h>
#endif
#else
#ifndef htonl
#define htonl(x) x
#endif
#ifndef htons
#define htons(x) x
#endif
#ifndef ntohl
#define ntohl(x) x
#endif
#ifndef ntohs
#define ntohs(x) x
#endif
#endif
using namespace std;
/* TODO: Wrap open_sockets with a mutex */
namespace Network{
NetworkException::~NetworkException() throw (){
}
MessageEnd::MessageEnd(){
}
InvalidPortException::InvalidPortException( int port, const string message ):
NetworkException(""){
ostringstream num;
num << port;
num << ". ";
num << message;
this->setMessage( "Invalid port " + num.str() );
}
/*
template <typename M>
int messageSize(const M& message);
*/
/*
template <>
int messageSize<Message>(Message const & message){
return message.size();
}
template <>
int messageSize<Message*>(Message* const & message){
return message->size();
}
*/
/*
template <class M>
uint8_t * messageDump(const M& message, uint8_t * buffer);
template <>
uint8_t * messageDump<Message>(const Message & message, uint8_t * buffer){
return message.dump(buffer);
}
template <>
uint8_t * messageDump<Message*>(Message* const & message, uint8_t * buffer){
return message->dump(buffer);
}
*/
#ifdef HAVE_NETWORKING
static string getHawkError(){
return string(" HawkNL error: '") +
string(nlGetErrorStr(nlGetError())) +
string("' HawkNL system error: '") +
string(nlGetSystemErrorStr(nlGetSystemError()));
}
template<typename X>
static X readX(Socket socket){
X data;
readBytes(socket, (uint8_t*) &data, sizeof(X));
return data;
}
int8_t read8(Socket socket){
return readX<uint8_t>(socket);
}
int16_t read16(Socket socket){
return ntohs(readX<uint16_t>(socket));
}
int32_t read32(Socket socket){
return ntohl(readX<uint32_t>(socket));
}
void send16(Socket socket, int16_t bytes){
bytes = htons(bytes);
sendBytes(socket, (uint8_t *) &bytes, sizeof(bytes));
}
char * dump16(char * where, int16_t bytes){
bytes = htons(bytes);
*(uint16_t*) where = bytes;
return where + sizeof(uint16_t);
}
char * parse16(char * where, uint16_t * out){
*out = ntohs(*(uint16_t*) where);
return where + sizeof(uint16_t);
}
char * dump32(char * where, uint32_t bytes){
bytes = htonl(bytes);
*(uint32_t*) where = bytes;
return where + sizeof(uint32_t);
}
char * parse32(char * where, uint32_t * out){
*out = ntohl(*(uint32_t*) where);
return where + sizeof(uint32_t);
}
char * parseString(char * where, string * out, uint16_t length){
*out = string(where);
return where + length;
}
char * dumpStr(char * where, const std::string & str){
memcpy(where, str.c_str(), str.size() + 1);
return where + str.size() + 1;
}
string readStr(Socket socket, const uint16_t length){
char buffer[length + 1];
NLint bytes = nlRead(socket, buffer, length);
if (bytes == NL_INVALID){
throw NetworkException(string("Could not read string.") + getHawkError());
}
buffer[length] = 0;
bytes += 1;
return string(buffer);
}
void sendStr(Socket socket, const string & str){
if (nlWrite(socket, str.c_str(), str.length() + 1) != (signed)(str.length() + 1)){
throw NetworkException( string("Could not write string.") + getHawkError() );
}
}
void sendAllBytes(Socket socket, const uint8_t * data, int length){
int sent = nlWrite(socket, data, length);
if (sent != length){
throw NetworkException(string("Could not send bytes.") + getHawkError());
}
}
void sendBytes(Socket socket, const uint8_t * data, int length){
const uint8_t * position = data;
int written = 0;
while ( written < length ){
int bytes = nlWrite(socket, position, length - written);
if (bytes == NL_INVALID){
throw NetworkException(string("Could not send bytes.") + getHawkError());
}
written += bytes;
position += bytes;
}
}
int readUptoBytes(Socket socket, uint8_t * data, int length){
return nlRead(socket, data, length);
}
void readBytes(Socket socket, uint8_t * data, int length){
uint8_t * position = data;
int read = 0;
while (read < length){
int bytes = nlRead(socket, position, length - read);
if (bytes == NL_INVALID){
switch (nlGetError()){
case NL_MESSAGE_END : throw MessageEnd();
default : throw NetworkException(string("Could not read bytes.") + getHawkError());
}
}
read += bytes;
position += bytes;
}
}
Util::Thread::Lock socketsLock;
Socket openReliable(int port){
// NLsocket server = nlOpen( port, NL_RELIABLE_PACKETS );
Global::debug(1, "network") << "Attemping to open reliable port " << port << endl;
Socket server = nlOpen(port, NL_RELIABLE);
/* server will either be NL_INVALID (-1) or some low integer. hawknl
* sockets are mapped internally to real sockets, so don't be surprised
* if you get a socket back like 0.
*/
if (server == NL_INVALID){
throw InvalidPortException(port, nlGetSystemErrorStr(nlGetSystemError()));
}
Global::debug(1, "network") << "Successfully opened a socket: " << server << endl;
Util::Thread::acquireLock(&socketsLock);
open_sockets.push_back(server);
Util::Thread::releaseLock(&socketsLock);
return server;
}
Socket openUnreliable(int port){
// NLsocket server = nlOpen( port, NL_RELIABLE_PACKETS );
Global::debug(1, "network") << "Attemping to open unreliable port " << port << endl;
Socket server = nlOpen(port, NL_UNRELIABLE);
/* server will either be NL_INVALID (-1) or some low integer. hawknl
* sockets are mapped internally to real sockets, so don't be surprised
* if you get a socket back like 0.
*/
if (server == NL_INVALID){
throw InvalidPortException(port, nlGetSystemErrorStr(nlGetSystemError()));
}
Global::debug(1, "network") << "Successfully opened a socket: " << server << endl;
Util::Thread::acquireLock(&socketsLock);
open_sockets.push_back(server);
Util::Thread::releaseLock(&socketsLock);
return server;
}
Socket connectReliable(string server, int port){
NLaddress address;
nlGetAddrFromName(server.c_str(), &address);
nlSetAddrPort(&address, port);
/* The port that this socket has opened will be immediately rebound to some
* other port by sock_connect, but we still need to call openReliable to get
* an NL_RELIABLE socket.
*/
Socket socket = openReliable(0);
if (nlConnect(socket, &address) == NL_FALSE){
close(socket);
throw NetworkException("Could not connect");
}
return socket;
}
Socket connectUnreliable(string server, int port){
NLaddress address;
nlGetAddrFromName(server.c_str(), &address);
nlSetAddrPort(&address, port);
/* The port that this socket has opened will be immediately rebound to some
* other port by sock_connect, but we still need to call openReliable to get
* an NL_RELIABLE socket.
*/
Socket socket = openUnreliable(0);
if (nlConnect(socket, &address) == NL_FALSE){
close(socket);
throw NetworkException("Could not connect");
}
return socket;
}
void close(Socket s){
Util::Thread::acquireLock(&socketsLock);
for (vector< Socket >::iterator it = open_sockets.begin(); it != open_sockets.end(); ){
if ( *it == s ){
Global::debug(1, "network") << "Closing socket " << s << endl;
nlClose(*it);
Global::debug(1, "network") << "Closed" << endl;
it = open_sockets.erase(it);
} else {
it++;
}
}
Util::Thread::releaseLock(&socketsLock);
}
void closeAll(){
Global::debug(1, "network") << "Closing all sockets" << std::endl;
Util::Thread::acquireLock(&socketsLock);
for (vector<Socket>::iterator it = open_sockets.begin(); it != open_sockets.end(); it++ ){
nlClose(*it);
}
open_sockets.clear();
Util::Thread::releaseLock(&socketsLock);
}
void init(){
nlInit();
nlSelectNetwork(NL_IP);
nlEnable(NL_BLOCKING_IO);
Util::Thread::initializeLock(&socketsLock);
// nlDisable( NL_BLOCKING_IO );
}
void reuseSockets(bool what){
if (what){
nlEnable(NL_REUSE_ADDRESS);
} else {
nlDisable(NL_REUSE_ADDRESS);
}
}
bool blocking(Socket s, bool b){
return nlSetSocketOpt(s, NL_BLOCKING_IO, b) == NL_TRUE;
}
void blocking(bool b){
if (b){
nlEnable(NL_BLOCKING_IO);
} else {
nlDisable(NL_BLOCKING_IO);
}
}
bool noDelay(Socket s, bool b){
return nlSetSocketOpt(s, NL_TCP_NO_DELAY, b) == NL_TRUE;
}
void listen( Socket s ) throw( NetworkException ){
if ( nlListen( s ) == NL_FALSE ){
throw CannotListenException( string(nlGetSystemErrorStr( nlGetSystemError() )) );
}
}
Socket accept( Socket s ) throw( NetworkException ){
Socket connection = nlAcceptConnection(s);
if ( connection == NL_INVALID ){
/*
if ( nlGetError() == NL_NO_PENDING ){
error = NO_CONNECTIONS_PENDING;
} else {
error = NETWORK_ERROR;
}
return s;
*/
if ( nlGetError() == NL_NO_PENDING ){
throw NoConnectionsPendingException();
}
throw NetworkException("Could not accept connection");
}
Util::Thread::acquireLock(&socketsLock);
open_sockets.push_back(connection);
Util::Thread::releaseLock(&socketsLock);
return connection;
}
void shutdown(){
nlShutdown();
}
#else
/* Dummy implementations */
char * dump16(char * where, int16_t length){
return where;
}
int8_t read8(Socket socket){
return 0;
}
int16_t read16(Socket socket){
return 0;
}
char * dumpStr(char * where, const std::string & str){
return where;
}
void readBytes(Socket socket, uint8_t * data, int length){
}
void sendBytes(Socket socket, const uint8_t * data, int length){
}
char * parseString(char * where, std::string * out, uint16_t length){
return where;
}
#endif
}

File Metadata

Mime Type
text/x-diff
Expires
Fri, May 15, 8:49 AM (14 h, 54 m ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
63899
Default Alt Text
(242 KB)

Event Timeline