Add freebsd rc script

.hgignore

@@ -1,3 +1,4 @@
-.*\.sw[p-z]$
+.*\.sw[a-z]$
 .*\.py[co]$
 ^build
+^pcaps

.hgtags

@@ -0,0 +1,10 @@
+38014f13f04d5871b70278518221a937867fd8b6 0.9.0
+21d438d34e21479a652ba6aa1ec14646385cae5a 0.9.1
+3a4befe8819ea7a81f89a6ed550cc88803108f6a 0.9.2
+8a41f4cfee7e6ea6d7e161f4e96cfc45bb485cc4 0.9.3
+4ef909311670c1ab1543793afa327749150bf1e2 0.9.4
+31b8ef65d3d239d7e94417de50b4b7e1c6c0a624 1.0.0
+1f7c28381493a9e0a24bf5b918d3772241d15587 1.0.1
+39e9e2070a25b17fac56ebc61338024b20538cc4 1.1.0
+c3284cd6d1af24bff19327344e89032967ce4ad2 1.1.1
+a4a1ac21d226ceb82e1a337123e1d5939ed116f0 1.1.2

.ycm_extra_conf.py

@@ -67,10 +67,9 @@
 # Set this to the absolute path to the folder (NOT the file!) containing the
 # compile_commands.json file to use that instead of 'flags'. See here for
 # more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html
-#
-# Most projects will NOT need to set this to anything; you can just change the
-# 'flags' list of compilation flags.
-compilation_database_folder = ''
+compilation_database_folder = os.getenv(
+    "MY_BUILD", os.path.join(os.getcwd(), "build")
+)
 
 if os.path.exists( compilation_database_folder ):
   database = ycm_core.CompilationDatabase( compilation_database_folder )

CMakeLists.txt

@@ -1,50 +1,122 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+# it probably works with older versions but this the oldest tested one:
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.9)
 
-PROJECT(LIFXD C)
+PROJECT(LIGHTSD C)
 
-SET(CPACK_PACKAGE_VERSION_MAJOR "0")
-SET(CPACK_PACKAGE_VERSION_MINOR "0")
-SET(CPACK_PACKAGE_VERSION_PATCH "1")
-SET(LIFXD_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
+SET(CPACK_PACKAGE_VERSION_MAJOR "1")
+SET(CPACK_PACKAGE_VERSION_MINOR "1")
+SET(CPACK_PACKAGE_VERSION_PATCH "2")
+SET(LIGHTSD_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
 
+MESSAGE(STATUS "lightsd version: ${LIGHTSD_VERSION}")
 MESSAGE(STATUS "CMake version: ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}")
-MESSAGE(STATUS "lifxd version: ${LIFXD_VERSION}")
 MESSAGE(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
-MESSAGE(STATUS "System: ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_VERSION}")
+MESSAGE(STATUS "Target system: ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_VERSION} ${CMAKE_SYSTEM_PROCESSOR}")
 MESSAGE(STATUS "Install prefix: ${CMAKE_INSTALL_PREFIX}")
-MESSAGE(STATUS "Source directory: ${LIFXD_SOURCE_DIR}")
+MESSAGE(STATUS "Source directory: ${LIGHTSD_SOURCE_DIR}")
 
-SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${LIFXD_SOURCE_DIR}/CMakeScripts)
+SET(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${LIGHTSD_SOURCE_DIR}/CMakeScripts")
+
+ENABLE_TESTING()
 
 ### Platform checks ############################################################
 
 # TODO: we need at least 2.0.19-stable because of the logging defines
 FIND_PACKAGE(Event2 REQUIRED COMPONENTS core)
 FIND_PACKAGE(Endian REQUIRED)
+FIND_PACKAGE(Sphinx)
+
+INCLUDE(CheckFunctionExists)
+INCLUDE(CheckVariableExists)
+INCLUDE(TestBigEndian)
+
+INCLUDE(CompatReallocArray)
+INCLUDE(CompatSetProctitle)
 INCLUDE(CompatTimeMonotonic)
 
-INCLUDE(CheckTypeSize)
-CHECK_TYPE_SIZE(suseconds_t SUSECONDS_T_SIZE)
-ADD_DEFINITIONS("-DLIFXD_SUSECONDS_T_SIZE=${SUSECONDS_T_SIZE}")
+TEST_BIG_ENDIAN(BIG_ENDIAN_SYSTEM)
 
 ### Global definitions #########################################################
 
-SET(CMAKE_C_FLAGS "-pipe -Wextra -Wall -Wstrict-prototypes -std=c99")
+INCLUDE(AddAllSubdirectories)
+INCLUDE(AddTestFromSources)
+
+SET(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
+
+SET(CMAKE_C_FLAGS "-pipe ${CMAKE_C_FLAGS}")
+STRING(STRIP "${CMAKE_C_FLAGS}" CMAKE_C_FLAGS)
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE}}")
+STRING(STRIP "${CMAKE_C_FLAGS}" CMAKE_C_FLAGS)
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wextra -Wall -Wstrict-prototypes -std=c99")
+SET(CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE} "")
 
-# Only relevant for the GNU libc:
 ADD_DEFINITIONS(
+    # Only relevant for the GNU libc:
     "-D_POSIX_C_SOURCE=200809L"
     "-D_BSD_SOURCE=1"
     "-D_DEFAULT_SOURCE=1"
+
+    "-D_DARWIN_C_SOURCE=1"
+
+    "-DLGTD_BIG_ENDIAN_SYSTEM=${BIG_ENDIAN_SYSTEM}"
+    "-DLGTD_SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P}"
+
+    "-DLGTD_HAVE_SETPROCTITLE=${HAVE_SETPROCTITLE}"
+    "-DLGTD_HAVE_REALLOCARRAY=${HAVE_REALLOCARRAY}"
+
+    "-DJSMN_STRICT=1"
+    "-DJSMN_PARENT_LINKS=1"
 )
 
 IF (CMAKE_BUILD_TYPE MATCHES "DEBUG")
     ADD_DEFINITIONS("-DQUEUE_MACRO_DEBUG=1")
     IF (CMAKE_COMPILER_IS_GNUCC)
-        ADD_DEFINITIONS("-g3" "-ggdb")
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g3 -ggdb3")
     ENDIF ()
 ENDIF ()
 
-INCLUDE_DIRECTORIES(${LIFXD_SOURCE_DIR}/compat/generic ${LIFXD_BINARY_DIR}/compat)
+IF (NOT LGTD_RUNTIME_DIRECTORY)
+    SET(LGTD_RUNTIME_DIRECTORY "${LIGHTSD_BINARY_DIR}")
+ENDIF ()
+MESSAGE(STATUS "lightsd runtime directory: ${LGTD_RUNTIME_DIRECTORY}")
 
+INCLUDE_DIRECTORIES(
+    ${EVENT2_INCLUDE_DIR}
+    ${LIGHTSD_BINARY_DIR}/compat
+    ${LIGHTSD_BINARY_DIR}/compat/generic
+)
+
+ADD_SUBDIRECTORY(compat)
 ADD_SUBDIRECTORY(core)
+ADD_SUBDIRECTORY(lifx)
+
+# 2.8.11 is the first version with TARGET_INCLUDE_DIRECTORIES:
+IF (CMAKE_VERSION VERSION_GREATER 2.8.10)
+    CONFIGURE_FILE(
+        CTestCustom.cmake.in "${LIGHTSD_BINARY_DIR}/CTestCustom.cmake" @ONLY
+    )
+    ADD_SUBDIRECTORY(tests)
+ELSE ()
+    MESSAGE(
+        STATUS
+        "The tests suite requires CMake >= 2.8.11 "
+        "but you have ${CMAKE_VERSION}, disabling it"
+    )
+ENDIF ()
+
+IF (SPHINX_FOUND)
+    ADD_SUBDIRECTORY(docs)
+ENDIF ()
+
+INSTALL(
+    FILES COPYING README.rst docs/protocol.rst
+    DESTINATION share/doc/lightsd
+)
+INSTALL(
+    DIRECTORY examples
+    DESTINATION share/lightsd
+    USE_SOURCE_PERMISSIONS
+    REGEX ".*\\.sw.$" EXCLUDE
+)
+INSTALL(FILES share/lightsc.sh DESTINATION share/lightsd)
+INSTALL(FILES dist/lightsd.service DESTINATION lib/systemd/system)

CMakeScripts/AddAllSubdirectories.cmake

@@ -0,0 +1,8 @@
+FUNCTION(ADD_ALL_SUBDIRECTORIES)
+    FILE(GLOB SUBDIRECTORIES "*")
+    FOREACH (ENTRY ${SUBDIRECTORIES})
+        IF (IS_DIRECTORY ${ENTRY} AND EXISTS "${ENTRY}/CMakeLists.txt")
+            ADD_SUBDIRECTORY(${ENTRY})
+        ENDIF ()
+    ENDFOREACH ()
+ENDFUNCTION()

CMakeScripts/AddTestFromSources.cmake

@@ -0,0 +1,11 @@
+FUNCTION(ADD_TEST_FROM_C_SOURCES TEST_SOURCE)
+    STRING(LENGTH ${TEST_SOURCE} TEST_NAME_LEN)
+    STRING(LENGTH "test_" PREFIX_LEN)
+    MATH(EXPR TEST_NAME_LEN "${TEST_NAME_LEN} - 2 - ${PREFIX_LEN}")
+    STRING(SUBSTRING ${ARGV0} ${PREFIX_LEN} ${TEST_NAME_LEN} TEST_NAME)
+    ADD_EXECUTABLE(${TEST_NAME} ${TEST_SOURCE})
+    IF (ARGN)
+        TARGET_LINK_LIBRARIES(${TEST_NAME} ${ARGN})
+    ENDIF ()
+    ADD_TEST(test_${TEST_NAME} ${TEST_NAME})
+ENDFUNCTION()

CMakeScripts/CompatReallocArray.cmake

@@ -0,0 +1,27 @@
+IF (DEFINED HAVE_REALLOCARRAY)
+    RETURN()
+ENDIF ()
+
+MESSAGE(STATUS "Looking for reallocarray")
+
+SET(CMAKE_REQUIRED_QUIET TRUE)
+CHECK_FUNCTION_EXISTS("reallocarray" HAVE_REALLOCARRAY)
+UNSET(CMAKE_REQUIRED_QUIET)
+IF (HAVE_REALLOCARRAY)
+    MESSAGE(STATUS "Looking for reallocarray - found")
+    SET(
+        HAVE_REALLOCARRAY 1
+        CACHE INTERNAL
+        "reallocarray found on the system"
+    )
+ELSE ()
+    MESSAGE(
+        STATUS
+        "Looking for reallocarray - not found, using built-in compatibilty file"
+    )
+    SET(
+        HAVE_REALLOCARRAY 0
+        CACHE INTERNAL
+        "reallocarray not found, using internal implementation"
+    )
+ENDIF ()

CMakeScripts/CompatSetProctitle.cmake

@@ -0,0 +1,59 @@
+IF (DEFINED HAVE_SETPROCTITLE)
+    IF (HAVE_SETPROCTITLE EQUAL 0)
+        IF (HAVE_CLEARENV)
+            ADD_DEFINITIONS("-DHAVE_CLEARENV=1")
+        ENDIF ()
+        IF (HAVE_GETEXECNAME)
+            ADD_DEFINITIONS("-DHAVE_GETEXECNAME=1")
+        ENDIF ()
+        IF (HAVE___PROGNAME)
+            ADD_DEFINITIONS("-DHAVE___PROGNAME=1")
+        ENDIF ()
+        IF (HAVE_HAVE_PROGRAM_INVOCATION_SHORT_NAME)
+            ADD_DEFINITIONS("-DHAVE_HAVE_PROGRAM_INVOCATION_SHORT_NAME=1")
+        ENDIF ()
+    ENDIF ()
+    RETURN()
+ENDIF ()
+
+MESSAGE(STATUS "Looking for setproctitle")
+
+SET(CMAKE_REQUIRED_QUIET TRUE)
+CHECK_FUNCTION_EXISTS("setproctitle" HAVE_SETPROCTITLE)
+UNSET(CMAKE_REQUIRED_QUIET)
+IF (HAVE_SETPROCTITLE)
+    MESSAGE(
+        STATUS
+        "Looking for setproctitle - found"
+    )
+    SET(HAVE_SETPROCTITLE 1 CACHE INTERNAL "setproctitle found on the system")
+ELSE ()
+    MESSAGE(
+        STATUS
+        "Looking for setproctitle - not found, using built-in compatibilty file"
+    )
+    SET(
+        HAVE_SETPROCTITLE 0
+        CACHE INTERNAL
+        "setproctitle not found, using internal implementation"
+    )
+
+    CHECK_FUNCTION_EXISTS("clearenv" HAVE_CLEARENV)
+    CHECK_FUNCTION_EXISTS("getexecname" HAVE_GETEXECNAME)
+    CHECK_VARIABLE_EXISTS("__progname" HAVE___PROGNAME)
+    CHECK_VARIABLE_EXISTS(
+        "program_invocation_short_name" HAVE_PROGRAM_INVOCATION_SHORT_NAME
+    )
+    IF (HAVE_CLEARENV)
+        ADD_DEFINITIONS("-DHAVE_CLEARENV=1")
+    ENDIF ()
+    IF (HAVE_GETEXECNAME)
+        ADD_DEFINITIONS("-DHAVE_GETEXECNAME=1")
+    ENDIF ()
+    IF (HAVE___PROGNAME)
+        ADD_DEFINITIONS("-DHAVE___PROGNAME=1")
+    ENDIF ()
+    IF (HAVE_HAVE_PROGRAM_INVOCATION_SHORT_NAME)
+        ADD_DEFINITIONS("-DHAVE_HAVE_PROGRAM_INVOCATION_SHORT_NAME=1")
+    ENDIF ()
+ENDIF ()

CMakeScripts/CompatTimeMonotonic.cmake

@@ -1,31 +1,48 @@
-INCLUDE(CheckFunctionExists)
-
-IF (NOT TIME_MONOTONIC_IMPL)
-    SET(COMPAT_TIME_MONOTONIC_IMPL "${LIFXD_SOURCE_DIR}/compat/${CMAKE_SYSTEM_NAME}/time_monotonic.c")
-    SET(COMPAT_TIME_MONOTONIC_H "${LIFXD_SOURCE_DIR}/compat/${CMAKE_SYSTEM_NAME}/time_monotonic.h")
-    SET(GENERIC_TIME_MONOTONIC_IMPL "${LIFXD_SOURCE_DIR}/compat/generic/time_monotonic.c")
-    SET(GENERIC_TIME_MONOTONIC_H "${LIFXD_SOURCE_DIR}/compat/generic/time_monotonic.h")
+IF (NOT TIME_MONOTONIC_LIBRARY)
+    SET(COMPAT_TIME_MONOTONIC_IMPL "${LIGHTSD_SOURCE_DIR}/compat/${CMAKE_SYSTEM_NAME}/time_monotonic.c")
+    SET(COMPAT_TIME_MONOTONIC_H "${LIGHTSD_SOURCE_DIR}/compat/${CMAKE_SYSTEM_NAME}/time_monotonic.h")
+    SET(GENERIC_TIME_MONOTONIC_IMPL "${LIGHTSD_SOURCE_DIR}/compat/generic/time_monotonic.c")
+    SET(GENERIC_TIME_MONOTONIC_H "${LIGHTSD_SOURCE_DIR}/compat/generic/time_monotonic.h")
+    SET(TIME_MONOTONIC_LIBRARY time_monotonic CACHE INTERNAL "lgtd_time_monotonic implementation")
 
     SET(CMAKE_REQUIRED_QUIET TRUE)
     MESSAGE(STATUS "Looking for clock_gettime")
     CHECK_FUNCTION_EXISTS("clock_gettime" HAVE_CLOCK_GETTIME)
+    IF (NOT HAVE_CLOCK_GETTIME)
+        # glibc < 2.17:
+        MESSAGE(STATUS "Looking for clock_gettime again in librt")
+        UNSET(HAVE_CLOCK_GETTIME CACHE)
+        SET(TIME_MONOTONIC_LIBRARY_DEP rt CACHE INTERNAL "dependency for lgtd_time_monotonic")
+        SET(CMAKE_REQUIRED_LIBRARIES ${TIME_MONOTONIC_LIBRARY_DEP})
+        CHECK_FUNCTION_EXISTS("clock_gettime" HAVE_CLOCK_GETTIME)
+        UNSET(CMAKE_REQUIRED_LIBRARIES)
+        IF (NOT HAVE_CLOCK_GETTIME)
+            UNSET(TIME_MONOTONIC_LIBRARY_DEP CACHE)
+        ENDIF ()
+    ENDIF ()
     UNSET(CMAKE_REQUIRED_QUIET)
 
     IF (HAVE_CLOCK_GETTIME)
         MESSAGE(STATUS "Looking for clock_gettime - found")
-        FILE(COPY "${GENERIC_TIME_MONOTONIC_H}" DESTINATION "${LIFXD_BINARY_DIR}/compat/")
+        FILE(COPY "${GENERIC_TIME_MONOTONIC_H}" DESTINATION "${LIGHTSD_BINARY_DIR}/core/")
         SET(
-            TIME_MONOTONIC_IMPL "${GENERIC_TIME_MONOTONIC_IMPL}"
-            CACHE INTERNAL "lifxd_time_monotonic (POSIX generic implementation)"
+            TIME_MONOTONIC_IMPL ${GENERIC_TIME_MONOTONIC_IMPL}
+            CACHE INTERNAL "lgtd_time_monotonic (POSIX generic source)"
         )
     ELSEIF (EXISTS "${COMPAT_TIME_MONOTONIC_IMPL}")
         MESSAGE(STATUS "Looking for clock_gettime - not found, using built-in compatibilty file")
-        FILE(COPY "${COMPAT_TIME_MONOTONIC_H}" DESTINATION "${LIFXD_BINARY_DIR}/compat/")
+        FILE(COPY "${COMPAT_TIME_MONOTONIC_H}" DESTINATION "${LIGHTSD_BINARY_DIR}/core/")
         SET(
             TIME_MONOTONIC_IMPL "${COMPAT_TIME_MONOTONIC_IMPL}"
-            CACHE INTERNAL "lifxd_time_monotonic (${CMAKE_SYSTEM_NAME} specific implementation)"
+            CACHE INTERNAL "lgtd_time_monotonic (${CMAKE_SYSTEM_NAME} specific source)"
         )
     ELSE ()
         MESSAGE(SEND_ERROR "Looking for clock_gettime - not found")
     ENDIF ()
 ENDIF ()
+
+ADD_LIBRARY(${TIME_MONOTONIC_LIBRARY} STATIC "${TIME_MONOTONIC_IMPL}")
+
+IF (TIME_MONOTONIC_LIBRARY_DEP)
+    TARGET_LINK_LIBRARIES(${TIME_MONOTONIC_LIBRARY} ${TIME_MONOTONIC_LIBRARY_DEP})
+ENDIF ()

CMakeScripts/FindEndian.cmake

@@ -1,20 +1,20 @@
 INCLUDE(CheckIncludeFile)
 
 IF (NOT ENDIAN_H_PATH)
-    SET(COMPAT_ENDIAN_H "${LIFXD_SOURCE_DIR}/compat/${CMAKE_SYSTEM_NAME}/endian.h")
-    SET(GENERIC_ENDIAN_H "${LIFXD_SOURCE_DIR}/compat/generic/endian.h")
+    SET(COMPAT_ENDIAN_H "${LIGHTSD_SOURCE_DIR}/compat/${CMAKE_SYSTEM_NAME}/endian.h")
+    SET(GENERIC_ENDIAN_H "${LIGHTSD_SOURCE_DIR}/compat/generic/endian.h")
 
     SET(CMAKE_REQUIRED_QUIET TRUE)
     MESSAGE(STATUS "Looking for endian.h")
     CHECK_INCLUDE_FILE("endian.h" HAVE_ENDIAN_H)
     UNSET(CMAKE_REQUIRED_QUIET)
 
     IF (HAVE_ENDIAN_H)
-        MESSAGE(STATUS "Looking for endan.h - found")
+        MESSAGE(STATUS "Looking for endian.h - found")
         SET(ENDIAN_H_PATH "using native headers" CACHE INTERNAL "endian.h path")
     ELSEIF (EXISTS "${COMPAT_ENDIAN_H}")
         MESSAGE(STATUS "Looking for endian.h - not found, using built-in compatibility file")
-        FILE(COPY "${COMPAT_ENDIAN_H}" DESTINATION "${LIFXD_BINARY_DIR}/compat/")
+        FILE(COPY "${COMPAT_ENDIAN_H}" DESTINATION "${LIGHTSD_BINARY_DIR}/compat/")
         SET(ENDIAN_H_PATH "${COMPAT_ENDIAN_H}" CACHE INTERNAL "endian.h path")
     ELSE ()
         MESSAGE(STATUS "Looking for endian.h - not found")

CMakeScripts/FindEvent2.cmake

@@ -1,18 +1,24 @@
+FIND_PATH(
+    EVENT2_INCLUDE_DIR
+    event2/event.h
+    # OpenBSD has libevent1 in /usr/lib, always try /usr/local first:
+    HINTS /usr/local/
+)
+
 FOREACH (COMPONENT ${Event2_FIND_COMPONENTS})
     STRING(TOUPPER ${COMPONENT} UPPER_COMPONENT)
-    FIND_LIBRARY(EVENT2_${UPPER_COMPONENT}_LIBRARY event_${COMPONENT})
+    FIND_LIBRARY(
+        EVENT2_${UPPER_COMPONENT}_LIBRARY event_${COMPONENT} HINTS /usr/local/
+    )
     IF (EVENT2_${UPPER_COMPONENT}_LIBRARY)
         SET(Event2_${COMPONENT}_FOUND TRUE)
     ENDIF ()
 ENDFOREACH ()
 
-FIND_PATH(EVENT2_INCLUDE_DIR event2/event.h)
-
 INCLUDE(FindPackageHandleStandardArgs)
 
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(
     Event2
-    FOUND_VAR Event2_FOUND
     HANDLE_COMPONENTS
     REQUIRED_VARS EVENT2_CORE_LIBRARY EVENT2_INCLUDE_DIR
 )