Makefile: correctly handle version suffixes on macOS

On macOS, the version suffix of a shared library comes before the `.dylib` suffix, which is different from the convention on other systems. Currently, the Makefile only overrides `DYLIB_MINOR_NAME` for macOS, but does not handle the other similar variables, namely `DYLIB_MAJOR_NAME`, `SSL_DYLIB_MINOR_NAME`, and `SSL_DYLIB_MAJOR_NAME`. This commit fixes the issue by overriding all these variables for macOS. Signed-off-by: Ruoyu Zhong <zhongruoyu@outlook.com>
Do not explicitly initialize openSSL in newer versions
2025-02-10 14:10:17 -08:00 · 2025-02-05 08:39:58 -08:00 · 2024-11-04 09:20:07 -08:00 · 2024-08-27 18:45:18 -07:00 · 2024-08-21 08:56:21 -07:00 · 2024-08-13 08:03:06 -07:00
38 changed files with 1686 additions and 308 deletions
--- a/.github/release-drafter-config.yml
+++ b/.github/release-drafter-config.yml
@ -34,7 +34,7 @@ categories:
      - 'BUG'
  - title: '🧰 Maintenance'
    label: 'maintenance'
-change-template: '- $TITLE (#$NUMBER)'
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
 exclude-labels:
  - 'skip-changelog'
 template: |
--- a/.github/spellcheck-settings.yml
+++ b/.github/spellcheck-settings.yml
@ -0,0 +1,29 @@
+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
@ -0,0 +1,99 @@
+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
@ -6,11 +6,7 @@ jobs:
    name: Ubuntu
    runs-on: ubuntu-latest
    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          repository: ${{ env.GITHUB_REPOSITORY }}
-          ref: ${{ env.GITHUB_HEAD_REF }}
+      - uses: actions/checkout@v3

      - name: Install dependencies
        run: |
@ -24,7 +20,7 @@ jobs:
          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-ubuntu && cd build-ubuntu && cmake ..
+        run: mkdir build && cd build && cmake .. && make

      - name: Build using makefile
        run: USE_SSL=1 TEST_ASYNC=1 make
@ -41,59 +37,16 @@ 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:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          repository: ${{ env.GITHUB_REPOSITORY }}
-          ref: ${{ env.GITHUB_HEAD_REF }}
-
-      - 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-centos7 && cd build-centos7 && cmake3 ..
-
-      - 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
    container: rockylinux:8
    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          repository: ${{ env.GITHUB_REPOSITORY }}
-          ref: ${{ env.GITHUB_HEAD_REF }}
+      - uses: actions/checkout@v3

      - name: Install dependencies
        run: |
+          dnf -y upgrade --refresh
          dnf -y install https://rpms.remirepo.net/enterprise/remi-release-8.rpm
          dnf -y module install redis:remi-6.0
          dnf -y group install "Development Tools"
@ -104,7 +57,7 @@ jobs:
          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-centos8 && cd build-centos8 && cmake ..
+        run: mkdir build && cd build && cmake .. && make

      - name: Build using Makefile
        run: USE_SSL=1 TEST_ASYNC=1 make
@ -123,17 +76,13 @@ jobs:
        run: $GITHUB_WORKSPACE/test.sh

  freebsd:
-    runs-on: macos-12
+    runs-on: ubuntu-latest
    name:  FreeBSD
    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          repository: ${{ env.GITHUB_REPOSITORY }}
-          ref: ${{ env.GITHUB_HEAD_REF }}
+      - uses: actions/checkout@v3

      - name: Build in FreeBSD
-        uses: vmactions/freebsd-vm@v0
+        uses: vmactions/freebsd-vm@v1.0.5
        with:
          prepare: pkg install -y gmake cmake
          run: |
@ -144,16 +93,12 @@ jobs:
    name: macOS
    runs-on: macos-latest
    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          repository: ${{ env.GITHUB_REPOSITORY }}
-          ref: ${{ env.GITHUB_HEAD_REF }}
+      - uses: actions/checkout@v3

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

      - name: Build hiredis
        run: USE_SSL=1 make
@ -167,11 +112,7 @@ jobs:
    name: Windows
    runs-on: windows-latest
    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          repository: ${{ env.GITHUB_REPOSITORY }}
-          ref: ${{ env.GITHUB_HEAD_REF }}
+      - uses: actions/checkout@v3

      - name: Install dependencies
        run: |
@ -188,21 +129,13 @@ jobs:
        run: |
          ./build/hiredis-test.exe

-      - name: Setup cygwin
-        uses: egor-tensin/setup-cygwin@v3
+      - name: Install Cygwin Action
+        uses: cygwin/cygwin-install-action@v2
        with:
-          platform: x64
          packages: make git gcc-core

      - name: Build in cygwin
        env:
          HIREDIS_PATH: ${{ github.workspace }}
        run: |
-          build_hiredis() {
-              git config --global --add safe.directory "$(cygpath -u $HIREDIS_PATH)"
-              cd $(cygpath -u $HIREDIS_PATH)
-              git clean -xfd
-              make
-          }
-          build_hiredis
-        shell: C:\tools\cygwin\bin\bash.exe --login --norc -eo pipefail -o igncr '{0}'
+          make clean && make
--- a/.github/workflows/spellcheck.yml
+++ b/.github/workflows/spellcheck.yml
@ -0,0 +1,14 @@
+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
@ -2,25 +2,23 @@ name: C/C++ CI

 on:
  push:
-    branches: [ master, dev ]
+    branches: [ master ]
  pull_request:
    branches: [ master ]

 jobs:
  full-build:
    name: Build all, plus default examples, run tests against redis
-
    runs-on: ubuntu-latest
    env:
      # the docker image used by the test.sh
      REDIS_DOCKER: redis:alpine

    steps:
-
-    - name: install prerequisites
+    - name: Install prerequisites
      run: sudo apt-get update && sudo apt-get install -y libev-dev libevent-dev libglib2.0-dev libssl-dev valgrind
-    - uses: actions/checkout@v2
-    - name: run make
+    - uses: actions/checkout@v3
+    - name: Run make
      run: make all examples
    - name: Run unittests
      run: make check
@ -34,10 +32,10 @@ jobs:
    name: Build and test minimal 32 bit linux
    runs-on: ubuntu-latest
    steps:
-    - name: install prerequisites
+    - name: Install prerequisites
      run: sudo apt-get update && sudo apt-get install gcc-multilib
-    - uses: actions/checkout@v2
-    - name: run make
+    - uses: actions/checkout@v3
+    - name: Run make
      run: make all
      env:
        PLATFORM_FLAGS: -m32
@ -60,14 +58,14 @@ jobs:
            emulator: qemu-aarch64

    steps:
-    - name: install qemu
+    - name: Install qemu
      if: matrix.emulator
-      run: sudo apt-get install  -y qemu-user 
-    - name: install ploatform toolset
+      run: sudo apt-get update && sudo apt-get install -y qemu-user
+    - name: Install platform toolset
      if: matrix.toolset
      run: sudo apt-get install -y gcc-${{matrix.toolset}}
-    - uses: actions/checkout@v2
-    - name: run make
+    - uses: actions/checkout@v3
+    - name: Run make
      run: make all
      env:
        CC: ${{matrix.toolset}}-gcc
@ -83,20 +81,20 @@ jobs:
    runs-on: windows-latest
    steps:
      - uses: microsoft/setup-msbuild@v1.0.2
-      - uses: actions/checkout@v2
-      - name: Cmake
-        run: cmake -Wno-dev CmakeLists.txt
-      - name: build redis
+      - 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: build redis_static
-        run: MSBuild hiredis_static.vcxproj /p:Configuration=Debug
-      - name: build redis-test
+      - name: Run CMake (static lib)
+        run: cmake -Wno-dev CMakeLists.txt -DBUILD_SHARED_LIBS=OFF
+      - name: Build hiredis (static lib)
+        run: MSBuild hiredis.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
      # install official redis containers on the windows runner
-      - name: install Memurai redis server
+      - name: Install Memurai redis server
        run: choco install -y memurai-developer.install
-      - name: run tests
+      - name: Run tests
        run: Debug\hiredis-test.exe
-      
-      
--- a/.gitignore
+++ b/.gitignore
@ -7,3 +7,4 @@
 /*.pc
 *.dSYM
 tags
+compile_commands.json
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,3 +1,219 @@
+## [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`.
+
+## 🐛 Bug Fixes
+
+- Add support for nan in RESP3 double [@filipecosta90](https://github.com/filipecosta90)
+  ([\#1133](https://github.com/redis/hiredis/pull/1133))
+
+## 🧰 Maintenance
+
+- 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)
+  ([\#1135](https://github.com/redis/hiredis/pull/1135))
+- CI updates ([@bjosv](https://github.com/redis/bjosv) ([\#1139](https://github.com/redis/hiredis/pull/1139))
+
+
+## Contributors
+We'd like to thank all the contributors who worked on this release!
+
+<a href="https://github.com/bjsov"><img src="https://github.com/bjosv.png" width="32" height="32"></a>
+<a href="https://github.com/filipecosta90"><img src="https://github.com/filipecosta90.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/pata00"><img src="https://github.com/pata00.png" width="32" height="32"></a>
+
+## [1.1.0-rc1](https://github.com/redis/hiredis/tree/v1.1.0-rc1) - (2022-11-06)
+
+Announcing Hiredis v1.1.0-rc1, with better SSL convenience, new async adapters, and a great many bug fixes.
+
+## 🚀 New Features
+
+- Add possibility to prefer IPv6, IPv4 or unspecified [@zuiderkwast](https://github.com/zuiderkwast)
+  ([\#1096](https://github.com/redis/hiredis/pull/1096))
+- Add adapters/libhv [@ithewei](https://github.com/ithewei) ([\#904](https://github.com/redis/hiredis/pull/904))
+- Add timeout support to libhv adapter. [@michael-grunder](https://github.com/michael-grunder) ([\#1109](https://github.com/redis/hiredis/pull/1109))
+- set default SSL verification path [@adobeturchenko](https://github.com/adobeturchenko) ([\#928](https://github.com/redis/hiredis/pull/928))
+- Introduce .close method for redisContextFuncs [@pizhenwei](https://github.com/pizhenwei) ([\#1094](https://github.com/redis/hiredis/pull/1094))
+- Make it possible to set SSL verify mode [@stanhu](https://github.com/stanhu) ([\#1085](https://github.com/redis/hiredis/pull/1085))
+- Polling adapter and example [@kristjanvalur](https://github.com/kristjanvalur) ([\#932](https://github.com/redis/hiredis/pull/932))
+- Unsubscribe handling in async [@bjosv](https://github.com/bjosv) ([\#1047](https://github.com/redis/hiredis/pull/1047))
+- Add timeout support for libuv adapter [@MichaelSuen-thePointer](https://github.com/@MichaelSuenthePointer) ([\#1016](https://github.com/redis/hiredis/pull/1016))
+
+## 🐛 Bug Fixes
+
+- Update for MinGW cross compile [@bit0fun](https://github.com/bit0fun) ([\#1127](https://github.com/redis/hiredis/pull/1127))
+- fixed CPP build error with adapters/libhv.h [@mtdxc](https://github.com/mtdxc) ([\#1125](https://github.com/redis/hiredis/pull/1125))
+- Fix protocol error
+  [@michael-grunder](https://github.com/michael-grunder),
+  [@mtuleika-appcast](https://github.com/mtuleika-appcast) ([\#1106](https://github.com/redis/hiredis/pull/1106))
+- Use a windows specific keepalive function. [@michael-grunder](https://github.com/michael-grunder) ([\#1104](https://github.com/redis/hiredis/pull/1104))
+- Fix CMake config path on Linux. [@xkszltl](https://github.com/xkszltl) ([\#989](https://github.com/redis/hiredis/pull/989))
+- Fix potential fault at createDoubleObject [@afcidk](https://github.com/afcidk) ([\#964](https://github.com/redis/hiredis/pull/964))
+- Fix some undefined behavior [@jengab](https://github.com/jengab) ([\#1091](https://github.com/redis/hiredis/pull/1091))
+- Copy OOM errors to redisAsyncContext when finding subscribe callback [@bjosv](https://github.com/bjosv) ([\#1090](https://github.com/redis/hiredis/pull/1090))
+- Maintain backward compatibility with our onConnect callback. [@michael-grunder](https://github.com/michael-grunder) ([\#1087](https://github.com/redis/hiredis/pull/1087))
+- Fix PUSH handler tests for Redis >= 7.0.5 [@michael-grunder](https://github.com/michael-grunder) ([\#1121](https://github.com/redis/hiredis/pull/1121))
+- fix heap-buffer-overflow [@zhangtaoXT5](https://github.com/zhangtaoXT5) ([\#957](https://github.com/redis/hiredis/pull/957))
+- Fix heap-buffer-overflow issue in redisvFormatCommad [@bjosv](https://github.com/bjosv) ([\#1097](https://github.com/redis/hiredis/pull/1097))
+- Polling adapter requires sockcompat.h [@michael-grunder](https://github.com/michael-grunder) ([\#1095](https://github.com/redis/hiredis/pull/1095))
+- Illumos test fixes, error message difference for bad hostname test. [@devnexen](https://github.com/devnexen) ([\#901](https://github.com/redis/hiredis/pull/901))
+- Remove semicolon after do-while in \_EL\_CLEANUP [@sundb](https://github.com/sundb) ([\#905](https://github.com/redis/hiredis/pull/905))
+- Stability: Support calling redisAsyncCommand and redisAsyncDisconnect from the onConnected callback [@kristjanvalur](https://github.com/kristjanvalur)
+  ([\#931](https://github.com/redis/hiredis/pull/931))
+- Fix async connect on Windows [@kristjanvalur](https://github.com/kristjanvalur) ([\#1073](https://github.com/redis/hiredis/pull/1073))
+- Fix tests so they work for Redis 7.0 [@michael-grunder](https://github.com/michael-grunder) ([\#1072](https://github.com/redis/hiredis/pull/1072))
+- Fix warnings on Win64 [@orgads](https://github.com/orgads) ([\#1058](https://github.com/redis/hiredis/pull/1058))
+- Handle push notifications before or after reply. [@yossigo](https://github.com/yossigo) ([\#1062](https://github.com/redis/hiredis/pull/1062))
+- Update hiredis sds with improvements found in redis [@bjosv](https://github.com/bjosv) ([\#1045](https://github.com/redis/hiredis/pull/1045))
+- Avoid incorrect call to the previous reply's callback [@bjosv](https://github.com/bjosv) ([\#1040](https://github.com/redis/hiredis/pull/1040))
+- fix building on AIX and SunOS [\#1031](https://github.com/redis/hiredis/pull/1031) ([@scddev](https://github.com/scddev))
+- Allow sending commands after sending an unsubscribe [@bjosv](https://github.com/bjosv) ([\#1036](https://github.com/redis/hiredis/pull/1036))
+- Correction for command timeout during pubsub [@bjosv](https://github.com/bjosv) ([\#1038](https://github.com/redis/hiredis/pull/1038))
+- Fix adapters/libevent.h compilation for 64-bit Windows [@pbtummillo](https://github.com/pbtummillo) ([\#937](https://github.com/redis/hiredis/pull/937))
+- Fix integer overflow when format command larger than 4GB [@sundb](https://github.com/sundb) ([\#1030](https://github.com/redis/hiredis/pull/1030))
+- Handle array response during subscribe in RESP3 [@bjosv](https://github.com/bjosv) ([\#1014](https://github.com/redis/hiredis/pull/1014))
+- Support PING while subscribing (RESP2) [@bjosv](https://github.com/bjosv) ([\#1027](https://github.com/redis/hiredis/pull/1027))
+
+## 🧰 Maintenance
+
+- CI fixes in preparation of release [@michael-grunder](https://github.com/michael-grunder) ([\#1130](https://github.com/redis/hiredis/pull/1130))
+- Add do while(0) (protection for macros [@afcidk](https://github.com/afcidk) [\#959](https://github.com/redis/hiredis/pull/959))
+- Fixup of PR734: Coverage of hiredis.c [@bjosv](https://github.com/bjosv) ([\#1124](https://github.com/redis/hiredis/pull/1124))
+- CMake corrections for building on Windows [@bjosv](https://github.com/bjosv) ([\#1122](https://github.com/redis/hiredis/pull/1122))
+- Install on windows fixes [@bjosv](https://github.com/bjosv) ([\#1117](https://github.com/redis/hiredis/pull/1117))
+- Add libhv example to our standard Makefile [@michael-grunder](https://github.com/michael-grunder) ([\#1108](https://github.com/redis/hiredis/pull/1108))
+- Additional include directory given by pkg-config [@bjosv](https://github.com/bjosv) ([\#1118](https://github.com/redis/hiredis/pull/1118))
+- Use __attribute__ when building with Clang on Windows [@bjosv](https://github.com/bjosv) ([\#1115](https://github.com/redis/hiredis/pull/1115))
+- Minor refactor [@michael-grunder](https://github.com/michael-grunder) ([\#1110](https://github.com/redis/hiredis/pull/1110))
+- Fix pkgconfig result for hiredis_ssl [@bjosv](https://github.com/bjosv) ([\#1107](https://github.com/redis/hiredis/pull/1107))
+- Update documentation to explain redisConnectWithOptions. [@michael-grunder](https://github.com/michael-grunder) ([\#1099](https://github.com/redis/hiredis/pull/1099))
+- uvadapter: reduce number of uv_poll_start calls [@noxiouz](https://github.com/noxiouz) ([\#1098](https://github.com/redis/hiredis/pull/1098))
+- Regression test for off-by-one parsing error [@bugwz](https://github.com/bugwz) ([\#1092](https://github.com/redis/hiredis/pull/1092))
+- CMake: remove dict.c form hiredis_sources [@Lipraxde](https://github.com/Lipraxde) ([\#1055](https://github.com/redis/hiredis/pull/1055))
+- Do store command timeout in the context for redisSetTimeout [@catterer](https://github.com/catterer) ([\#593](https://github.com/redis/hiredis/pull/593), [\#1093](https://github.com/redis/hiredis/pull/1093))
+- Add GitHub Actions CI workflow for hiredis: Arm, Arm64, 386, windows. [@kristjanvalur](https://github.com/kristjanvalur) ([\#943](https://github.com/redis/hiredis/pull/943))
+- CI: bump macOS runner version [@SukkaW](https://github.com/SukkaW) ([\#1079](https://github.com/redis/hiredis/pull/1079))
+- Support for generating release notes [@chayim](https://github.com/chayim) ([\#1083](https://github.com/redis/hiredis/pull/1083))
+- Improve example for SSL initialization in README.md [@stanhu](https://github.com/stanhu) ([\#1084](https://github.com/redis/hiredis/pull/1084))
+- Fix README typos [@bjosv](https://github.com/bjosv) ([\#1080](https://github.com/redis/hiredis/pull/1080))
+- fix cmake version [@smmir-cent](https://github.com/@smmircent) ([\#1050](https://github.com/redis/hiredis/pull/1050))
+- Use the same name for static and shared libraries [@orgads](https://github.com/orgads) ([\#1057](https://github.com/redis/hiredis/pull/1057))
+- Embed debug information in windows static .lib file [@kristjanvalur](https://github.com/kristjanvalur) ([\#1054](https://github.com/redis/hiredis/pull/1054))
+- Improved async documentation [@kristjanvalur](https://github.com/kristjanvalur) ([\#1074](https://github.com/redis/hiredis/pull/1074))
+- Use official repository for redis package. [@yossigo](https://github.com/yossigo) ([\#1061](https://github.com/redis/hiredis/pull/1061))
+- Whitelist hiredis repo path in cygwin [@michael-grunder](https://github.com/michael-grunder) ([\#1063](https://github.com/redis/hiredis/pull/1063))
+- CentOS 8 is EOL, switch to RockyLinux [@michael-grunder](https://github.com/michael-grunder) ([\#1046](https://github.com/redis/hiredis/pull/1046))
+- CMakeLists.txt: allow building without a C++ compiler [@ffontaine](https://github.com/ffontaine) ([\#872](https://github.com/redis/hiredis/pull/872))
+- Makefile: move SSL options into a block and refine rules [@pizhenwei](https://github.com/pizhenwei) ([\#997](https://github.com/redis/hiredis/pull/997))
+- Update CMakeLists.txt for more portability [@EricDeng1001](https://github.com/EricDeng1001) ([\#1005](https://github.com/redis/hiredis/pull/1005))
+- FreeBSD build fixes + CI [@michael-grunder](https://github.com/michael-grunder) ([\#1026](https://github.com/redis/hiredis/pull/1026))
+- Add asynchronous test for pubsub using RESP3 [@bjosv](https://github.com/bjosv) ([\#1012](https://github.com/redis/hiredis/pull/1012))
+- Trigger CI failure when Valgrind issues are found [@bjosv](https://github.com/bjosv) ([\#1011](https://github.com/redis/hiredis/pull/1011))
+- Move to using make directly in Cygwin [@michael-grunder](https://github.com/michael-grunder) ([\#1020](https://github.com/redis/hiredis/pull/1020))
+- Add asynchronous API tests [@bjosv](https://github.com/bjosv) ([\#1010](https://github.com/redis/hiredis/pull/1010))
+- Correcting the build target `coverage` for enabled SSL [@bjosv](https://github.com/bjosv) ([\#1009](https://github.com/redis/hiredis/pull/1009))
+- GH Actions: Run SSL tests during CI [@bjosv](https://github.com/bjosv) ([\#1008](https://github.com/redis/hiredis/pull/1008))
+- GH: Actions - Add valgrind and CMake [@michael-grunder](https://github.com/michael-grunder) ([\#1004](https://github.com/redis/hiredis/pull/1004))
+- Add Centos8 tests in GH Actions [@michael-grunder](https://github.com/michael-grunder) ([\#1001](https://github.com/redis/hiredis/pull/1001))
+- We should run actions on PRs [@michael-grunder](https://github.com/michael-grunder) (([\#1000](https://github.com/redis/hiredis/pull/1000))
+- Add Cygwin test in GitHub actions [@michael-grunder](https://github.com/michael-grunder) ([\#999](https://github.com/redis/hiredis/pull/999))
+- Add Windows tests in GitHub actions [@michael-grunder](https://github.com/michael-grunder) ([\#996](https://github.com/redis/hiredis/pull/996))
+- Switch to GitHub actions [@michael-grunder](https://github.com/michael-grunder) ([\#995](https://github.com/redis/hiredis/pull/995))
+- Minor refactor of CVE-2021-32765 fix. [@michael-grunder](https://github.com/michael-grunder) ([\#993](https://github.com/redis/hiredis/pull/993))
+- Remove extra comma from CMake var. [@xkszltl](https://github.com/xkszltl) ([\#988](https://github.com/redis/hiredis/pull/988))
+- Add REDIS\_OPT\_PREFER\_UNSPEC [@michael-grunder](https://github.com/michael-grunder) ([\#1101](https://github.com/redis/hiredis/pull/1101))
+
+## Contributors
+We'd like to thank all the contributors who worked on this release!
+
+<a href="https://github.com/EricDeng1001"><img src="https://github.com/EricDeng1001.png" width="32" height="32"></a>
+<a href="https://github.com/Lipraxde"><img src="https://github.com/Lipraxde.png" width="32" height="32"></a>
+<a href="https://github.com/MichaelSuen-thePointer"><img src="https://github.com/MichaelSuen-thePointer.png" width="32" height="32"></a>
+<a href="https://github.com/SukkaW"><img src="https://github.com/SukkaW.png" width="32" height="32"></a>
+<a href="https://github.com/adobeturchenko"><img src="https://github.com/adobeturchenko.png" width="32" height="32"></a>
+<a href="https://github.com/afcidk"><img src="https://github.com/afcidk.png" width="32" height="32"></a>
+<a href="https://github.com/bit0fun"><img src="https://github.com/bit0fun.png" width="32" height="32"></a>
+<a href="https://github.com/bjosv"><img src="https://github.com/bjosv.png" width="32" height="32"></a>
+<a href="https://github.com/bugwz"><img src="https://github.com/bugwz.png" width="32" height="32"></a>
+<a href="https://github.com/catterer"><img src="https://github.com/catterer.png" width="32" height="32"></a>
+<a href="https://github.com/chayim"><img src="https://github.com/chayim.png" width="32" height="32"></a>
+<a href="https://github.com/devnexen"><img src="https://github.com/devnexen.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/ithewei"><img src="https://github.com/ithewei.png" width="32" height="32"></a>
+<a href="https://github.com/jengab"><img src="https://github.com/jengab.png" width="32" height="32"></a>
+<a href="https://github.com/kristjanvalur"><img src="https://github.com/kristjanvalur.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/noxiouz"><img src="https://github.com/noxiouz.png" width="32" height="32"></a>
+<a href="https://github.com/mtdxc"><img src="https://github.com/mtdxc.png" width="32" height="32"></a>
+<a href="https://github.com/orgads"><img src="https://github.com/orgads.png" width="32" height="32"></a>
+<a href="https://github.com/pbtummillo"><img src="https://github.com/pbtummillo.png" width="32" height="32"></a>
+<a href="https://github.com/pizhenwei"><img src="https://github.com/pizhenwei.png" width="32" height="32"></a>
+<a href="https://github.com/scddev"><img src="https://github.com/scddev.png" width="32" height="32"></a>
+<a href="https://github.com/smmir-cent"><img src="https://github.com/smmir-cent.png" width="32" height="32"></a>
+<a href="https://github.com/stanhu"><img src="https://github.com/stanhu.png" width="32" height="32"></a>
+<a href="https://github.com/sundb"><img src="https://github.com/sundb.png" width="32" height="32"></a>
+<a href="https://github.com/vturchenko"><img src="https://github.com/vturchenko.png" width="32" height="32"></a>
+<a href="https://github.com/xkszltl"><img src="https://github.com/xkszltl.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/zhangtaoXT5"><img src="https://github.com/zhangtaoXT5.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.0.2](https://github.com/redis/hiredis/tree/v1.0.2) - (2021-10-07)

 Announcing Hiredis v1.0.2, which fixes CVE-2021-32765 but returns the SONAME to the correct value of `1.0.0`.
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,10 +1,5 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 3.0.0)

-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"
@ -22,13 +17,20 @@ 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
@ -41,39 +43,30 @@ SET(hiredis_sources
 SET(hiredis_sources ${hiredis_sources})

 IF(WIN32)
-    ADD_COMPILE_DEFINITIONS(_CRT_SECURE_NO_WARNINGS WIN32_LEAN_AND_MEAN)
+    ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -DWIN32_LEAN_AND_MEAN)
 ENDIF()

-ADD_LIBRARY(hiredis SHARED ${hiredis_sources})
-ADD_LIBRARY(hiredis_static STATIC ${hiredis_sources})
+ADD_LIBRARY(hiredis ${hiredis_sources})
 ADD_LIBRARY(hiredis::hiredis ALIAS hiredis)
-ADD_LIBRARY(hiredis::hiredis_static ALIAS hiredis_static)
-
-IF(NOT MSVC)
-    SET_TARGET_PROPERTIES(hiredis_static
-        PROPERTIES OUTPUT_NAME hiredis)
-ENDIF()
+set(hiredis_export_name hiredis CACHE STRING "Name of the exported target")
+set_target_properties(hiredis PROPERTIES EXPORT_NAME ${hiredis_export_name})

 SET_TARGET_PROPERTIES(hiredis
    PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE
    VERSION "${HIREDIS_SONAME}")
-IF(WIN32)
-SET_TARGET_PROPERTIES(hiredis_static
+IF(MSVC)
+    SET_TARGET_PROPERTIES(hiredis
        PROPERTIES COMPILE_FLAGS /Z7)
 ENDIF()
-IF(WIN32 OR MINGW)
+IF(WIN32)
    TARGET_LINK_LIBRARIES(hiredis PUBLIC ws2_32 crypt32)
-    TARGET_LINK_LIBRARIES(hiredis_static PUBLIC ws2_32 crypt32)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
    TARGET_LINK_LIBRARIES(hiredis PUBLIC m)
-    TARGET_LINK_LIBRARIES(hiredis_static PUBLIC m)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "SunOS")
    TARGET_LINK_LIBRARIES(hiredis PUBLIC socket)
-    TARGET_LINK_LIBRARIES(hiredis_static PUBLIC socket)
 ENDIF()

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

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

@ -103,24 +96,23 @@ set(CPACK_RPM_PACKAGE_AUTOREQPROV ON)

 include(CPack)

-INSTALL(TARGETS hiredis hiredis_static
+INSTALL(TARGETS hiredis
    EXPORT hiredis-targets
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})

-if (MSVC)
+if (MSVC AND BUILD_SHARED_LIBS)
    INSTALL(FILES $<TARGET_PDB_FILE:hiredis>
        DESTINATION ${CMAKE_INSTALL_BINDIR}
        CONFIGURATIONS Debug RelWithDebInfo)
-    INSTALL(FILES $<TARGET_FILE_DIR:hiredis_static>/$<TARGET_FILE_BASE_NAME:hiredis_static>.pdb
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        CONFIGURATIONS Debug RelWithDebInfo)
 endif()

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

 INSTALL(FILES hiredis.h read.h sds.h async.h alloc.h sockcompat.h
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
@ -142,6 +134,8 @@ else()
 endif()
 SET(INCLUDE_INSTALL_DIR include)
 include(CMakePackageConfigHelpers)
+write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/hiredis-config-version.cmake"
+                                 COMPATIBILITY SameMajorVersion)
 configure_package_config_file(hiredis-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config.cmake
                              INSTALL_DESTINATION ${CMAKE_CONF_INSTALL_DIR}
                              PATH_VARS INCLUDE_INSTALL_DIR)
@ -152,6 +146,7 @@ INSTALL(EXPORT hiredis-targets
        DESTINATION ${CMAKE_CONF_INSTALL_DIR})

 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config-version.cmake
        DESTINATION ${CMAKE_CONF_INSTALL_DIR})


@ -164,16 +159,10 @@ IF(ENABLE_SSL)
    FIND_PACKAGE(OpenSSL REQUIRED)
    SET(hiredis_ssl_sources
        ssl.c)
-    ADD_LIBRARY(hiredis_ssl SHARED
-            ${hiredis_ssl_sources})
-    ADD_LIBRARY(hiredis_ssl_static STATIC
-            ${hiredis_ssl_sources})
-    IF(NOT MSVC)
-        SET_TARGET_PROPERTIES(hiredis_ssl_static
-            PROPERTIES OUTPUT_NAME hiredis_ssl)
-    ENDIF()
+    ADD_LIBRARY(hiredis_ssl ${hiredis_ssl_sources})
+    ADD_LIBRARY(hiredis::hiredis_ssl ALIAS hiredis_ssl)

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

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

-    INSTALL(TARGETS hiredis_ssl hiredis_ssl_static
+    INSTALL(TARGETS hiredis_ssl
        EXPORT hiredis_ssl-targets
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})

-    if (MSVC)
+    if (MSVC AND BUILD_SHARED_LIBS)
        INSTALL(FILES $<TARGET_PDB_FILE:hiredis_ssl>
            DESTINATION ${CMAKE_INSTALL_BINDIR}
            CONFIGURATIONS Debug RelWithDebInfo)
-        INSTALL(FILES $<TARGET_FILE_DIR:hiredis_ssl_static>/$<TARGET_FILE_BASE_NAME:hiredis_ssl_static>.pdb
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            CONFIGURATIONS Debug RelWithDebInfo)
    endif()

    INSTALL(FILES hiredis_ssl.h
--- a/52
+++ b/52
@ -39,7 +39,11 @@ 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 -W -Wstrict-prototypes -Wwrite-strings -Wno-missing-field-initializers
+WARNINGS=-Wall -Wextra -Wstrict-prototypes -Wwrite-strings -Wno-missing-field-initializers
+USE_WERROR?=1
+ifeq ($(USE_WERROR),1)
+  WARNINGS+=-Werror
+endif
 DEBUG_FLAGS?= -g -ggdb
 REAL_CFLAGS=$(OPTIMIZATION) -fPIC $(CPPFLAGS) $(CFLAGS) $(WARNINGS) $(DEBUG_FLAGS) $(PLATFORM_FLAGS)
 REAL_LDFLAGS=$(LDFLAGS)
@ -92,18 +96,25 @@ ifeq ($(TEST_ASYNC),1)
 endif

 ifeq ($(USE_SSL),1)
-  ifeq ($(uname_S),Linux)
+  ifndef OPENSSL_PREFIX
+    ifeq ($(uname_S),Darwin)
+      SEARCH_PATH1=/opt/homebrew/opt/openssl
+      SEARCH_PATH2=/usr/local/opt/openssl
+
+      ifneq ($(wildcard $(SEARCH_PATH1)),)
+        OPENSSL_PREFIX=$(SEARCH_PATH1)
+      else ifneq ($(wildcard $(SEARCH_PATH2)),)
+        OPENSSL_PREFIX=$(SEARCH_PATH2)
+      endif
+    endif
+  endif
+
  ifdef OPENSSL_PREFIX
    CFLAGS+=-I$(OPENSSL_PREFIX)/include
-      SSL_LDFLAGS+=-L$(OPENSSL_PREFIX)/lib -lssl -lcrypto
-    else
-      SSL_LDFLAGS=-lssl -lcrypto
-    endif
-  else
-    OPENSSL_PREFIX?=/usr/local/opt/openssl
-    CFLAGS+=-I$(OPENSSL_PREFIX)/include
-    SSL_LDFLAGS+=-L$(OPENSSL_PREFIX)/lib -lssl -lcrypto
+    SSL_LDFLAGS+=-L$(OPENSSL_PREFIX)/lib
  endif
+
+  SSL_LDFLAGS+=-lssl -lcrypto
 endif

 ifeq ($(uname_S),FreeBSD)
@ -130,7 +141,10 @@ 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
@ -180,6 +194,9 @@ hiredis-example-libevent-ssl: examples/example-libevent-ssl.c adapters/libevent.
 hiredis-example-libev: examples/example-libev.c adapters/libev.h $(STLIBNAME)
 	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -lev $(STLIBNAME) $(REAL_LDFLAGS)

+hiredis-example-libhv: examples/example-libhv.c adapters/libhv.h $(STLIBNAME)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -lhv $(STLIBNAME) $(REAL_LDFLAGS)
+
 hiredis-example-glib: examples/example-glib.c adapters/glib.h $(STLIBNAME)
 	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(shell pkg-config --cflags --libs glib-2.0) $(STLIBNAME) $(REAL_LDFLAGS)

@ -272,20 +289,22 @@ $(PKGCONFNAME): hiredis.h
 	@echo prefix=$(PREFIX) > $@
 	@echo exec_prefix=\$${prefix} >> $@
 	@echo libdir=$(PREFIX)/$(LIBRARY_PATH) >> $@
-	@echo includedir=$(PREFIX)/$(INCLUDE_PATH) >> $@
+	@echo includedir=$(PREFIX)/include >> $@
+	@echo pkgincludedir=$(PREFIX)/$(INCLUDE_PATH) >> $@
 	@echo >> $@
 	@echo Name: hiredis >> $@
 	@echo Description: Minimalistic C client library for Redis. >> $@
 	@echo Version: $(HIREDIS_MAJOR).$(HIREDIS_MINOR).$(HIREDIS_PATCH) >> $@
 	@echo Libs: -L\$${libdir} -lhiredis >> $@
-	@echo Cflags: -I\$${includedir} -D_FILE_OFFSET_BITS=64 >> $@
+	@echo Cflags: -I\$${pkgincludedir} -I\$${includedir} -D_FILE_OFFSET_BITS=64 >> $@

 $(SSL_PKGCONFNAME): hiredis_ssl.h
 	@echo "Generating $@ for pkgconfig..."
 	@echo prefix=$(PREFIX) > $@
 	@echo exec_prefix=\$${prefix} >> $@
 	@echo libdir=$(PREFIX)/$(LIBRARY_PATH) >> $@
-	@echo includedir=$(PREFIX)/$(INCLUDE_PATH) >> $@
+	@echo includedir=$(PREFIX)/include >> $@
+	@echo pkgincludedir=$(PREFIX)/$(INCLUDE_PATH) >> $@
 	@echo >> $@
 	@echo Name: hiredis_ssl >> $@
 	@echo Description: SSL Support for hiredis. >> $@
@ -299,7 +318,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)
+	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIBNAME) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIB_MAJOR_NAME)
 	$(INSTALL) $(STLIBNAME) $(INSTALL_LIBRARY_PATH)
 	mkdir -p $(INSTALL_PKGCONF_PATH)
 	$(INSTALL) $(PKGCONFNAME) $(INSTALL_PKGCONF_PATH)
@ -308,7 +327,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)
+	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(SSL_DYLIB_MINOR_NAME) $(SSL_DYLIBNAME) && ln -sf $(SSL_DYLIB_MINOR_NAME) $(SSL_DYLIB_MAJOR_NAME)
 	$(INSTALL) $(SSL_STLIBNAME) $(INSTALL_LIBRARY_PATH)
 	mkdir -p $(INSTALL_PKGCONF_PATH)
 	$(INSTALL) $(SSL_PKGCONFNAME) $(INSTALL_PKGCONF_PATH)
@ -333,7 +352,8 @@ coverage: gcov
 	make check
 	mkdir -p tmp/lcov
 	lcov -d . -c --exclude '/usr*' -o tmp/lcov/hiredis.info
-	genhtml --legend -o tmp/lcov/report tmp/lcov/hiredis.info
+	lcov -q -l tmp/lcov/hiredis.info
+	genhtml --legend -q -o tmp/lcov/report tmp/lcov/hiredis.info

 noopt:
 	$(MAKE) OPTIMIZATION=""
--- a/README.md
+++ b/README.md
@ -23,6 +23,24 @@ 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.
+
+**NOTE**:  Hiredis can now return `nan` in addition to `-inf` and `inf` in a `REDIS_REPLY_DOUBLE`.
+           Applications that deal with `RESP3` doubles should make sure to account for this.
+
 ## Upgrading to `1.0.2`

 <span style="color:red">NOTE:  v1.0.1 erroneously bumped SONAME, which is why it is skipped here.</span>
@ -116,6 +134,8 @@ 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.
@ -126,11 +146,41 @@ There are several flags you may set in the `redisOptions` struct to change defau
 | REDIS\_OPT\_REUSEADDR | Tells hiredis to set the [SO_REUSEADDR](https://man7.org/linux/man-pages/man7/socket.7.html) socket option |
 | REDIS\_OPT\_PREFER\_IPV4<br>REDIS\_OPT\_PREFER_IPV6<br>REDIS\_OPT\_PREFER\_IP\_UNSPEC | Informs hiredis to either prefer IPv4 or IPv6 when invoking [getaddrinfo](https://man7.org/linux/man-pages/man3/gai_strerror.3.html).  `REDIS_OPT_PREFER_IP_UNSPEC` will cause hiredis to specify `AF_UNSPEC` in the getaddrinfo call, which means both IPv4 and IPv6 addresses will be searched simultaneously.<br>Hiredis prefers IPv4 by default. |
 | REDIS\_OPT\_NO\_PUSH\_AUTOFREE | Tells hiredis to not install the default RESP3 PUSH handler (which just intercepts and frees the replies).  This is useful in situations where you want to process these messages in-band. |
-| REDIS\_OPT\_NOAUOTFREEREPLIES | **ASYNC**: tells hiredis not to automatically invoke `freeReplyObject` after executing the reply callback. |
+| REDIS\_OPT\_NOAUTOFREEREPLIES | **ASYNC**: tells hiredis not to automatically invoke `freeReplyObject` after executing the reply callback. |
 | REDIS\_OPT\_NOAUTOFREE | **ASYNC**: Tells hiredis not to automatically free the `redisAsyncContext` on connection/communication failure, but only if the user makes an explicit call to `redisAsyncDisconnect` or `redisAsyncFree` |

 *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
@ -252,7 +302,7 @@ void redisFree(redisContext *c);
 This function immediately closes the socket and then frees the allocations done in
 creating the context.

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

 Together with `redisCommand`, the function `redisCommandArgv` can be used to issue commands.
 It has the following prototype:
@ -444,7 +494,6 @@ 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.
@ -609,8 +658,8 @@ unaffected so no additional dependencies are introduced.
 First, you'll need to make sure you include the SSL header file:

 ```c
-#include "hiredis.h"
-#include "hiredis_ssl.h"
+#include <hiredis/hiredis.h>
+#include <hiredis/hiredis_ssl.h>
 ```

 You will also need to link against `libhiredis_ssl`, **in addition** to
--- a/adapters/libhv.h
+++ b/adapters/libhv.h
@ -0,0 +1,123 @@
+#ifndef __HIREDIS_LIBHV_H__
+#define __HIREDIS_LIBHV_H__
+
+#include <hv/hloop.h>
+#include "../hiredis.h"
+#include "../async.h"
+
+typedef struct redisLibhvEvents {
+    hio_t *io;
+    htimer_t *timer;
+} redisLibhvEvents;
+
+static void redisLibhvHandleEvents(hio_t* io) {
+    redisAsyncContext* context = (redisAsyncContext*)hevent_userdata(io);
+    int events = hio_events(io);
+    int revents = hio_revents(io);
+    if (context && (events & HV_READ) && (revents & HV_READ)) {
+        redisAsyncHandleRead(context);
+    }
+    if (context && (events & HV_WRITE) && (revents & HV_WRITE)) {
+        redisAsyncHandleWrite(context);
+    }
+}
+
+static void redisLibhvAddRead(void *privdata) {
+    redisLibhvEvents* events = (redisLibhvEvents*)privdata;
+    hio_add(events->io, redisLibhvHandleEvents, HV_READ);
+}
+
+static void redisLibhvDelRead(void *privdata) {
+    redisLibhvEvents* events = (redisLibhvEvents*)privdata;
+    hio_del(events->io, HV_READ);
+}
+
+static void redisLibhvAddWrite(void *privdata) {
+    redisLibhvEvents* events = (redisLibhvEvents*)privdata;
+    hio_add(events->io, redisLibhvHandleEvents, HV_WRITE);
+}
+
+static void redisLibhvDelWrite(void *privdata) {
+    redisLibhvEvents* events = (redisLibhvEvents*)privdata;
+    hio_del(events->io, HV_WRITE);
+}
+
+static void redisLibhvCleanup(void *privdata) {
+    redisLibhvEvents* events = (redisLibhvEvents*)privdata;
+
+    if (events->timer)
+        htimer_del(events->timer);
+
+    hio_close(events->io);
+    hevent_set_userdata(events->io, NULL);
+
+    hi_free(events);
+}
+
+static void redisLibhvTimeout(htimer_t* timer) {
+    hio_t* io = (hio_t*)hevent_userdata(timer);
+    redisAsyncHandleTimeout((redisAsyncContext*)hevent_userdata(io));
+}
+
+static void redisLibhvSetTimeout(void *privdata, struct timeval tv) {
+    redisLibhvEvents* events;
+    uint32_t millis;
+    hloop_t* loop;
+
+    events = (redisLibhvEvents*)privdata;
+    millis = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+
+    if (millis == 0) {
+        /* Libhv disallows zero'd timers so treat this as a delete or NO OP */
+        if (events->timer) {
+            htimer_del(events->timer);
+            events->timer = NULL;
+        }
+    } else if (events->timer == NULL) {
+        /* Add new timer */
+        loop = hevent_loop(events->io);
+        events->timer = htimer_add(loop, redisLibhvTimeout, millis, 1);
+        hevent_set_userdata(events->timer, events->io);
+    } else {
+        /* Update existing timer */
+        htimer_reset(events->timer, millis);
+    }
+}
+
+static int redisLibhvAttach(redisAsyncContext* ac, hloop_t* loop) {
+    redisContext *c = &(ac->c);
+    redisLibhvEvents *events;
+    hio_t* io = NULL;
+
+    if (ac->ev.data != NULL) {
+        return REDIS_ERR;
+    }
+
+    /* Create container struct to keep track of our io and any timer */
+    events = (redisLibhvEvents*)hi_malloc(sizeof(*events));
+    if (events == NULL) {
+        return REDIS_ERR;
+    }
+
+    io = hio_get(loop, c->fd);
+    if (io == NULL) {
+        hi_free(events);
+        return REDIS_ERR;
+    }
+
+    hevent_set_userdata(io, ac);
+
+    events->io = io;
+    events->timer = NULL;
+
+    ac->ev.addRead  = redisLibhvAddRead;
+    ac->ev.delRead  = redisLibhvDelRead;
+    ac->ev.addWrite = redisLibhvAddWrite;
+    ac->ev.delWrite = redisLibhvDelWrite;
+    ac->ev.cleanup  = redisLibhvCleanup;
+    ac->ev.scheduleTimer = redisLibhvSetTimeout;
+    ac->ev.data = events;
+
+    return REDIS_OK;
+}
+#endif
--- a/adapters/libsdevent.h
+++ b/adapters/libsdevent.h
@ -0,0 +1,177 @@
+#ifndef HIREDIS_LIBSDEVENT_H
+#define HIREDIS_LIBSDEVENT_H
+#include <systemd/sd-event.h>
+#include "../hiredis.h"
+#include "../async.h"
+
+#define REDIS_LIBSDEVENT_DELETED 0x01
+#define REDIS_LIBSDEVENT_ENTERED 0x02
+
+typedef struct redisLibsdeventEvents {
+    redisAsyncContext *context;
+    struct sd_event *event;
+    struct sd_event_source *fdSource;
+    struct sd_event_source *timerSource;
+    int fd;
+    short flags;
+    short state;
+} redisLibsdeventEvents;
+
+static void redisLibsdeventDestroy(redisLibsdeventEvents *e) {
+    if (e->fdSource) {
+        e->fdSource = sd_event_source_disable_unref(e->fdSource);
+    }
+    if (e->timerSource) {
+        e->timerSource = sd_event_source_disable_unref(e->timerSource);
+    }
+    sd_event_unref(e->event);
+    hi_free(e);
+}
+
+static int redisLibsdeventTimeoutHandler(sd_event_source *s, uint64_t usec, void *userdata) {
+    ((void)s);
+    ((void)usec);
+    redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;
+    redisAsyncHandleTimeout(e->context);
+    return 0;
+}
+
+static int redisLibsdeventHandler(sd_event_source *s, int fd, uint32_t event, void *userdata) {
+    ((void)s);
+    ((void)fd);
+    redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;
+    e->state |= REDIS_LIBSDEVENT_ENTERED;
+
+#define CHECK_DELETED() if (e->state & REDIS_LIBSDEVENT_DELETED) {\
+        redisLibsdeventDestroy(e);\
+        return 0; \
+    }
+
+    if ((event & EPOLLIN) && e->context && (e->state & REDIS_LIBSDEVENT_DELETED) == 0) {
+        redisAsyncHandleRead(e->context);
+        CHECK_DELETED();
+    }
+
+    if ((event & EPOLLOUT) && e->context && (e->state & REDIS_LIBSDEVENT_DELETED) == 0) {
+        redisAsyncHandleWrite(e->context);
+        CHECK_DELETED();
+    }
+
+    e->state &= ~REDIS_LIBSDEVENT_ENTERED;
+#undef CHECK_DELETED
+
+    return 0;
+}
+
+static void redisLibsdeventAddRead(void *userdata) {
+    redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;
+
+    if (e->flags & EPOLLIN) {
+        return;
+    }
+
+    e->flags |= EPOLLIN;
+
+    if (e->flags & EPOLLOUT) {
+        sd_event_source_set_io_events(e->fdSource, e->flags);
+    } else {
+        sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redisLibsdeventHandler, e);
+    }
+}
+
+static void redisLibsdeventDelRead(void *userdata) {
+    redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;
+
+    e->flags &= ~EPOLLIN;
+
+    if (e->flags) {
+        sd_event_source_set_io_events(e->fdSource, e->flags);
+    } else {
+        e->fdSource = sd_event_source_disable_unref(e->fdSource);
+    }
+}
+
+static void redisLibsdeventAddWrite(void *userdata) {
+    redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;
+
+    if (e->flags & EPOLLOUT) {
+        return;
+    }
+
+    e->flags |= EPOLLOUT;
+
+    if (e->flags & EPOLLIN) {
+        sd_event_source_set_io_events(e->fdSource, e->flags);
+    } else {
+        sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redisLibsdeventHandler, e);
+    }
+}
+
+static void redisLibsdeventDelWrite(void *userdata) {
+    redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;
+
+    e->flags &= ~EPOLLOUT;
+
+    if (e->flags) {
+        sd_event_source_set_io_events(e->fdSource, e->flags);
+    } else {
+        e->fdSource = sd_event_source_disable_unref(e->fdSource);
+    }
+}
+
+static void redisLibsdeventCleanup(void *userdata) {
+    redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata;
+
+    if (!e) {
+        return;
+    }
+
+    if (e->state & REDIS_LIBSDEVENT_ENTERED) {
+        e->state |= REDIS_LIBSDEVENT_DELETED;
+    } else {
+        redisLibsdeventDestroy(e);
+    }
+}
+
+static void redisLibsdeventSetTimeout(void *userdata, struct timeval tv) {
+    redisLibsdeventEvents *e = (redisLibsdeventEvents *)userdata;
+
+    uint64_t usec = tv.tv_sec * 1000000 + tv.tv_usec;
+    if (!e->timerSource) {
+        sd_event_add_time_relative(e->event, &e->timerSource, CLOCK_MONOTONIC, usec, 1, redisLibsdeventTimeoutHandler, e);
+    } else {
+        sd_event_source_set_time_relative(e->timerSource, usec);
+    }
+}
+
+static int redisLibsdeventAttach(redisAsyncContext *ac, struct sd_event *event) {
+    redisContext *c = &(ac->c);
+    redisLibsdeventEvents *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 = (redisLibsdeventEvents*)hi_calloc(1, sizeof(*e));
+    if (e == NULL)
+        return REDIS_ERR;
+
+    /* Initialize and increase event refcount */
+    e->context = ac;
+    e->event = event;
+    e->fd = c->fd;
+    sd_event_ref(event);
+
+    /* Register functions to start/stop listening for events */
+    ac->ev.addRead = redisLibsdeventAddRead;
+    ac->ev.delRead = redisLibsdeventDelRead;
+    ac->ev.addWrite = redisLibsdeventAddWrite;
+    ac->ev.delWrite = redisLibsdeventDelWrite;
+    ac->ev.cleanup = redisLibsdeventCleanup;
+    ac->ev.scheduleTimer = redisLibsdeventSetTimeout;
+    ac->ev.data = e;
+
+    return REDIS_OK;
+}
+#endif
--- a/adapters/libuv.h
+++ b/adapters/libuv.h
@ -159,6 +159,7 @@ 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,7 +1,35 @@
-//
-//  Created by Дмитрий Бахвалов on 13.07.15.
-//  Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.
-//
+/*
+ * 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.
+ */

 #ifndef __HIREDIS_MACOSX_H__
 #define __HIREDIS_MACOSX_H__
--- a/adapters/redismoduleapi.h
+++ b/adapters/redismoduleapi.h
@ -0,0 +1,144 @@
+#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
@ -413,7 +413,11 @@ static void __redisAsyncFree(redisAsyncContext *ac) {
 * free'ing. To do so, a flag is set on the context which is picked up by
 * redisProcessCallbacks(). Otherwise, the context is immediately free'd. */
 void redisAsyncFree(redisAsyncContext *ac) {
+    if (ac == NULL)
+        return;
+
    redisContext *c = &(ac->c);
+
    c->flags |= REDIS_FREEING;
    if (!(c->flags & REDIS_IN_CALLBACK))
        __redisAsyncFree(ac);
@ -474,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/topics/pubsub#format-of-pushed-messages */
+     * https://redis.io/docs/latest/develop/interact/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
@ -25,12 +25,24 @@ if (LIBEVENT)
    TARGET_LINK_LIBRARIES(example-libevent hiredis event)
 ENDIF()

+FIND_PATH(LIBHV hv/hv.h)
+IF (LIBHV)
+    ADD_EXECUTABLE(example-libhv example-libhv.c)
+    TARGET_LINK_LIBRARIES(example-libhv hiredis hv)
+ENDIF()
+
 FIND_PATH(LIBUV uv.h)
 IF (LIBUV)
    ADD_EXECUTABLE(example-libuv example-libuv.c)
    TARGET_LINK_LIBRARIES(example-libuv hiredis 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)
+ENDIF()
+
 IF (APPLE)
    FIND_LIBRARY(CF CoreFoundation)
    ADD_EXECUTABLE(example-macosx example-macosx.c)
--- a/examples/example-libhv.c
+++ b/examples/example-libhv.c
@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#include <hiredis.h>
+#include <async.h>
+#include <adapters/libhv.h>
+
+void getCallback(redisAsyncContext *c, void *r, void *privdata) {
+    redisReply *reply = r;
+    if (reply == NULL) return;
+    printf("argv[%s]: %s\n", (char*)privdata, reply->str);
+
+    /* Disconnect after receiving the reply to GET */
+    redisAsyncDisconnect(c);
+}
+
+void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
+    (void)privdata;
+    redisReply *reply = r;
+
+    if (reply == NULL) {
+        printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        return;
+    }
+
+    redisAsyncDisconnect(c);
+}
+
+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");
+}
+
+int main (int argc, char **argv) {
+#ifndef _WIN32
+    signal(SIGPIPE, SIG_IGN);
+#endif
+
+    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+    if (c->err) {
+        /* Let *c leak for now... */
+        printf("Error: %s\n", c->errstr);
+        return 1;
+    }
+
+    hloop_t* loop = hloop_new(HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS);
+    redisLibhvAttach(c, loop);
+    redisAsyncSetTimeout(c, (struct timeval){.tv_sec = 0, .tv_usec = 500000});
+    redisAsyncSetConnectCallback(c,connectCallback);
+    redisAsyncSetDisconnectCallback(c,disconnectCallback);
+    redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+    redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+    redisAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %d", 1);
+    hloop_run(loop);
+    hloop_free(&loop);
+    return 0;
+}
--- a/examples/example-libsdevent.c
+++ b/examples/example-libsdevent.c
@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#include <hiredis.h>
+#include <async.h>
+#include <adapters/libsdevent.h>
+
+void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
+    (void)privdata;
+    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) {
+        printf("`GET key` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        return;
+    }
+    printf("`GET key` result: 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("connect error: %s\n", c->errstr);
+        return;
+    }
+    printf("Connected...\n");
+}
+
+void disconnectCallback(const redisAsyncContext *c, int status) {
+    if (status != REDIS_OK) {
+        printf("disconnect because of error: %s\n", c->errstr);
+        return;
+    }
+    printf("Disconnected...\n");
+}
+
+int main (int argc, char **argv) {
+    signal(SIGPIPE, SIG_IGN);
+
+    struct sd_event *event;
+    sd_event_default(&event);
+
+    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+    if (c->err) {
+        printf("Error: %s\n", c->errstr);
+        redisAsyncFree(c);
+        return 1;
+    }
+
+    redisLibsdeventAttach(c,event);
+    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 libsdevent 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", argv[argc-1], strlen(argv[argc-1]));
+    redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+
+    /* sd-event does not quit when there are no handlers registered. Manually exit after 1.5 seconds */
+    sd_event_source *s;
+    sd_event_add_time_relative(event, &s, CLOCK_MONOTONIC, 1500000, 1, NULL, NULL);
+
+    sd_event_loop(event);
+    sd_event_source_disable_unref(s);
+    sd_event_unref(event);
+    return 0;
+}
--- a/examples/example-macosx.c
+++ b/examples/example-macosx.c
@ -1,7 +1,35 @@
-//
-//  Created by Дмитрий Бахвалов on 13.07.15.
-//  Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.
-//
+/*
+ * 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.
+ */

 #include <stdio.h>

--- a/examples/example-redismoduleapi.c
+++ b/examples/example-redismoduleapi.c
@ -0,0 +1,101 @@
+#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/examples/example.c
+++ b/examples/example.c
@ -7,6 +7,54 @@
 #include <winsock2.h> /* For struct timeval */
 #endif

+static void example_argv_command(redisContext *c, size_t n) {
+    char **argv, tmp[42];
+    size_t *argvlen;
+    redisReply *reply;
+
+    /* We're allocating two additional elements for command and key */
+    argv = malloc(sizeof(*argv) * (2 + n));
+    argvlen = malloc(sizeof(*argvlen) * (2 + n));
+
+    /* First the command */
+    argv[0] = (char*)"RPUSH";
+    argvlen[0] = sizeof("RPUSH") - 1;
+
+    /* Now our key */
+    argv[1] = (char*)"argvlist";
+    argvlen[1] = sizeof("argvlist") - 1;
+
+    /* Now add the entries we wish to add to the list */
+    for (size_t i = 2; i < (n + 2); i++) {
+        argvlen[i] = snprintf(tmp, sizeof(tmp), "argv-element-%zu", i - 2);
+        argv[i] = strdup(tmp);
+    }
+
+    /* Execute the command using redisCommandArgv.  We're sending the arguments with
+     * two explicit arrays.  One for each argument's string, and the other for its
+     * length. */
+    reply = redisCommandArgv(c, n + 2, (const char **)argv, (const size_t*)argvlen);
+
+    if (reply == NULL || c->err) {
+        fprintf(stderr, "Error:  Couldn't execute redisCommandArgv\n");
+        exit(1);
+    }
+
+    if (reply->type == REDIS_REPLY_INTEGER) {
+        printf("%s reply: %lld\n", argv[0], reply->integer);
+    }
+
+    freeReplyObject(reply);
+
+    /* Clean up */
+    for (size_t i = 2; i < (n + 2); i++) {
+        free(argv[i]);
+    }
+
+    free(argv);
+    free(argvlen);
+}
+
 int main(int argc, char **argv) {
    unsigned int j, isunix = 0;
    redisContext *c;
@ -87,6 +135,9 @@ int main(int argc, char **argv) {
    }
    freeReplyObject(reply);

+    /* See function for an example of redisCommandArgv */
+    example_argv_command(c, 10);
+
    /* Disconnects and frees the context */
    redisFree(c);

--- 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)
+IF (NOT TARGET hiredis::@hiredis_export_name@)
 	INCLUDE(${CMAKE_CURRENT_LIST_DIR}/hiredis-targets.cmake)
 ENDIF()

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

 check_required_components(hiredis)
--- a/hiredis.c
+++ b/hiredis.c
@ -102,6 +102,7 @@ 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) {
@ -160,6 +161,7 @@ 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;
@ -192,6 +194,7 @@ 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;
@ -212,6 +215,7 @@ 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;
@ -249,6 +253,7 @@ 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;
@ -267,6 +272,7 @@ 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;
@ -287,6 +293,7 @@ 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;
@ -392,12 +399,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(*_p)) _p++;
+                    while (*_p != '\0' && isdigit((int) *_p)) _p++;

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

                    /* Copy va_list before consuming with va_arg */
@ -747,7 +754,7 @@ void redisFree(redisContext *c) {
    if (c->privdata && c->free_privdata)
        c->free_privdata(c->privdata);

-    if (c->funcs->free_privctx)
+    if (c->funcs && c->funcs->free_privctx)
        c->funcs->free_privctx(c->privctx);

    memset(c, 0xff, sizeof(*c));
@ -860,7 +867,9 @@ redisContext *redisConnectWithOptions(const redisOptions *options) {
        return NULL;
    }

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

@ -942,11 +951,18 @@ 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) {
-    if (redisKeepAlive(c, REDIS_KEEPALIVE_INTERVAL) != REDIS_OK)
-        return REDIS_ERR;
-    return REDIS_OK;
+    return redisKeepAlive(c, REDIS_KEEPALIVE_INTERVAL);
+}
+
+/* Set the socket option TCP_USER_TIMEOUT. */
+int redisSetTcpUserTimeout(redisContext *c, unsigned int timeout) {
+    return redisContextSetTcpUserTimeout(c, timeout);
 }

 /* 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 0
-#define HIREDIS_PATCH 3
-#define HIREDIS_SONAME 1.0.3-dev
+#define HIREDIS_MINOR 2
+#define HIREDIS_PATCH 0
+#define HIREDIS_SONAME 1.2.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,24 +154,18 @@ struct redisSsl;

 #define REDIS_OPT_NONBLOCK 0x01
 #define REDIS_OPT_REUSEADDR 0x02
-#define REDIS_OPT_PREFER_IPV4 0x04
-#define REDIS_OPT_PREFER_IPV6 0x08
+#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_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
@ -328,6 +322,8 @@ 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.pc.in
+++ b/hiredis.pc.in
@ -9,4 +9,4 @@ Name: hiredis
 Description: Minimalistic C client library for Redis.
 Version: @PROJECT_VERSION@
 Libs: -L${libdir} -lhiredis
-Cflags: -I${pkgincludedir} -D_FILE_OFFSET_BITS=64
+Cflags: -I${pkgincludedir} -I${includedir} -D_FILE_OFFSET_BITS=64
--- a/hiredis_ssl-config.cmake.in
+++ b/hiredis_ssl-config.cmake.in
@ -2,6 +2,9 @@

 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/hiredis_ssl.h
+++ b/hiredis_ssl.h
@ -56,8 +56,9 @@ typedef enum {
    REDIS_SSL_CTX_CERT_KEY_REQUIRED,            /* Client cert and key must both be specified or skipped */
    REDIS_SSL_CTX_CA_CERT_LOAD_FAILED,          /* Failed to load CA Certificate or CA Path */
    REDIS_SSL_CTX_CLIENT_CERT_LOAD_FAILED,      /* Failed to load client certificate */
+    REDIS_SSL_CTX_CLIENT_DEFAULT_CERT_FAILED,   /* Failed to set client default certificate directory */
    REDIS_SSL_CTX_PRIVATE_KEY_LOAD_FAILED,      /* Failed to load private key */
-    REDIS_SSL_CTX_OS_CERTSTORE_OPEN_FAILED,     /* Failed to open system certifcate store */
+    REDIS_SSL_CTX_OS_CERTSTORE_OPEN_FAILED,     /* Failed to open system certificate store */
    REDIS_SSL_CTX_OS_CERT_ADD_FAILED            /* Failed to add CA certificates obtained from system to the SSL context */
 } redisSSLContextError;

--- a/net.c
+++ b/net.c
@ -41,6 +41,7 @@
 #include <stdio.h>
 #include <limits.h>
 #include <stdlib.h>
+#include <time.h>

 #include "net.h"
 #include "sds.h"
@ -172,6 +173,10 @@ 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));
@ -228,6 +233,23 @@ 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)
@ -238,6 +260,7 @@ static int redisContextTimeoutMsec(redisContext *c, long *result)
    /* Only use timeout when not NULL. */
    if (timeout != NULL) {
        if (timeout->tv_usec > 1000000 || timeout->tv_sec > __MAX_MSEC) {
+            __redisSetError(c, REDIS_ERR_IO, "Invalid timeout specified");
            *result = msec;
            return REDIS_ERR;
        }
@ -253,24 +276,46 @@ 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[1];
-
-    wfd[0].fd     = c->fd;
-    wfd[0].events = POLLOUT;
-
-    if (errno == EINPROGRESS) {
+    struct pollfd wfd;
+    long end;
    int res;

-        if ((res = poll(wfd, 1, msec)) == -1) {
+    if (errno != EINPROGRESS) {
+        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
+        redisNetClose(c);
+        return REDIS_ERR;
+    }
+
+    wfd.fd = c->fd;
+    wfd.events = POLLOUT;
+    end = msec >= 0 ? redisPollMillis() + msec : 0;
+
+    while ((res = poll(&wfd, 1, msec)) <= 0) {
+        if (res < 0 && errno != EINTR) {
            __redisSetErrorFromErrno(c, REDIS_ERR_IO, "poll(2)");
            redisNetClose(c);
            return REDIS_ERR;
-        } else if (res == 0) {
+        } else if (res == 0 || (msec >= 0 && redisPollMillis() >= end)) {
            errno = ETIMEDOUT;
            __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) {
@ -281,11 +326,6 @@ static int redisContextWaitReady(redisContext *c, long msec) {
    return REDIS_OK;
 }

-    __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-    redisNetClose(c);
-    return REDIS_ERR;
-}
-
 int redisCheckConnectDone(redisContext *c, int *completed) {
    int rc = connect(c->fd, (const struct sockaddr *)c->saddr, c->addrlen);
    if (rc == 0) {
@ -435,7 +475,6 @@ static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,
    }

    if (redisContextTimeoutMsec(c, &timeout_msec) != REDIS_OK) {
-        __redisSetError(c, REDIS_ERR_IO, "Invalid timeout specified");
        goto error;
    }

@ -629,7 +668,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 == EINPROGRESS && !blocking) {
+        if ((errno == EAGAIN || errno == EINPROGRESS) && !blocking) {
            /* This is ok. */
        } else {
            if (redisContextWaitReady(c,timeout_msec) != REDIS_OK)
--- a/net.h
+++ b/net.h
@ -52,5 +52,6 @@ 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,6 +250,7 @@ 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) {
@ -303,11 +304,14 @@ 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)) {
+                d = NAN; /* nan. */
            } else {
                d = strtod((char*)buf,&eptr);
                /* RESP3 only allows "inf", "-inf", and finite values, while
-                 * strtod() allows other variations on infinity, NaN,
-                 * etc. We explicity handle our two allowed infinite cases
+                 * strtod() allows other variations on infinity,
+                 * etc. We explicity handle our two allowed infinite cases and NaN
                 * above, so strtod() should only result in finite values. */
                if (buf[0] == '\0' || eptr != &buf[len] || !isfinite(d)) {
                    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
@ -531,7 +535,7 @@ static int processAggregateItem(redisReader *r) {

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

            if (r->fn && r->fn->createArray)
                obj = r->fn->createArray(cur,elements);
@ -599,6 +603,9 @@ 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;
@ -639,6 +646,7 @@ 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 *start, *end, *sp, *ep;
+    char *end, *sp, *ep;
    size_t len;

-    sp = start = s;
+    sp = 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(*p))
+            if (isprint((int) *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(*p)) p++;
+        while(*p && isspace((int) *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(*(p+2)) &&
-                                             isxdigit(*(p+3)))
+                                             isxdigit((int) *(p+2)) &&
+                                             isxdigit((int) *(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(*(p+1))) goto err;
+                        if (*(p+1) && !isspace((int) *(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(*(p+1))) goto err;
+                        if (*(p+1) && !isspace((int) *(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
--- a/sds.h
+++ b/sds.h
@ -35,9 +35,11 @@

 #define SDS_MAX_PREALLOC (1024*1024)
 #ifdef _MSC_VER
-#define __attribute__(x)
 typedef long long ssize_t;
 #define SSIZE_MAX (LLONG_MAX >> 1)
+#ifndef __clang__
+#define __attribute__(x)
+#endif
 #endif

 #include <sys/types.h>
--- a/sockcompat.h
+++ b/sockcompat.h
@ -50,7 +50,7 @@
 #include <ws2tcpip.h>
 #include <stddef.h>
 #include <errno.h>
-#include <Mstcpip.h>
+#include <mstcpip.h>

 #ifdef _MSC_VER
 typedef long long ssize_t;
--- a/ssl.c
+++ b/ssl.c
@ -40,6 +40,14 @@
 #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
@ -51,6 +59,8 @@
 #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 {
@ -92,7 +102,7 @@ redisContextFuncs redisContextSSLFuncs;
 * Note that this is only required for OpenSSL < 1.1.0.
 */

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

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

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

@ -185,7 +195,7 @@ const char *redisSSLContextGetError(redisSSLContextError error)
        case REDIS_SSL_CTX_PRIVATE_KEY_LOAD_FAILED:
            return "Failed to load private key";
        case REDIS_SSL_CTX_OS_CERTSTORE_OPEN_FAILED:
-            return "Failed to open system certifcate store";
+            return "Failed to open system certificate store";
        case REDIS_SSL_CTX_OS_CERT_ADD_FAILED:
            return "Failed to add CA certificates obtained from system to the SSL context";
        default:
@ -248,13 +258,25 @@ redisSSLContext *redisCreateSSLContextWithOptions(redisSSLOptions *options, redi
    if (ctx == NULL)
        goto error;

-    ctx->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
+    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);
    if (!ctx->ssl_ctx) {
        if (error) *error = REDIS_SSL_CTX_CREATE_FAILED;
        goto error;
    }

-    SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
+#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_verify(ctx->ssl_ctx, options->verify_mode, NULL);

    if ((cert_filename != NULL && private_key_filename == NULL) ||
@ -293,6 +315,11 @@ redisSSLContext *redisCreateSSLContextWithOptions(redisSSLOptions *options, redi
            if (error) *error = REDIS_SSL_CTX_CA_CERT_LOAD_FAILED;
            goto error;
        }
+    } else {
+        if (!SSL_CTX_set_default_verify_paths(ctx->ssl_ctx)) {
+            if (error) *error = REDIS_SSL_CTX_CLIENT_DEFAULT_CERT_FAILED;
+            goto error;
+        }
    }

    if (cert_filename) {
@ -337,7 +364,6 @@ 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);
@ -345,15 +371,19 @@ 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)) {
+        (rv == SSL_ERROR_WANT_READ || rv == SSL_ERROR_WANT_WRITE))
+    {
+        c->funcs = &redisContextSSLFuncs;
        c->privctx = rssl;
        return REDIS_OK;
    }
--- a/test.c
+++ b/test.c
@ -35,11 +35,11 @@ enum connection_type {

 struct config {
    enum connection_type type;
+    struct timeval connect_timeout;

    struct {
        const char *host;
        int port;
-        struct timeval timeout;
    } tcp;

    struct {
@ -78,7 +78,7 @@ static int tests = 0, fails = 0, skips = 0;

 static void millisleep(int ms)
 {
-#if _MSC_VER
+#ifdef _MSC_VER
    Sleep(ms);
 #else
    usleep(ms*1000);
@ -104,6 +104,13 @@ 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) {
@ -149,7 +156,7 @@ static redisContext *select_database(redisContext *c) {
    assert(reply != NULL);
    freeReplyObject(reply);

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

    if (c == NULL) {
@ -409,10 +416,37 @@ 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);

-    disconnect(c, 0);
+#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);
 }

 static void test_reply_reader(void) {
@ -674,12 +708,23 @@ static void test_reply_reader(void) {
    freeReplyObject(reply);
    redisReaderFree(reader);

-    test("Set error when RESP3 double is NaN: ");
+    test("Correctly parses RESP3 double NaN: ");
    reader = redisReaderCreate();
    redisReaderFeed(reader, ",nan\r\n",6);
    ret = redisReaderGetReply(reader,&reply);
-    test_cond(ret == REDIS_ERR &&
-              strcasecmp(reader->errstr,"Bad double value") == 0);
+    test_cond(ret == REDIS_OK &&
+              ((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&
+              isnan(((redisReply*)reply)->dval));
+    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);

@ -750,6 +795,26 @@ 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);
@ -782,6 +847,20 @@ static void test_reply_reader(void) {
        !strcmp(((redisReply*)reply)->str,"3492890328409238509324850943850943825024385"));
    freeReplyObject(reply);
    redisReaderFree(reader);
+
+    test("Can parse RESP3 doubles in an array: ");
+    reader = redisReaderCreate();
+    redisReaderFeed(reader, "*1\r\n,3.14159265358979323846\r\n",31);
+    ret = redisReaderGetReply(reader,&reply);
+    test_cond(ret == REDIS_OK &&
+        ((redisReply*)reply)->type == REDIS_REPLY_ARRAY &&
+        ((redisReply*)reply)->elements == 1 &&
+        ((redisReply*)reply)->element[0]->type == REDIS_REPLY_DOUBLE &&
+        fabs(((redisReply*)reply)->element[0]->dval - 3.14159265358979323846) < 0.00000001 &&
+        ((redisReply*)reply)->element[0]->len == 22 &&
+        strcmp(((redisReply*)reply)->element[0]->str, "3.14159265358979323846") == 0);
+    freeReplyObject(reply);
+    redisReaderFree(reader);
 }

 static void test_free_null(void) {
@ -856,9 +935,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) {
@ -885,12 +964,26 @@ 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... */
@ -954,7 +1047,7 @@ static void test_resp3_push_handler(redisContext *c) {
    reply = redisCommand(c, "SET key:0 val:0");
    /* We need another command because depending on the version of Redis, the
     * notification may be delivered after the command's reply. */
-    test_cond(reply != NULL);
+    assert(reply != NULL);
    freeReplyObject(reply);
    reply = redisCommand(c, "PING");
    test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && pc.str == 1);
@ -962,6 +1055,9 @@ static void test_resp3_push_handler(redisContext *c) {

    test("We properly handle a NIL invalidation payload: ");
    reply = redisCommand(c, "FLUSHDB");
+    assert(reply != NULL);
+    freeReplyObject(reply);
+    reply = redisCommand(c, "PING");
    test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && pc.nil == 1);
    freeReplyObject(reply);

@ -1138,6 +1234,13 @@ static void test_blocking_connection(struct config config) {
              strcasecmp(reply->element[1]->str,"pong") == 0);
    freeReplyObject(reply);

+    test("Send command by passing argc/argv: ");
+    const char *argv[3] = {"SET", "foo", "bar"};
+    size_t argvlen[3] = {3, 3, 3};
+    reply = redisCommandArgv(c,3,argv,argvlen);
+    test_cond(reply->type == REDIS_REPLY_STATUS);
+    freeReplyObject(reply);
+
    /* Make sure passing NULL to redisGetReply is safe */
    test("Can pass NULL to redisGetReply: ");
    assert(redisAppendCommand(c, "PING") == REDIS_OK);
@ -1173,15 +1276,13 @@ static void test_blocking_connection_timeouts(struct config config) {
    redisContext *c;
    redisReply *reply;
    ssize_t s;
-    const char *sleep_cmd = "DEBUG SLEEP 3\r\n";
-    struct timeval tv;
+    const char *sleep_cmd = "DEBUG SLEEP 1\r\n";
+    struct timeval tv = {.tv_sec = 0, .tv_usec = 10000};

    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);
@ -1199,8 +1300,6 @@ 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
@ -1213,7 +1312,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(3000);
+        millisleep(1100);
    } else {
        test_skipped();
    }
@ -1282,26 +1381,38 @@ static void test_blocking_io_errors(struct config config) {
 }

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

-    test("Set error when an invalid timeout usec value is given to redisConnectWithTimeout: ");
+    test("Set error when an invalid timeout usec value is used during connect: ");

-    config.tcp.timeout.tv_sec = 0;
-    config.tcp.timeout.tv_usec = 10000001;
+    config.connect_timeout.tv_sec = 0;
+    config.connect_timeout.tv_usec = 10000001;

-    c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.tcp.timeout);
+    if (config.type == CONN_TCP || config.type == CONN_SSL) {
+        c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.connect_timeout);
+    } else if(config.type == CONN_UNIX) {
+        c = redisConnectUnixWithTimeout(config.unix_sock.path, config.connect_timeout);
+    } else {
+        redisTestPanic("Unknown connection type!");
+    }

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

-    test("Set error when an invalid timeout sec value is given to redisConnectWithTimeout: ");
+    test("Set error when an invalid timeout sec value is used during connect: ");

-    config.tcp.timeout.tv_sec = (((LONG_MAX) - 999) / 1000) + 1;
-    config.tcp.timeout.tv_usec = 0;
+    config.connect_timeout.tv_sec = (((LONG_MAX) - 999) / 1000) + 1;
+    config.connect_timeout.tv_usec = 0;

-    c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.tcp.timeout);
+    if (config.type == CONN_TCP || config.type == CONN_SSL) {
+        c = redisConnectWithTimeout(config.tcp.host, config.tcp.port, config.connect_timeout);
+    } else if(config.type == CONN_UNIX) {
+        c = redisConnectUnixWithTimeout(config.unix_sock.path, config.connect_timeout);
+    } else {
+        redisTestPanic("Unknown connection type!");
+    }

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

@ -1506,6 +1617,9 @@ 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 {
@ -1811,6 +1925,7 @@ void subscribe_channel_a_cb(redisAsyncContext *ac, void *r, void *privdata) {
 void subscribe_channel_b_cb(redisAsyncContext *ac, void *r, void *privdata) {
    redisReply *reply = r;
    TestState *state = privdata;
+    (void)ac;

    assert(reply != NULL && reply->type == REDIS_REPLY_ARRAY &&
           reply->elements == 3);
@ -1999,7 +2114,7 @@ static void connectCallback(redisAsyncContext *c, int status) {
    }
    else if (t->testno == ASTEST_ISSUE_931_PING)
    {
-        status = redisAsyncCommand(c, commandCallback, NULL, "PING");
+        redisAsyncCommand(c, commandCallback, NULL, "PING");
    }
 }
 static void disconnectCallback(const redisAsyncContext *c, int status) {
@ -2051,11 +2166,11 @@ static redisAsyncContext *do_aconnect(struct config config, astest_no testno)

    if (config.type == CONN_TCP) {
        options.type = REDIS_CONN_TCP;
-        options.connect_timeout = &config.tcp.timeout;
+        options.connect_timeout = &config.connect_timeout;
        REDIS_OPTIONS_SET_TCP(&options, config.tcp.host, config.tcp.port);
    } else if (config.type == CONN_SSL) {
        options.type = REDIS_CONN_TCP;
-        options.connect_timeout = &config.tcp.timeout;
+        options.connect_timeout = &config.connect_timeout;
        REDIS_OPTIONS_SET_TCP(&options, config.ssl.host, config.ssl.port);
    } else if (config.type == CONN_UNIX) {
        options.type = REDIS_CONN_UNIX;
@ -2117,7 +2232,7 @@ static void test_async_polling(struct config config) {
        /* timeout can only be simulated with network */
        test("Async connect timeout: ");
        config.tcp.host = "192.168.254.254";  /* blackhole ip */
-        config.tcp.timeout.tv_usec = 100000;
+        config.connect_timeout.tv_usec = 100000;
        c = do_aconnect(config, ASTEST_CONN_TIMEOUT);
        assert(c);
        assert(c->err == 0);
@ -2149,7 +2264,7 @@ static void test_async_polling(struct config config) {
     */
    if (config.type == CONN_TCP || config.type == CONN_SSL) {
        test("Async PING/PONG after connect timeout: ");
-        config.tcp.timeout.tv_usec = 10000; /* 10ms  */
+        config.connect_timeout.tv_usec = 10000; /* 10ms  */
        c = do_aconnect(config, ASTEST_PINGPONG_TIMEOUT);
        while(astest.connected == 0)
            redisPollTick(c, 0.1);
@ -2179,7 +2294,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, reponse callback destroys context */
+    /* connect callback issues ping, response callback destroys context */
    while(astest.ac)
        redisPollTick(c, 0.1);
    assert(astest.connected == 0);
@ -2281,6 +2396,8 @@ int main(int argc, char **argv) {
        test_blocking_connection(cfg);
        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
Ruoyu Zhong	77bcc73ebb	Makefile: correctly handle version suffixes on macOS On macOS, the version suffix of a shared library comes before the `.dylib` suffix, which is different from the convention on other systems. Currently, the Makefile only overrides `DYLIB_MINOR_NAME` for macOS, but does not handle the other similar variables, namely `DYLIB_MAJOR_NAME`, `SSL_DYLIB_MINOR_NAME`, and `SSL_DYLIB_MAJOR_NAME`. This commit fixes the issue by overriding all these variables for macOS. Signed-off-by: Ruoyu Zhong <zhongruoyu@outlook.com>	2025-02-10 14:10:17 -08:00
Cristian Rodríguez	ab8c75ebcb	Do not explicitly initialize openSSL in newer versions	2025-02-05 08:39:58 -08:00
David W. Dougherty	8d8703ee61	Update old link for modules-api-ref.md	2024-11-04 09:20:07 -08:00
Orion Poplawski	e0f48202aa	Make test.sh use REDIS_SERVER everywhere	2024-08-27 18:45:18 -07:00
michael-grunder	329346bb64	Test for both EAGAIN and EINPROGRESS for AF_UNIX sockets. Reading the manpage it seems like we only need to test for `EAGAIN` but testing for both seems more prudent since this may be subtly different on more esoteric kernels (SunOS, AIX, BSD, etc). Fixes #1260	2024-08-21 08:56:21 -07:00
michael-grunder	0c63e3f396	Fix timing based macOS CI failure. Signed-off-by: michael-grunder <michael.grunder@gmail.com>	2024-08-13 08:03:06 -07:00
michael-grunder	45b7820dc3	CentOS 7 is EOL CentOS 7 reached EOL of even maintinance updates on 2024-06-30.	2024-08-06 14:14:19 -07:00
michael-grunder	643dddafab	Clarify macos adapter and example license. Fixes #1271	2024-08-06 14:11:56 -07:00
michael-grunder	19cfd60d92	Only override context read/write funcs on SSL_connect success. Fixes #1233	2024-04-03 07:57:33 -07:00
michael-grunder	2a7b8fac96	Remove dead assignment in sdstrim. The assignment is harmless but causes noise in static analysers	2024-04-02 14:19:35 -07:00
guoguangwu	7ab6b824c7	fix: typos Signed-off-by: guoguangwu <guoguangwug@gmail.com>	2024-03-15 20:56:25 -07:00
Uilian Ries	398e16e7cc	[cmake] Fix cmake options position to support cmake toolchain (#1250 ) Move CMake `OPTION` values below where we declare the `PROJECT` so they are scoped within it. Signed-off-by: Uilian Ries <uilianries@gmail.com>	2024-02-14 10:24:17 -08:00
git-hulk	ab30060a6e	Fix review comments	2024-01-31 12:08:52 -08:00
git-hulk	5b253d89c7	Add support of RESP3 attribute type Currently, Redis DEBUG PROTOCOL 'attrib' command will return an attribute type, but hiredis doesn't support it yet. So it got the protocol type error: ``` 127.0.0.1:6379> DEBUG PROTOCOL attrib Error: Protocol error, got "\|" as reply type byte ``` After apply this PR, it should reply: ``` 127.0.0.1:6379> DEBUG PROTOCOL attrib 1# "key-popularity" 1# 1) "key:123" 2) (integer) 90 ```	2024-01-31 12:08:52 -08:00
Mark Agranat	2706c3e16d	Fix memory leak. When redisLibuvAttach receives error from call to uv_poll_init_socket there is a memory leaked ptr of type redisLibuvEvents.	2024-01-30 10:42:32 -08:00
Yann E. MORIN	ff7a064490	CMakeList: add option to not install NuGet packaging The NuGet hiredis.target packaging description file is of no use on systems that are not using NuGet, like Linux systems, and the spurious presence of that file is not "clean". Add a cmake option to allow users to disable installation of that file. As some people may have relied on that file to be installed, continue to install it by default. Signed-off-by: Yann E. MORIN <yann.morin.1998@free.fr>	2024-01-21 13:31:26 -08:00
michael-grunder	94d931d96a	Fix macOS and FreeBSD CI runners. * Update macOS to brew install redis@7.2 * Switch freeBSD runner to v1 and switch from running it on a macos runner to ubuntu.	2024-01-21 12:28:15 -08:00
Michael Grunder	869f3d0ef1	Make redisEnableKeepAlive a no-op on AF_UNIX connections. (#1215 ) Fixes #1185	2023-08-18 21:07:25 -07:00
Chayim	039385bd8b	Integrating spellcheck into CI (#1218 ) * Adding spellcheck testing * words * updating version of spellcheck action	2023-08-18 21:06:47 -07:00
michael-grunder	e07ae7d3b6	Add a panic helper for non-assert aborts. We merged a fix for a "maybe uninitialized" warning in #1209, but after merging there could actually have then been a double free. The reason is that when compiling with NDEBUG our assert macro becomes a no-op, meaning that execution would no longer stop after `assert(NULL)`. This commit just adds a simple panic macro which will execute regardless of whether NDEBUG is defined or not.	2023-07-25 11:16:07 -07:00
michael-grunder	bfe45d9f80	Document poll(2) logic changes. See #1206, #1213	2023-07-25 11:15:04 -07:00
michael-grunder	af95517612	Retry poll(2) if we are intterupted. This commit adds logic to retry our poll call when waiting for the connection to complete, in the event that we are interrupted by a signal. Additionally we do some simple bookkeeping to keep track of the overall timeout specified by the user. Fixes #1206	2023-07-25 10:24:06 -07:00
V G	dedc6208b1	Fix a false positive warning of gcc 12+ -Werror=maybe-uninitialized	2023-07-14 08:37:31 -07:00
Romain Geissler	bff171c9fc	Allow disabling the -Werror flag.	2023-07-13 11:27:05 -07:00
michael-grunder	d7a84df9ea	Bump development SONAME.	2023-07-13 09:17:53 -07:00
Chayim	60e5075d4a	Version 1.2.0 (#1202 ) Co-authored-by: Michael Grunder <michael.grunder@gmail.com>	2023-07-12 10:31:17 +03:00
Valentino Geron	adef139a75	Remove support in deprecated TLS versions 1.0 and 1.1 (#1205 )	2023-07-12 09:20:56 +03:00
Yossi Gottlieb	d543baba67	Install major version symlink of shared objects. This change addresses the issue discussed in #1202 and should make it possible in the future to update minor versions without requiring re-linking binaries.	2023-07-10 08:44:57 -07:00
windyakin	052f99ab2d	Ensure functionality without _MSC_VER definition	2023-06-08 12:18:12 -07:00
Michael Grunder	ded32c7d1a	Add a test for the TCP_USER_TIMEOUT option. (#1192 ) * Add a test for the TCP_USER_TIMEOUT option. * Explicitly set errno to ENOTSUP on unsupported OS's	2023-06-01 09:09:11 -07:00
Yossi Gottlieb	5cbd1f2960	Add -Werror as a default. (#1193 )	2023-06-01 19:03:24 +03:00
Yossi Gottlieb	af14456383	CI: Update homebrew Redis version. (#1191 ) Fixes cross-compilation QEMU CI tests * CI: Update homebrew Redis version. * CI: Try apt-get update as a workaround.	2023-05-30 14:09:03 -07:00
Yossi Gottlieb	6de326e872	Fix a typo in `b6a052f`.	2023-05-30 14:05:28 -07:00
Viktor Söderqvist	b6a052fe09	Helper for setting TCP_USER_TIMEOUT socket option (#1188 ) * Implement redisSetTcpUserTimeout to set socket option TCP_USER_TIMEOUT * Documentation for redisSetTcpUserTimeout and some more undocumented functions Documentation for redisReconnect() and the setters of socket options: * redisKeepAlive() * redisEnableKeepAliveWithInterval() * redisSetTcpUserTimeout()	2023-05-29 13:25:34 -07:00
Ozan Tezcan	3fa9b69443	Add RedisModule adapter (#1182 ) * Add RedisModule adapter * add timer callback, add compatibility helper	2023-04-24 15:00:47 -07:00
Jacky Hu	d13c091e9f	Fix wincrypt symbols conflict	2023-04-18 20:03:41 -07:00
michael-grunder	5d84c8cfdb	Add a test ensuring we don't clobber connection error. Adds a test that we don't attempt to set any socket timeout if the connection itself failed. This issue only seemed to occur on macOS but it's nice to have a test for it.	2023-04-15 17:20:11 -07:00
michael-grunder	3f95fcdae4	Don't attempt to set a timeout if we are in an error state.	2023-04-14 23:02:01 -07:00
michael-grunder	aacb84b8d4	Fix typo in makefile.	2023-04-14 12:42:14 -07:00
Michael Grunder	563b062e37	Accept -nan per the RESP3 spec recommendation. For reference: https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md	2023-04-14 12:41:58 -07:00
Viktor Söderqvist	04c1b5b029	Fix colliding option values	2023-03-13 12:08:58 -07:00
michael-grunder	4ca8e73f66	Rework searching for openssl	2023-03-09 15:53:55 -08:00
Victor Polevoy	cd208812f9	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-09 15:53:55 -08:00
michael-grunder	011f7093c0	Allow specifying the keepalive interval Fixes #1155	2023-03-07 17:06:35 -08:00
autoantwort	e9243d4f70	Cmake static or shared (#1160 ) * cmake: build either static or shared libs * cmake: allow to build non-PIC static libs * fix typo * cmake: add ALIAS targets * cmake: link to OpenSSL imported targets CMake imported targets are more robust * turn ENABLE_EXAMPLES to a CMake option * fix typo * install pdb files if shared * fix hiredis_ssl-config file * Fix more targets * CMake knows when to enable CMAKE_POSITION_INDEPENDENT_CODE * Restore setting of /Z7 * [ci] fix building of shared and static libs * Apply suggestions from code review Co-authored-by: Bjorn Svensson <bjorn.a.svensson@est.tech> * Make it possible to change name of exported target --------- Co-authored-by: SpaceIm <30052553+SpaceIm@users.noreply.github.com> Co-authored-by: Bjorn Svensson <bjorn.a.svensson@est.tech>	2023-03-07 17:05:25 -08:00
Dominik Charousset	1cbd5bc762	Write a version file for the CMake package (#1165 ) * Write a version file for the CMake package > If no VERSION is given, the PROJECT_VERSION variable is used. Since we set the project version to `${VERSION}`, we can safely skip passing it to `write_basic_package_version_file` as well.	2023-02-24 11:42:18 -08:00
Till Krüss	6f5bae8c69	fix typo	2023-01-06 12:29:45 -08:00
Fabrice Fontaine	acd09461d3	CMakeLists.txt: respect BUILD_SHARED_LIBS To allow building hiredis on toolchain without dynamic library support, respect standard cmake BUILD_SHARED_LIBS: https://cmake.org/cmake/help/latest/variable/BUILD_SHARED_LIBS.html Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>	2022-12-27 11:24:55 -08:00
Michael de Lang	97fcf0fd1a	Add sdevent adapter	2022-12-21 15:55:54 -08:00
michael-grunder	ccff093bcd	Bump dev version for the next release cycle.	2022-11-15 21:18:54 -08:00
michael-grunder	c14775b4e4	Prepare for v1.1.0 GA	2022-11-14 20:34:30 -08:00
filipe oliveira	f0bdf8405b	Add support for nan in RESP3 double (#1133 )	2022-11-14 08:55:52 -08:00
Michael Grunder	991b0b0b31	Add an example that calls redisCommandArgv (#1140 ) See #1138	2022-11-12 20:18:45 -08:00
Bjorn Svensson	a36686f84f	CI updates (#1139 ) * Build CMake generated makefiles * Simplify and update checkout * Update CI workflow 'C/C++ CI' * Some corrections of spelling and naming. * Remove running on branch dev since not officially available.	2022-11-10 11:20:43 -08:00
dachui	8ad4985e9d	fix flag reference	2022-11-09 21:17:59 -08:00
michael-grunder	7583ebb1b2	Make freeing a NULL redisAsyncContext a no op. This makes our behavior consistent with redisFree and freeReplyObject.	2022-11-09 18:35:59 -08:00
michael-grunder	2c53dea7f9	Update version in dev branch.	2022-11-09 18:13:54 -08:00
michael-grunder	f063370edf	Prepare for v1.1.0-rc1 - Update changelog. - Bump version/soname defines.	2022-11-06 17:39:21 -08:00
michael-grunder	2b069573a5	CI fixes in preparation of release - Upgrade to actions/checkout@v3 as node 12 is being phased out. - Perform a manual dnf refresh on RockyLinux during setup. - Switch to official cygwin/cygwin-install-action	2022-11-02 14:43:59 -07:00
michael-grunder	e1e9eb40db	Add author information to release-drafter template.	2022-11-02 11:25:16 -07:00
bit0fun	afc29ee1a1	Update for mingw cross compile - Used lowercase for Mstcpip.h as mingw will not find the file otherwise	2022-10-26 18:09:00 -07:00
cqm	ceb8a8815e	fixed cpp build error with adapters/libhv.h	2022-10-24 11:04:47 -07:00
Bjorn Svensson	3b15a04b59	Fixup of PR734: Coverage of hiredis.c (#1124 ) Improve coverage (#734) * Remove duplicate tests - double covered by: "Can parse RESP3 doubles" - bool covered via: "Can parse RESP3 bool" * Make (connect) timeout in test config general * Set error string in Unix connect with invalid timeout Restructure testcase since redisConnectWithTimeout() and redisConnectUnixWithTimeout() now behaves similar. * Use quiet flag in lcov/genhtml instead of piping to /dev/null * Fixup of redisCommandArgv test case * Update test case to match what it covers Use new test case info text since the previous one seemed copy&pasted. The sought coverage was the handling of the parent-chaining for a double object, which the test case now focuses on. Co-authored-by: Ariel <ashtul@gmail.com>	2022-10-14 08:11:40 -07:00
Bjorn Svensson	c245df9fb9	CMake corrections for building on Windows (#1122 ) * Replace use of newer CMake builtins than in v3.0.0 Visual Studio generator will replace -D with /D. * Only use /Z7 flag on a Visual Studio compilator Flag is not available on a GNU compilator running on windows, like in a mingw64 setup.	2022-09-29 10:20:49 -07:00
michael-grunder	9c338a5981	Fix PUSH handler tests for Redis >= 7.0.5 Redis updated how invalidation push messages are sent to the client after a FLUSHDB or FLUSHALL command. See: redis/redis#8935	2022-09-27 14:33:26 -07:00
Bjorn Svensson	6d5c3ee74d	Install on windows fixes (#1117 ) * Remove attempt to install .pdb file for windows static lib From `ff57c18b` (#1054) the debug information was embedded in the windows static lib rather than creating a .pdb file. Removing the installation step of this file in CMake when building with buildtype Debug or RelWithDebInfo. * Embed debug information in windows hiredis_ssl_static lib See `ff57c18b` (#1054) for same change in library hiredis_static.	2022-09-27 09:56:42 -07:00
Michael Grunder	68b29e1ad5	Add timeout support to libhv adapter. (#1109 ) Add timeout support to libhv adapter. See: #904	2022-09-21 15:10:37 -07:00
Bjorn Svensson	722e3409c7	Additional include directory given by pkg-config (#1118 ) * Update include example in README * Update pkg-config installed via CMake Gives the include directory to enable the use of: #include <hiredis/hiredis.h> but keeps the existing include dir. for backwards compatibility. Example: > pkg-config hiredis --cflags -D_FILE_OFFSET_BITS=64 -I/usr/local/include/hiredis -I/usr/local/include * Update pkg-config installed via Make Gives the include directory to enable the use of: #include <hiredis/hiredis.h> but keeps the existing include path for backwards compatibility. Example: > pkg-config hiredis --cflags -D_FILE_OFFSET_BITS=64 -I/usr/local/include/hiredis -I/usr/local/include	2022-09-19 10:49:55 -07:00
Björn Svensson	bd9ccb8c47	Use __attribute__ when building with clang on windows Since clang supports __attribute__ we can avoid disabling it and use packed sdshdr structs. This also make sure we dont affect subsequent header files that require __attribute__. Note: Clang attempts to be compatible with MSVC and defines _MSC_VER	2022-09-14 16:56:41 -07:00
Vlad Turchenko	5392adc265	set default SSL certificate directory	2022-09-08 14:02:29 -07:00
michael-grunder	560e664862	Minor refactor Protect against a NULL pointer dereference, and remove unused write to a variable.	2022-09-08 11:18:43 -07:00
michael-grunder	d756f68a59	Add libhv example to our standard Makefile See #904	2022-09-07 15:20:28 -07:00
hewei.it	a66916719b	Add adapters/libhv	2022-09-07 11:14:45 -07:00