Rework searching for openssl

Attempt to find the correct path for openssl.
The installation path for openssl may vary depending on the way used for its installation and the macOS version. This commit attempts to find the correct path for openssl to use.
2023-03-06 12:59:09 -08:00 · 2023-03-06 12:59:09 -08:00
28 changed files with 243 additions and 874 deletions
--- a/.github/spellcheck-settings.yml
+++ b/.github/spellcheck-settings.yml
@ -1,29 +0,0 @@
-matrix:
- name: Markdown
-  expect_match: false
-  apsell:
-    lang: en
-    d: en_US
-    ignore-case: true
-  dictionary:
-    wordlists:
-    - .github/wordlist.txt
-    output: wordlist.dic
-  pipeline:
-  - pyspelling.filters.markdown:
-      markdown_extensions:
-      - markdown.extensions.extra:
-  - pyspelling.filters.html:
-      comments: false
-      attributes:
-      - alt
-      ignores:
-      - ':matches(code, pre)'
-      - code
-      - pre
-      - blockquote
-      - img
-  sources:
-  - 'README.md'
-  - 'FAQ.md'
-  - 'docs/**'
--- a/.github/wordlist.txt
+++ b/.github/wordlist.txt
@ -1,99 +0,0 @@
-ABI
-ACLs
-alloc
-Allocator
-allocators
-antirez
-api
-APIs
-ASYNC
-asyncRedisContext
-asyncronous
-AUTOFREE
-autoload
-autoloader
-autoloading
-Autoloading
-backend
-backends
-behaviour
-boolean
-CAS
-Changelog
-customizable
-Customizable
-CVE
-dataset
-de
-deallocation
-ElastiCache
-extensibility
-FPM
-getaddrinfo
-gmail
-grunder
-Grunder
-hiredis
-Hiredis
-HIREDIS
-hostname
-IANA
-IPv
-IPV
-keepalive
-keyspace
-keyspaces
-KiB
-libc
-libev
-libevent
-localhost
-Lua
-michael
-minimalistic
-namespace
-NOAUTOFREE
-NOAUTOFREEREPLIES
-NONBLOCK
-Noordhuis
-OpenSSL
-Packagist
-pcnoordhuis
-PhpRedis
-Pieter
-pipelined
-pipelining
-pluggable
-Predis
-PRERELEASE
-printf
-PSR
-PSUBSCRIBE
-rb
-Readme
-README
-rebalanced
-rebalancing
-redis
-Redis
-redisAsyncContext
-redisContext
-redisOptions
-redisReader
-reusability
-REUSEADDR
-runtime
-Sanfilippo
-SHA
-sharding
-SONAME
-SSL
-struct
-stunnel
-subelements
-TCP
-TLS
-unparsed
-UNSPEC
-URI
-variadic
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -37,6 +37,42 @@ jobs:
      #          TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full
      #        run: $GITHUB_WORKSPACE/test.sh

+  centos7:
+    name: CentOS 7
+    runs-on: ubuntu-latest
+    container: centos:7
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install dependencies
+        run: |
+          yum -y install http://rpms.remirepo.net/enterprise/remi-release-7.rpm
+          yum -y --enablerepo=remi install redis
+          yum -y install gcc gcc-c++ make openssl openssl-devel cmake3 valgrind libevent-devel
+
+      - name: Build using cmake
+        env:
+          EXTRA_CMAKE_OPTS: -DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON -DENABLE_ASYNC_TESTS:BOOL=ON
+          CFLAGS: -Werror
+          CXXFLAGS: -Werror
+        run: mkdir build && cd build && cmake3 .. && make
+
+      - name: Build using Makefile
+        run: USE_SSL=1 TEST_ASYNC=1 make
+
+      - name: Run tests
+        env:
+          SKIPS_AS_FAILS: 1
+          TEST_SSL: 1
+        run: $GITHUB_WORKSPACE/test.sh
+
+      - name: Run tests under valgrind
+        env:
+          SKIPS_AS_FAILS: 1
+          TEST_SSL: 1
+          TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full
+        run: $GITHUB_WORKSPACE/test.sh
+
  centos8:
    name: RockyLinux 8
    runs-on: ubuntu-latest
@ -76,13 +112,13 @@ jobs:
        run: $GITHUB_WORKSPACE/test.sh

  freebsd:
-    runs-on: ubuntu-latest
+    runs-on: macos-12
    name:  FreeBSD
    steps:
      - uses: actions/checkout@v3

      - name: Build in FreeBSD
-        uses: vmactions/freebsd-vm@v1.0.5
+        uses: vmactions/freebsd-vm@v0
        with:
          prepare: pkg install -y gmake cmake
          run: |
@ -97,8 +133,8 @@ jobs:

      - name: Install dependencies
        run: |
-          brew install openssl redis@7.2
-          brew link redis@7.2 --force
+          brew install openssl redis@6.2
+          brew link redis@6.2 --force

      - name: Build hiredis
        run: USE_SSL=1 make
--- a/.github/workflows/spellcheck.yml
+++ b/.github/workflows/spellcheck.yml
@ -1,14 +0,0 @@
-name: spellcheck
-on:
-  pull_request:
-jobs:
-  check-spelling:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Check Spelling
-        uses: rojopolis/spellcheck-github-actions@0.33.1
-        with:
-          config_path: .github/spellcheck-settings.yml
-          task_name: Markdown
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@ -60,7 +60,7 @@ jobs:
    steps:
    - name: Install qemu
      if: matrix.emulator
-      run: sudo apt-get update && sudo apt-get install -y qemu-user
+      run: sudo apt-get install -y qemu-user
    - name: Install platform toolset
      if: matrix.toolset
      run: sudo apt-get install -y gcc-${{matrix.toolset}}
@ -82,14 +82,12 @@ jobs:
    steps:
      - uses: microsoft/setup-msbuild@v1.0.2
      - uses: actions/checkout@v3
-      - name: Run CMake (shared lib)
-        run: cmake -Wno-dev CMakeLists.txt
-      - name: Build hiredis (shared lib)
-        run: MSBuild hiredis.vcxproj /p:Configuration=Debug
-      - name: Run CMake (static lib)
-        run: cmake -Wno-dev CMakeLists.txt -DBUILD_SHARED_LIBS=OFF
-      - name: Build hiredis (static lib)
+      - name: Run CMake
+        run: cmake -Wno-dev CmakeLists.txt
+      - name: Build hiredis
        run: MSBuild hiredis.vcxproj /p:Configuration=Debug
+      - name: Build hiredis_static
+        run: MSBuild hiredis_static.vcxproj /p:Configuration=Debug
      - name: Build hiredis-test
        run: MSBuild hiredis-test.vcxproj /p:Configuration=Debug
      # use memurai, redis compatible server, since it is easy to install.  Can't
--- a/.gitignore
+++ b/.gitignore
@ -7,4 +7,3 @@
 /*.pc
 *.dSYM
 tags
-compile_commands.json
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,63 +1,12 @@
-## [1.2.0](https://github.com/redis/hiredis/tree/v1.2.0) - (2023-06-04)
-
-Announcing Hiredis v1.2.0 with with new adapters, and a great many bug fixes.
-
-## 🚀 New Features
-
- Add sdevent adapter @Oipo (#1144)
- Allow specifying the keepalive interval @michael-grunder (#1168)
- Add RedisModule adapter @tezc (#1182)
- Helper for setting TCP_USER_TIMEOUT socket option @zuiderkwast (#1188)
-
-## 🐛 Bug Fixes
-
- Fix a typo in b6a052f. @yossigo (#1190)
- Fix wincrypt symbols conflict @hudayou (#1151)
- Don't attempt to set a timeout if we are in an error state. @michael-grunder (#1180)
- Accept -nan per the RESP3 spec recommendation. @michael-grunder (#1178)
- Fix colliding option values @zuiderkwast (#1172)
- Ensure functionality without `_MSC_VER` definition @windyakin (#1194)
-
-## 🧰 Maintenance
-
- Add a test for the TCP_USER_TIMEOUT option. @michael-grunder (#1192)
- Add -Werror as a default. @yossigo (#1193)
- CI: Update homebrew Redis version. @yossigo (#1191)
- Fix typo in makefile. @michael-grunder (#1179)
- Write a version file for the CMake package @Neverlord (#1165)
- CMakeLists.txt: respect BUILD_SHARED_LIBS @ffontaine (#1147)
- Cmake static or shared @autoantwort (#1160)
- fix typo @tillkruss (#1153)
- Add a test ensuring we don't clobber connection error. @michael-grunder (#1181)
- Search for openssl on macOS @michael-grunder (#1169)
-
-
-## Contributors
-We'd like to thank all the contributors who worked on this release!
-
-<a href="https://github.com/neverlord"><img src="https://github.com/neverlord.png" width="32" height="32"></a>
-<a href="https://github.com/Oipo"><img src="https://github.com/Oipo.png" width="32" height="32"></a>
-<a href="https://github.com/autoantwort"><img src="https://github.com/autoantwort.png" width="32" height="32"></a>
-<a href="https://github.com/ffontaine"><img src="https://github.com/ffontaine.png" width="32" height="32"></a>
-<a href="https://github.com/hudayou"><img src="https://github.com/hudayou.png" width="32" height="32"></a>
-<a href="https://github.com/michael-grunder"><img src="https://github.com/michael-grunder.png" width="32" height="32"></a>
-<a href="https://github.com/postgraph"><img src="https://github.com/postgraph.png" width="32" height="32"></a>
-<a href="https://github.com/tezc"><img src="https://github.com/tezc.png" width="32" height="32"></a>
-<a href="https://github.com/tillkruss"><img src="https://github.com/tillkruss.png" width="32" height="32"></a>
-<a href="https://github.com/vityafx"><img src="https://github.com/vityafx.png" width="32" height="32"></a>
-<a href="https://github.com/windyakin"><img src="https://github.com/windyakin.png" width="32" height="32"></a>
-<a href="https://github.com/yossigo"><img src="https://github.com/yossigo.png" width="32" height="32"></a>
-<a href="https://github.com/zuiderkwast"><img src="https://github.com/zuiderkwast.png" width="32" height="32"></a>
-
 ## [1.1.0](https://github.com/redis/hiredis/tree/v1.1.0) - (2022-11-15)

 Announcing Hiredis v1.1.0 GA with better SSL convenience, new async adapters and a great many bug fixes.

-**NOTE**:  Hiredis can now return `nan` in addition to `-inf` and `inf` when returning a `REDIS_REPLY_DOUBLE`.
+**NOTE**:  Hiredis can now return `nan` in addition to `-inf` and `inf` when returning a `REDIS_REPLY_DOUBLE`. 

 ## 🐛 Bug Fixes

- Add support for nan in RESP3 double [@filipecosta90](https://github.com/filipecosta90)
+- Add support for nan in RESP3 double [@filipecosta90](https://github.com/filipecosta90) 
  ([\#1133](https://github.com/redis/hiredis/pull/1133))

 ## 🧰 Maintenance
@ -65,7 +14,7 @@ Announcing Hiredis v1.1.0 GA with better SSL convenience, new async adapters and
 - Add an example that calls redisCommandArgv [@michael-grunder](https://github.com/michael-grunder)
  ([\#1140](https://github.com/redis/hiredis/pull/1140))
 - fix flag reference [@pata00](https://github.com/pata00) ([\#1136](https://github.com/redis/hiredis/pull/1136))
- Make freeing a NULL redisAsyncContext a no op. [@michael-grunder](https://github.com/michael-grunder)
+- Make freeing a NULL redisAsyncContext a no op. [@michael-grunder](https://github.com/michael-grunder) 
  ([\#1135](https://github.com/redis/hiredis/pull/1135))
 - CI updates ([@bjosv](https://github.com/redis/bjosv) ([\#1139](https://github.com/redis/hiredis/pull/1139))

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,5 +1,11 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 3.0.0)

+OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
+OPTION(ENABLE_SSL "Build hiredis_ssl for SSL support" OFF)
+OPTION(DISABLE_TESTS "If tests should be compiled or not" OFF)
+OPTION(ENABLE_SSL_TESTS "Should we test SSL connections" OFF)
+OPTION(ENABLE_ASYNC_TESTS "Should we run all asynchronous API tests" OFF)
+
 MACRO(getVersionBit name)
  SET(VERSION_REGEX "^#define ${name} (.+)$")
  FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/hiredis.h"
@ -17,20 +23,13 @@ MESSAGE("Detected version: ${VERSION}")
 PROJECT(hiredis LANGUAGES "C" VERSION "${VERSION}")
 INCLUDE(GNUInstallDirs)

-OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
-OPTION(ENABLE_SSL "Build hiredis_ssl for SSL support" OFF)
-OPTION(DISABLE_TESTS "If tests should be compiled or not" OFF)
-OPTION(ENABLE_SSL_TESTS "Should we test SSL connections" OFF)
-OPTION(ENABLE_EXAMPLES "Enable building hiredis examples" OFF)
-OPTION(ENABLE_ASYNC_TESTS "Should we run all asynchronous API tests" OFF)
-# Historically, the NuGet file was always install; default
-# to ON for those who rely on that historical behaviour.
-OPTION(ENABLE_NUGET "Install NuGET packaging details" ON)
-
 # Hiredis requires C99
 SET(CMAKE_C_STANDARD 99)
+SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
 SET(CMAKE_DEBUG_POSTFIX d)

+SET(ENABLE_EXAMPLES OFF CACHE BOOL "Enable building hiredis examples")
+
 SET(hiredis_sources
    alloc.c
    async.c
@ -46,27 +45,50 @@ IF(WIN32)
    ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -DWIN32_LEAN_AND_MEAN)
 ENDIF()

-ADD_LIBRARY(hiredis ${hiredis_sources})
-ADD_LIBRARY(hiredis::hiredis ALIAS hiredis)
-set(hiredis_export_name hiredis CACHE STRING "Name of the exported target")
-set_target_properties(hiredis PROPERTIES EXPORT_NAME ${hiredis_export_name})
+ADD_LIBRARY(hiredis_static STATIC ${hiredis_sources})
+ADD_LIBRARY(hiredis::hiredis_static ALIAS hiredis_static)
+SET(HIREDIS_DEFAULT_LIBRARY hiredis_static)
+SET(HIREDIS_TARGETS hiredis_static)

-SET_TARGET_PROPERTIES(hiredis
-    PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE
-    VERSION "${HIREDIS_SONAME}")
-IF(MSVC)
+IF(NOT MSVC)
+    SET_TARGET_PROPERTIES(hiredis_static
+        PROPERTIES OUTPUT_NAME hiredis)
+ENDIF()
+
+IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(hiredis SHARED ${hiredis_sources})
+    ADD_LIBRARY(hiredis::hiredis ALIAS hiredis)
+    SET(HIREDIS_DEFAULT_LIBRARY hiredis)
+    SET(HIREDIS_TARGETS ${HIREDIS_TARGETS} hiredis)
    SET_TARGET_PROPERTIES(hiredis
+        PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE
+        VERSION "${HIREDIS_SONAME}")
+ENDIF()
+IF(MSVC)
+    SET_TARGET_PROPERTIES(hiredis_static
        PROPERTIES COMPILE_FLAGS /Z7)
 ENDIF()
-IF(WIN32)
-    TARGET_LINK_LIBRARIES(hiredis PUBLIC ws2_32 crypt32)
+IF(WIN32 OR MINGW)
+    IF(BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(hiredis PUBLIC ws2_32 crypt32)
+    ENDIF()
+    TARGET_LINK_LIBRARIES(hiredis_static PUBLIC ws2_32 crypt32)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-    TARGET_LINK_LIBRARIES(hiredis PUBLIC m)
+    IF(BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(hiredis PUBLIC m)
+    ENDIF()
+    TARGET_LINK_LIBRARIES(hiredis_static PUBLIC m)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "SunOS")
-    TARGET_LINK_LIBRARIES(hiredis PUBLIC socket)
+    IF(BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(hiredis PUBLIC socket)
+    ENDIF()
+    TARGET_LINK_LIBRARIES(hiredis_static PUBLIC socket)
 ENDIF()

-TARGET_INCLUDE_DIRECTORIES(hiredis PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+IF(BUILD_SHARED_LIBS)
+    TARGET_INCLUDE_DIRECTORIES(hiredis PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+ENDIF()
+TARGET_INCLUDE_DIRECTORIES(hiredis_static PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)

 CONFIGURE_FILE(hiredis.pc.in hiredis.pc @ONLY)

@ -96,7 +118,7 @@ set(CPACK_RPM_PACKAGE_AUTOREQPROV ON)

 include(CPack)

-INSTALL(TARGETS hiredis
+INSTALL(TARGETS ${HIREDIS_TARGETS}
    EXPORT hiredis-targets
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@ -108,11 +130,9 @@ if (MSVC AND BUILD_SHARED_LIBS)
        CONFIGURATIONS Debug RelWithDebInfo)
 endif()

-if (ENABLE_NUGET)
-    # For NuGet packages
-    INSTALL(FILES hiredis.targets
-        DESTINATION build/native)
-endif()
+# For NuGet packages
+INSTALL(FILES hiredis.targets
+    DESTINATION build/native)

 INSTALL(FILES hiredis.h read.h sds.h async.h alloc.h sockcompat.h
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
@ -159,28 +179,52 @@ IF(ENABLE_SSL)
    FIND_PACKAGE(OpenSSL REQUIRED)
    SET(hiredis_ssl_sources
        ssl.c)
-    ADD_LIBRARY(hiredis_ssl ${hiredis_ssl_sources})
-    ADD_LIBRARY(hiredis::hiredis_ssl ALIAS hiredis_ssl)
+
+    ADD_LIBRARY(hiredis_ssl_static STATIC
+            ${hiredis_ssl_sources})
+    SET(HIREDIS_SSL_DEFAULT_LIBRARY hiredis_ssl_static)
+    SET(HIREDIS_SSL_TARGETS hiredis_ssl_static)
+    IF(BUILD_SHARED_LIBS)
+        ADD_LIBRARY(hiredis_ssl SHARED
+            ${hiredis_ssl_sources})
+        SET(HIREDIS_SSL_DEFAULT_LIBRARY hiredis_ssl)
+        SET(HIREDIS_SSL_TARGETS ${HIREDIS_SSL_TARGETS} hiredis_ssl)
+    ENDIF()
+    IF(NOT MSVC)
+        SET_TARGET_PROPERTIES(hiredis_ssl_static
+            PROPERTIES OUTPUT_NAME hiredis_ssl)
+    ENDIF()

    IF (APPLE AND BUILD_SHARED_LIBS)
        SET_PROPERTY(TARGET hiredis_ssl PROPERTY LINK_FLAGS "-Wl,-undefined -Wl,dynamic_lookup")
    ENDIF()

-    SET_TARGET_PROPERTIES(hiredis_ssl
-        PROPERTIES
-        WINDOWS_EXPORT_ALL_SYMBOLS TRUE
-        VERSION "${HIREDIS_SONAME}")
-    IF(MSVC)
+    IF(BUILD_SHARED_LIBS)
        SET_TARGET_PROPERTIES(hiredis_ssl
+            PROPERTIES
+            WINDOWS_EXPORT_ALL_SYMBOLS TRUE
+            VERSION "${HIREDIS_SONAME}")
+    ENDIF()
+    IF(MSVC)
+        SET_TARGET_PROPERTIES(hiredis_ssl_static
            PROPERTIES COMPILE_FLAGS /Z7)
    ENDIF()
-    TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE OpenSSL::SSL)
-    IF(WIN32)
-        TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE hiredis)
+
+    TARGET_INCLUDE_DIRECTORIES(hiredis_ssl_static PRIVATE "${OPENSSL_INCLUDE_DIR}")
+    IF(BUILD_SHARED_LIBS)
+        TARGET_INCLUDE_DIRECTORIES(hiredis_ssl PRIVATE "${OPENSSL_INCLUDE_DIR}")
+        TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE ${OPENSSL_LIBRARIES})
+    ENDIF()
+
+    IF (WIN32 OR MINGW)
+        IF (BUILD_SHARED_LIBS)
+            TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE hiredis)
+        ENDIF()
+        TARGET_LINK_LIBRARIES(hiredis_ssl_static PUBLIC hiredis_static)
    ENDIF()
    CONFIGURE_FILE(hiredis_ssl.pc.in hiredis_ssl.pc @ONLY)

-    INSTALL(TARGETS hiredis_ssl
+    INSTALL(TARGETS ${HIREDIS_SSL_TARGETS}
        EXPORT hiredis_ssl-targets
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@ -223,10 +267,10 @@ ENDIF()
 IF(NOT DISABLE_TESTS)
    ENABLE_TESTING()
    ADD_EXECUTABLE(hiredis-test test.c)
-    TARGET_LINK_LIBRARIES(hiredis-test hiredis)
+    TARGET_LINK_LIBRARIES(hiredis-test ${HIREDIS_DEFAULT_LIBRARY})
    IF(ENABLE_SSL_TESTS)
        ADD_DEFINITIONS(-DHIREDIS_TEST_SSL=1)
-        TARGET_LINK_LIBRARIES(hiredis-test hiredis_ssl)
+        TARGET_LINK_LIBRARIES(hiredis-test ${HIREDIS_SSL_DEFAULT_LIBRARY})
    ENDIF()
    IF(ENABLE_ASYNC_TESTS)
        ADD_DEFINITIONS(-DHIREDIS_TEST_ASYNC=1)
@ -238,5 +282,5 @@ ENDIF()

 # Add examples
 IF(ENABLE_EXAMPLES)
-    ADD_SUBDIRECTORY(examples)
+  ADD_SUBDIRECTORY(examples)
 ENDIF(ENABLE_EXAMPLES)
--- a/15
+++ b/15
@ -39,11 +39,7 @@ export REDIS_TEST_CONFIG
 CC:=$(shell sh -c 'type $${CC%% *} >/dev/null 2>/dev/null && echo $(CC) || echo gcc')
 CXX:=$(shell sh -c 'type $${CXX%% *} >/dev/null 2>/dev/null && echo $(CXX) || echo g++')
 OPTIMIZATION?=-O3
-WARNINGS=-Wall -Wextra -Wstrict-prototypes -Wwrite-strings -Wno-missing-field-initializers
-USE_WERROR?=1
-ifeq ($(USE_WERROR),1)
-  WARNINGS+=-Werror
-endif
+WARNINGS=-Wall -W -Wstrict-prototypes -Wwrite-strings -Wno-missing-field-initializers
 DEBUG_FLAGS?= -g -ggdb
 REAL_CFLAGS=$(OPTIMIZATION) -fPIC $(CPPFLAGS) $(CFLAGS) $(WARNINGS) $(DEBUG_FLAGS) $(PLATFORM_FLAGS)
 REAL_LDFLAGS=$(LDFLAGS)
@ -103,7 +99,7 @@ ifeq ($(USE_SSL),1)

      ifneq ($(wildcard $(SEARCH_PATH1)),)
        OPENSSL_PREFIX=$(SEARCH_PATH1)
-      else ifneq ($(wildcard $(SEARCH_PATH2)),)
+      else ifneq($(wildcard $(SEARCH_PATH2)),)
        OPENSSL_PREFIX=$(SEARCH_PATH2)
      endif
    endif
@ -141,10 +137,7 @@ endif
 ifeq ($(uname_S),Darwin)
  DYLIBSUFFIX=dylib
  DYLIB_MINOR_NAME=$(LIBNAME).$(HIREDIS_SONAME).$(DYLIBSUFFIX)
-  DYLIB_MAJOR_NAME=$(LIBNAME).$(HIREDIS_MAJOR).$(DYLIBSUFFIX)
  DYLIB_MAKE_CMD=$(CC) -dynamiclib -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(DYLIB_MINOR_NAME) -o $(DYLIBNAME) $(LDFLAGS)
-  SSL_DYLIB_MINOR_NAME=$(SSL_LIBNAME).$(HIREDIS_SONAME).$(DYLIBSUFFIX)
-  SSL_DYLIB_MAJOR_NAME=$(SSL_LIBNAME).$(HIREDIS_MAJOR).$(DYLIBSUFFIX)
  SSL_DYLIB_MAKE_CMD=$(CC) -dynamiclib -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(SSL_DYLIB_MINOR_NAME) -o $(SSL_DYLIBNAME) $(LDFLAGS) $(SSL_LDFLAGS)
  DYLIB_PLUGIN=-Wl,-undefined -Wl,dynamic_lookup
 endif
@ -318,7 +311,7 @@ install: $(DYLIBNAME) $(STLIBNAME) $(PKGCONFNAME) $(SSL_INSTALL)
 	$(INSTALL) hiredis.h async.h read.h sds.h alloc.h sockcompat.h $(INSTALL_INCLUDE_PATH)
 	$(INSTALL) adapters/*.h $(INSTALL_INCLUDE_PATH)/adapters
 	$(INSTALL) $(DYLIBNAME) $(INSTALL_LIBRARY_PATH)/$(DYLIB_MINOR_NAME)
-	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIBNAME) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIB_MAJOR_NAME)
+	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIBNAME)
 	$(INSTALL) $(STLIBNAME) $(INSTALL_LIBRARY_PATH)
 	mkdir -p $(INSTALL_PKGCONF_PATH)
 	$(INSTALL) $(PKGCONFNAME) $(INSTALL_PKGCONF_PATH)
@ -327,7 +320,7 @@ install-ssl: $(SSL_DYLIBNAME) $(SSL_STLIBNAME) $(SSL_PKGCONFNAME)
 	mkdir -p $(INSTALL_INCLUDE_PATH) $(INSTALL_LIBRARY_PATH)
 	$(INSTALL) hiredis_ssl.h $(INSTALL_INCLUDE_PATH)
 	$(INSTALL) $(SSL_DYLIBNAME) $(INSTALL_LIBRARY_PATH)/$(SSL_DYLIB_MINOR_NAME)
-	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(SSL_DYLIB_MINOR_NAME) $(SSL_DYLIBNAME) && ln -sf $(SSL_DYLIB_MINOR_NAME) $(SSL_DYLIB_MAJOR_NAME)
+	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(SSL_DYLIB_MINOR_NAME) $(SSL_DYLIBNAME)
 	$(INSTALL) $(SSL_STLIBNAME) $(INSTALL_LIBRARY_PATH)
 	mkdir -p $(INSTALL_PKGCONF_PATH)
 	$(INSTALL) $(SSL_PKGCONFNAME) $(INSTALL_PKGCONF_PATH)
--- a/README.md
+++ b/README.md
@ -23,17 +23,6 @@ Redis version >= 1.2.0.
 The library comes with multiple APIs. There is the
 *synchronous API*, the *asynchronous API* and the *reply parsing API*.

-## Upgrading to > 1.2.0 (**PRERELEASE**)
-
-* After v1.2.0 we modified how we invoke `poll(2)` to wait for connections to complete, such that we will now retry
-  the call if it is interrupted by a signal until:
-
-  a) The connection succeeds or fails.
-  b) The overall connection timeout is reached.
-
-  In previous versions, an interrupted `poll(2)` call would cause the connection to fail
-  with `c->err` set to `REDIS_ERR_IO` and `c->errstr` set to `poll(2): Interrupted system call`.
-
 ## Upgrading to `1.1.0`

 Almost all users will simply need to recompile their applications against the newer version of hiredis.
@ -134,8 +123,6 @@ REDIS_OPTIONS_SET_PRIVDATA(&opt, myPrivData, myPrivDataDtor);
 opt->options |= REDIS_OPT_PREFER_IPV4;
 ```

-If a connection is lost, `int redisReconnect(redisContext *c)` can be used to restore the connection using the same endpoint and options as the given context.
-
 ### Configurable redisOptions flags

 There are several flags you may set in the `redisOptions` struct to change default behavior.  You can specify the flags via the `redisOptions->options` member.
@ -151,36 +138,6 @@ There are several flags you may set in the `redisOptions` struct to change defau

 *Note: A `redisContext` is not thread-safe.*

-### Other configuration using socket options
-
-The following socket options are applied directly to the underlying socket.
-The values are not stored in the `redisContext`, so they are not automatically applied when reconnecting using `redisReconnect()`.
-These functions return `REDIS_OK` on success.
-On failure, `REDIS_ERR` is returned and the underlying connection is closed.
-
-To configure these for an asynchronous context (see *Asynchronous API* below), use `ac->c` to get the redisContext out of an asyncRedisContext.
-
-```C
-int redisEnableKeepAlive(redisContext *c);
-int redisEnableKeepAliveWithInterval(redisContext *c, int interval);
-```
-
-Enables TCP keepalive by setting the following socket options (with some variations depending on OS):
-
-* `SO_KEEPALIVE`;
-* `TCP_KEEPALIVE` or `TCP_KEEPIDLE`, value configurable using the `interval` parameter, default 15 seconds;
-* `TCP_KEEPINTVL` set to 1/3 of `interval`;
-* `TCP_KEEPCNT` set to 3.
-
-```C
-int redisSetTcpUserTimeout(redisContext *c, unsigned int timeout);
-```
-
-Set the `TCP_USER_TIMEOUT` Linux-specific socket option which is as described in the `tcp` man page:
-
-> When the value is greater than 0, it specifies the maximum amount of time in milliseconds that trans mitted data may remain unacknowledged before TCP will forcibly close the corresponding connection and return ETIMEDOUT to the application.
-> If the option value is specified as 0, TCP will use the system default.
-
 ### Sending commands

 There are several ways to issue commands to Redis. The first that will be introduced is
@ -302,7 +259,7 @@ void redisFree(redisContext *c);
 This function immediately closes the socket and then frees the allocations done in
 creating the context.

-### Sending commands (continued)
+### Sending commands (cont'd)

 Together with `redisCommand`, the function `redisCommandArgv` can be used to issue commands.
 It has the following prototype:
@ -494,6 +451,7 @@ void appOnDisconnect(redisAsyncContext *c, int status)
 }
 ```

+
 ### Sending commands and their callbacks

 In an asynchronous context, commands are automatically pipelined due to the nature of an event loop.
--- a/adapters/libuv.h
+++ b/adapters/libuv.h
@ -159,7 +159,6 @@ static int redisLibuvAttach(redisAsyncContext* ac, uv_loop_t* loop) {
    memset(p, 0, sizeof(*p));

    if (uv_poll_init_socket(loop, &p->handle, c->fd) != 0) {
-        hi_free(p);
        return REDIS_ERR;
    }

--- a/adapters/macosx.h
+++ b/adapters/macosx.h
@ -1,35 +1,7 @@
-/*
- * Copyright (c) 2015 Дмитрий Бахвалов (Dmitry Bakhvalov)
- *
- * Permission for license update:
- *   https://github.com/redis/hiredis/issues/1271#issuecomment-2258225227
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
+//
+//  Created by Дмитрий Бахвалов on 13.07.15.
+//  Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.
+//

 #ifndef __HIREDIS_MACOSX_H__
 #define __HIREDIS_MACOSX_H__
--- a/adapters/redismoduleapi.h
+++ b/adapters/redismoduleapi.h
@ -1,144 +0,0 @@
-#ifndef __HIREDIS_REDISMODULEAPI_H__
-#define __HIREDIS_REDISMODULEAPI_H__
-
-#include "redismodule.h"
-
-#include "../async.h"
-#include "../hiredis.h"
-
-#include <sys/types.h>
-
-typedef struct redisModuleEvents {
-    redisAsyncContext *context;
-    RedisModuleCtx *module_ctx;
-    int fd;
-    int reading, writing;
-    int timer_active;
-    RedisModuleTimerID timer_id;
-} redisModuleEvents;
-
-static inline void redisModuleReadEvent(int fd, void *privdata, int mask) {
-    (void) fd;
-    (void) mask;
-
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    redisAsyncHandleRead(e->context);
-}
-
-static inline void redisModuleWriteEvent(int fd, void *privdata, int mask) {
-    (void) fd;
-    (void) mask;
-
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    redisAsyncHandleWrite(e->context);
-}
-
-static inline void redisModuleAddRead(void *privdata) {
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    if (!e->reading) {
-        e->reading = 1;
-        RedisModule_EventLoopAdd(e->fd, REDISMODULE_EVENTLOOP_READABLE, redisModuleReadEvent, e);
-    }
-}
-
-static inline void redisModuleDelRead(void *privdata) {
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    if (e->reading) {
-        e->reading = 0;
-        RedisModule_EventLoopDel(e->fd, REDISMODULE_EVENTLOOP_READABLE);
-    }
-}
-
-static inline void redisModuleAddWrite(void *privdata) {
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    if (!e->writing) {
-        e->writing = 1;
-        RedisModule_EventLoopAdd(e->fd, REDISMODULE_EVENTLOOP_WRITABLE, redisModuleWriteEvent, e);
-    }
-}
-
-static inline void redisModuleDelWrite(void *privdata) {
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    if (e->writing) {
-        e->writing = 0;
-        RedisModule_EventLoopDel(e->fd, REDISMODULE_EVENTLOOP_WRITABLE);
-    }
-}
-
-static inline void redisModuleStopTimer(void *privdata) {
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    if (e->timer_active) {
-        RedisModule_StopTimer(e->module_ctx, e->timer_id, NULL);
-    }
-    e->timer_active = 0;
-}
-
-static inline void redisModuleCleanup(void *privdata) {
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    redisModuleDelRead(privdata);
-    redisModuleDelWrite(privdata);
-    redisModuleStopTimer(privdata);
-    hi_free(e);
-}
-
-static inline void redisModuleTimeout(RedisModuleCtx *ctx, void *privdata) {
-    (void) ctx;
-
-    redisModuleEvents *e = (redisModuleEvents*)privdata;
-    e->timer_active = 0;
-    redisAsyncHandleTimeout(e->context);
-}
-
-static inline void redisModuleSetTimeout(void *privdata, struct timeval tv) {
-    redisModuleEvents* e = (redisModuleEvents*)privdata;
-
-    redisModuleStopTimer(privdata);
-
-    mstime_t millis = tv.tv_sec * 1000 + tv.tv_usec / 1000.0;
-    e->timer_id = RedisModule_CreateTimer(e->module_ctx, millis, redisModuleTimeout, e);
-    e->timer_active = 1;
-}
-
-/* Check if Redis version is compatible with the adapter. */
-static inline int redisModuleCompatibilityCheck(void) {
-    if (!RedisModule_EventLoopAdd ||
-        !RedisModule_EventLoopDel ||
-        !RedisModule_CreateTimer ||
-        !RedisModule_StopTimer) {
-        return REDIS_ERR;
-    }
-    return REDIS_OK;
-}
-
-static inline int redisModuleAttach(redisAsyncContext *ac, RedisModuleCtx *module_ctx) {
-    redisContext *c = &(ac->c);
-    redisModuleEvents *e;
-
-    /* Nothing should be attached when something is already attached */
-    if (ac->ev.data != NULL)
-        return REDIS_ERR;
-
-    /* Create container for context and r/w events */
-    e = (redisModuleEvents*)hi_malloc(sizeof(*e));
-    if (e == NULL)
-        return REDIS_ERR;
-
-    e->context = ac;
-    e->module_ctx = module_ctx;
-    e->fd = c->fd;
-    e->reading = e->writing = 0;
-    e->timer_active = 0;
-
-    /* Register functions to start/stop listening for events */
-    ac->ev.addRead = redisModuleAddRead;
-    ac->ev.delRead = redisModuleDelRead;
-    ac->ev.addWrite = redisModuleAddWrite;
-    ac->ev.delWrite = redisModuleDelWrite;
-    ac->ev.cleanup = redisModuleCleanup;
-    ac->ev.scheduleTimer = redisModuleSetTimeout;
-    ac->ev.data = e;
-
-    return REDIS_OK;
-}
-
-#endif
--- a/async.c
+++ b/async.c
@ -478,7 +478,7 @@ static int __redisGetSubscribeCallback(redisAsyncContext *ac, redisReply *reply,

    /* Match reply with the expected format of a pushed message.
     * The type and number of elements (3 to 4) are specified at:
-     * https://redis.io/docs/latest/develop/interact/pubsub/#format-of-pushed-messages */
+     * https://redis.io/topics/pubsub#format-of-pushed-messages */
    if ((reply->type == REDIS_REPLY_ARRAY && !(c->flags & REDIS_SUPPORTS_PUSH) && reply->elements >= 3) ||
        reply->type == REDIS_REPLY_PUSH) {
        assert(reply->element[0]->type == REDIS_REPLY_STRING);
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@ -6,7 +6,7 @@ if (GLIB2_FOUND)
    INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
    LINK_DIRECTORIES(${GLIB2_LIBRARY_DIRS})
    ADD_EXECUTABLE(example-glib example-glib.c)
-    TARGET_LINK_LIBRARIES(example-glib hiredis ${GLIB2_LIBRARIES})
+    TARGET_LINK_LIBRARIES(example-glib ${HIREDIS_DEFAULT_LIBRARY} ${GLIB2_LIBRARIES})
 ENDIF(GLIB2_FOUND)

 FIND_PATH(LIBEV ev.h
@ -16,46 +16,46 @@ FIND_PATH(LIBEV ev.h
 if (LIBEV)
    # Just compile and link with libev
    ADD_EXECUTABLE(example-libev example-libev.c)
-    TARGET_LINK_LIBRARIES(example-libev hiredis ev)
+    TARGET_LINK_LIBRARIES(example-libev ${HIREDIS_DEFAULT_LIBRARY} ev)
 ENDIF()

 FIND_PATH(LIBEVENT event.h)
 if (LIBEVENT)
    ADD_EXECUTABLE(example-libevent example-libevent.c)
-    TARGET_LINK_LIBRARIES(example-libevent hiredis event)
+    TARGET_LINK_LIBRARIES(example-libevent ${HIREDIS_DEFAULT_LIBRARY} event)
 ENDIF()

 FIND_PATH(LIBHV hv/hv.h)
 IF (LIBHV)
    ADD_EXECUTABLE(example-libhv example-libhv.c)
-    TARGET_LINK_LIBRARIES(example-libhv hiredis hv)
+    TARGET_LINK_LIBRARIES(example-libhv ${HIREDIS_DEFAULT_LIBRARY} hv)
 ENDIF()

 FIND_PATH(LIBUV uv.h)
 IF (LIBUV)
    ADD_EXECUTABLE(example-libuv example-libuv.c)
-    TARGET_LINK_LIBRARIES(example-libuv hiredis uv)
+    TARGET_LINK_LIBRARIES(example-libuv ${HIREDIS_DEFAULT_LIBRARY} uv)
 ENDIF()

 FIND_PATH(LIBSDEVENT systemd/sd-event.h)
 IF (LIBSDEVENT)
    ADD_EXECUTABLE(example-libsdevent example-libsdevent.c)
-    TARGET_LINK_LIBRARIES(example-libsdevent hiredis systemd)
+    TARGET_LINK_LIBRARIES(example-libsdevent ${HIREDIS_DEFAULT_LIBRARY} systemd)
 ENDIF()

 IF (APPLE)
    FIND_LIBRARY(CF CoreFoundation)
    ADD_EXECUTABLE(example-macosx example-macosx.c)
-    TARGET_LINK_LIBRARIES(example-macosx hiredis ${CF})
+    TARGET_LINK_LIBRARIES(example-macosx ${HIREDIS_DEFAULT_LIBRARY} ${CF})
 ENDIF()

 IF (ENABLE_SSL)
    ADD_EXECUTABLE(example-ssl example-ssl.c)
-    TARGET_LINK_LIBRARIES(example-ssl hiredis hiredis_ssl)
+    TARGET_LINK_LIBRARIES(example-ssl ${HIREDIS_DEFAULT_LIBRARY} ${HIREDIS_SSL_DEFAULT_LIBRARY})
 ENDIF()

 ADD_EXECUTABLE(example example.c)
-TARGET_LINK_LIBRARIES(example hiredis)
+TARGET_LINK_LIBRARIES(example ${HIREDIS_DEFAULT_LIBRARY})

 ADD_EXECUTABLE(example-push example-push.c)
-TARGET_LINK_LIBRARIES(example-push hiredis)
+TARGET_LINK_LIBRARIES(example-push ${HIREDIS_DEFAULT_LIBRARY})
--- a/examples/example-macosx.c
+++ b/examples/example-macosx.c
@ -1,35 +1,7 @@
-/*
- * Copyright (c) 2015 Дмитрий Бахвалов (Dmitry Bakhvalov)
- *
- * Permission for license update:
- *   https://github.com/redis/hiredis/issues/1271#issuecomment-2258225227
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
+//
+//  Created by Дмитрий Бахвалов on 13.07.15.
+//  Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.
+//

 #include <stdio.h>

--- a/examples/example-redismoduleapi.c
+++ b/examples/example-redismoduleapi.c
@ -1,101 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-
-#include <hiredis.h>
-#include <async.h>
-#include <adapters/redismoduleapi.h>
-
-void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
-    (void)privdata; //unused
-    redisReply *reply = r;
-    if (reply == NULL) {
-        /* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */
-        printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
-        return;
-    }
-    /* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/
-    redisAsyncDisconnect(c);
-}
-
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
-    redisReply *reply = r;
-    if (reply == NULL) {
-        if (c->errstr) {
-            printf("errstr: %s\n", c->errstr);
-        }
-        return;
-    }
-    printf("argv[%s]: %s\n", (char*)privdata, reply->str);
-
-    /* start another request that demonstrate timeout */
-    redisAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %f", 1.5);
-}
-
-void connectCallback(const redisAsyncContext *c, int status) {
-    if (status != REDIS_OK) {
-        printf("Error: %s\n", c->errstr);
-        return;
-    }
-    printf("Connected...\n");
-}
-
-void disconnectCallback(const redisAsyncContext *c, int status) {
-    if (status != REDIS_OK) {
-        printf("Error: %s\n", c->errstr);
-        return;
-    }
-    printf("Disconnected...\n");
-}
-
-/*
- * This example requires Redis 7.0 or above.
- *
- * 1- Compile this file as a shared library. Directory of "redismodule.h" must
- *    be in the include path.
- *       gcc -fPIC -shared -I../../redis/src/ -I.. example-redismoduleapi.c -o example-redismoduleapi.so
- *
- * 2- Load module:
- *       redis-server --loadmodule ./example-redismoduleapi.so value
- */
-int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-
-    int ret = RedisModule_Init(ctx, "example-redismoduleapi", 1, REDISMODULE_APIVER_1);
-    if (ret != REDISMODULE_OK) {
-        printf("error module init \n");
-        return REDISMODULE_ERR;
-    }
-
-    if (redisModuleCompatibilityCheck() != REDIS_OK) {
-        printf("Redis 7.0 or above is required! \n");
-        return REDISMODULE_ERR;
-    }
-
-    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
-        /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
-        return 1;
-    }
-
-    size_t len;
-    const char *val = RedisModule_StringPtrLen(argv[argc-1], &len);
-
-    RedisModuleCtx *module_ctx = RedisModule_GetDetachedThreadSafeContext(ctx);
-    redisModuleAttach(c, module_ctx);
-    redisAsyncSetConnectCallback(c,connectCallback);
-    redisAsyncSetDisconnectCallback(c,disconnectCallback);
-    redisAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});
-
-    /*
-    In this demo, we first `set key`, then `get key` to demonstrate the basic usage of the adapter.
-    Then in `getCallback`, we start a `debug sleep` command to create 1.5 second long request.
-    Because we have set a 1 second timeout to the connection, the command will always fail with a
-    timeout error, which is shown in the `debugCallback`.
-    */
-
-    redisAsyncCommand(c, NULL, NULL, "SET key %b", val, len);
-    redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
-    return 0;
-}
--- a/hiredis-config.cmake.in
+++ b/hiredis-config.cmake.in
@ -2,11 +2,11 @@

 set_and_check(hiredis_INCLUDEDIR "@PACKAGE_INCLUDE_INSTALL_DIR@")

-IF (NOT TARGET hiredis::@hiredis_export_name@)
+IF (NOT TARGET hiredis::hiredis)
 	INCLUDE(${CMAKE_CURRENT_LIST_DIR}/hiredis-targets.cmake)
 ENDIF()

-SET(hiredis_LIBRARIES hiredis::@hiredis_export_name@)
+SET(hiredis_LIBRARIES hiredis::hiredis)
 SET(hiredis_INCLUDE_DIRS ${hiredis_INCLUDEDIR})

 check_required_components(hiredis)
--- a/hiredis.c
+++ b/hiredis.c
@ -102,7 +102,6 @@ void freeReplyObject(void *reply) {
        break; /* Nothing to free */
    case REDIS_REPLY_ARRAY:
    case REDIS_REPLY_MAP:
-    case REDIS_REPLY_ATTR:
    case REDIS_REPLY_SET:
    case REDIS_REPLY_PUSH:
        if (r->element != NULL) {
@ -161,7 +160,6 @@ static void *createStringObject(const redisReadTask *task, char *str, size_t len
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY ||
               parent->type == REDIS_REPLY_MAP ||
-               parent->type == REDIS_REPLY_ATTR ||
               parent->type == REDIS_REPLY_SET ||
               parent->type == REDIS_REPLY_PUSH);
        parent->element[task->idx] = r;
@ -194,7 +192,6 @@ static void *createArrayObject(const redisReadTask *task, size_t elements) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY ||
               parent->type == REDIS_REPLY_MAP ||
-               parent->type == REDIS_REPLY_ATTR ||
               parent->type == REDIS_REPLY_SET ||
               parent->type == REDIS_REPLY_PUSH);
        parent->element[task->idx] = r;
@ -215,7 +212,6 @@ static void *createIntegerObject(const redisReadTask *task, long long value) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY ||
               parent->type == REDIS_REPLY_MAP ||
-               parent->type == REDIS_REPLY_ATTR ||
               parent->type == REDIS_REPLY_SET ||
               parent->type == REDIS_REPLY_PUSH);
        parent->element[task->idx] = r;
@ -253,7 +249,6 @@ static void *createDoubleObject(const redisReadTask *task, double value, char *s
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY ||
               parent->type == REDIS_REPLY_MAP ||
-               parent->type == REDIS_REPLY_ATTR ||
               parent->type == REDIS_REPLY_SET ||
               parent->type == REDIS_REPLY_PUSH);
        parent->element[task->idx] = r;
@ -272,7 +267,6 @@ static void *createNilObject(const redisReadTask *task) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY ||
               parent->type == REDIS_REPLY_MAP ||
-               parent->type == REDIS_REPLY_ATTR ||
               parent->type == REDIS_REPLY_SET ||
               parent->type == REDIS_REPLY_PUSH);
        parent->element[task->idx] = r;
@ -293,7 +287,6 @@ static void *createBoolObject(const redisReadTask *task, int bval) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY ||
               parent->type == REDIS_REPLY_MAP ||
-               parent->type == REDIS_REPLY_ATTR ||
               parent->type == REDIS_REPLY_SET ||
               parent->type == REDIS_REPLY_PUSH);
        parent->element[task->idx] = r;
@ -399,12 +392,12 @@ int redisvFormatCommand(char **target, const char *format, va_list ap) {
                    while (*_p != '\0' && strchr(flags,*_p) != NULL) _p++;

                    /* Field width */
-                    while (*_p != '\0' && isdigit((int) *_p)) _p++;
+                    while (*_p != '\0' && isdigit(*_p)) _p++;

                    /* Precision */
                    if (*_p == '.') {
                        _p++;
-                        while (*_p != '\0' && isdigit((int) *_p)) _p++;
+                        while (*_p != '\0' && isdigit(*_p)) _p++;
                    }

                    /* Copy va_list before consuming with va_arg */
@ -867,9 +860,7 @@ redisContext *redisConnectWithOptions(const redisOptions *options) {
        return NULL;
    }

-    if (c->err == 0 && c->fd != REDIS_INVALID_FD &&
-        options->command_timeout != NULL && (c->flags & REDIS_BLOCK))
-    {
+    if (options->command_timeout != NULL && (c->flags & REDIS_BLOCK) && c->fd != REDIS_INVALID_FD) {
        redisContextSetTimeout(c, *options->command_timeout);
    }

@ -951,18 +942,11 @@ int redisSetTimeout(redisContext *c, const struct timeval tv) {
    return REDIS_ERR;
 }

-int redisEnableKeepAliveWithInterval(redisContext *c, int interval) {
-    return redisKeepAlive(c, interval);
-}
-
 /* Enable connection KeepAlive. */
 int redisEnableKeepAlive(redisContext *c) {
-    return redisKeepAlive(c, REDIS_KEEPALIVE_INTERVAL);
-}
-
-/* Set the socket option TCP_USER_TIMEOUT. */
-int redisSetTcpUserTimeout(redisContext *c, unsigned int timeout) {
-    return redisContextSetTcpUserTimeout(c, timeout);
+    if (redisKeepAlive(c, REDIS_KEEPALIVE_INTERVAL) != REDIS_OK)
+        return REDIS_ERR;
+    return REDIS_OK;
 }

 /* Set a user provided RESP3 PUSH handler and return any old one set. */
--- a/hiredis.h
+++ b/hiredis.h
@ -46,9 +46,9 @@ typedef long long ssize_t;
 #include "alloc.h" /* for allocation wrappers */

 #define HIREDIS_MAJOR 1
-#define HIREDIS_MINOR 2
-#define HIREDIS_PATCH 0
-#define HIREDIS_SONAME 1.2.1-dev
+#define HIREDIS_MINOR 1
+#define HIREDIS_PATCH 1
+#define HIREDIS_SONAME 1.1.1-dev

 /* Connection type can be blocking or non-blocking and is set in the
 * least significant bit of the flags field in redisContext. */
@ -154,18 +154,24 @@ struct redisSsl;

 #define REDIS_OPT_NONBLOCK 0x01
 #define REDIS_OPT_REUSEADDR 0x02
-#define REDIS_OPT_NOAUTOFREE 0x04        /* Don't automatically free the async
-                                          * object on a connection failure, or
-                                          * other implicit conditions. Only free
-                                          * on an explicit call to disconnect()
-                                          * or free() */
-#define REDIS_OPT_NO_PUSH_AUTOFREE 0x08  /* Don't automatically intercept and
-                                          * free RESP3 PUSH replies. */
-#define REDIS_OPT_NOAUTOFREEREPLIES 0x10 /* Don't automatically free replies. */
-#define REDIS_OPT_PREFER_IPV4 0x20       /* Prefer IPv4 in DNS lookups. */
-#define REDIS_OPT_PREFER_IPV6 0x40       /* Prefer IPv6 in DNS lookups. */
+#define REDIS_OPT_PREFER_IPV4 0x04
+#define REDIS_OPT_PREFER_IPV6 0x08
 #define REDIS_OPT_PREFER_IP_UNSPEC (REDIS_OPT_PREFER_IPV4 | REDIS_OPT_PREFER_IPV6)

+/**
+ * Don't automatically free the async object on a connection failure,
+ * or other implicit conditions. Only free on an explicit call to disconnect() or free()
+ */
+#define REDIS_OPT_NOAUTOFREE 0x04
+
+/* Don't automatically intercept and free RESP3 PUSH replies. */
+#define REDIS_OPT_NO_PUSH_AUTOFREE 0x08
+
+/**
+ * Don't automatically free replies
+ */
+#define REDIS_OPT_NOAUTOFREEREPLIES 0x10
+
 /* In Unix systems a file descriptor is a regular signed int, with -1
 * representing an invalid descriptor. In Windows it is a SOCKET
 * (32- or 64-bit unsigned integer depending on the architecture), where
@ -322,8 +328,6 @@ int redisReconnect(redisContext *c);
 redisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn);
 int redisSetTimeout(redisContext *c, const struct timeval tv);
 int redisEnableKeepAlive(redisContext *c);
-int redisEnableKeepAliveWithInterval(redisContext *c, int interval);
-int redisSetTcpUserTimeout(redisContext *c, unsigned int timeout);
 void redisFree(redisContext *c);
 redisFD redisFreeKeepFd(redisContext *c);
 int redisBufferRead(redisContext *c);
--- a/hiredis_ssl-config.cmake.in
+++ b/hiredis_ssl-config.cmake.in
@ -2,9 +2,6 @@

 set_and_check(hiredis_ssl_INCLUDEDIR "@PACKAGE_INCLUDE_INSTALL_DIR@")

-include(CMakeFindDependencyMacro)
-find_dependency(OpenSSL)
-
 IF (NOT TARGET hiredis::hiredis_ssl)
 	INCLUDE(${CMAKE_CURRENT_LIST_DIR}/hiredis_ssl-targets.cmake)
 ENDIF()
--- a/net.c
+++ b/net.c
@ -41,7 +41,6 @@
 #include <stdio.h>
 #include <limits.h>
 #include <stdlib.h>
-#include <time.h>

 #include "net.h"
 #include "sds.h"
@ -173,10 +172,6 @@ int redisKeepAlive(redisContext *c, int interval) {
    int val = 1;
    redisFD fd = c->fd;

-    /* TCP_KEEPALIVE makes no sense with AF_UNIX connections */
-    if (c->connection_type == REDIS_CONN_UNIX)
-        return REDIS_ERR;
-
 #ifndef _WIN32
    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
@ -233,23 +228,6 @@ int redisSetTcpNoDelay(redisContext *c) {
    return REDIS_OK;
 }

-int redisContextSetTcpUserTimeout(redisContext *c, unsigned int timeout) {
-    int res;
-#ifdef TCP_USER_TIMEOUT
-    res = setsockopt(c->fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout, sizeof(timeout));
-#else
-    res = -1;
-    errno = ENOTSUP;
-    (void)timeout;
-#endif
-    if (res == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(TCP_USER_TIMEOUT)");
-        redisNetClose(c);
-        return REDIS_ERR;
-    }
-    return REDIS_OK;
-}
-
 #define __MAX_MSEC (((LONG_MAX) - 999) / 1000)

 static int redisContextTimeoutMsec(redisContext *c, long *result)
@ -276,54 +254,37 @@ static int redisContextTimeoutMsec(redisContext *c, long *result)
    return REDIS_OK;
 }

-static long redisPollMillis(void) {
-#ifndef _MSC_VER
-    struct timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
-    return (now.tv_sec * 1000) + now.tv_nsec / 1000000;
-#else
-    FILETIME ft;
-    GetSystemTimeAsFileTime(&ft);
-    return (((long long)ft.dwHighDateTime << 32) | ft.dwLowDateTime) / 10;
-#endif
-}
-
 static int redisContextWaitReady(redisContext *c, long msec) {
-    struct pollfd wfd;
-    long end;
-    int res;
+    struct pollfd   wfd[1];

-    if (errno != EINPROGRESS) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-        redisNetClose(c);
-        return REDIS_ERR;
-    }
+    wfd[0].fd     = c->fd;
+    wfd[0].events = POLLOUT;

-    wfd.fd = c->fd;
-    wfd.events = POLLOUT;
-    end = msec >= 0 ? redisPollMillis() + msec : 0;
+    if (errno == EINPROGRESS) {
+        int res;

-    while ((res = poll(&wfd, 1, msec)) <= 0) {
-        if (res < 0 && errno != EINTR) {
+        if ((res = poll(wfd, 1, msec)) == -1) {
            __redisSetErrorFromErrno(c, REDIS_ERR_IO, "poll(2)");
            redisNetClose(c);
            return REDIS_ERR;
-        } else if (res == 0 || (msec >= 0 && redisPollMillis() >= end)) {
+        } else if (res == 0) {
            errno = ETIMEDOUT;
-            __redisSetErrorFromErrno(c, REDIS_ERR_IO, NULL);
+            __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
            redisNetClose(c);
            return REDIS_ERR;
-        } else {
-            /* res < 0 && errno == EINTR, try again */
        }
+
+        if (redisCheckConnectDone(c, &res) != REDIS_OK || res == 0) {
+            redisCheckSocketError(c);
+            return REDIS_ERR;
+        }
+
+        return REDIS_OK;
    }

-    if (redisCheckConnectDone(c, &res) != REDIS_OK || res == 0) {
-        redisCheckSocketError(c);
-        return REDIS_ERR;
-    }
-
-    return REDIS_OK;
+    __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
+    redisNetClose(c);
+    return REDIS_ERR;
 }

 int redisCheckConnectDone(redisContext *c, int *completed) {
@ -668,7 +629,7 @@ int redisContextConnectUnix(redisContext *c, const char *path, const struct time
    sa->sun_family = AF_UNIX;
    strncpy(sa->sun_path, path, sizeof(sa->sun_path) - 1);
    if (connect(c->fd, (struct sockaddr*)sa, sizeof(*sa)) == -1) {
-        if ((errno == EAGAIN || errno == EINPROGRESS) && !blocking) {
+        if (errno == EINPROGRESS && !blocking) {
            /* This is ok. */
        } else {
            if (redisContextWaitReady(c,timeout_msec) != REDIS_OK)
--- a/net.h
+++ b/net.h
@ -52,6 +52,5 @@ int redisKeepAlive(redisContext *c, int interval);
 int redisCheckConnectDone(redisContext *c, int *completed);

 int redisSetTcpNoDelay(redisContext *c);
-int redisContextSetTcpUserTimeout(redisContext *c, unsigned int timeout);

 #endif
--- a/read.c
+++ b/read.c
@ -250,7 +250,6 @@ static void moveToNextTask(redisReader *r) {
        prv = r->task[r->ridx-1];
        assert(prv->type == REDIS_REPLY_ARRAY ||
               prv->type == REDIS_REPLY_MAP ||
-               prv->type == REDIS_REPLY_ATTR ||
               prv->type == REDIS_REPLY_SET ||
               prv->type == REDIS_REPLY_PUSH);
        if (cur->idx == prv->elements-1) {
@ -304,8 +303,7 @@ static int processLineItem(redisReader *r) {
                d = INFINITY; /* Positive infinite. */
            } else if (len == 4 && strcasecmp(buf,"-inf") == 0) {
                d = -INFINITY; /* Negative infinite. */
-            } else if ((len == 3 && strcasecmp(buf,"nan") == 0) ||
-                       (len == 4 && strcasecmp(buf, "-nan") == 0)) {
+            } else if (len == 3 && strcasecmp(buf,"nan") == 0) {
                d = NAN; /* nan. */
            } else {
                d = strtod((char*)buf,&eptr);
@ -535,7 +533,7 @@ static int processAggregateItem(redisReader *r) {

            moveToNextTask(r);
        } else {
-            if (cur->type == REDIS_REPLY_MAP || cur->type == REDIS_REPLY_ATTR) elements *= 2;
+            if (cur->type == REDIS_REPLY_MAP) elements *= 2;

            if (r->fn && r->fn->createArray)
                obj = r->fn->createArray(cur,elements);
@ -603,9 +601,6 @@ static int processItem(redisReader *r) {
            case '%':
                cur->type = REDIS_REPLY_MAP;
                break;
-            case '|':
-                cur->type = REDIS_REPLY_ATTR;
-                break;
            case '~':
                cur->type = REDIS_REPLY_SET;
                break;
@ -646,7 +641,6 @@ static int processItem(redisReader *r) {
        return processBulkItem(r);
    case REDIS_REPLY_ARRAY:
    case REDIS_REPLY_MAP:
-    case REDIS_REPLY_ATTR:
    case REDIS_REPLY_SET:
    case REDIS_REPLY_PUSH:
        return processAggregateItem(r);
--- a/sds.c
+++ b/sds.c
@ -692,10 +692,10 @@ fmt_error:
 * Output will be just "Hello World".
 */
 sds sdstrim(sds s, const char *cset) {
-    char *end, *sp, *ep;
+    char *start, *end, *sp, *ep;
    size_t len;

-    sp = s;
+    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > sp && strchr(cset, *ep)) ep--;
@ -886,7 +886,7 @@ sds sdscatrepr(sds s, const char *p, size_t len) {
        case '\a': s = sdscatlen(s,"\\a",2); break;
        case '\b': s = sdscatlen(s,"\\b",2); break;
        default:
-            if (isprint((int) *p))
+            if (isprint(*p))
                s = sdscatprintf(s,"%c",*p);
            else
                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
@ -948,7 +948,7 @@ sds *sdssplitargs(const char *line, int *argc) {
    *argc = 0;
    while(1) {
        /* skip blanks */
-        while(*p && isspace((int) *p)) p++;
+        while(*p && isspace(*p)) p++;
        if (*p) {
            /* get a token */
            int inq=0;  /* set to 1 if we are in "quotes" */
@ -959,8 +959,8 @@ sds *sdssplitargs(const char *line, int *argc) {
            while(!done) {
                if (inq) {
                    if (*p == '\\' && *(p+1) == 'x' &&
-                                             isxdigit((int) *(p+2)) &&
-                                             isxdigit((int) *(p+3)))
+                                             isxdigit(*(p+2)) &&
+                                             isxdigit(*(p+3)))
                    {
                        unsigned char byte;

@ -984,7 +984,7 @@ sds *sdssplitargs(const char *line, int *argc) {
                    } else if (*p == '"') {
                        /* closing quote must be followed by a space or
                         * nothing at all. */
-                        if (*(p+1) && !isspace((int) *(p+1))) goto err;
+                        if (*(p+1) && !isspace(*(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
@ -999,7 +999,7 @@ sds *sdssplitargs(const char *line, int *argc) {
                    } else if (*p == '\'') {
                        /* closing quote must be followed by a space or
                         * nothing at all. */
-                        if (*(p+1) && !isspace((int) *(p+1))) goto err;
+                        if (*(p+1) && !isspace(*(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
--- a/ssl.c
+++ b/ssl.c
@ -40,14 +40,6 @@
 #ifdef _WIN32
 #include <windows.h>
 #include <wincrypt.h>
-#ifdef OPENSSL_IS_BORINGSSL
-#undef X509_NAME
-#undef X509_EXTENSIONS
-#undef PKCS7_ISSUER_AND_SERIAL
-#undef PKCS7_SIGNER_INFO
-#undef OCSP_REQUEST
-#undef OCSP_RESPONSE
-#endif
 #else
 #include <pthread.h>
 #endif
@ -59,8 +51,6 @@
 #include "async_private.h"
 #include "hiredis_ssl.h"

-#define OPENSSL_1_1_0 0x10100000L
-
 void __redisSetError(redisContext *c, int type, const char *str);

 struct redisSSLContext {
@ -102,7 +92,7 @@ redisContextFuncs redisContextSSLFuncs;
 * Note that this is only required for OpenSSL < 1.1.0.
 */

-#if OPENSSL_VERSION_NUMBER < OPENSSL_1_1_0
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
 #define HIREDIS_USE_CRYPTO_LOCKS
 #endif

@ -167,8 +157,8 @@ static int initOpensslLocks(void) {

 int redisInitOpenSSL(void)
 {
-#ifdef HIREDIS_USE_CRYPTO_LOCKS
    SSL_library_init();
+#ifdef HIREDIS_USE_CRYPTO_LOCKS
    initOpensslLocks();
 #endif

@ -258,25 +248,13 @@ redisSSLContext *redisCreateSSLContextWithOptions(redisSSLOptions *options, redi
    if (ctx == NULL)
        goto error;

-    const SSL_METHOD *ssl_method;
-#if OPENSSL_VERSION_NUMBER >= OPENSSL_1_1_0
-    ssl_method = TLS_client_method();
-#else
-    ssl_method = SSLv23_client_method();
-#endif
-
-    ctx->ssl_ctx = SSL_CTX_new(ssl_method);
+    ctx->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
    if (!ctx->ssl_ctx) {
        if (error) *error = REDIS_SSL_CTX_CREATE_FAILED;
        goto error;
    }

-#if OPENSSL_VERSION_NUMBER >= OPENSSL_1_1_0
-    SSL_CTX_set_min_proto_version(ctx->ssl_ctx, TLS1_2_VERSION);
-#else
-    SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1);
-#endif
-
+    SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
    SSL_CTX_set_verify(ctx->ssl_ctx, options->verify_mode, NULL);

    if ((cert_filename != NULL && private_key_filename == NULL) ||
@ -364,6 +342,7 @@ static int redisSSLConnect(redisContext *c, SSL *ssl) {
        return REDIS_ERR;
    }

+    c->funcs = &redisContextSSLFuncs;
    rssl->ssl = ssl;

    SSL_set_mode(rssl->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
@ -371,19 +350,15 @@ static int redisSSLConnect(redisContext *c, SSL *ssl) {
    SSL_set_connect_state(rssl->ssl);

    ERR_clear_error();
-
    int rv = SSL_connect(rssl->ssl);
    if (rv == 1) {
-        c->funcs = &redisContextSSLFuncs;
        c->privctx = rssl;
        return REDIS_OK;
    }

    rv = SSL_get_error(rssl->ssl, rv);
    if (((c->flags & REDIS_BLOCK) == 0) &&
-        (rv == SSL_ERROR_WANT_READ || rv == SSL_ERROR_WANT_WRITE))
-    {
-        c->funcs = &redisContextSSLFuncs;
+        (rv == SSL_ERROR_WANT_READ || rv == SSL_ERROR_WANT_WRITE)) {
        c->privctx = rssl;
        return REDIS_OK;
    }
--- a/test.c
+++ b/test.c
@ -78,7 +78,7 @@ static int tests = 0, fails = 0, skips = 0;

 static void millisleep(int ms)
 {
-#ifdef _MSC_VER
+#if _MSC_VER
    Sleep(ms);
 #else
    usleep(ms*1000);
@ -104,13 +104,6 @@ static long long usec(void) {
 #define assert(e) (void)(e)
 #endif

-#define redisTestPanic(msg) \
-    do { \
-        fprintf(stderr, "PANIC: %s (In function \"%s\", file \"%s\", line %d)\n", \
-                msg, __func__, __FILE__, __LINE__); \
-        exit(1); \
-    } while (1)
-
 /* Helper to extract Redis version information.  Aborts on any failure. */
 #define REDIS_VERSION_FIELD "redis_version:"
 void get_redis_version(redisContext *c, int *majorptr, int *minorptr) {
@ -156,7 +149,7 @@ static redisContext *select_database(redisContext *c) {
    assert(reply != NULL);
    freeReplyObject(reply);

-    /* Make sure the DB is empty */
+    /* Make sure the DB is emtpy */
    reply = redisCommand(c,"DBSIZE");
    assert(reply != NULL);
    if (reply->type == REDIS_REPLY_INTEGER && reply->integer == 0) {
@ -239,7 +232,7 @@ static redisContext *do_connect(struct config config) {
            c = redisConnectFd(fd);
        }
    } else {
-        redisTestPanic("Unknown connection type!");
+        assert(NULL);
    }

    if (c == NULL) {
@ -416,37 +409,10 @@ static void test_tcp_options(struct config cfg) {
    redisContext *c;

    c = do_connect(cfg);
-
    test("We can enable TCP_KEEPALIVE: ");
    test_cond(redisEnableKeepAlive(c) == REDIS_OK);

-#ifdef TCP_USER_TIMEOUT
-    test("We can set TCP_USER_TIMEOUT: ");
-    test_cond(redisSetTcpUserTimeout(c, 100) == REDIS_OK);
-#else
-    test("Setting TCP_USER_TIMEOUT errors when unsupported: ");
-    test_cond(redisSetTcpUserTimeout(c, 100) == REDIS_ERR && c->err == REDIS_ERR_IO);
-#endif
-
-    redisFree(c);
-}
-
-static void test_unix_keepalive(struct config cfg) {
-    redisContext *c;
-    redisReply *r;
-
-    c = do_connect(cfg);
-
-    test("Setting TCP_KEEPALIVE on a unix socket returns an error: ");
-    test_cond(redisEnableKeepAlive(c) == REDIS_ERR && c->err == 0);
-
-    test("Setting TCP_KEEPALIVE on a unix socket doesn't break the connection: ");
-    r = redisCommand(c, "PING");
-    test_cond(r != NULL && r->type == REDIS_REPLY_STATUS && r->len == 4 &&
-              !memcmp(r->str, "PONG", 4));
-    freeReplyObject(r);
-
-    redisFree(c);
+    disconnect(c, 0);
 }

 static void test_reply_reader(void) {
@ -718,16 +684,6 @@ static void test_reply_reader(void) {
    freeReplyObject(reply);
    redisReaderFree(reader);

-    test("Correctly parses RESP3 double -Nan: ");
-    reader = redisReaderCreate();
-    redisReaderFeed(reader, ",-nan\r\n", 7);
-    ret = redisReaderGetReply(reader, &reply);
-    test_cond(ret == REDIS_OK &&
-              ((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&
-              isnan(((redisReply*)reply)->dval));
-    freeReplyObject(reply);
-    redisReaderFree(reader);
-
    test("Can parse RESP3 nil: ");
    reader = redisReaderCreate();
    redisReaderFeed(reader, "_\r\n",3);
@ -795,26 +751,6 @@ static void test_reply_reader(void) {
    freeReplyObject(reply);
    redisReaderFree(reader);

-    test("Can parse RESP3 attribute: ");
-    reader = redisReaderCreate();
-    redisReaderFeed(reader, "|2\r\n+foo\r\n:123\r\n+bar\r\n#t\r\n",26);
-    ret = redisReaderGetReply(reader,&reply);
-    test_cond(ret == REDIS_OK &&
-        ((redisReply*)reply)->type == REDIS_REPLY_ATTR &&
-        ((redisReply*)reply)->elements == 4 &&
-        ((redisReply*)reply)->element[0]->type == REDIS_REPLY_STATUS &&
-        ((redisReply*)reply)->element[0]->len == 3 &&
-        !strcmp(((redisReply*)reply)->element[0]->str,"foo") &&
-        ((redisReply*)reply)->element[1]->type == REDIS_REPLY_INTEGER &&
-        ((redisReply*)reply)->element[1]->integer == 123 &&
-        ((redisReply*)reply)->element[2]->type == REDIS_REPLY_STATUS &&
-        ((redisReply*)reply)->element[2]->len == 3 &&
-        !strcmp(((redisReply*)reply)->element[2]->str,"bar") &&
-        ((redisReply*)reply)->element[3]->type == REDIS_REPLY_BOOL &&
-        ((redisReply*)reply)->element[3]->integer);
-    freeReplyObject(reply);
-    redisReaderFree(reader);
-
    test("Can parse RESP3 set: ");
    reader = redisReaderCreate();
    redisReaderFeed(reader, "~5\r\n+orange\r\n$5\r\napple\r\n#f\r\n:100\r\n:999\r\n",40);
@ -935,9 +871,9 @@ static void test_allocator_injection(void) {

 #define HIREDIS_BAD_DOMAIN "idontexist-noreally.com"
 static void test_blocking_connection_errors(void) {
+    redisContext *c;
    struct addrinfo hints = {.ai_family = AF_INET};
    struct addrinfo *ai_tmp = NULL;
-    redisContext *c;

    int rv = getaddrinfo(HIREDIS_BAD_DOMAIN, "6379", &hints, &ai_tmp);
    if (rv != 0) {
@ -964,26 +900,12 @@ static void test_blocking_connection_errors(void) {
    }

 #ifndef _WIN32
-    redisOptions opt = {0};
-    struct timeval tv;
-
    test("Returns error when the port is not open: ");
    c = redisConnect((char*)"localhost", 1);
    test_cond(c->err == REDIS_ERR_IO &&
        strcmp(c->errstr,"Connection refused") == 0);
    redisFree(c);

-
-    /* Verify we don't regress from the fix in PR #1180 */
-    test("We don't clobber connection exception with setsockopt error: ");
-    tv = (struct timeval){.tv_sec = 0, .tv_usec = 500000};
-    opt.command_timeout = opt.connect_timeout = &tv;
-    REDIS_OPTIONS_SET_TCP(&opt, "localhost", 10337);
-    c = redisConnectWithOptions(&opt);
-    test_cond(c->err == REDIS_ERR_IO &&
-              strcmp(c->errstr, "Connection refused") == 0);
-    redisFree(c);
-
    test("Returns error when the unix_sock socket path doesn't accept connections: ");
    c = redisConnectUnix((char*)"/tmp/idontexist.sock");
    test_cond(c->err == REDIS_ERR_IO); /* Don't care about the message... */
@ -1276,13 +1198,15 @@ static void test_blocking_connection_timeouts(struct config config) {
    redisContext *c;
    redisReply *reply;
    ssize_t s;
-    const char *sleep_cmd = "DEBUG SLEEP 1\r\n";
-    struct timeval tv = {.tv_sec = 0, .tv_usec = 10000};
+    const char *sleep_cmd = "DEBUG SLEEP 3\r\n";
+    struct timeval tv;

    c = do_connect(config);
    test("Successfully completes a command when the timeout is not exceeded: ");
    reply = redisCommand(c,"SET foo fast");
    freeReplyObject(reply);
+    tv.tv_sec = 0;
+    tv.tv_usec = 10000;
    redisSetTimeout(c, tv);
    reply = redisCommand(c, "GET foo");
    test_cond(reply != NULL && reply->type == REDIS_REPLY_STRING && memcmp(reply->str, "fast", 4) == 0);
@ -1300,6 +1224,8 @@ static void test_blocking_connection_timeouts(struct config config) {
        sdsfree(c->obuf);
        c->obuf = sdsempty();

+        tv.tv_sec = 0;
+        tv.tv_usec = 10000;
        redisSetTimeout(c, tv);
        reply = redisCommand(c, "GET foo");
 #ifndef _WIN32
@ -1312,7 +1238,7 @@ static void test_blocking_connection_timeouts(struct config config) {
        freeReplyObject(reply);

        // wait for the DEBUG SLEEP to complete so that Redis server is unblocked for the following tests
-        millisleep(1100);
+        millisleep(3000);
    } else {
        test_skipped();
    }
@ -1381,7 +1307,7 @@ static void test_blocking_io_errors(struct config config) {
 }

 static void test_invalid_timeout_errors(struct config config) {
-    redisContext *c = NULL;
+    redisContext *c;

    test("Set error when an invalid timeout usec value is used during connect: ");

@ -1393,10 +1319,10 @@ static void test_invalid_timeout_errors(struct config config) {
    } else if(config.type == CONN_UNIX) {
        c = redisConnectUnixWithTimeout(config.unix_sock.path, config.connect_timeout);
    } else {
-        redisTestPanic("Unknown connection type!");
+        assert(NULL);
    }

-    test_cond(c != NULL && c->err == REDIS_ERR_IO && strcmp(c->errstr, "Invalid timeout specified") == 0);
+    test_cond(c->err == REDIS_ERR_IO && strcmp(c->errstr, "Invalid timeout specified") == 0);
    redisFree(c);

    test("Set error when an invalid timeout sec value is used during connect: ");
@ -1409,10 +1335,10 @@ static void test_invalid_timeout_errors(struct config config) {
    } else if(config.type == CONN_UNIX) {
        c = redisConnectUnixWithTimeout(config.unix_sock.path, config.connect_timeout);
    } else {
-        redisTestPanic("Unknown connection type!");
+        assert(NULL);
    }

-    test_cond(c != NULL && c->err == REDIS_ERR_IO && strcmp(c->errstr, "Invalid timeout specified") == 0);
+    test_cond(c->err == REDIS_ERR_IO && strcmp(c->errstr, "Invalid timeout specified") == 0);
    redisFree(c);
 }

@ -1617,9 +1543,6 @@ static void test_throughput(struct config config) {
 // }

 #ifdef HIREDIS_TEST_ASYNC
-
-#pragma GCC diagnostic ignored "-Woverlength-strings"   /* required on gcc 4.8.x due to assert statements */
-
 struct event_base *base;

 typedef struct TestState {
@ -2294,7 +2217,7 @@ static void test_async_polling(struct config config) {
     */
    test("Ping/Pong from onConnected callback (Issue #931): ");
    c = do_aconnect(config, ASTEST_ISSUE_931_PING);
-    /* connect callback issues ping, response callback destroys context */
+    /* connect callback issues ping, reponse callback destroys context */
    while(astest.ac)
        redisPollTick(c, 0.1);
    assert(astest.connected == 0);
@ -2397,7 +2320,6 @@ int main(int argc, char **argv) {
        test_blocking_connection_timeouts(cfg);
        test_blocking_io_errors(cfg);
        test_invalid_timeout_errors(cfg);
-        test_unix_keepalive(cfg);
        if (throughput) test_throughput(cfg);
    } else {
        test_skipped();
--- a/test.sh
+++ b/test.sh
@ -11,7 +11,7 @@ SKIPS_ARG=${SKIPS_ARG:-}
 REDIS_DOCKER=${REDIS_DOCKER:-}

 # We need to enable the DEBUG command for redis-server >= 7.0.0
-REDIS_MAJOR_VERSION="$(${REDIS_SERVER} --version|awk -F'[^0-9]+' '{ print $2 }')"
+REDIS_MAJOR_VERSION="$(redis-server --version|awk -F'[^0-9]+' '{ print $2 }')"
 if [ "$REDIS_MAJOR_VERSION" -gt "6" ]; then
    ENABLE_DEBUG_CMD="enable-debug-command local"
 fi
@ -98,7 +98,7 @@ if [ -n "${REDIS_DOCKER}" ] ; then
        -p ${REDIS_SSL_PORT}:${REDIS_SSL_PORT} \
        -v ${tmpdir}:${tmpdir} \
        ${REDIS_DOCKER} \
-        ${REDIS_SERVER} ${tmpdir}/redis.conf
+        redis-server ${tmpdir}/redis.conf
 else
    ${REDIS_SERVER} ${tmpdir}/redis.conf
 fi
Author	SHA1	Message	Date
michael-grunder	b652ad61e7	Rework searching for openssl	2023-03-06 12:59:09 -08:00
Victor Polevoy	a88c1da738	Attempt to find the correct path for openssl. The installation path for openssl may vary depending on the way used for its installation and the macOS version. This commit attempts to find the correct path for openssl to use.	2023-03-06 12:59:09 -08:00