Remove performance zapping test code

reenable optimized string dup code
Forkless background save. NOT OPTIMIZED
2019-10-21 01:48:58 -04:00 · 2019-10-21 00:08:38 -04:00 · 2019-10-20 23:54:05 -04:00 · 2019-10-17 23:10:45 -04:00 · 2019-10-17 22:53:50 -04:00 · 2019-10-17 17:20:47 -04:00
233 changed files with 6045 additions and 24097 deletions
@@ -1,20 +0,0 @@
---
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
---
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-** Log Files **
-These should be KeyDB logs, not syslogs or logs from your container manager.  If you are reporting a crash there will be a line in your log stating:
-"=== KEYDB BUG REPORT START: Cut & paste starting from here ==="
-
-Please copy everything after this line.
-
-**To Reproduce**
-Do you know how to reproduce this?  If so please provide repro steps.
@@ -1,20 +0,0 @@
---
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
---
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
@@ -1,33 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  test-ubuntu-latest:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-    - name: make
-      run: |
-          sudo apt-get install uuid-dev libcurl4-openssl-dev
-          make
-    - name: test
-      run: |
-        sudo apt-get install tcl8.5
-        ./runtest --clients 2 --verbose
-
-  build-ubuntu-old:
-    runs-on: ubuntu-16.04
-    steps:
-    - uses: actions/checkout@v1
-    - name: make
-      run: | 
-        sudo apt-get install uuid-dev libcurl4-openssl-dev
-        make
-
-  build-macos-latest:
-    runs-on: macos-latest
-    steps:
-    - uses: actions/checkout@v1
-    - name: make
-      run: make
@@ -1,9 +1,6 @@
 .*.swp
 core
 *.o
-*.xo
-*.so
-*.d
 *.log
 dump.rdb
 redis-benchmark
@@ -30,7 +27,7 @@ release.h
 src/transfer.sh
 src/configs
 redis.ds
-src/keydb.conf
+src/redis.conf
 src/nodes.conf
 deps/lua/src/lua
 deps/lua/src/luac
@@ -39,5 +36,3 @@ deps/lua/src/liblua.a
 .prerequisites
 *.dSYM
 Makefile.dep
-.vscode/*
-.idea/*
@@ -0,0 +1,29 @@
+language: generic
+os: osx
+matrix:
+  include:
+    - os: linux
+      script: make
+      env: COMPILER_NAME=g++-6 CXX=g++-6 CC=gcc-6
+      addons:
+        apt:
+          packages:
+            - g++-6
+            - nasm
+            - uuid-dev
+          sources: &sources
+            - llvm-toolchain-precise-3.8
+            - ubuntu-toolchain-r-test
+    - os: linux
+      script: make MALLOC=libc
+      env: COMPILER_NAME=clang CXX=clang++-3.8 CC=clang-3.8 CXXFLAGS="-I/usr/include/libcxxabi/" LDFLAGS="-lc++"
+      addons:
+        apt:
+          packages:
+            - libc++abi-dev
+            - clang-3.8
+            - libc++-dev
+            - libc++abi-dev
+            - nasm
+            - uuid-dev
+          sources: *sources
@@ -0,0 +1,58 @@
+{
+    "files.associations": {
+        "zmalloc.h": "c",
+        "stat.h": "c",
+        "array": "cpp",
+        "atomic": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "fstream": "cpp",
+        "functional": "cpp",
+        "future": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "scoped_allocator": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "utility": "cpp",
+        "set": "cpp",
+        "algorithm": "cpp"
+    }
+}
@@ -4,7 +4,7 @@ FROM ubuntu:18.04

 RUN apt-get update \
    && DEBIAN_FRONTEND=noninteractive apt-get install -qqy \
-        build-essential nasm autotools-dev autoconf libcurl4-openssl-dev libjemalloc-dev tcl tcl-dev uuid-dev libcurl4-openssl-dev \
+        build-essential nasm autotools-dev autoconf libcurl4-openssl-dev libjemalloc-dev tcl tcl-dev uuid-dev \
    && apt-get clean

 CMD make
@@ -4,20 +4,16 @@

 ##### Need Help? Check out our extensive [documentation](https://docs.keydb.dev).

-##### Have feedback?  Take our quick survey: https://www.surveymonkey.com/r/Y9XNS93
-
 What is KeyDB?
 --------------

 KeyDB is a high performance fork of Redis with a focus on multithreading, memory efficiency, and high throughput.  In addition to multithreading, KeyDB also has features only available in Redis Enterprise such as [Active Replication](https://github.com/JohnSully/KeyDB/wiki/Active-Replication), [FLASH storage](https://github.com/JohnSully/KeyDB/wiki/FLASH-Storage) support, and some not available at all such as direct backup to AWS S3. 

-KeyDB maintains full compatibility with the Redis protocol, modules, and scripts.  This includes the atomicity guarantees for scripts and transactions.  Because KeyDB keeps in sync with Redis development KeyDB is a superset of Redis functionality, making KeyDB a drop in replacement for existing Redis deployments.
+KeyDB maintains full compatibility with the Redis protocol, modules, and scripts.  This includes the atomicity gurantees for scripts and transactions.  Because KeyDB keeps in sync with Redis development KeyDB is a superset of Redis functionality, making KeyDB a drop in replacement for existing Redis deployments.

 On the same hardware KeyDB can perform twice as many queries per second as Redis, with 60% lower latency. Active-Replication simplifies hot-spare failover allowing you to easily distribute writes over replicas and use simple TCP based load balancing/failover. KeyDB's higher performance allows you to do more on less hardware which reduces operation costs and complexity.

-<img src="https://keydb.dev/assets/img/blog/5x_opspersecVSdatasize.PNG"/>
-
-See the full benchmark results and setup information here: https://docs.keydb.dev/blog/2019/10/07/blog-post/
+<img src=https://cdn-images-1.medium.com/max/1400/1*s7mTb7Qb0kxc951mz8bdgA.png width=420 height=300/><img src=https://cdn-images-1.medium.com/max/1400/1*R00A5U4AFGohGOYHMfT6fA.png height=300/>

 Why fork Redis?
 ---------------
@@ -88,11 +84,6 @@ Compiling is as simple as:

    % make

-To build with TLS support, you'll need OpenSSL development libraries (e.g.
-libssl-dev on Debian/Ubuntu) and run:
-
-    % make BUILD_TLS=yes
-
 You can enable flash support with:

    % make MALLOC=memkind
@@ -100,13 +91,6 @@ You can enable flash support with:
 ***Note that the following dependencies may be needed: 
    % sudo apt-get install autoconf autotools-dev libnuma-dev libtool

-If TLS is built, running the tests with TLS enabled (you will need `tcl-tls`
-installed):
-
-    % ./utils/gen-test-certs.sh
-    % ./runtest --tls
-
-
 Fixing build problems with dependencies or cached build options
 ---------

@@ -189,14 +173,6 @@ as options using the command line. Examples:
 All the options in keydb.conf are also supported as options using the command
 line, with exactly the same name.

-
-Running Redis with TLS:
------------------
-
-Please consult the [TLS.md](TLS.md) file for more information on
-how to use Redis with TLS.
-
-
 Playing with KeyDB
 ------------------

@@ -1,89 +0,0 @@
-TLS Support
-===========
-
-Getting Started
---------------
-
-### Building
-
-To build with TLS support you'll need OpenSSL development libraries (e.g.
-libssl-dev on Debian/Ubuntu).
-
-Run `make BUILD_TLS=yes`.
-
-### Tests
-
-To run Redis test suite with TLS, you'll need TLS support for TCL (i.e.
-`tcl-tls` package on Debian/Ubuntu).
-
-1. Run `./utils/gen-test-certs.sh` to generate a root CA and a server
-   certificate.
-
-2. Run `./runtest --tls` or `./runtest-cluster --tls` to run Redis and Redis
-   Cluster tests in TLS mode.
-
-### Running manually
-
-To manually run a Redis server with TLS mode (assuming `gen-test-certs.sh` was
-invoked so sample certificates/keys are available):
-
-    ./src/redis-server --tls-port 6379 --port 0 \
-        --tls-cert-file ./tests/tls/redis.crt \
-        --tls-key-file ./tests/tls/redis.key \
-        --tls-ca-cert-file ./tests/tls/ca.crt
-
-To connect to this Redis server with `redis-cli`:
-
-    ./src/redis-cli --tls \
-        --cert ./tests/tls/redis.crt \
-        --key ./tests/tls/redis.key \
-        --cacert ./tests/tls/ca.crt
-
-This will disable TCP and enable TLS on port 6379. It's also possible to have
-both TCP and TLS available, but you'll need to assign different ports.
-
-To make a Replica connect to the master using TLS, use `--tls-replication yes`,
-and to make Redis Cluster use TLS across nodes use `--tls-cluster yes`.
-
-Connections
-----------
-
-All socket operations now go through a connection abstraction layer that hides
-I/O and read/write event handling from the caller.
-
-**Multi-threading I/O is not currently supported for TLS**, as a TLS connection
-needs to do its own manipulation of AE events which is not thread safe. The
-solution is probably to manage independent AE loops for I/O threads and longer
-term association of connections with threads. This may potentially improve
-overall performance as well.
-
-Sync IO for TLS is currently implemented in a hackish way, i.e. making the
-socket blocking and configuring socket-level timeout.  This means the timeout
-value may not be so accurate, and there would be a lot of syscall overhead.
-However I believe that getting rid of syncio completely in favor of pure async
-work is probably a better move than trying to fix that. For replication it would
-probably not be so hard. For cluster keys migration it might be more difficult,
-but there are probably other good reasons to improve that part anyway.
-
-To-Do List
----------
-
- [ ] Add session caching support. Check if/how it's handled by clients to
-  assess how useful/important it is.
- [ ] redis-benchmark support. The current implementation is a mix of using
-  hiredis for parsing and basic networking (establishing connections), but
-  directly manipulating sockets for most actions. This will need to be cleaned
-  up for proper TLS support. The best approach is probably to migrate to hiredis
-  async mode.
- [ ] redis-cli `--slave` and `--rdb` support.
-
-Multi-port
----------
-
-Consider the implications of allowing TLS to be configured on a separate port,
-making Redis listening on multiple ports:
-
-1. Startup banner port notification
-2. Proctitle
-3. How slaves announce themselves
-4. Cluster bus port calculation
@@ -41,13 +41,9 @@ distclean:

 .PHONY: distclean

-ifeq ($(BUILD_TLS),yes)
-    HIREDIS_MAKE_FLAGS = USE_SSL=1
-endif
-
 hiredis: .make-prerequisites
 	@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
-	cd hiredis && $(MAKE) static $(HIREDIS_MAKE_FLAGS)
+	cd hiredis && $(MAKE) static

 .PHONY: hiredis

@@ -5,4 +5,3 @@
 /*.dylib
 /*.a
 /*.pc
-*.dSYM
@@ -26,72 +26,20 @@ addons:
    - libc6-dev-i386
    - libc6-dbg:i386
    - gcc-multilib
-    - g++-multilib
    - valgrind

 env:
-  - BITS="32"
-  - BITS="64"
-
-script:
-  - EXTRA_CMAKE_OPTS="-DENABLE_EXAMPLES:BOOL=ON -DHIREDIS_SSL:BOOL=ON";
-    if [ "$TRAVIS_OS_NAME" == "osx" ]; then
-      if [ "$BITS" == "32" ]; then
-        CFLAGS="-m32 -Werror";
-        CXXFLAGS="-m32 -Werror";
-        LDFLAGS="-m32";
-        EXTRA_CMAKE_OPTS=;
-      else
-        CFLAGS="-Werror";
-        CXXFLAGS="-Werror";
-      fi;
-    else
-      TEST_PREFIX="valgrind --track-origins=yes --leak-check=full";
-      if [ "$BITS" == "32" ]; then
-        CFLAGS="-m32 -Werror";
-        CXXFLAGS="-m32 -Werror";
-        LDFLAGS="-m32";
-        EXTRA_CMAKE_OPTS=;
-      else
-        CFLAGS="-Werror";
-        CXXFLAGS="-Werror";
-      fi;
-    fi;
-    export CFLAGS CXXFLAGS LDFLAGS TEST_PREFIX EXTRA_CMAKE_OPTS
-  - mkdir build/ && cd build/
-  - cmake .. ${EXTRA_CMAKE_OPTS}
-  - make VERBOSE=1
-  - ctest -V
+    - CFLAGS="-Werror"
+    - PRE="valgrind --track-origins=yes --leak-check=full"
+    - TARGET="32bit" TARGET_VARS="32bit-vars" CFLAGS="-Werror"
+    - TARGET="32bit" TARGET_VARS="32bit-vars" PRE="valgrind --track-origins=yes --leak-check=full"

 matrix:
-  include:
-    # Windows MinGW cross compile on Linux
-    - os: linux
-      dist: xenial
-      compiler: mingw
-      addons:
-        apt:
-          packages:
-            - ninja-build
-            - gcc-mingw-w64-x86-64
-            - g++-mingw-w64-x86-64
-      script:
-        - mkdir build && cd build
-        - CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++ cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_BUILD_WITH_INSTALL_RPATH=on
-        - ninja -v
+  exclude:
+    - os: osx
+      env: PRE="valgrind --track-origins=yes --leak-check=full"

-    # Windows MSVC 2017
-    - os: windows
-      compiler: msvc
-      env:
-        - MATRIX_EVAL="CC=cl.exe && CXX=cl.exe"
-      before_install:
-        - eval "${MATRIX_EVAL}"
-      install:
-        - choco install ninja
-      script:
-        - mkdir build && cd build
-        - cmd.exe /C '"C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliary\Build\vcvarsall.bat" amd64 &&
-          cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release &&
-          ninja -v'
-        - ctest -V
+    - os: osx
+      env: TARGET="32bit" TARGET_VARS="32bit-vars" PRE="valgrind --track-origins=yes --leak-check=full"
+
+script: make $TARGET CFLAGS="$CFLAGS" && make check PRE="$PRE" && make $TARGET_VARS hiredis-example
@@ -12,16 +12,6 @@
  compare to other values, casting might be necessary or can be removed, if
  casting was applied before.

-### 0.x.x (unreleased)
-**BREAKING CHANGES**:
-
-* Change `redisReply.len` to `size_t`, as it denotes the the size of a string
-
-User code should compare this to `size_t` values as well.
-If it was used to compare to other values, casting might be necessary or can be removed, if casting was applied before.
-
-* `redisReplyObjectFunctions.createArray` now takes `size_t` for its length parameter.
-
 ### 0.14.0 (2018-09-25)

 * Make string2ll static to fix conflict with Redis (Tom Lee [c3188b])
@@ -60,9 +50,8 @@ If it was used to compare to other values, casting might be necessary or can be
 * Import latest upstream sds. This breaks applications that are linked against the old hiredis v0.13
 * Fix warnings, when compiled with -Wshadow
 * Make hiredis compile in Cygwin on Windows, now CI-tested
-* Bulk and multi-bulk lengths less than -1 or greater than `LLONG_MAX` are now
-  protocol errors. This is consistent with the RESP specification. On 32-bit
-  platforms, the upper bound is lowered to `SIZE_MAX`.
+
+**BREAKING CHANGES**:

 * Remove backwards compatibility macro's

@@ -1,90 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.4.0)
-INCLUDE(GNUInstallDirs)
-PROJECT(hiredis)
-
-OPTION(ENABLE_SSL "Build hiredis_ssl for SSL support" OFF)
-
-MACRO(getVersionBit name)
-  SET(VERSION_REGEX "^#define ${name} (.+)$")
-  FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/hiredis.h"
-    VERSION_BIT REGEX ${VERSION_REGEX})
-  STRING(REGEX REPLACE ${VERSION_REGEX} "\\1" ${name} "${VERSION_BIT}")
-ENDMACRO(getVersionBit)
-
-getVersionBit(HIREDIS_MAJOR)
-getVersionBit(HIREDIS_MINOR)
-getVersionBit(HIREDIS_PATCH)
-getVersionBit(HIREDIS_SONAME)
-SET(VERSION "${HIREDIS_MAJOR}.${HIREDIS_MINOR}.${HIREDIS_PATCH}")
-MESSAGE("Detected version: ${VERSION}")
-
-PROJECT(hiredis VERSION "${VERSION}")
-
-SET(ENABLE_EXAMPLES OFF CACHE BOOL "Enable building hiredis examples")
-
-ADD_LIBRARY(hiredis SHARED
-    async.c
-    dict.c
-    hiredis.c
-    net.c
-    read.c
-    sds.c
-    sockcompat.c)
-
-SET_TARGET_PROPERTIES(hiredis
-    PROPERTIES
-    VERSION "${HIREDIS_SONAME}")
-IF(WIN32 OR MINGW)
-    TARGET_LINK_LIBRARIES(hiredis PRIVATE ws2_32)
-ENDIF()
-TARGET_INCLUDE_DIRECTORIES(hiredis PUBLIC .)
-
-CONFIGURE_FILE(hiredis.pc.in hiredis.pc @ONLY)
-
-INSTALL(TARGETS hiredis
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-
-INSTALL(FILES hiredis.h read.h sds.h async.h
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
-    
-INSTALL(DIRECTORY adapters
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
-    
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis.pc
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-
-IF(ENABLE_SSL)
-    IF (NOT OPENSSL_ROOT_DIR)
-        IF (APPLE)
-            SET(OPENSSL_ROOT_DIR "/usr/local/opt/openssl")
-        ENDIF()
-    ENDIF()
-    FIND_PACKAGE(OpenSSL REQUIRED)
-    ADD_LIBRARY(hiredis_ssl SHARED
-        ssl.c)
-    TARGET_INCLUDE_DIRECTORIES(hiredis_ssl PRIVATE "${OPENSSL_INCLUDE_DIR}")
-    TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE ${OPENSSL_LIBRARIES})
-    CONFIGURE_FILE(hiredis_ssl.pc.in hiredis_ssl.pc @ONLY)
-
-    INSTALL(TARGETS hiredis_ssl
-        DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-
-    INSTALL(FILES hiredis_ssl.h
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
-    
-    INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl.pc
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-ENDIF()
-
-IF(NOT (WIN32 OR MINGW))
-    ENABLE_TESTING()
-    ADD_EXECUTABLE(hiredis-test test.c)
-    TARGET_LINK_LIBRARIES(hiredis-test hiredis)
-    ADD_TEST(NAME hiredis-test
-        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test.sh)
-ENDIF()
-
-# Add examples
-IF(ENABLE_EXAMPLES)
-  ADD_SUBDIRECTORY(examples)
-ENDIF(ENABLE_EXAMPLES)
@@ -3,17 +3,11 @@
 # Copyright (C) 2010-2011 Pieter Noordhuis <pcnoordhuis at gmail dot com>
 # This file is released under the BSD license, see the COPYING file

-OBJ=net.o hiredis.o sds.o async.o read.o sockcompat.o
-SSL_OBJ=ssl.o
+OBJ=net.o hiredis.o sds.o async.o read.o
 EXAMPLES=hiredis-example hiredis-example-libevent hiredis-example-libev hiredis-example-glib
-ifeq ($(USE_SSL),1)
-EXAMPLES+=hiredis-example-ssl hiredis-example-libevent-ssl
-endif
 TESTS=hiredis-test
 LIBNAME=libhiredis
-SSL_LIBNAME=libhiredis_ssl
 PKGCONFNAME=hiredis.pc
-SSL_PKGCONFNAME=hiredis_ssl.pc

 HIREDIS_MAJOR=$(shell grep HIREDIS_MAJOR hiredis.h | awk '{print $$3}')
 HIREDIS_MINOR=$(shell grep HIREDIS_MINOR hiredis.h | awk '{print $$3}')
@@ -45,7 +39,7 @@ export REDIS_TEST_CONFIG
 CC:=$(shell sh -c 'type $${CC%% *} >/dev/null 2>/dev/null && echo $(CC) || echo gcc')
 CXX:=$(shell sh -c 'type $${CXX%% *} >/dev/null 2>/dev/null && echo $(CXX) || echo g++')
 OPTIMIZATION?=-O3
-WARNINGS=-Wall -W -Wstrict-prototypes -Wwrite-strings -Wno-missing-field-initializers
+WARNINGS=-Wall -W -Wstrict-prototypes -Wwrite-strings
 DEBUG_FLAGS?= -g -ggdb
 REAL_CFLAGS=$(OPTIMIZATION) -fPIC $(CPPFLAGS) $(CFLAGS) $(WARNINGS) $(DEBUG_FLAGS)
 REAL_LDFLAGS=$(LDFLAGS)
@@ -55,30 +49,12 @@ STLIBSUFFIX=a
 DYLIB_MINOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_SONAME)
 DYLIB_MAJOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_MAJOR)
 DYLIBNAME=$(LIBNAME).$(DYLIBSUFFIX)
-SSL_DYLIBNAME=$(SSL_LIBNAME).$(DYLIBSUFFIX)
-DYLIB_MAKE_CMD=$(CC) -shared -Wl,-soname,$(DYLIB_MINOR_NAME)
+DYLIB_MAKE_CMD=$(CC) -shared -Wl,-soname,$(DYLIB_MINOR_NAME) -o $(DYLIBNAME) $(LDFLAGS)
 STLIBNAME=$(LIBNAME).$(STLIBSUFFIX)
-SSL_STLIBNAME=$(SSL_LIBNAME).$(STLIBSUFFIX)
-STLIB_MAKE_CMD=$(AR) rcs
+STLIB_MAKE_CMD=ar rcs $(STLIBNAME)

 # Platform-specific overrides
 uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
-
-USE_SSL?=0
-
-# This is required for test.c only
-ifeq ($(USE_SSL),1)
-  CFLAGS+=-DHIREDIS_TEST_SSL
-endif
-
-ifeq ($(uname_S),Linux)
-  SSL_LDFLAGS=-lssl -lcrypto
-else
-  OPENSSL_PREFIX?=/usr/local/opt/openssl
-  CFLAGS+=-I$(OPENSSL_PREFIX)/include
-  SSL_LDFLAGS+=-L$(OPENSSL_PREFIX)/lib -lssl -lcrypto
-endif
-
 ifeq ($(uname_S),SunOS)
  REAL_LDFLAGS+= -ldl -lnsl -lsocket
  DYLIB_MAKE_CMD=$(CC) -G -o $(DYLIBNAME) -h $(DYLIB_MINOR_NAME) $(LDFLAGS)
@@ -90,61 +66,40 @@ ifeq ($(uname_S),Darwin)
 endif

 all: $(DYLIBNAME) $(STLIBNAME) hiredis-test $(PKGCONFNAME)
-ifeq ($(USE_SSL),1)
-all: $(SSL_DYLIBNAME) $(SSL_STLIBNAME) $(SSL_PKGCONFNAME)
-endif

 # Deps (use make dep to generate this)
 async.o: async.c fmacros.h async.h hiredis.h read.h sds.h net.h dict.c dict.h
 dict.o: dict.c fmacros.h dict.h
-hiredis.o: hiredis.c fmacros.h hiredis.h read.h sds.h net.h win32.h
-net.o: net.c fmacros.h net.h hiredis.h read.h sds.h sockcompat.h win32.h
+hiredis.o: hiredis.c fmacros.h hiredis.h read.h sds.h net.h
+net.o: net.c fmacros.h net.h hiredis.h read.h sds.h
 read.o: read.c fmacros.h read.h sds.h
 sds.o: sds.c sds.h
-sockcompat.o: sockcompat.c sockcompat.h
-ssl.o: ssl.c hiredis.h
 test.o: test.c fmacros.h hiredis.h read.h sds.h

 $(DYLIBNAME): $(OBJ)
-	$(DYLIB_MAKE_CMD) -o $(DYLIBNAME) $(OBJ) $(REAL_LDFLAGS)
+	$(DYLIB_MAKE_CMD) $(OBJ)

 $(STLIBNAME): $(OBJ)
-	$(STLIB_MAKE_CMD) $(STLIBNAME) $(OBJ)
-
-$(SSL_DYLIBNAME): $(SSL_OBJ)
-	$(DYLIB_MAKE_CMD) -o $(SSL_DYLIBNAME) $(SSL_OBJ) $(REAL_LDFLAGS) $(SSL_LDFLAGS)
-
-$(SSL_STLIBNAME): $(SSL_OBJ)
-	$(STLIB_MAKE_CMD) $(SSL_STLIBNAME) $(SSL_OBJ)
+	$(STLIB_MAKE_CMD) $(OBJ)

 dynamic: $(DYLIBNAME)
 static: $(STLIBNAME)
-ifeq ($(USE_SSL),1)
-dynamic: $(SSL_DYLIBNAME)
-static: $(SSL_STLIBNAME)
-endif

 # Binaries:
 hiredis-example-libevent: examples/example-libevent.c adapters/libevent.h $(STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -levent $(STLIBNAME) $(REAL_LDFLAGS)
-
-hiredis-example-libevent-ssl: examples/example-libevent-ssl.c adapters/libevent.h $(STLIBNAME) $(SSL_STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -levent $(STLIBNAME) $(SSL_STLIBNAME) $(REAL_LDFLAGS) $(SSL_LDFLAGS)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. $< -levent $(STLIBNAME)

 hiredis-example-libev: examples/example-libev.c adapters/libev.h $(STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -lev $(STLIBNAME) $(REAL_LDFLAGS)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. $< -lev $(STLIBNAME)

 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)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. $< $(shell pkg-config --cflags --libs glib-2.0) $(STLIBNAME)

 hiredis-example-ivykis: examples/example-ivykis.c adapters/ivykis.h $(STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -livykis $(STLIBNAME) $(REAL_LDFLAGS)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. $< -livykis $(STLIBNAME)

 hiredis-example-macosx: examples/example-macosx.c adapters/macosx.h $(STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< -framework CoreFoundation $(STLIBNAME) $(REAL_LDFLAGS)
-
-hiredis-example-ssl: examples/example-ssl.c $(STLIBNAME) $(SSL_STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(STLIBNAME) $(SSL_STLIBNAME) $(REAL_LDFLAGS) $(SSL_LDFLAGS)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. $< -framework CoreFoundation $(STLIBNAME)

 ifndef AE_DIR
 hiredis-example-ae:
@@ -161,7 +116,7 @@ hiredis-example-libuv:
 	@false
 else
 hiredis-example-libuv: examples/example-libuv.c adapters/libuv.h $(STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. -I$(LIBUV_DIR)/include $< $(LIBUV_DIR)/.libs/libuv.a -lpthread -lrt $(STLIBNAME) $(REAL_LDFLAGS)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. -I$(LIBUV_DIR)/include $< $(LIBUV_DIR)/.libs/libuv.a -lpthread -lrt $(STLIBNAME)
 endif

 ifeq ($(and $(QT_MOC),$(QT_INCLUDE_DIR),$(QT_LIBRARY_DIR)),)
@@ -178,33 +133,32 @@ hiredis-example-qt: examples/example-qt.cpp adapters/qt.h $(STLIBNAME)
 endif

 hiredis-example: examples/example.c $(STLIBNAME)
-	$(CC) -o examples/$@ $(REAL_CFLAGS) -I. $< $(STLIBNAME) $(REAL_LDFLAGS)
+	$(CC) -o examples/$@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I. $< $(STLIBNAME)

 examples: $(EXAMPLES)

-TEST_LIBS = $(STLIBNAME)
-ifeq ($(USE_SSL),1)
-    TEST_LIBS += $(SSL_STLIBNAME) -lssl -lcrypto -lpthread
-endif
-hiredis-test: test.o $(TEST_LIBS)
+hiredis-test: test.o $(STLIBNAME)

 hiredis-%: %.o $(STLIBNAME)
-	$(CC) $(REAL_CFLAGS) -o $@ $< $(TEST_LIBS) $(REAL_LDFLAGS)
+	$(CC) $(REAL_CFLAGS) -o $@ $(REAL_LDFLAGS) $< $(STLIBNAME)

 test: hiredis-test
 	./hiredis-test

 check: hiredis-test
-	TEST_SSL=$(USE_SSL) ./test.sh
+	@echo "$$REDIS_TEST_CONFIG" | $(REDIS_SERVER) -
+	$(PRE) ./hiredis-test -h 127.0.0.1 -p $(REDIS_PORT) -s /tmp/hiredis-test-redis.sock || \
+			( kill `cat /tmp/hiredis-test-redis.pid` && false )
+	kill `cat /tmp/hiredis-test-redis.pid`

 .c.o:
 	$(CC) -std=c99 -pedantic -c $(REAL_CFLAGS) $<

 clean:
-	rm -rf $(DYLIBNAME) $(STLIBNAME) $(SSL_DYLIBNAME) $(SSL_STLIBNAME) $(TESTS) $(PKGCONFNAME) examples/hiredis-example* *.o *.gcda *.gcno *.gcov
+	rm -rf $(DYLIBNAME) $(STLIBNAME) $(TESTS) $(PKGCONFNAME) examples/hiredis-example* *.o *.gcda *.gcno *.gcov

 dep:
-	$(CC) $(CPPFLAGS) $(CFLAGS) -MM *.c
+	$(CC) -MM *.c

 INSTALL?= cp -pPR

@@ -221,20 +175,6 @@ $(PKGCONFNAME): hiredis.h
 	@echo Libs: -L\$${libdir} -lhiredis >> $@
 	@echo Cflags: -I\$${includedir} -D_FILE_OFFSET_BITS=64 >> $@

-$(SSL_PKGCONFNAME): hiredis.h
-	@echo "Generating $@ for pkgconfig..."
-	@echo prefix=$(PREFIX) > $@
-	@echo exec_prefix=\$${prefix} >> $@
-	@echo libdir=$(PREFIX)/$(LIBRARY_PATH) >> $@
-	@echo includedir=$(PREFIX)/$(INCLUDE_PATH) >> $@
-	@echo >> $@
-	@echo Name: hiredis_ssl >> $@
-	@echo Description: SSL Support for hiredis. >> $@
-	@echo Version: $(HIREDIS_MAJOR).$(HIREDIS_MINOR).$(HIREDIS_PATCH) >> $@
-	@echo Requires: hiredis >> $@
-	@echo Libs: -L\$${libdir} -lhiredis_ssl >> $@
-	@echo Libs.private: -lssl -lcrypto >> $@
-
 install: $(DYLIBNAME) $(STLIBNAME) $(PKGCONFNAME)
 	mkdir -p $(INSTALL_INCLUDE_PATH) $(INSTALL_INCLUDE_PATH)/adapters $(INSTALL_LIBRARY_PATH)
 	$(INSTALL) hiredis.h async.h read.h sds.h $(INSTALL_INCLUDE_PATH)
@@ -286,7 +286,6 @@ return `REDIS_ERR`. The function to set the disconnect callback has the followin
 ```c
 int redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconnectCallback *fn);
 ```
-`ac->data` may be used to pass user data to this callback, the same can be done for redisConnectCallback.
 ### Sending commands and their callbacks

 In an asynchronous context, commands are automatically pipelined due to the nature of an event loop.
@@ -407,6 +406,6 @@ as soon as possible in order to prevent allocation of useless memory.
 ## AUTHORS

 Hiredis was written by Salvatore Sanfilippo (antirez at gmail) and
-Pieter Noordhuis (pcnoordhuis at gmail) and is released under the BSD license.
+Pieter Noordhuis (pcnoordhuis at gmail) and is released under the BSD license.  
 Hiredis is currently maintained by Matt Stancliff (matt at genges dot com) and
 Jan-Erik Rediger (janerik at fnordig dot com)
@@ -34,113 +34,48 @@
 #include "../hiredis.h"
 #include "../async.h"

-#define REDIS_LIBEVENT_DELETED 0x01
-#define REDIS_LIBEVENT_ENTERED 0x02
-
 typedef struct redisLibeventEvents {
    redisAsyncContext *context;
-    struct event *ev;
-    struct event_base *base;
-    struct timeval tv;
-    short flags;
-    short state;
+    struct event *rev, *wev;
 } redisLibeventEvents;

-static void redisLibeventDestroy(redisLibeventEvents *e) {
-    free(e);
-}
-
-static void redisLibeventHandler(int fd, short event, void *arg) {
-    ((void)fd);
+static void redisLibeventReadEvent(int fd, short event, void *arg) {
+    ((void)fd); ((void)event);
    redisLibeventEvents *e = (redisLibeventEvents*)arg;
-    e->state |= REDIS_LIBEVENT_ENTERED;
-
-    #define CHECK_DELETED() if (e->state & REDIS_LIBEVENT_DELETED) {\
-        redisLibeventDestroy(e);\
-        return; \
-    }
-
-    if ((event & EV_TIMEOUT) && (e->state & REDIS_LIBEVENT_DELETED) == 0) {
-        redisAsyncHandleTimeout(e->context);
-        CHECK_DELETED();
-    }
-
-    if ((event & EV_READ) && e->context && (e->state & REDIS_LIBEVENT_DELETED) == 0) {
-        redisAsyncHandleRead(e->context);
-        CHECK_DELETED();
-    }
-
-    if ((event & EV_WRITE) && e->context && (e->state & REDIS_LIBEVENT_DELETED) == 0) {
-        redisAsyncHandleWrite(e->context);
-        CHECK_DELETED();
-    }
-
-    e->state &= ~REDIS_LIBEVENT_ENTERED;
-    #undef CHECK_DELETED
+    redisAsyncHandleRead(e->context);
 }

-static void redisLibeventUpdate(void *privdata, short flag, int isRemove) {
-    redisLibeventEvents *e = (redisLibeventEvents *)privdata;
-    const struct timeval *tv = e->tv.tv_sec || e->tv.tv_usec ? &e->tv : NULL;
-
-    if (isRemove) {
-        if ((e->flags & flag) == 0) {
-            return;
-        } else {
-            e->flags &= ~flag;
-        }
-    } else {
-        if (e->flags & flag) {
-            return;
-        } else {
-            e->flags |= flag;
-        }
-    }
-
-    event_del(e->ev);
-    event_assign(e->ev, e->base, e->context->c.fd, e->flags | EV_PERSIST,
-                 redisLibeventHandler, privdata);
-    event_add(e->ev, tv);
+static void redisLibeventWriteEvent(int fd, short event, void *arg) {
+    ((void)fd); ((void)event);
+    redisLibeventEvents *e = (redisLibeventEvents*)arg;
+    redisAsyncHandleWrite(e->context);
 }

 static void redisLibeventAddRead(void *privdata) {
-    redisLibeventUpdate(privdata, EV_READ, 0);
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
+    event_add(e->rev,NULL);
 }

 static void redisLibeventDelRead(void *privdata) {
-    redisLibeventUpdate(privdata, EV_READ, 1);
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
+    event_del(e->rev);
 }

 static void redisLibeventAddWrite(void *privdata) {
-    redisLibeventUpdate(privdata, EV_WRITE, 0);
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
+    event_add(e->wev,NULL);
 }

 static void redisLibeventDelWrite(void *privdata) {
-    redisLibeventUpdate(privdata, EV_WRITE, 1);
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
+    event_del(e->wev);
 }

 static void redisLibeventCleanup(void *privdata) {
    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
-    if (!e) {
-        return;
-    }
-    event_del(e->ev);
-    event_free(e->ev);
-    e->ev = NULL;
-
-    if (e->state & REDIS_LIBEVENT_ENTERED) {
-        e->state |= REDIS_LIBEVENT_DELETED;
-    } else {
-        redisLibeventDestroy(e);
-    }
-}
-
-static void redisLibeventSetTimeout(void *privdata, struct timeval tv) {
-    redisLibeventEvents *e = (redisLibeventEvents *)privdata;
-    short flags = e->flags;
-    e->flags = 0;
-    e->tv = tv;
-    redisLibeventUpdate(e, flags, 0);
+    event_free(e->rev);
+    event_free(e->wev);
+    free(e);
 }

 static int redisLibeventAttach(redisAsyncContext *ac, struct event_base *base) {
@@ -152,7 +87,7 @@ static int redisLibeventAttach(redisAsyncContext *ac, struct event_base *base) {
        return REDIS_ERR;

    /* Create container for context and r/w events */
-    e = (redisLibeventEvents*)calloc(1, sizeof(*e));
+    e = (redisLibeventEvents*)malloc(sizeof(*e));
    e->context = ac;

    /* Register functions to start/stop listening for events */
@@ -161,12 +96,13 @@ static int redisLibeventAttach(redisAsyncContext *ac, struct event_base *base) {
    ac->ev.addWrite = redisLibeventAddWrite;
    ac->ev.delWrite = redisLibeventDelWrite;
    ac->ev.cleanup = redisLibeventCleanup;
-    ac->ev.scheduleTimer = redisLibeventSetTimeout;
    ac->ev.data = e;

    /* Initialize and install read/write events */
-    e->ev = event_new(base, c->fd, EV_READ | EV_WRITE, redisLibeventHandler, e);
-    e->base = base;
+    e->rev = event_new(base, c->fd, EV_READ, redisLibeventReadEvent, e);
+    e->wev = event_new(base, c->fd, EV_WRITE, redisLibeventWriteEvent, e);
+    event_add(e->rev, NULL);
+    event_add(e->wev, NULL);
    return REDIS_OK;
 }
 #endif
@@ -5,9 +5,8 @@ environment:
          CC: gcc
        - CYG_BASH: C:\cygwin\bin\bash
          CC: gcc
-          CFLAGS: -m32
-          CXXFLAGS: -m32
-          LDFLAGS: -m32
+          TARGET: 32bit
+          TARGET_VARS: 32bit-vars

 clone_depth: 1

@@ -21,4 +20,4 @@ install:

 build_script:
    - 'echo building...'
-    - '%CYG_BASH% -lc "cd $APPVEYOR_BUILD_FOLDER; exec 0</dev/null; mkdir build && cd build && cmake .. -G \"Unix Makefiles\" && make VERBOSE=1"'
+    - '%CYG_BASH% -lc "cd $APPVEYOR_BUILD_FOLDER; exec 0</dev/null; make LDFLAGS=$LDFLAGS CC=$CC $TARGET CFLAGS=$CFLAGS && make LDFLAGS=$LDFLAGS CC=$CC $TARGET_VARS hiredis-example"'
@@ -32,9 +32,7 @@
 #include "fmacros.h"
 #include <stdlib.h>
 #include <string.h>
-#ifndef _MSC_VER
 #include <strings.h>
-#endif
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
@@ -42,9 +40,22 @@
 #include "net.h"
 #include "dict.c"
 #include "sds.h"
-#include "win32.h"

-#include "async_private.h"
+#define _EL_ADD_READ(ctx) do { \
+        if ((ctx)->ev.addRead) (ctx)->ev.addRead((ctx)->ev.data); \
+    } while(0)
+#define _EL_DEL_READ(ctx) do { \
+        if ((ctx)->ev.delRead) (ctx)->ev.delRead((ctx)->ev.data); \
+    } while(0)
+#define _EL_ADD_WRITE(ctx) do { \
+        if ((ctx)->ev.addWrite) (ctx)->ev.addWrite((ctx)->ev.data); \
+    } while(0)
+#define _EL_DEL_WRITE(ctx) do { \
+        if ((ctx)->ev.delWrite) (ctx)->ev.delWrite((ctx)->ev.data); \
+    } while(0)
+#define _EL_CLEANUP(ctx) do { \
+        if ((ctx)->ev.cleanup) (ctx)->ev.cleanup((ctx)->ev.data); \
+    } while(0);

 /* Forward declaration of function in hiredis.c */
 int __redisAppendCommand(redisContext *c, const char *cmd, size_t len);
@@ -115,7 +126,6 @@ static redisAsyncContext *redisAsyncInitialize(redisContext *c) {
    ac->ev.addWrite = NULL;
    ac->ev.delWrite = NULL;
    ac->ev.cleanup = NULL;
-    ac->ev.scheduleTimer = NULL;

    ac->onConnect = NULL;
    ac->onDisconnect = NULL;
@@ -140,52 +150,56 @@ static void __redisAsyncCopyError(redisAsyncContext *ac) {
    ac->errstr = c->errstr;
 }

-redisAsyncContext *redisAsyncConnectWithOptions(const redisOptions *options) {
-    redisOptions myOptions = *options;
+redisAsyncContext *redisAsyncConnect(const char *ip, int port) {
    redisContext *c;
    redisAsyncContext *ac;

-    myOptions.options |= REDIS_OPT_NONBLOCK;
-    c = redisConnectWithOptions(&myOptions);
-    if (c == NULL) {
+    c = redisConnectNonBlock(ip,port);
+    if (c == NULL)
        return NULL;
-    }
+
    ac = redisAsyncInitialize(c);
    if (ac == NULL) {
        redisFree(c);
        return NULL;
    }
+
    __redisAsyncCopyError(ac);
    return ac;
 }

-redisAsyncContext *redisAsyncConnect(const char *ip, int port) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    return redisAsyncConnectWithOptions(&options);
-}
-
 redisAsyncContext *redisAsyncConnectBind(const char *ip, int port,
                                         const char *source_addr) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    options.endpoint.tcp.source_addr = source_addr;
-    return redisAsyncConnectWithOptions(&options);
+    redisContext *c = redisConnectBindNonBlock(ip,port,source_addr);
+    redisAsyncContext *ac = redisAsyncInitialize(c);
+    __redisAsyncCopyError(ac);
+    return ac;
 }

 redisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,
                                                  const char *source_addr) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    options.options |= REDIS_OPT_REUSEADDR;
-    options.endpoint.tcp.source_addr = source_addr;
-    return redisAsyncConnectWithOptions(&options);
+    redisContext *c = redisConnectBindNonBlockWithReuse(ip,port,source_addr);
+    redisAsyncContext *ac = redisAsyncInitialize(c);
+    __redisAsyncCopyError(ac);
+    return ac;
 }

 redisAsyncContext *redisAsyncConnectUnix(const char *path) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_UNIX(&options, path);
-    return redisAsyncConnectWithOptions(&options);
+    redisContext *c;
+    redisAsyncContext *ac;
+
+    c = redisConnectUnixNonBlock(path);
+    if (c == NULL)
+        return NULL;
+
+    ac = redisAsyncInitialize(c);
+    if (ac == NULL) {
+        redisFree(c);
+        return NULL;
+    }
+
+    __redisAsyncCopyError(ac);
+    return ac;
 }

 int redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCallback *fn) {
@@ -314,7 +328,7 @@ void redisAsyncFree(redisAsyncContext *ac) {
 }

 /* Helper function to make the disconnect happen and clean up. */
-void __redisAsyncDisconnect(redisAsyncContext *ac) {
+static void __redisAsyncDisconnect(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);

    /* Make sure error is accessible if there is any */
@@ -330,15 +344,9 @@ void __redisAsyncDisconnect(redisAsyncContext *ac) {
        c->flags |= REDIS_DISCONNECTING;
    }

-    /* cleanup event library on disconnect.
-     * this is safe to call multiple times */
-    _EL_CLEANUP(ac);
-
    /* For non-clean disconnects, __redisAsyncFree() will execute pending
     * callbacks with a NULL-reply. */
-    if (!(c->flags & REDIS_NO_AUTO_FREE)) {
-      __redisAsyncFree(ac);
-    }
+    __redisAsyncFree(ac);
 }

 /* Tries to do a clean disconnect from Redis, meaning it stops new commands
@@ -350,9 +358,6 @@ void __redisAsyncDisconnect(redisAsyncContext *ac) {
 void redisAsyncDisconnect(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);
    c->flags |= REDIS_DISCONNECTING;
-
-    /** unset the auto-free flag here, because disconnect undoes this */
-    c->flags &= ~REDIS_NO_AUTO_FREE;
    if (!(c->flags & REDIS_IN_CALLBACK) && ac->replies.head == NULL)
        __redisAsyncDisconnect(ac);
 }
@@ -403,7 +408,7 @@ static int __redisGetSubscribeCallback(redisAsyncContext *ac, redisReply *reply,
                assert(reply->element[2]->type == REDIS_REPLY_INTEGER);

                /* Unset subscribed flag only when no pipelined pending subscribe. */
-                if (reply->element[2]->integer == 0
+                if (reply->element[2]->integer == 0 
                    && dictSize(ac->sub.channels) == 0
                    && dictSize(ac->sub.patterns) == 0)
                    c->flags &= ~REDIS_SUBSCRIBED;
@@ -519,18 +524,6 @@ static int __redisAsyncHandleConnect(redisAsyncContext *ac) {
    }
 }

-void redisAsyncRead(redisAsyncContext *ac) {
-    redisContext *c = &(ac->c);
-
-    if (redisBufferRead(c) == REDIS_ERR) {
-        __redisAsyncDisconnect(ac);
-    } else {
-        /* Always re-schedule reads */
-        _EL_ADD_READ(ac);
-        redisProcessCallbacks(ac);
-    }
-}
-
 /* This function should be called when the socket is readable.
 * It processes all replies that can be read and executes their callbacks.
 */
@@ -546,13 +539,28 @@ void redisAsyncHandleRead(redisAsyncContext *ac) {
            return;
    }

-    c->funcs->async_read(ac);
+    if (redisBufferRead(c) == REDIS_ERR) {
+        __redisAsyncDisconnect(ac);
+    } else {
+        /* Always re-schedule reads */
+        _EL_ADD_READ(ac);
+        redisProcessCallbacks(ac);
+    }
 }

-void redisAsyncWrite(redisAsyncContext *ac) {
+void redisAsyncHandleWrite(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);
    int done = 0;

+    if (!(c->flags & REDIS_CONNECTED)) {
+        /* Abort connect was not successful. */
+        if (__redisAsyncHandleConnect(ac) != REDIS_OK)
+            return;
+        /* Try again later when the context is still not connected. */
+        if (!(c->flags & REDIS_CONNECTED))
+            return;
+    }
+
    if (redisBufferWrite(c,&done) == REDIS_ERR) {
        __redisAsyncDisconnect(ac);
    } else {
@@ -567,51 +575,6 @@ void redisAsyncWrite(redisAsyncContext *ac) {
    }
 }

-void redisAsyncHandleWrite(redisAsyncContext *ac) {
-    redisContext *c = &(ac->c);
-
-    if (!(c->flags & REDIS_CONNECTED)) {
-        /* Abort connect was not successful. */
-        if (__redisAsyncHandleConnect(ac) != REDIS_OK)
-            return;
-        /* Try again later when the context is still not connected. */
-        if (!(c->flags & REDIS_CONNECTED))
-            return;
-    }
-
-    c->funcs->async_write(ac);
-}
-
-void __redisSetError(redisContext *c, int type, const char *str);
-
-void redisAsyncHandleTimeout(redisAsyncContext *ac) {
-    redisContext *c = &(ac->c);
-    redisCallback cb;
-
-    if ((c->flags & REDIS_CONNECTED) && ac->replies.head == NULL) {
-        /* Nothing to do - just an idle timeout */
-        return;
-    }
-
-    if (!c->err) {
-        __redisSetError(c, REDIS_ERR_TIMEOUT, "Timeout");
-    }
-
-    if (!(c->flags & REDIS_CONNECTED) && ac->onConnect) {
-        ac->onConnect(ac, REDIS_ERR);
-    }
-
-    while (__redisShiftCallback(&ac->replies, &cb) == REDIS_OK) {
-        __redisRunCallback(ac, &cb, NULL);
-    }
-
-    /**
-     * TODO: Don't automatically sever the connection,
-     * rather, allow to ignore <x> responses before the queue is clear
-     */
-    __redisAsyncDisconnect(ac);
-}
-
 /* Sets a pointer to the first argument and its length starting at p. Returns
 * the number of bytes to skip to get to the following argument. */
 static const char *nextArgument(const char *start, const char **str, size_t *len) {
@@ -751,16 +714,3 @@ int redisAsyncFormattedCommand(redisAsyncContext *ac, redisCallbackFn *fn, void
    int status = __redisAsyncCommand(ac,fn,privdata,cmd,len);
    return status;
 }
-
-void redisAsyncSetTimeout(redisAsyncContext *ac, struct timeval tv) {
-    if (!ac->c.timeout) {
-        ac->c.timeout = calloc(1, sizeof(tv));
-    }
-
-    if (tv.tv_sec == ac->c.timeout->tv_sec &&
-        tv.tv_usec == ac->c.timeout->tv_usec) {
-        return;
-    }
-
-    *ac->c.timeout = tv;
-}
@@ -57,7 +57,6 @@ typedef struct redisCallbackList {
 /* Connection callback prototypes */
 typedef void (redisDisconnectCallback)(const struct redisAsyncContext*, int status);
 typedef void (redisConnectCallback)(const struct redisAsyncContext*, int status);
-typedef void(redisTimerCallback)(void *timer, void *privdata);

 /* Context for an async connection to Redis */
 typedef struct redisAsyncContext {
@@ -82,7 +81,6 @@ typedef struct redisAsyncContext {
        void (*addWrite)(void *privdata);
        void (*delWrite)(void *privdata);
        void (*cleanup)(void *privdata);
-        void (*scheduleTimer)(void *privdata, struct timeval tv);
    } ev;

    /* Called when either the connection is terminated due to an error or per
@@ -108,7 +106,6 @@ typedef struct redisAsyncContext {
 } redisAsyncContext;

 /* Functions that proxy to hiredis */
-redisAsyncContext *redisAsyncConnectWithOptions(const redisOptions *options);
 redisAsyncContext *redisAsyncConnect(const char *ip, int port);
 redisAsyncContext *redisAsyncConnectBind(const char *ip, int port, const char *source_addr);
 redisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,
@@ -116,17 +113,12 @@ redisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,
 redisAsyncContext *redisAsyncConnectUnix(const char *path);
 int redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCallback *fn);
 int redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconnectCallback *fn);
-
-void redisAsyncSetTimeout(redisAsyncContext *ac, struct timeval tv);
 void redisAsyncDisconnect(redisAsyncContext *ac);
 void redisAsyncFree(redisAsyncContext *ac);

 /* Handle read/write events */
 void redisAsyncHandleRead(redisAsyncContext *ac);
 void redisAsyncHandleWrite(redisAsyncContext *ac);
-void redisAsyncHandleTimeout(redisAsyncContext *ac);
-void redisAsyncRead(redisAsyncContext *ac);
-void redisAsyncWrite(redisAsyncContext *ac);

 /* Command functions for an async context. Write the command to the
 * output buffer and register the provided callback. */
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
- *
- * 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_ASYNC_PRIVATE_H
-#define __HIREDIS_ASYNC_PRIVATE_H
-
-#define _EL_ADD_READ(ctx)                                         \
-    do {                                                          \
-        refreshTimeout(ctx);                                      \
-        if ((ctx)->ev.addRead) (ctx)->ev.addRead((ctx)->ev.data); \
-    } while (0)
-#define _EL_DEL_READ(ctx) do { \
-        if ((ctx)->ev.delRead) (ctx)->ev.delRead((ctx)->ev.data); \
-    } while(0)
-#define _EL_ADD_WRITE(ctx)                                          \
-    do {                                                            \
-        refreshTimeout(ctx);                                        \
-        if ((ctx)->ev.addWrite) (ctx)->ev.addWrite((ctx)->ev.data); \
-    } while (0)
-#define _EL_DEL_WRITE(ctx) do { \
-        if ((ctx)->ev.delWrite) (ctx)->ev.delWrite((ctx)->ev.data); \
-    } while(0)
-#define _EL_CLEANUP(ctx) do { \
-        if ((ctx)->ev.cleanup) (ctx)->ev.cleanup((ctx)->ev.data); \
-        ctx->ev.cleanup = NULL; \
-    } while(0);
-
-static inline void refreshTimeout(redisAsyncContext *ctx) {
-    if (ctx->c.timeout && ctx->ev.scheduleTimer &&
-        (ctx->c.timeout->tv_sec || ctx->c.timeout->tv_usec)) {
-        ctx->ev.scheduleTimer(ctx->ev.data, *ctx->c.timeout);
-    // } else {
-    //     printf("Not scheduling timer.. (tmo=%p)\n", ctx->c.timeout);
-    //     if (ctx->c.timeout){
-    //         printf("tv_sec: %u. tv_usec: %u\n", ctx->c.timeout->tv_sec,
-    //                ctx->c.timeout->tv_usec);
-    //     }
-    }
-}
-
-void __redisAsyncDisconnect(redisAsyncContext *ac);
-void redisProcessCallbacks(redisAsyncContext *ac);
-
-#endif  /* __HIREDIS_ASYNC_PRIVATE_H */
@@ -1,46 +0,0 @@
-INCLUDE(FindPkgConfig)
-# Check for GLib
-
-PKG_CHECK_MODULES(GLIB2 glib-2.0)
-if (GLIB2_FOUND)
-    INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
-    LINK_DIRECTORIES(${GLIB2_LIBRARY_DIRS})
-    ADD_EXECUTABLE(example-glib example-glib.c)
-    TARGET_LINK_LIBRARIES(example-glib hiredis ${GLIB2_LIBRARIES})
-ENDIF(GLIB2_FOUND)
-
-FIND_PATH(LIBEV ev.h
-    HINTS /usr/local /usr/opt/local
-    ENV LIBEV_INCLUDE_DIR)
-
-if (LIBEV)
-    # Just compile and link with libev
-    ADD_EXECUTABLE(example-libev example-libev.c)
-    TARGET_LINK_LIBRARIES(example-libev hiredis ev)
-ENDIF()
-
-FIND_PATH(LIBEVENT event.h)
-if (LIBEVENT)
-    ADD_EXECUTABLE(example-libevent example-libevent)
-    TARGET_LINK_LIBRARIES(example-libevent hiredis event)
-ENDIF()
-
-FIND_PATH(LIBUV uv.h)
-IF (LIBUV)
-    ADD_EXECUTABLE(example-libuv example-libuv.c)
-    TARGET_LINK_LIBRARIES(example-libuv hiredis uv)
-ENDIF()
-
-IF (APPLE)
-    FIND_LIBRARY(CF CoreFoundation)
-    ADD_EXECUTABLE(example-macosx example-macosx.c)
-    TARGET_LINK_LIBRARIES(example-macosx hiredis ${CF})
-ENDIF()
-
-IF (ENABLE_SSL)
-    ADD_EXECUTABLE(example-ssl example-ssl.c)
-    TARGET_LINK_LIBRARIES(example-ssl hiredis hiredis_ssl)
-ENDIF()
-
-ADD_EXECUTABLE(example example.c)
-TARGET_LINK_LIBRARIES(example hiredis)
@@ -1,73 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-
-#include <hiredis.h>
-#include <hiredis_ssl.h>
-#include <async.h>
-#include <adapters/libevent.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 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) {
-    signal(SIGPIPE, SIG_IGN);
-    struct event_base *base = event_base_new();
-    if (argc < 5) {
-        fprintf(stderr,
-                "Usage: %s <key> <host> <port> <cert> <certKey> [ca]\n", argv[0]);
-        exit(1);
-    }
-
-    const char *value = argv[1];
-    size_t nvalue = strlen(value);
-
-    const char *hostname = argv[2];
-    int port = atoi(argv[3]);
-
-    const char *cert = argv[4];
-    const char *certKey = argv[5];
-    const char *caCert = argc > 5 ? argv[6] : NULL;
-
-    redisAsyncContext *c = redisAsyncConnect(hostname, port);
-    if (c->err) {
-        /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
-        return 1;
-    }
-    if (redisSecureConnection(&c->c, caCert, cert, certKey, "sni") != REDIS_OK) {
-        printf("SSL Error!\n");
-        exit(1);
-    }
-
-    redisLibeventAttach(c,base);
-    redisAsyncSetConnectCallback(c,connectCallback);
-    redisAsyncSetDisconnectCallback(c,disconnectCallback);
-    redisAsyncCommand(c, NULL, NULL, "SET key %b", value, nvalue);
-    redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
-    event_base_dispatch(base);
-    return 0;
-}
@@ -9,12 +9,7 @@

 void getCallback(redisAsyncContext *c, void *r, void *privdata) {
    redisReply *reply = r;
-    if (reply == NULL) {
-        if (c->errstr) {
-            printf("errstr: %s\n", c->errstr);
-        }
-        return;
-    }
+    if (reply == NULL) return;
    printf("argv[%s]: %s\n", (char*)privdata, reply->str);

    /* Disconnect after receiving the reply to GET */
@@ -40,14 +35,8 @@ void disconnectCallback(const redisAsyncContext *c, int status) {
 int main (int argc, char **argv) {
    signal(SIGPIPE, SIG_IGN);
    struct event_base *base = event_base_new();
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, "127.0.0.1", 6379);
-    struct timeval tv = {0};
-    tv.tv_sec = 1;
-    options.timeout = &tv;

-
-    redisAsyncContext *c = redisAsyncConnectWithOptions(&options);
+    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
    if (c->err) {
        /* Let *c leak for now... */
        printf("Error: %s\n", c->errstr);
@@ -1,97 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <hiredis.h>
-#include <hiredis_ssl.h>
-
-int main(int argc, char **argv) {
-    unsigned int j;
-    redisContext *c;
-    redisReply *reply;
-    if (argc < 4) {
-        printf("Usage: %s <host> <port> <cert> <key> [ca]\n", argv[0]);
-        exit(1);
-    }
-    const char *hostname = (argc > 1) ? argv[1] : "127.0.0.1";
-    int port = atoi(argv[2]);
-    const char *cert = argv[3];
-    const char *key = argv[4];
-    const char *ca = argc > 4 ? argv[5] : NULL;
-
-    struct timeval tv = { 1, 500000 }; // 1.5 seconds
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, hostname, port);
-    options.timeout = &tv;
-    c = redisConnectWithOptions(&options);
-
-    if (c == NULL || c->err) {
-        if (c) {
-            printf("Connection error: %s\n", c->errstr);
-            redisFree(c);
-        } else {
-            printf("Connection error: can't allocate redis context\n");
-        }
-        exit(1);
-    }
-
-    if (redisSecureConnection(c, ca, cert, key, "sni") != REDIS_OK) {
-        printf("Couldn't initialize SSL!\n");
-        printf("Error: %s\n", c->errstr);
-        redisFree(c);
-        exit(1);
-    }
-
-    /* PING server */
-    reply = redisCommand(c,"PING");
-    printf("PING: %s\n", reply->str);
-    freeReplyObject(reply);
-
-    /* Set a key */
-    reply = redisCommand(c,"SET %s %s", "foo", "hello world");
-    printf("SET: %s\n", reply->str);
-    freeReplyObject(reply);
-
-    /* Set a key using binary safe API */
-    reply = redisCommand(c,"SET %b %b", "bar", (size_t) 3, "hello", (size_t) 5);
-    printf("SET (binary API): %s\n", reply->str);
-    freeReplyObject(reply);
-
-    /* Try a GET and two INCR */
-    reply = redisCommand(c,"GET foo");
-    printf("GET foo: %s\n", reply->str);
-    freeReplyObject(reply);
-
-    reply = redisCommand(c,"INCR counter");
-    printf("INCR counter: %lld\n", reply->integer);
-    freeReplyObject(reply);
-    /* again ... */
-    reply = redisCommand(c,"INCR counter");
-    printf("INCR counter: %lld\n", reply->integer);
-    freeReplyObject(reply);
-
-    /* Create a list of numbers, from 0 to 9 */
-    reply = redisCommand(c,"DEL mylist");
-    freeReplyObject(reply);
-    for (j = 0; j < 10; j++) {
-        char buf[64];
-
-        snprintf(buf,64,"%u",j);
-        reply = redisCommand(c,"LPUSH mylist element-%s", buf);
-        freeReplyObject(reply);
-    }
-
-    /* Let's check what we have inside the list */
-    reply = redisCommand(c,"LRANGE mylist 0 -1");
-    if (reply->type == REDIS_REPLY_ARRAY) {
-        for (j = 0; j < reply->elements; j++) {
-            printf("%u) %s\n", j, reply->element[j]->str);
-        }
-    }
-    freeReplyObject(reply);
-
-    /* Disconnects and frees the context */
-    redisFree(c);
-
-    return 0;
-}
@@ -5,27 +5,14 @@
 #include <hiredis.h>

 int main(int argc, char **argv) {
-    unsigned int j, isunix = 0;
+    unsigned int j;
    redisContext *c;
    redisReply *reply;
    const char *hostname = (argc > 1) ? argv[1] : "127.0.0.1";
-
-    if (argc > 2) {
-        if (*argv[2] == 'u' || *argv[2] == 'U') {
-            isunix = 1;
-            /* in this case, host is the path to the unix socket */
-            printf("Will connect to unix socket @%s\n", hostname);
-        }
-    }
-
    int port = (argc > 2) ? atoi(argv[2]) : 6379;

    struct timeval timeout = { 1, 500000 }; // 1.5 seconds
-    if (isunix) {
-        c = redisConnectUnixWithTimeout(hostname, timeout);
-    } else {
-        c = redisConnectWithTimeout(hostname, port, timeout);
-    }
+    c = redisConnectWithTimeout(hostname, port, timeout);
    if (c == NULL || c->err) {
        if (c) {
            printf("Connection error: %s\n", c->errstr);
@@ -34,6 +34,7 @@
 #include "fmacros.h"
 #include <string.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include <assert.h>
 #include <errno.h>
 #include <ctype.h>
@@ -41,20 +42,10 @@
 #include "hiredis.h"
 #include "net.h"
 #include "sds.h"
-#include "async.h"
-#include "win32.h"
-
-static redisContextFuncs redisContextDefaultFuncs = {
-    .free_privdata = NULL,
-    .async_read = redisAsyncRead,
-    .async_write = redisAsyncWrite,
-    .read = redisNetRead,
-    .write = redisNetWrite
-};

 static redisReply *createReplyObject(int type);
 static void *createStringObject(const redisReadTask *task, char *str, size_t len);
-static void *createArrayObject(const redisReadTask *task, size_t elements);
+static void *createArrayObject(const redisReadTask *task, int elements);
 static void *createIntegerObject(const redisReadTask *task, long long value);
 static void *createDoubleObject(const redisReadTask *task, double value, char *str, size_t len);
 static void *createNilObject(const redisReadTask *task);
@@ -121,34 +112,21 @@ static void *createStringObject(const redisReadTask *task, char *str, size_t len
    if (r == NULL)
        return NULL;

+    buf = malloc(len+1);
+    if (buf == NULL) {
+        freeReplyObject(r);
+        return NULL;
+    }
+
    assert(task->type == REDIS_REPLY_ERROR  ||
           task->type == REDIS_REPLY_STATUS ||
-           task->type == REDIS_REPLY_STRING ||
-           task->type == REDIS_REPLY_VERB);
+           task->type == REDIS_REPLY_STRING);

    /* Copy string value */
-    if (task->type == REDIS_REPLY_VERB) {
-        buf = malloc(len-4+1); /* Skip 4 bytes of verbatim type header. */
-        if (buf == NULL) {
-            freeReplyObject(r);
-            return NULL;
-        }
-        memcpy(r->vtype,str,3);
-        r->vtype[3] = '\0';
-        memcpy(buf,str+4,len-4);
-        buf[len-4] = '\0';
-        r->len = len-4;
-    } else {
-        buf = malloc(len+1);
-        if (buf == NULL) {
-            freeReplyObject(r);
-            return NULL;
-        }
-        memcpy(buf,str,len);
-        buf[len] = '\0';
-        r->len = len;
-    }
+    memcpy(buf,str,len);
+    buf[len] = '\0';
    r->str = buf;
+    r->len = len;

    if (task->parent) {
        parent = task->parent->obj;
@@ -160,7 +138,7 @@ static void *createStringObject(const redisReadTask *task, char *str, size_t len
    return r;
 }

-static void *createArrayObject(const redisReadTask *task, size_t elements) {
+static void *createArrayObject(const redisReadTask *task, int elements) {
    redisReply *r, *parent;

    r = createReplyObject(task->type);
@@ -671,30 +649,29 @@ redisReader *redisReaderCreate(void) {
    return redisReaderCreateWithFunctions(&defaultFunctions);
 }

-static redisContext *redisContextInit(const redisOptions *options) {
+static redisContext *redisContextInit(void) {
    redisContext *c;

-    c = calloc(1, sizeof(*c));
+    c = calloc(1,sizeof(redisContext));
    if (c == NULL)
        return NULL;

-    c->funcs = &redisContextDefaultFuncs;
    c->obuf = sdsempty();
    c->reader = redisReaderCreate();
-    c->fd = REDIS_INVALID_FD;

    if (c->obuf == NULL || c->reader == NULL) {
        redisFree(c);
        return NULL;
    }
-    (void)options; /* options are used in other functions */
+
    return c;
 }

 void redisFree(redisContext *c) {
    if (c == NULL)
        return;
-    redisNetClose(c);
+    if (c->fd > 0)
+        close(c->fd);

    sdsfree(c->obuf);
    redisReaderFree(c->reader);
@@ -703,16 +680,12 @@ void redisFree(redisContext *c) {
    free(c->unix_sock.path);
    free(c->timeout);
    free(c->saddr);
-    if (c->funcs->free_privdata) {
-        c->funcs->free_privdata(c->privdata);
-    }
-    memset(c, 0xff, sizeof(*c));
    free(c);
 }

-redisFD redisFreeKeepFd(redisContext *c) {
-    redisFD fd = c->fd;
-    c->fd = REDIS_INVALID_FD;
+int redisFreeKeepFd(redisContext *c) {
+    int fd = c->fd;
+    c->fd = -1;
    redisFree(c);
    return fd;
 }
@@ -721,13 +694,10 @@ int redisReconnect(redisContext *c) {
    c->err = 0;
    memset(c->errstr, '\0', strlen(c->errstr));

-    if (c->privdata && c->funcs->free_privdata) {
-        c->funcs->free_privdata(c->privdata);
-        c->privdata = NULL;
+    if (c->fd > 0) {
+        close(c->fd);
    }

-    redisNetClose(c);
-
    sdsfree(c->obuf);
    redisReaderFree(c->reader);

@@ -748,107 +718,112 @@ int redisReconnect(redisContext *c) {
    return REDIS_ERR;
 }

-redisContext *redisConnectWithOptions(const redisOptions *options) {
-    redisContext *c = redisContextInit(options);
-    if (c == NULL) {
-        return NULL;
-    }
-    if (!(options->options & REDIS_OPT_NONBLOCK)) {
-        c->flags |= REDIS_BLOCK;
-    }
-    if (options->options & REDIS_OPT_REUSEADDR) {
-        c->flags |= REDIS_REUSEADDR;
-    }
-    if (options->options & REDIS_OPT_NOAUTOFREE) {
-      c->flags |= REDIS_NO_AUTO_FREE;
-    }
-
-    if (options->type == REDIS_CONN_TCP) {
-        redisContextConnectBindTcp(c, options->endpoint.tcp.ip,
-                                   options->endpoint.tcp.port, options->timeout,
-                                   options->endpoint.tcp.source_addr);
-    } else if (options->type == REDIS_CONN_UNIX) {
-        redisContextConnectUnix(c, options->endpoint.unix_socket,
-                                options->timeout);
-    } else if (options->type == REDIS_CONN_USERFD) {
-        c->fd = options->endpoint.fd;
-        c->flags |= REDIS_CONNECTED;
-    } else {
-        // Unknown type - FIXME - FREE
-        return NULL;
-    }
-    if (options->timeout != NULL && (c->flags & REDIS_BLOCK) && c->fd != REDIS_INVALID_FD) {
-        redisContextSetTimeout(c, *options->timeout);
-    }
-    return c;
-}
-
 /* Connect to a Redis instance. On error the field error in the returned
 * context will be set to the return value of the error function.
 * When no set of reply functions is given, the default set will be used. */
 redisContext *redisConnect(const char *ip, int port) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    return redisConnectWithOptions(&options);
+    redisContext *c;
+
+    c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+
+    c->flags |= REDIS_BLOCK;
+    redisContextConnectTcp(c,ip,port,NULL);
+    return c;
 }

 redisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    options.timeout = &tv;
-    return redisConnectWithOptions(&options);
+    redisContext *c;
+
+    c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+
+    c->flags |= REDIS_BLOCK;
+    redisContextConnectTcp(c,ip,port,&tv);
+    return c;
 }

 redisContext *redisConnectNonBlock(const char *ip, int port) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    options.options |= REDIS_OPT_NONBLOCK;
-    return redisConnectWithOptions(&options);
+    redisContext *c;
+
+    c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+
+    c->flags &= ~REDIS_BLOCK;
+    redisContextConnectTcp(c,ip,port,NULL);
+    return c;
 }

 redisContext *redisConnectBindNonBlock(const char *ip, int port,
                                       const char *source_addr) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    options.endpoint.tcp.source_addr = source_addr;
-    options.options |= REDIS_OPT_NONBLOCK;
-    return redisConnectWithOptions(&options);
+    redisContext *c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+    c->flags &= ~REDIS_BLOCK;
+    redisContextConnectBindTcp(c,ip,port,NULL,source_addr);
+    return c;
 }

 redisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,
                                                const char *source_addr) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_TCP(&options, ip, port);
-    options.endpoint.tcp.source_addr = source_addr;
-    options.options |= REDIS_OPT_NONBLOCK|REDIS_OPT_REUSEADDR;
-    return redisConnectWithOptions(&options);
+    redisContext *c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+    c->flags &= ~REDIS_BLOCK;
+    c->flags |= REDIS_REUSEADDR;
+    redisContextConnectBindTcp(c,ip,port,NULL,source_addr);
+    return c;
 }

 redisContext *redisConnectUnix(const char *path) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_UNIX(&options, path);
-    return redisConnectWithOptions(&options);
+    redisContext *c;
+
+    c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+
+    c->flags |= REDIS_BLOCK;
+    redisContextConnectUnix(c,path,NULL);
+    return c;
 }

 redisContext *redisConnectUnixWithTimeout(const char *path, const struct timeval tv) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_UNIX(&options, path);
-    options.timeout = &tv;
-    return redisConnectWithOptions(&options);
+    redisContext *c;
+
+    c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+
+    c->flags |= REDIS_BLOCK;
+    redisContextConnectUnix(c,path,&tv);
+    return c;
 }

 redisContext *redisConnectUnixNonBlock(const char *path) {
-    redisOptions options = {0};
-    REDIS_OPTIONS_SET_UNIX(&options, path);
-    options.options |= REDIS_OPT_NONBLOCK;
-    return redisConnectWithOptions(&options);
+    redisContext *c;
+
+    c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+
+    c->flags &= ~REDIS_BLOCK;
+    redisContextConnectUnix(c,path,NULL);
+    return c;
 }

-redisContext *redisConnectFd(redisFD fd) {
-    redisOptions options = {0};
-    options.type = REDIS_CONN_USERFD;
-    options.endpoint.fd = fd;
-    return redisConnectWithOptions(&options);
+redisContext *redisConnectFd(int fd) {
+    redisContext *c;
+
+    c = redisContextInit();
+    if (c == NULL)
+        return NULL;
+
+    c->fd = fd;
+    c->flags |= REDIS_BLOCK | REDIS_CONNECTED;
+    return c;
 }

 /* Set read/write timeout on a blocking socket. */
@@ -878,15 +853,22 @@ int redisBufferRead(redisContext *c) {
    if (c->err)
        return REDIS_ERR;

-    nread = c->funcs->read(c, buf, sizeof(buf));
-    if (nread > 0) {
-        if (redisReaderFeed(c->reader, buf, nread) != REDIS_OK) {
-            __redisSetError(c, c->reader->err, c->reader->errstr);
-            return REDIS_ERR;
+    nread = read(c->fd,buf,sizeof(buf));
+    if (nread == -1) {
+        if ((errno == EAGAIN && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
+            /* Try again later */
        } else {
+            __redisSetError(c,REDIS_ERR_IO,NULL);
+            return REDIS_ERR;
        }
-    } else if (nread < 0) {
+    } else if (nread == 0) {
+        __redisSetError(c,REDIS_ERR_EOF,"Server closed the connection");
        return REDIS_ERR;
+    } else {
+        if (redisReaderFeed(c->reader,buf,nread) != REDIS_OK) {
+            __redisSetError(c,c->reader->err,c->reader->errstr);
+            return REDIS_ERR;
+        }
    }
    return REDIS_OK;
 }
@@ -901,15 +883,21 @@ int redisBufferRead(redisContext *c) {
 * c->errstr to hold the appropriate error string.
 */
 int redisBufferWrite(redisContext *c, int *done) {
+    int nwritten;

    /* Return early when the context has seen an error. */
    if (c->err)
        return REDIS_ERR;

    if (sdslen(c->obuf) > 0) {
-        int nwritten = c->funcs->write(c);
-        if (nwritten < 0) {
-            return REDIS_ERR;
+        nwritten = write(c->fd,c->obuf,sdslen(c->obuf));
+        if (nwritten == -1) {
+            if ((errno == EAGAIN && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
+                /* Try again later */
+            } else {
+                __redisSetError(c,REDIS_ERR_IO,NULL);
+                return REDIS_ERR;
+            }
        } else if (nwritten > 0) {
            if (nwritten == (signed)sdslen(c->obuf)) {
                sdsfree(c->obuf);
@@ -35,11 +35,7 @@
 #define __HIREDIS_H
 #include "read.h"
 #include <stdarg.h> /* for va_list */
-#ifndef _MSC_VER
 #include <sys/time.h> /* for struct timeval */
-#else
-struct timeval; /* forward declaration */
-#endif
 #include <stdint.h> /* uintXX_t, etc */
 #include "sds.h" /* for sds */

@@ -78,12 +74,6 @@ struct timeval; /* forward declaration */
 /* Flag that is set when we should set SO_REUSEADDR before calling bind() */
 #define REDIS_REUSEADDR 0x80

-/**
- * Flag that indicates the user does not want the context to
- * be automatically freed upon error
- */
-#define REDIS_NO_AUTO_FREE 0x200
-
 #define REDIS_KEEPALIVE_INTERVAL 15 /* seconds */

 /* number of times we retry to connect in the case of EADDRNOTAVAIL and
@@ -102,8 +92,6 @@ typedef struct redisReply {
    size_t len; /* Length of string */
    char *str; /* Used for REDIS_REPLY_ERROR, REDIS_REPLY_STRING
                  and REDIS_REPLY_DOUBLE (in additionl to dval). */
-    char vtype[4]; /* Used for REDIS_REPLY_VERB, contains the null
-                      terminated 3 character content type, such as "txt". */
    size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */
    struct redisReply **element; /* elements vector for REDIS_REPLY_ARRAY */
 } redisReply;
@@ -123,93 +111,14 @@ void redisFreeSdsCommand(sds cmd);

 enum redisConnectionType {
    REDIS_CONN_TCP,
-    REDIS_CONN_UNIX,
-    REDIS_CONN_USERFD
+    REDIS_CONN_UNIX
 };

-struct redisSsl;
-
-#define REDIS_OPT_NONBLOCK 0x01
-#define REDIS_OPT_REUSEADDR 0x02
-
-/**
- * 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
-
-/* 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
- * all bits set (~0) is INVALID_SOCKET.  */
-#ifndef _WIN32
-typedef int redisFD;
-#define REDIS_INVALID_FD -1
-#else
-#ifdef _WIN64
-typedef unsigned long long redisFD; /* SOCKET = 64-bit UINT_PTR */
-#else
-typedef unsigned long redisFD;      /* SOCKET = 32-bit UINT_PTR */
-#endif
-#define REDIS_INVALID_FD ((redisFD)(~0)) /* INVALID_SOCKET */
-#endif
-
-typedef struct {
-    /*
-     * the type of connection to use. This also indicates which
-     * `endpoint` member field to use
-     */
-    int type;
-    /* bit field of REDIS_OPT_xxx */
-    int options;
-    /* timeout value. if NULL, no timeout is used */
-    const struct timeval *timeout;
-    union {
-        /** use this field for tcp/ip connections */
-        struct {
-            const char *source_addr;
-            const char *ip;
-            int port;
-        } tcp;
-        /** use this field for unix domain sockets */
-        const char *unix_socket;
-        /**
-         * use this field to have hiredis operate an already-open
-         * file descriptor */
-        redisFD fd;
-    } endpoint;
-} redisOptions;
-
-/**
- * Helper macros to initialize options to their specified fields.
- */
-#define REDIS_OPTIONS_SET_TCP(opts, ip_, port_) \
-    (opts)->type = REDIS_CONN_TCP; \
-    (opts)->endpoint.tcp.ip = ip_; \
-    (opts)->endpoint.tcp.port = port_;
-
-#define REDIS_OPTIONS_SET_UNIX(opts, path) \
-    (opts)->type = REDIS_CONN_UNIX;        \
-    (opts)->endpoint.unix_socket = path;
-
-struct redisAsyncContext;
-struct redisContext;
-
-typedef struct redisContextFuncs {
-    void (*free_privdata)(void *);
-    void (*async_read)(struct redisAsyncContext *);
-    void (*async_write)(struct redisAsyncContext *);
-    int (*read)(struct redisContext *, char *, size_t);
-    int (*write)(struct redisContext *);
-} redisContextFuncs;
-
 /* Context for a connection to Redis */
 typedef struct redisContext {
-    const redisContextFuncs *funcs;   /* Function table */
-
    int err; /* Error flags, 0 when there is no error */
    char errstr[128]; /* String representation of error when applicable */
-    redisFD fd;
+    int fd;
    int flags;
    char *obuf; /* Write buffer */
    redisReader *reader; /* Protocol reader */
@@ -230,12 +139,8 @@ typedef struct redisContext {
    /* For non-blocking connect */
    struct sockadr *saddr;
    size_t addrlen;
-
-    /* Additional private data for hiredis addons such as SSL */
-    void *privdata;
 } redisContext;

-redisContext *redisConnectWithOptions(const redisOptions *options);
 redisContext *redisConnect(const char *ip, int port);
 redisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv);
 redisContext *redisConnectNonBlock(const char *ip, int port);
@@ -246,7 +151,7 @@ redisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,
 redisContext *redisConnectUnix(const char *path);
 redisContext *redisConnectUnixWithTimeout(const char *path, const struct timeval tv);
 redisContext *redisConnectUnixNonBlock(const char *path);
-redisContext *redisConnectFd(redisFD fd);
+redisContext *redisConnectFd(int fd);

 /**
 * Reconnect the given context using the saved information.
@@ -262,7 +167,7 @@ int redisReconnect(redisContext *c);
 int redisSetTimeout(redisContext *c, const struct timeval tv);
 int redisEnableKeepAlive(redisContext *c);
 void redisFree(redisContext *c);
-redisFD redisFreeKeepFd(redisContext *c);
+int redisFreeKeepFd(redisContext *c);
 int redisBufferRead(redisContext *c);
 int redisBufferWrite(redisContext *c, int *done);

@@ -1,11 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-libdir=${exec_prefix}/lib
-includedir=${prefix}/include
-pkgincludedir=${includedir}/hiredis
-
-Name: hiredis
-Description: Minimalistic C client library for Redis.
-Version: @PROJECT_VERSION@
-Libs: -L${libdir} -lhiredis
-Cflags: -I${pkgincludedir} -D_FILE_OFFSET_BITS=64
@@ -1,53 +0,0 @@
-
-/*
- * Copyright (c) 2019, Redis Labs
- *
- * 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_SSL_H
-#define __HIREDIS_SSL_H
-
-/* This is the underlying struct for SSL in ssl.h, which is not included to
- * keep build dependencies short here.
- */
-struct ssl_st;
-
-/**
- * Secure the connection using SSL. This should be done before any command is
- * executed on the connection.
- */
-int redisSecureConnection(redisContext *c, const char *capath, const char *certpath,
-                          const char *keypath, const char *servername);
-
-/**
- * Initiate SSL/TLS negotiation on a provided context.
- */
-
-int redisInitiateSSL(redisContext *c, struct ssl_st *ssl);
-
-#endif  /* __HIREDIS_SSL_H */
@@ -1,12 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-libdir=${exec_prefix}/lib
-includedir=${prefix}/include
-pkgincludedir=${includedir}/hiredis
-
-Name: hiredis_ssl
-Description: SSL Support for hiredis.
-Version: @PROJECT_VERSION@
-Requires: hiredis
-Libs: -L${libdir} -lhiredis_ssl
-Libs.private: -lssl -lcrypto
@@ -34,64 +34,36 @@

 #include "fmacros.h"
 #include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/select.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <unistd.h>
 #include <fcntl.h>
 #include <string.h>
+#include <netdb.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdio.h>
+#include <poll.h>
 #include <limits.h>
 #include <stdlib.h>

 #include "net.h"
 #include "sds.h"
-#include "sockcompat.h"
-#include "win32.h"

 /* Defined in hiredis.c */
 void __redisSetError(redisContext *c, int type, const char *str);

-void redisNetClose(redisContext *c) {
-    if (c && c->fd != REDIS_INVALID_FD) {
+static void redisContextCloseFd(redisContext *c) {
+    if (c && c->fd >= 0) {
        close(c->fd);
-        c->fd = REDIS_INVALID_FD;
+        c->fd = -1;
    }
 }

-int redisNetRead(redisContext *c, char *buf, size_t bufcap) {
-    int nread = recv(c->fd, buf, bufcap, 0);
-    if (nread == -1) {
-        if ((errno == EWOULDBLOCK && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
-            /* Try again later */
-            return 0;
-        } else if(errno == ETIMEDOUT && (c->flags & REDIS_BLOCK)) {
-            /* especially in windows */
-            __redisSetError(c, REDIS_ERR_TIMEOUT, "recv timeout");
-            return -1;
-        } else {
-            __redisSetError(c, REDIS_ERR_IO, NULL);
-            return -1;
-        }
-    } else if (nread == 0) {
-        __redisSetError(c, REDIS_ERR_EOF, "Server closed the connection");
-        return -1;
-    } else {
-        return nread;
-    }
-}
-
-int redisNetWrite(redisContext *c) {
-    int nwritten = send(c->fd, c->obuf, sdslen(c->obuf), 0);
-    if (nwritten < 0) {
-        if ((errno == EWOULDBLOCK && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
-            /* Try again later */
-        } else {
-            __redisSetError(c, REDIS_ERR_IO, NULL);
-            return -1;
-        }
-    }
-    return nwritten;
-}
-
 static void __redisSetErrorFromErrno(redisContext *c, int type, const char *prefix) {
    int errorno = errno;  /* snprintf() may change errno */
    char buf[128] = { 0 };
@@ -107,15 +79,15 @@ static int redisSetReuseAddr(redisContext *c) {
    int on = 1;
    if (setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-        redisNetClose(c);
+        redisContextCloseFd(c);
        return REDIS_ERR;
    }
    return REDIS_OK;
 }

 static int redisCreateSocket(redisContext *c, int type) {
-    redisFD s;
-    if ((s = socket(type, SOCK_STREAM, 0)) == REDIS_INVALID_FD) {
+    int s;
+    if ((s = socket(type, SOCK_STREAM, 0)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        return REDIS_ERR;
    }
@@ -129,7 +101,6 @@ static int redisCreateSocket(redisContext *c, int type) {
 }

 static int redisSetBlocking(redisContext *c, int blocking) {
-#ifndef _WIN32
    int flags;

    /* Set the socket nonblocking.
@@ -137,7 +108,7 @@ static int redisSetBlocking(redisContext *c, int blocking) {
     * interrupted by a signal. */
    if ((flags = fcntl(c->fd, F_GETFL)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_GETFL)");
-        redisNetClose(c);
+        redisContextCloseFd(c);
        return REDIS_ERR;
    }

@@ -148,23 +119,15 @@ static int redisSetBlocking(redisContext *c, int blocking) {

    if (fcntl(c->fd, F_SETFL, flags) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
-        redisNetClose(c);
+        redisContextCloseFd(c);
        return REDIS_ERR;
    }
-#else
-    u_long mode = blocking ? 0 : 1;
-    if (ioctl(c->fd, FIONBIO, &mode) == -1) {
-        __redisSetErrorFromErrno(c, REDIS_ERR_IO, "ioctl(FIONBIO)");
-        redisNetClose(c);
-        return REDIS_ERR;
-    }
-#endif /* _WIN32 */
    return REDIS_OK;
 }

 int redisKeepAlive(redisContext *c, int interval) {
    int val = 1;
-    redisFD fd = c->fd;
+    int fd = c->fd;

    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
@@ -207,7 +170,7 @@ static int redisSetTcpNoDelay(redisContext *c) {
    int yes = 1;
    if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(TCP_NODELAY)");
-        redisNetClose(c);
+        redisContextCloseFd(c);
        return REDIS_ERR;
    }
    return REDIS_OK;
@@ -249,12 +212,12 @@ static int redisContextWaitReady(redisContext *c, long msec) {

        if ((res = poll(wfd, 1, msec)) == -1) {
            __redisSetErrorFromErrno(c, REDIS_ERR_IO, "poll(2)");
-            redisNetClose(c);
+            redisContextCloseFd(c);
            return REDIS_ERR;
        } else if (res == 0) {
            errno = ETIMEDOUT;
            __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-            redisNetClose(c);
+            redisContextCloseFd(c);
            return REDIS_ERR;
        }

@@ -267,7 +230,7 @@ static int redisContextWaitReady(redisContext *c, long msec) {
    }

    __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-    redisNetClose(c);
+    redisContextCloseFd(c);
    return REDIS_ERR;
 }

@@ -314,18 +277,11 @@ int redisCheckSocketError(redisContext *c) {
 }

 int redisContextSetTimeout(redisContext *c, const struct timeval tv) {
-    const void *to_ptr = &tv;
-    size_t to_sz = sizeof(tv);
-#ifdef _WIN32
-    DWORD timeout_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000;
-    to_ptr = &timeout_msec;
-    to_sz = sizeof(timeout_msec);
-#endif
-    if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,to_ptr,to_sz) == -1) {
+    if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_RCVTIMEO)");
        return REDIS_ERR;
    }
-    if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,to_ptr,to_sz) == -1) {
+    if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(tv)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_SNDTIMEO)");
        return REDIS_ERR;
    }
@@ -335,8 +291,7 @@ int redisContextSetTimeout(redisContext *c, const struct timeval tv) {
 static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,
                                   const struct timeval *timeout,
                                   const char *source_addr) {
-    redisFD s;
-    int rv, n;
+    int s, rv, n;
    char _port[6];  /* strlen("65535"); */
    struct addrinfo hints, *servinfo, *bservinfo, *p, *b;
    int blocking = (c->flags & REDIS_BLOCK);
@@ -405,7 +360,7 @@ static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,
    }
    for (p = servinfo; p != NULL; p = p->ai_next) {
 addrretry:
-        if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == REDIS_INVALID_FD)
+        if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)
            continue;

        c->fd = s;
@@ -446,14 +401,16 @@ addrretry:
        }

        /* For repeat connection */
-        free(c->saddr);
+        if (c->saddr) {
+            free(c->saddr);
+        }
        c->saddr = malloc(p->ai_addrlen);
        memcpy(c->saddr, p->ai_addr, p->ai_addrlen);
        c->addrlen = p->ai_addrlen;

        if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {
            if (errno == EHOSTUNREACH) {
-                redisNetClose(c);
+                redisContextCloseFd(c);
                continue;
            } else if (errno == EINPROGRESS) {
                if (blocking) {
@@ -467,7 +424,7 @@ addrretry:
                if (++reuses >= REDIS_CONNECT_RETRIES) {
                    goto error;
                } else {
-                    redisNetClose(c);
+                    redisContextCloseFd(c);
                    goto addrretry;
                }
            } else {
@@ -514,9 +471,8 @@ int redisContextConnectBindTcp(redisContext *c, const char *addr, int port,
 }

 int redisContextConnectUnix(redisContext *c, const char *path, const struct timeval *timeout) {
-#ifndef _WIN32
    int blocking = (c->flags & REDIS_BLOCK);
-    struct sockaddr_un *sa;
+    struct sockaddr_un sa;
    long timeout_msec = -1;

    if (redisCreateSocket(c,AF_UNIX) < 0)
@@ -543,11 +499,9 @@ int redisContextConnectUnix(redisContext *c, const char *path, const struct time
    if (redisContextTimeoutMsec(c,&timeout_msec) != REDIS_OK)
        return REDIS_ERR;

-    sa = (struct sockaddr_un*)(c->saddr = malloc(sizeof(struct sockaddr_un)));
-    c->addrlen = sizeof(struct sockaddr_un);
-    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) {
+    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) {
            /* This is ok. */
        } else {
@@ -562,10 +516,4 @@ int redisContextConnectUnix(redisContext *c, const char *path, const struct time

    c->flags |= REDIS_CONNECTED;
    return REDIS_OK;
-#else
-    /* We currently do not support Unix sockets for Windows. */
-    /* TODO(m): https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/ */
-    errno = EPROTONOSUPPORT;
-    return REDIS_ERR;
-#endif /* _WIN32 */
 }
@@ -37,10 +37,6 @@

 #include "hiredis.h"

-void redisNetClose(redisContext *c);
-int redisNetRead(redisContext *c, char *buf, size_t bufcap);
-int redisNetWrite(redisContext *c);
-
 int redisCheckSocketError(redisContext *c);
 int redisContextSetTimeout(redisContext *c, const struct timeval tv);
 int redisContextConnectTcp(redisContext *c, const char *addr, int port, const struct timeval *timeout);
@@ -31,10 +31,10 @@

 #include "fmacros.h"
 #include <string.h>
+#include <strings.h>
 #include <stdlib.h>
 #ifndef _MSC_VER
 #include <unistd.h>
-#include <strings.h>
 #endif
 #include <assert.h>
 #include <errno.h>
@@ -44,7 +44,6 @@

 #include "read.h"
 #include "sds.h"
-#include "win32.h"

 static void __redisReaderSetError(redisReader *r, int type, const char *str) {
    size_t len;
@@ -295,9 +294,9 @@ static int processLineItem(redisReader *r) {
                buf[len] = '\0';

                if (strcasecmp(buf,",inf") == 0) {
-                    d = INFINITY; /* Positive infinite. */
+                    d = 1.0/0.0; /* Positive infinite. */
                } else if (strcasecmp(buf,",-inf") == 0) {
-                    d = -INFINITY; /* Nevative infinite. */
+                    d = -1.0/0.0; /* Nevative infinite. */
                } else {
                    d = strtod((char*)buf,&eptr);
                    if (buf[0] == '\0' || eptr[0] != '\0' || isnan(d)) {
@@ -380,18 +379,10 @@ static int processBulkItem(redisReader *r) {
            /* Only continue when the buffer contains the entire bulk item. */
            bytelen += len+2; /* include \r\n */
            if (r->pos+bytelen <= r->len) {
-                if ((cur->type == REDIS_REPLY_VERB && len < 4) ||
-                    (cur->type == REDIS_REPLY_VERB && s[5] != ':'))
-                {
-                    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
-                            "Verbatim string 4 bytes of content type are "
-                            "missing or incorrectly encoded.");
-                    return REDIS_ERR;
-                }
                if (r->fn && r->fn->createString)
                    obj = r->fn->createString(cur,s+2,len);
                else
-                    obj = (void*)(long)cur->type;
+                    obj = (void*)REDIS_REPLY_STRING;
                success = 1;
            }
        }
@@ -439,7 +430,7 @@ static int processAggregateItem(redisReader *r) {

        root = (r->ridx == 0);

-        if (elements < -1 || (LLONG_MAX > SIZE_MAX && elements > SIZE_MAX)) {
+        if (elements < -1 || elements > INT_MAX) {
            __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
                    "Multi-bulk length out of range");
            return REDIS_ERR;
@@ -532,9 +523,6 @@ static int processItem(redisReader *r) {
            case '#':
                cur->type = REDIS_REPLY_BOOL;
                break;
-            case '=':
-                cur->type = REDIS_REPLY_VERB;
-                break;
            default:
                __redisReaderSetErrorProtocolByte(r,*p);
                return REDIS_ERR;
@@ -555,7 +543,6 @@ static int processItem(redisReader *r) {
    case REDIS_REPLY_BOOL:
        return processLineItem(r);
    case REDIS_REPLY_STRING:
-    case REDIS_REPLY_VERB:
        return processBulkItem(r);
    case REDIS_REPLY_ARRAY:
    case REDIS_REPLY_MAP:
@@ -670,11 +657,8 @@ int redisReaderGetReply(redisReader *r, void **reply) {

    /* Emit a reply when there is one. */
    if (r->ridx == -1) {
-        if (reply != NULL) {
+        if (reply != NULL)
            *reply = r->reply;
-        } else if (r->reply != NULL && r->fn && r->fn->freeObject) {
-            r->fn->freeObject(r->reply);
-        }
        r->reply = NULL;
    }
    return REDIS_OK;
@@ -45,7 +45,6 @@
 #define REDIS_ERR_EOF 3 /* End of file */
 #define REDIS_ERR_PROTOCOL 4 /* Protocol error */
 #define REDIS_ERR_OOM 5 /* Out of memory */
-#define REDIS_ERR_TIMEOUT 6 /* Timed out */
 #define REDIS_ERR_OTHER 2 /* Everything else... */

 #define REDIS_REPLY_STRING 1
@@ -56,12 +55,12 @@
 #define REDIS_REPLY_ERROR 6
 #define REDIS_REPLY_DOUBLE 7
 #define REDIS_REPLY_BOOL 8
+#define REDIS_REPLY_VERB 9
 #define REDIS_REPLY_MAP 9
 #define REDIS_REPLY_SET 10
 #define REDIS_REPLY_ATTR 11
 #define REDIS_REPLY_PUSH 12
 #define REDIS_REPLY_BIGNUM 13
-#define REDIS_REPLY_VERB 14

 #define REDIS_READER_MAX_BUF (1024*16)  /* Default max unused reader buffer. */

@@ -80,7 +79,7 @@ typedef struct redisReadTask {

 typedef struct redisReplyObjectFunctions {
    void *(*createString)(const redisReadTask*, char*, size_t);
-    void *(*createArray)(const redisReadTask*, size_t);
+    void *(*createArray)(const redisReadTask*, int);
    void *(*createInteger)(const redisReadTask*, long long);
    void *(*createDouble)(const redisReadTask*, double, char*, size_t);
    void *(*createNil)(const redisReadTask*);
@@ -1035,7 +1035,7 @@ sds *sdssplitargs(const char *line, int *argc) {
                    s_free(vector);
                    return NULL;
                }
-
+                
                vector = new_vector;
                vector[*argc] = current;
                (*argc)++;
@@ -34,9 +34,6 @@
 #define __SDS_H

 #define SDS_MAX_PREALLOC (1024*1024)
-#ifdef _MSC_VER
-#define __attribute__(x)
-#endif

 #include <sys/types.h>
 #include <stdarg.h>
@@ -146,20 +143,20 @@ static inline void sdssetlen(sds s, size_t newlen) {
        case SDS_TYPE_5:
            {
                unsigned char *fp = ((unsigned char*)s)-1;
-                *fp = (unsigned char)(SDS_TYPE_5 | (newlen << SDS_TYPE_BITS));
+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
            }
            break;
        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len = (uint8_t)newlen;
+            SDS_HDR(8,s)->len = newlen;
            break;
        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len = (uint16_t)newlen;
+            SDS_HDR(16,s)->len = newlen;
            break;
        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len = (uint32_t)newlen;
+            SDS_HDR(32,s)->len = newlen;
            break;
        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len = (uint64_t)newlen;
+            SDS_HDR(64,s)->len = newlen;
            break;
    }
 }
@@ -170,21 +167,21 @@ static inline void sdsinclen(sds s, size_t inc) {
        case SDS_TYPE_5:
            {
                unsigned char *fp = ((unsigned char*)s)-1;
-                unsigned char newlen = SDS_TYPE_5_LEN(flags)+(unsigned char)inc;
+                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
            }
            break;
        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len += (uint8_t)inc;
+            SDS_HDR(8,s)->len += inc;
            break;
        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len += (uint16_t)inc;
+            SDS_HDR(16,s)->len += inc;
            break;
        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len += (uint32_t)inc;
+            SDS_HDR(32,s)->len += inc;
            break;
        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len += (uint64_t)inc;
+            SDS_HDR(64,s)->len += inc;
            break;
    }
 }
@@ -214,16 +211,16 @@ static inline void sdssetalloc(sds s, size_t newlen) {
            /* Nothing to do, this type has no total allocation info. */
            break;
        case SDS_TYPE_8:
-            SDS_HDR(8,s)->alloc = (uint8_t)newlen;
+            SDS_HDR(8,s)->alloc = newlen;
            break;
        case SDS_TYPE_16:
-            SDS_HDR(16,s)->alloc = (uint16_t)newlen;
+            SDS_HDR(16,s)->alloc = newlen;
            break;
        case SDS_TYPE_32:
-            SDS_HDR(32,s)->alloc = (uint32_t)newlen;
+            SDS_HDR(32,s)->alloc = newlen;
            break;
        case SDS_TYPE_64:
-            SDS_HDR(64,s)->alloc = (uint64_t)newlen;
+            SDS_HDR(64,s)->alloc = newlen;
            break;
    }
 }
@@ -1,248 +0,0 @@
-/*
- * Copyright (c) 2019, Marcus Geelnard <m at bitsnbites dot eu>
- *
- * 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.
- */
-
-#define REDIS_SOCKCOMPAT_IMPLEMENTATION
-#include "sockcompat.h"
-
-#ifdef _WIN32
-static int _wsaErrorToErrno(int err) {
-    switch (err) {
-        case WSAEWOULDBLOCK:
-            return EWOULDBLOCK;
-        case WSAEINPROGRESS:
-            return EINPROGRESS;
-        case WSAEALREADY:
-            return EALREADY;
-        case WSAENOTSOCK:
-            return ENOTSOCK;
-        case WSAEDESTADDRREQ:
-            return EDESTADDRREQ;
-        case WSAEMSGSIZE:
-            return EMSGSIZE;
-        case WSAEPROTOTYPE:
-            return EPROTOTYPE;
-        case WSAENOPROTOOPT:
-            return ENOPROTOOPT;
-        case WSAEPROTONOSUPPORT:
-            return EPROTONOSUPPORT;
-        case WSAEOPNOTSUPP:
-            return EOPNOTSUPP;
-        case WSAEAFNOSUPPORT:
-            return EAFNOSUPPORT;
-        case WSAEADDRINUSE:
-            return EADDRINUSE;
-        case WSAEADDRNOTAVAIL:
-            return EADDRNOTAVAIL;
-        case WSAENETDOWN:
-            return ENETDOWN;
-        case WSAENETUNREACH:
-            return ENETUNREACH;
-        case WSAENETRESET:
-            return ENETRESET;
-        case WSAECONNABORTED:
-            return ECONNABORTED;
-        case WSAECONNRESET:
-            return ECONNRESET;
-        case WSAENOBUFS:
-            return ENOBUFS;
-        case WSAEISCONN:
-            return EISCONN;
-        case WSAENOTCONN:
-            return ENOTCONN;
-        case WSAETIMEDOUT:
-            return ETIMEDOUT;
-        case WSAECONNREFUSED:
-            return ECONNREFUSED;
-        case WSAELOOP:
-            return ELOOP;
-        case WSAENAMETOOLONG:
-            return ENAMETOOLONG;
-        case WSAEHOSTUNREACH:
-            return EHOSTUNREACH;
-        case WSAENOTEMPTY:
-            return ENOTEMPTY;
-        default:
-            /* We just return a generic I/O error if we could not find a relevant error. */
-            return EIO;
-    }
-}
-
-static void _updateErrno(int success) {
-    errno = success ? 0 : _wsaErrorToErrno(WSAGetLastError());
-}
-
-static int _initWinsock() {
-    static int s_initialized = 0;
-    if (!s_initialized) {
-        static WSADATA wsadata;
-        int err = WSAStartup(MAKEWORD(2,2), &wsadata);
-        if (err != 0) {
-            errno = _wsaErrorToErrno(err);
-            return 0;
-        }
-        s_initialized = 1;
-    }
-    return 1;
-}
-
-int win32_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {
-    /* Note: This function is likely to be called before other functions, so run init here. */
-    if (!_initWinsock()) {
-        return EAI_FAIL;
-    }
-
-    switch (getaddrinfo(node, service, hints, res)) {
-        case 0:                     return 0;
-        case WSATRY_AGAIN:          return EAI_AGAIN;
-        case WSAEINVAL:             return EAI_BADFLAGS;
-        case WSAEAFNOSUPPORT:       return EAI_FAMILY;
-        case WSA_NOT_ENOUGH_MEMORY: return EAI_MEMORY;
-        case WSAHOST_NOT_FOUND:     return EAI_NONAME;
-        case WSATYPE_NOT_FOUND:     return EAI_SERVICE;
-        case WSAESOCKTNOSUPPORT:    return EAI_SOCKTYPE;
-        default:                    return EAI_FAIL;     /* Including WSANO_RECOVERY */
-    }
-}
-
-const char *win32_gai_strerror(int errcode) {
-    switch (errcode) {
-        case 0:            errcode = 0;                     break;
-        case EAI_AGAIN:    errcode = WSATRY_AGAIN;          break;
-        case EAI_BADFLAGS: errcode = WSAEINVAL;             break;
-        case EAI_FAMILY:   errcode = WSAEAFNOSUPPORT;       break;
-        case EAI_MEMORY:   errcode = WSA_NOT_ENOUGH_MEMORY; break;
-        case EAI_NONAME:   errcode = WSAHOST_NOT_FOUND;     break;
-        case EAI_SERVICE:  errcode = WSATYPE_NOT_FOUND;     break;
-        case EAI_SOCKTYPE: errcode = WSAESOCKTNOSUPPORT;    break;
-        default:           errcode = WSANO_RECOVERY;        break; /* Including EAI_FAIL */
-    }
-    return gai_strerror(errcode);
-}
-
-void win32_freeaddrinfo(struct addrinfo *res) {
-    freeaddrinfo(res);
-}
-
-SOCKET win32_socket(int domain, int type, int protocol) {
-    SOCKET s;
-
-    /* Note: This function is likely to be called before other functions, so run init here. */
-    if (!_initWinsock()) {
-        return INVALID_SOCKET;
-    }
-
-    _updateErrno((s = socket(domain, type, protocol)) != INVALID_SOCKET);
-    return s;
-}
-
-int win32_ioctl(SOCKET fd, unsigned long request, unsigned long *argp) {
-    int ret = ioctlsocket(fd, (long)request, argp);
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-int win32_bind(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen) {
-    int ret = bind(sockfd, addr, addrlen);
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-int win32_connect(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen) {
-    int ret = connect(sockfd, addr, addrlen);
-    _updateErrno(ret != SOCKET_ERROR);
-
-    /* For Winsock connect(), the WSAEWOULDBLOCK error means the same thing as
-     * EINPROGRESS for POSIX connect(), so we do that translation to keep POSIX
-     * logic consistent. */
-    if (errno == EWOULDBLOCK) {
-        errno = EINPROGRESS;
-    }
-
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-int win32_getsockopt(SOCKET sockfd, int level, int optname, void *optval, socklen_t *optlen) {
-    int ret = 0;
-    if ((level == SOL_SOCKET) && ((optname == SO_RCVTIMEO) || (optname == SO_SNDTIMEO))) {
-        if (*optlen >= sizeof (struct timeval)) {
-            struct timeval *tv = optval;
-            DWORD timeout = 0;
-            socklen_t dwlen = 0;
-            ret = getsockopt(sockfd, level, optname, (char *)&timeout, &dwlen);
-            tv->tv_sec = timeout / 1000;
-            tv->tv_usec = (timeout * 1000) % 1000000;
-        } else {
-            ret = WSAEFAULT;
-        }
-        *optlen = sizeof (struct timeval);
-    } else {
-        ret = getsockopt(sockfd, level, optname, (char*)optval, optlen);
-    }
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-int win32_setsockopt(SOCKET sockfd, int level, int optname, const void *optval, socklen_t optlen) {
-    int ret = 0;
-    if ((level == SOL_SOCKET) && ((optname == SO_RCVTIMEO) || (optname == SO_SNDTIMEO))) {
-        struct timeval *tv = optval;
-        DWORD timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;
-        ret = setsockopt(sockfd, level, optname, (const char*)&timeout, sizeof(DWORD));
-    } else {
-        ret = setsockopt(sockfd, level, optname, (const char*)optval, optlen);
-    }
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-int win32_close(SOCKET fd) {
-    int ret = closesocket(fd);
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-ssize_t win32_recv(SOCKET sockfd, void *buf, size_t len, int flags) {
-    int ret = recv(sockfd, (char*)buf, (int)len, flags);
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-ssize_t win32_send(SOCKET sockfd, const void *buf, size_t len, int flags) {
-    int ret = send(sockfd, (const char*)buf, (int)len, flags);
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-
-int win32_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
-    int ret = WSAPoll(fds, nfds, timeout);
-    _updateErrno(ret != SOCKET_ERROR);
-    return ret != SOCKET_ERROR ? ret : -1;
-}
-#endif /* _WIN32 */
@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 2019, Marcus Geelnard <m at bitsnbites dot eu>
- *
- * 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 __SOCKCOMPAT_H
-#define __SOCKCOMPAT_H
-
-#ifndef _WIN32
-/* For POSIX systems we use the standard BSD socket API. */
-#include <unistd.h>
-#include <sys/socket.h>
-#include <sys/select.h>
-#include <sys/un.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <poll.h>
-#else
-/* For Windows we use winsock. */
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0600 /* To get WSAPoll etc. */
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#include <stddef.h>
-
-#ifdef _MSC_VER
-typedef signed long ssize_t;
-#endif
-
-/* Emulate the parts of the BSD socket API that we need (override the winsock signatures). */
-int win32_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
-const char *win32_gai_strerror(int errcode);
-void win32_freeaddrinfo(struct addrinfo *res);
-SOCKET win32_socket(int domain, int type, int protocol);
-int win32_ioctl(SOCKET fd, unsigned long request, unsigned long *argp);
-int win32_bind(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen);
-int win32_connect(SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen);
-int win32_getsockopt(SOCKET sockfd, int level, int optname, void *optval, socklen_t *optlen);
-int win32_setsockopt(SOCKET sockfd, int level, int optname, const void *optval, socklen_t optlen);
-int win32_close(SOCKET fd);
-ssize_t win32_recv(SOCKET sockfd, void *buf, size_t len, int flags);
-ssize_t win32_send(SOCKET sockfd, const void *buf, size_t len, int flags);
-typedef ULONG nfds_t;
-int win32_poll(struct pollfd *fds, nfds_t nfds, int timeout);
-
-#ifndef REDIS_SOCKCOMPAT_IMPLEMENTATION
-#define getaddrinfo(node, service, hints, res) win32_getaddrinfo(node, service, hints, res)
-#undef gai_strerror
-#define gai_strerror(errcode) win32_gai_strerror(errcode)
-#define freeaddrinfo(res) win32_freeaddrinfo(res)
-#define socket(domain, type, protocol) win32_socket(domain, type, protocol)
-#define ioctl(fd, request, argp) win32_ioctl(fd, request, argp)
-#define bind(sockfd, addr, addrlen) win32_bind(sockfd, addr, addrlen)
-#define connect(sockfd, addr, addrlen) win32_connect(sockfd, addr, addrlen)
-#define getsockopt(sockfd, level, optname, optval, optlen) win32_getsockopt(sockfd, level, optname, optval, optlen)
-#define setsockopt(sockfd, level, optname, optval, optlen) win32_setsockopt(sockfd, level, optname, optval, optlen)
-#define close(fd) win32_close(fd)
-#define recv(sockfd, buf, len, flags) win32_recv(sockfd, buf, len, flags)
-#define send(sockfd, buf, len, flags) win32_send(sockfd, buf, len, flags)
-#define poll(fds, nfds, timeout) win32_poll(fds, nfds, timeout)
-#endif /* REDIS_SOCKCOMPAT_IMPLEMENTATION */
-#endif /* _WIN32 */
-
-#endif /* __SOCKCOMPAT_H */
@@ -1,448 +0,0 @@
-/*
- * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
- * Copyright (c) 2019, Redis Labs
- *
- * 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 "hiredis.h"
-#include "async.h"
-
-#include <assert.h>
-#include <pthread.h>
-#include <errno.h>
-#include <string.h>
-
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-
-#include "async_private.h"
-
-void __redisSetError(redisContext *c, int type, const char *str);
-
-/* The SSL context is attached to SSL/TLS connections as a privdata. */
-typedef struct redisSSLContext {
-    /**
-     * OpenSSL SSL_CTX; It is optional and will not be set when using
-     * user-supplied SSL.
-     */
-    SSL_CTX *ssl_ctx;
-
-    /**
-     * OpenSSL SSL object.
-     */
-    SSL *ssl;
-
-    /**
-     * SSL_write() requires to be called again with the same arguments it was
-     * previously called with in the event of an SSL_read/SSL_write situation
-     */
-    size_t lastLen;
-
-    /** Whether the SSL layer requires read (possibly before a write) */
-    int wantRead;
-
-    /**
-     * Whether a write was requested prior to a read. If set, the write()
-     * should resume whenever a read takes place, if possible
-     */
-    int pendingWrite;
-} redisSSLContext;
-
-/* Forward declaration */
-redisContextFuncs redisContextSSLFuncs;
-
-#ifdef HIREDIS_SSL_TRACE
-/**
- * Callback used for debugging
- */
-static void sslLogCallback(const SSL *ssl, int where, int ret) {
-    const char *retstr = "";
-    int should_log = 1;
-    /* Ignore low-level SSL stuff */
-
-    if (where & SSL_CB_ALERT) {
-        should_log = 1;
-    }
-    if (where == SSL_CB_HANDSHAKE_START || where == SSL_CB_HANDSHAKE_DONE) {
-        should_log = 1;
-    }
-    if ((where & SSL_CB_EXIT) && ret == 0) {
-        should_log = 1;
-    }
-
-    if (!should_log) {
-        return;
-    }
-
-    retstr = SSL_alert_type_string(ret);
-    printf("ST(0x%x). %s. R(0x%x)%s\n", where, SSL_state_string_long(ssl), ret, retstr);
-
-    if (where == SSL_CB_HANDSHAKE_DONE) {
-        printf("Using SSL version %s. Cipher=%s\n", SSL_get_version(ssl), SSL_get_cipher_name(ssl));
-    }
-}
-#endif
-
-/**
- * OpenSSL global initialization and locking handling callbacks.
- * Note that this is only required for OpenSSL < 1.1.0.
- */
-
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
-#define HIREDIS_USE_CRYPTO_LOCKS
-#endif
-
-#ifdef HIREDIS_USE_CRYPTO_LOCKS
-typedef pthread_mutex_t sslLockType;
-static void sslLockInit(sslLockType *l) {
-    pthread_mutex_init(l, NULL);
-}
-static void sslLockAcquire(sslLockType *l) {
-    pthread_mutex_lock(l);
-}
-static void sslLockRelease(sslLockType *l) {
-    pthread_mutex_unlock(l);
-}
-static pthread_mutex_t *ossl_locks;
-
-static void opensslDoLock(int mode, int lkid, const char *f, int line) {
-    sslLockType *l = ossl_locks + lkid;
-
-    if (mode & CRYPTO_LOCK) {
-        sslLockAcquire(l);
-    } else {
-        sslLockRelease(l);
-    }
-
-    (void)f;
-    (void)line;
-}
-
-static void initOpensslLocks(void) {
-    unsigned ii, nlocks;
-    if (CRYPTO_get_locking_callback() != NULL) {
-        /* Someone already set the callback before us. Don't destroy it! */
-        return;
-    }
-    nlocks = CRYPTO_num_locks();
-    ossl_locks = malloc(sizeof(*ossl_locks) * nlocks);
-    for (ii = 0; ii < nlocks; ii++) {
-        sslLockInit(ossl_locks + ii);
-    }
-    CRYPTO_set_locking_callback(opensslDoLock);
-}
-#endif /* HIREDIS_USE_CRYPTO_LOCKS */
-
-/**
- * SSL Connection initialization.
- */
-
-static int redisSSLConnect(redisContext *c, SSL_CTX *ssl_ctx, SSL *ssl) {
-    if (c->privdata) {
-        __redisSetError(c, REDIS_ERR_OTHER, "redisContext was already associated");
-        return REDIS_ERR;
-    }
-    c->privdata = calloc(1, sizeof(redisSSLContext));
-
-    c->funcs = &redisContextSSLFuncs;
-    redisSSLContext *rssl = c->privdata;
-
-    rssl->ssl_ctx = ssl_ctx;
-    rssl->ssl = ssl;
-
-    SSL_set_mode(rssl->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
-    SSL_set_fd(rssl->ssl, c->fd);
-    SSL_set_connect_state(rssl->ssl);
-
-    ERR_clear_error();
-    int rv = SSL_connect(rssl->ssl);
-    if (rv == 1) {
-        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)) {
-        return REDIS_OK;
-    }
-
-    if (c->err == 0) {
-        char err[512];
-        if (rv == SSL_ERROR_SYSCALL)
-            snprintf(err,sizeof(err)-1,"SSL_connect failed: %s",strerror(errno));
-        else {
-            unsigned long e = ERR_peek_last_error();
-            snprintf(err,sizeof(err)-1,"SSL_connect failed: %s",
-                    ERR_reason_error_string(e));
-        }
-        __redisSetError(c, REDIS_ERR_IO, err);
-    }
-    return REDIS_ERR;
-}
-
-int redisInitiateSSL(redisContext *c, SSL *ssl) {
-    return redisSSLConnect(c, NULL, ssl);
-}
-
-int redisSecureConnection(redisContext *c, const char *capath,
-                          const char *certpath, const char *keypath, const char *servername) {
-
-    SSL_CTX *ssl_ctx = NULL;
-    SSL *ssl = NULL;
-
-    /* Initialize global OpenSSL stuff */
-    static int isInit = 0;
-    if (!isInit) {
-        isInit = 1;
-        SSL_library_init();
-#ifdef HIREDIS_USE_CRYPTO_LOCKS
-        initOpensslLocks();
-#endif
-    }
-
-    ssl_ctx = SSL_CTX_new(SSLv23_client_method());
-    if (!ssl_ctx) {
-        __redisSetError(c, REDIS_ERR_OTHER, "Failed to create SSL_CTX");
-        goto error;
-    }
-
-#ifdef HIREDIS_SSL_TRACE
-    SSL_CTX_set_info_callback(ssl_ctx, sslLogCallback);
-#endif
-    SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
-    SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER, NULL);
-    if ((certpath != NULL && keypath == NULL) || (keypath != NULL && certpath == NULL)) {
-        __redisSetError(c, REDIS_ERR_OTHER, "certpath and keypath must be specified together");
-        goto error;
-    }
-
-    if (capath) {
-        if (!SSL_CTX_load_verify_locations(ssl_ctx, capath, NULL)) {
-            __redisSetError(c, REDIS_ERR_OTHER, "Invalid CA certificate");
-            goto error;
-        }
-    }
-    if (certpath) {
-        if (!SSL_CTX_use_certificate_chain_file(ssl_ctx, certpath)) {
-            __redisSetError(c, REDIS_ERR_OTHER, "Invalid client certificate");
-            goto error;
-        }
-        if (!SSL_CTX_use_PrivateKey_file(ssl_ctx, keypath, SSL_FILETYPE_PEM)) {
-            __redisSetError(c, REDIS_ERR_OTHER, "Invalid client key");
-            goto error;
-        }
-    }
-
-    ssl = SSL_new(ssl_ctx);
-    if (!ssl) {
-        __redisSetError(c, REDIS_ERR_OTHER, "Couldn't create new SSL instance");
-        goto error;
-    }
-    if (servername) {
-        if (!SSL_set_tlsext_host_name(ssl, servername)) {
-            __redisSetError(c, REDIS_ERR_OTHER, "Couldn't set server name indication");
-            goto error;
-        }
-    }
-
-    return redisSSLConnect(c, ssl_ctx, ssl);
-
-error:
-    if (ssl) SSL_free(ssl);
-    if (ssl_ctx) SSL_CTX_free(ssl_ctx);
-    return REDIS_ERR;
-}
-
-static int maybeCheckWant(redisSSLContext *rssl, int rv) {
-    /**
-     * If the error is WANT_READ or WANT_WRITE, the appropriate flags are set
-     * and true is returned. False is returned otherwise
-     */
-    if (rv == SSL_ERROR_WANT_READ) {
-        rssl->wantRead = 1;
-        return 1;
-    } else if (rv == SSL_ERROR_WANT_WRITE) {
-        rssl->pendingWrite = 1;
-        return 1;
-    } else {
-        return 0;
-    }
-}
-
-/**
- * Implementation of redisContextFuncs for SSL connections.
- */
-
-static void redisSSLFreeContext(void *privdata){
-    redisSSLContext *rsc = privdata;
-
-    if (!rsc) return;
-    if (rsc->ssl) {
-        SSL_free(rsc->ssl);
-        rsc->ssl = NULL;
-    }
-    if (rsc->ssl_ctx) {
-        SSL_CTX_free(rsc->ssl_ctx);
-        rsc->ssl_ctx = NULL;
-    }
-    free(rsc);
-}
-
-static int redisSSLRead(redisContext *c, char *buf, size_t bufcap) {
-    redisSSLContext *rssl = c->privdata;
-
-    int nread = SSL_read(rssl->ssl, buf, bufcap);
-    if (nread > 0) {
-        return nread;
-    } else if (nread == 0) {
-        __redisSetError(c, REDIS_ERR_EOF, "Server closed the connection");
-        return -1;
-    } else {
-        int err = SSL_get_error(rssl->ssl, nread);
-        if (c->flags & REDIS_BLOCK) {
-            /**
-             * In blocking mode, we should never end up in a situation where
-             * we get an error without it being an actual error, except
-             * in the case of EINTR, which can be spuriously received from
-             * debuggers or whatever.
-             */
-            if (errno == EINTR) {
-                return 0;
-            } else {
-                const char *msg = NULL;
-                if (errno == EAGAIN) {
-                    msg = "Resource temporarily unavailable";
-                }
-                __redisSetError(c, REDIS_ERR_IO, msg);
-                return -1;
-            }
-        }
-
-        /**
-         * We can very well get an EWOULDBLOCK/EAGAIN, however
-         */
-        if (maybeCheckWant(rssl, err)) {
-            return 0;
-        } else {
-            __redisSetError(c, REDIS_ERR_IO, NULL);
-            return -1;
-        }
-    }
-}
-
-static int redisSSLWrite(redisContext *c) {
-    redisSSLContext *rssl = c->privdata;
-
-    size_t len = rssl->lastLen ? rssl->lastLen : sdslen(c->obuf);
-    int rv = SSL_write(rssl->ssl, c->obuf, len);
-
-    if (rv > 0) {
-        rssl->lastLen = 0;
-    } else if (rv < 0) {
-        rssl->lastLen = len;
-
-        int err = SSL_get_error(rssl->ssl, rv);
-        if ((c->flags & REDIS_BLOCK) == 0 && maybeCheckWant(rssl, err)) {
-            return 0;
-        } else {
-            __redisSetError(c, REDIS_ERR_IO, NULL);
-            return -1;
-        }
-    }
-    return rv;
-}
-
-static void redisSSLAsyncRead(redisAsyncContext *ac) {
-    int rv;
-    redisSSLContext *rssl = ac->c.privdata;
-    redisContext *c = &ac->c;
-
-    rssl->wantRead = 0;
-
-    if (rssl->pendingWrite) {
-        int done;
-
-        /* This is probably just a write event */
-        rssl->pendingWrite = 0;
-        rv = redisBufferWrite(c, &done);
-        if (rv == REDIS_ERR) {
-            __redisAsyncDisconnect(ac);
-            return;
-        } else if (!done) {
-            _EL_ADD_WRITE(ac);
-        }
-    }
-
-    rv = redisBufferRead(c);
-    if (rv == REDIS_ERR) {
-        __redisAsyncDisconnect(ac);
-    } else {
-        _EL_ADD_READ(ac);
-        redisProcessCallbacks(ac);
-    }
-}
-
-static void redisSSLAsyncWrite(redisAsyncContext *ac) {
-    int rv, done = 0;
-    redisSSLContext *rssl = ac->c.privdata;
-    redisContext *c = &ac->c;
-
-    rssl->pendingWrite = 0;
-    rv = redisBufferWrite(c, &done);
-    if (rv == REDIS_ERR) {
-        __redisAsyncDisconnect(ac);
-        return;
-    }
-
-    if (!done) {
-        if (rssl->wantRead) {
-            /* Need to read-before-write */
-            rssl->pendingWrite = 1;
-            _EL_DEL_WRITE(ac);
-        } else {
-            /* No extra reads needed, just need to write more */
-            _EL_ADD_WRITE(ac);
-        }
-    } else {
-        /* Already done! */
-        _EL_DEL_WRITE(ac);
-    }
-
-    /* Always reschedule a read */
-    _EL_ADD_READ(ac);
-}
-
-redisContextFuncs redisContextSSLFuncs = {
-    .free_privdata = redisSSLFreeContext,
-    .async_read = redisSSLAsyncRead,
-    .async_write = redisSSLAsyncWrite,
-    .read = redisSSLRead,
-    .write = redisSSLWrite
-};
-
@@ -13,16 +13,12 @@
 #include <limits.h>

 #include "hiredis.h"
-#ifdef HIREDIS_TEST_SSL
-#include "hiredis_ssl.h"
-#endif
 #include "net.h"

 enum connection_type {
    CONN_TCP,
    CONN_UNIX,
-    CONN_FD,
-    CONN_SSL
+    CONN_FD
 };

 struct config {
@@ -37,14 +33,6 @@ struct config {
    struct {
        const char *path;
    } unix_sock;
-
-    struct {
-        const char *host;
-        int port;
-        const char *ca_cert;
-        const char *cert;
-        const char *key;
-    } ssl;
 };

 /* The following lines make up our testing "framework" :) */
@@ -105,27 +93,11 @@ static int disconnect(redisContext *c, int keep_fd) {
    return -1;
 }

-static void do_ssl_handshake(redisContext *c, struct config config) {
-#ifdef HIREDIS_TEST_SSL
-    redisSecureConnection(c, config.ssl.ca_cert, config.ssl.cert, config.ssl.key, NULL);
-    if (c->err) {
-        printf("SSL error: %s\n", c->errstr);
-        redisFree(c);
-        exit(1);
-    }
-#else
-    (void) c;
-    (void) config;
-#endif
-}
-
 static redisContext *do_connect(struct config config) {
    redisContext *c = NULL;

    if (config.type == CONN_TCP) {
        c = redisConnect(config.tcp.host, config.tcp.port);
-    } else if (config.type == CONN_SSL) {
-        c = redisConnect(config.ssl.host, config.ssl.port);
    } else if (config.type == CONN_UNIX) {
        c = redisConnectUnix(config.unix_sock.path);
    } else if (config.type == CONN_FD) {
@@ -149,21 +121,9 @@ static redisContext *do_connect(struct config config) {
        exit(1);
    }

-    if (config.type == CONN_SSL) {
-        do_ssl_handshake(c, config);
-    }
-
    return select_database(c);
 }

-static void do_reconnect(redisContext *c, struct config config) {
-    redisReconnect(c);
-
-    if (config.type == CONN_SSL) {
-        do_ssl_handshake(c, config);
-    }
-}
-
 static void test_format_commands(void) {
    char *cmd;
    int len;
@@ -400,8 +360,7 @@ static void test_reply_reader(void) {
    freeReplyObject(reply);
    redisReaderFree(reader);

-#if LLONG_MAX > SIZE_MAX
-    test("Set error when array > SIZE_MAX: ");
+    test("Set error when array > INT_MAX: ");
    reader = redisReaderCreate();
    redisReaderFeed(reader, "*9223372036854775807\r\n+asdf\r\n",29);
    ret = redisReaderGetReply(reader,&reply);
@@ -410,6 +369,7 @@ static void test_reply_reader(void) {
    freeReplyObject(reply);
    redisReaderFree(reader);

+#if LLONG_MAX > SIZE_MAX
    test("Set error when bulk > SIZE_MAX: ");
    reader = redisReaderCreate();
    redisReaderFeed(reader, "$9223372036854775807\r\nasdf\r\n",28);
@@ -474,23 +434,22 @@ static void test_free_null(void) {
    test_cond(reply == NULL);
 }

-#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;
+    const char *bad_domain = "idontexist.com";

-    int rv = getaddrinfo(HIREDIS_BAD_DOMAIN, "6379", &hints, &ai_tmp);
+    int rv = getaddrinfo(bad_domain, "6379", &hints, &ai_tmp);
    if (rv != 0) {
        // Address does *not* exist
        test("Returns error when host cannot be resolved: ");
        // First see if this domain name *actually* resolves to NXDOMAIN
-        c = redisConnect(HIREDIS_BAD_DOMAIN, 6379);
+        c = redisConnect("dontexist.com", 6379);
        test_cond(
            c->err == REDIS_ERR_OTHER &&
            (strcmp(c->errstr, "Name or service not known") == 0 ||
-             strcmp(c->errstr, "Can't resolve: " HIREDIS_BAD_DOMAIN) == 0 ||
-             strcmp(c->errstr, "Name does not resolve") == 0 ||
+             strcmp(c->errstr, "Can't resolve: sadkfjaskfjsa.com") == 0 ||
             strcmp(c->errstr,
                    "nodename nor servname provided, or not known") == 0 ||
             strcmp(c->errstr, "No address associated with hostname") == 0 ||
@@ -615,8 +574,7 @@ static void test_blocking_connection_timeouts(struct config config) {

    c = do_connect(config);
    test("Does not return a reply when the command times out: ");
-    redisAppendFormattedCommand(c, cmd, strlen(cmd));
-    s = c->funcs->write(c);
+    s = write(c->fd, cmd, strlen(cmd));
    tv.tv_sec = 0;
    tv.tv_usec = 10000;
    redisSetTimeout(c, tv);
@@ -625,7 +583,7 @@ static void test_blocking_connection_timeouts(struct config config) {
    freeReplyObject(reply);

    test("Reconnect properly reconnects after a timeout: ");
-    do_reconnect(c, config);
+    redisReconnect(c);
    reply = redisCommand(c, "PING");
    test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && strcmp(reply->str, "PONG") == 0);
    freeReplyObject(reply);
@@ -633,7 +591,7 @@ static void test_blocking_connection_timeouts(struct config config) {
    test("Reconnect properly uses owned parameters: ");
    config.tcp.host = "foo";
    config.unix_sock.path = "foo";
-    do_reconnect(c, config);
+    redisReconnect(c);
    reply = redisCommand(c, "PING");
    test_cond(reply != NULL && reply->type == REDIS_REPLY_STATUS && strcmp(reply->str, "PONG") == 0);
    freeReplyObject(reply);
@@ -936,23 +894,6 @@ int main(int argc, char **argv) {
            throughput = 0;
        } else if (argc >= 1 && !strcmp(argv[0],"--skip-inherit-fd")) {
            test_inherit_fd = 0;
-#ifdef HIREDIS_TEST_SSL
-        } else if (argc >= 2 && !strcmp(argv[0],"--ssl-port")) {
-            argv++; argc--;
-            cfg.ssl.port = atoi(argv[0]);
-        } else if (argc >= 2 && !strcmp(argv[0],"--ssl-host")) {
-            argv++; argc--;
-            cfg.ssl.host = argv[0];
-        } else if (argc >= 2 && !strcmp(argv[0],"--ssl-ca-cert")) {
-            argv++; argc--;
-            cfg.ssl.ca_cert  = argv[0];
-        } else if (argc >= 2 && !strcmp(argv[0],"--ssl-cert")) {
-            argv++; argc--;
-            cfg.ssl.cert = argv[0];
-        } else if (argc >= 2 && !strcmp(argv[0],"--ssl-key")) {
-            argv++; argc--;
-            cfg.ssl.key = argv[0];
-#endif
        } else {
            fprintf(stderr, "Invalid argument: %s\n", argv[0]);
            exit(1);
@@ -981,20 +922,6 @@ int main(int argc, char **argv) {
    test_blocking_io_errors(cfg);
    if (throughput) test_throughput(cfg);

-#ifdef HIREDIS_TEST_SSL
-    if (cfg.ssl.port && cfg.ssl.host) {
-        printf("\nTesting against SSL connection (%s:%d):\n", cfg.ssl.host, cfg.ssl.port);
-        cfg.type = CONN_SSL;
-
-        test_blocking_connection(cfg);
-        test_blocking_connection_timeouts(cfg);
-        test_blocking_io_errors(cfg);
-        test_invalid_timeout_errors(cfg);
-        test_append_formatted_commands(cfg);
-        if (throughput) test_throughput(cfg);
-    }
-#endif
-
    if (test_inherit_fd) {
        printf("\nTesting against inherited fd (%s):\n", cfg.unix_sock.path);
        cfg.type = CONN_FD;
@@ -1,70 +0,0 @@
-#!/bin/sh -ue
-
-REDIS_SERVER=${REDIS_SERVER:-redis-server}
-REDIS_PORT=${REDIS_PORT:-56379}
-REDIS_SSL_PORT=${REDIS_SSL_PORT:-56443}
-TEST_SSL=${TEST_SSL:-0}
-SSL_TEST_ARGS=
-
-tmpdir=$(mktemp -d)
-PID_FILE=${tmpdir}/hiredis-test-redis.pid
-SOCK_FILE=${tmpdir}/hiredis-test-redis.sock
-
-if [ "$TEST_SSL" = "1" ]; then
-    SSL_CA_CERT=${tmpdir}/ca.crt
-    SSL_CA_KEY=${tmpdir}/ca.key
-    SSL_CERT=${tmpdir}/redis.crt
-    SSL_KEY=${tmpdir}/redis.key
-
-    openssl genrsa -out ${tmpdir}/ca.key 4096
-    openssl req \
-        -x509 -new -nodes -sha256 \
-        -key ${SSL_CA_KEY} \
-        -days 3650 \
-        -subj '/CN=Hiredis Test CA' \
-        -out ${SSL_CA_CERT}
-    openssl genrsa -out ${SSL_KEY} 2048
-    openssl req \
-        -new -sha256 \
-        -key ${SSL_KEY} \
-        -subj '/CN=Hiredis Test Cert' | \
-        openssl x509 \
-            -req -sha256 \
-            -CA ${SSL_CA_CERT} \
-            -CAkey ${SSL_CA_KEY} \
-            -CAserial ${tmpdir}/ca.txt \
-            -CAcreateserial \
-            -days 365 \
-            -out ${SSL_CERT}
-
-    SSL_TEST_ARGS="--ssl-host 127.0.0.1 --ssl-port ${REDIS_SSL_PORT} --ssl-ca-cert ${SSL_CA_CERT} --ssl-cert ${SSL_CERT} --ssl-key ${SSL_KEY}"
-fi
-
-cleanup() {
-  set +e
-  kill $(cat ${PID_FILE})
-  rm -rf ${tmpdir}
-}
-trap cleanup INT TERM EXIT
-
-cat > ${tmpdir}/redis.conf <<EOF
-daemonize yes
-pidfile ${PID_FILE}
-port ${REDIS_PORT}
-bind 127.0.0.1
-unixsocket ${SOCK_FILE}
-EOF
-
-if [ "$TEST_SSL" = "1" ]; then
-    cat >> ${tmpdir}/redis.conf <<EOF
-tls-port ${REDIS_SSL_PORT}
-tls-ca-cert-file ${SSL_CA_CERT}
-tls-cert-file ${SSL_CERT}
-tls-key-file ${SSL_KEY}
-EOF
-fi
-
-cat ${tmpdir}/redis.conf
-${REDIS_SERVER} ${tmpdir}/redis.conf
-
-${TEST_PREFIX:-} ./hiredis-test -h 127.0.0.1 -p ${REDIS_PORT} -s ${SOCK_FILE} ${SSL_TEST_ARGS}
@@ -2,20 +2,10 @@
 #define _WIN32_HELPER_INCLUDE
 #ifdef _MSC_VER

-#include <winsock2.h> /* for struct timeval */
-
 #ifndef inline
 #define inline __inline
 #endif

-#ifndef strcasecmp
-#define strcasecmp stricmp
-#endif
-
-#ifndef strncasecmp
-#define strncasecmp strnicmp
-#endif
-
 #ifndef va_copy
 #define va_copy(d,s) ((d) = (s))
 #endif
@@ -47,10 +37,6 @@ __inline int c99_snprintf(char* str, size_t size, const char* format, ...)
    return count;
 }
 #endif
-#endif /* _MSC_VER */

-#ifdef _WIN32
-#define strerror_r(errno,buf,len) strerror_s(buf,len,errno)
-#endif /* _WIN32 */
-
-#endif /* _WIN32_HELPER_INCLUDE */
+#endif
+#endif
@@ -787,13 +787,7 @@ background_thread_stats_read(tsdn_t *tsdn, background_thread_stats_t *stats) {
 	nstime_init(&stats->run_interval, 0);
 	for (unsigned i = 0; i < max_background_threads; i++) {
 		background_thread_info_t *info = &background_thread_info[i];
-		if (malloc_mutex_trylock(tsdn, &info->mtx)) {
-			/*
-			 * Each background thread run may take a long time;
-			 * avoid waiting on the stats if the thread is active.
-			 */
-			continue;
-		}
+		malloc_mutex_lock(tsdn, &info->mtx);
 		if (info->state != background_thread_stopped) {
 			num_runs += info->tot_n_runs;
 			nstime_add(&stats->run_interval, &info->tot_sleep_time);
@@ -21,7 +21,7 @@ So what usually happens is either:
 
 The result is a pollution of binaries without line editing support.

-So I spent more or less two hours doing a reality check resulting in this little library: is it *really* needed for a line editing library to be 20k lines of code? Apparently not, it is possibe to get a very small, zero configuration, trivial to embed library, that solves the problem. Smaller programs will just include this, supporting line editing out of the box. Larger programs may use this little library or just checking with configure if readline/libedit is available and resorting to Linenoise if not.
+So I spent more or less two hours doing a reality check resulting in this little library: is it *really* needed for a line editing library to be 20k lines of code? Apparently not, it is possibe to get a very small, zero configuration, trivial to embed library, that solves the problem. Smaller programs will just include this, supporing line editing out of the box. Larger programs may use this little library or just checking with configure if readline/libedit is available and resorting to Linenoise if not.

 ## Terminals, in 2010.

@@ -126,24 +126,6 @@ Linenoise has direct support for persisting the history into an history
 file. The functions `linenoiseHistorySave` and `linenoiseHistoryLoad` do
 just that. Both functions return -1 on error and 0 on success.

-## Mask mode
-
-Sometimes it is useful to allow the user to type passwords or other
-secrets that should not be displayed. For such situations linenoise supports
-a "mask mode" that will just replace the characters the user is typing 
-with `*` characters, like in the following example:
-
-    $ ./linenoise_example
-    hello> get mykey
-    echo: 'get mykey'
-    hello> /mask
-    hello> *********
-
-You can enable and disable mask mode using the following two functions:
-
-    void linenoiseMaskModeEnable(void);
-    void linenoiseMaskModeDisable(void);
-
 ## Completion

 Linenoise supports completion, which is the ability to complete the user
@@ -240,8 +222,3 @@ Sometimes you may want to clear the screen as a result of something the
 user typed. You can do this by calling the following function:

    void linenoiseClearScreen(void);
-
-## Related projects
-
-* [Linenoise NG](https://github.com/arangodb/linenoise-ng) is a fork of Linenoise that aims to add more advanced features like UTF-8 support, Windows support and other features. Uses C++ instead of C as development language.
-* [Linenoise-swift](https://github.com/andybest/linenoise-swift) is a reimplementation of Linenoise written in Swift.
@@ -55,7 +55,6 @@ int main(int argc, char **argv) {
     *
     * The typed string is returned as a malloc() allocated string by
     * linenoise, so the user needs to free() it. */
-    
    while((line = linenoise("hello> ")) != NULL) {
        /* Do something with the string. */
        if (line[0] != '\0' && line[0] != '/') {
@@ -66,10 +65,6 @@ int main(int argc, char **argv) {
            /* The "/historylen" command will change the history len. */
            int len = atoi(line+11);
            linenoiseHistorySetMaxLen(len);
-        } else if (!strncmp(line, "/mask", 5)) {
-            linenoiseMaskModeEnable();
-        } else if (!strncmp(line, "/unmask", 7)) {
-            linenoiseMaskModeDisable();
        } else if (line[0] == '/') {
            printf("Unreconized command: %s\n", line);
        }
@@ -125,7 +125,6 @@ static linenoiseHintsCallback *hintsCallback = NULL;
 static linenoiseFreeHintsCallback *freeHintsCallback = NULL;

 static struct termios orig_termios; /* In order to restore at exit.*/
-static int maskmode = 0; /* Show "***" instead of input. For passwords. */
 static int rawmode = 0; /* For atexit() function to check if restore is needed*/
 static int mlmode = 0;  /* Multi line mode. Default is single line. */
 static int atexit_registered = 0; /* Register atexit just 1 time. */
@@ -198,19 +197,6 @@ FILE *lndebug_fp = NULL;

 /* ======================= Low level terminal handling ====================== */

-/* Enable "mask mode". When it is enabled, instead of the input that
- * the user is typing, the terminal will just display a corresponding
- * number of asterisks, like "****". This is useful for passwords and other
- * secrets that should not be displayed. */
-void linenoiseMaskModeEnable(void) {
-    maskmode = 1;
-}
-
-/* Disable mask mode. */
-void linenoiseMaskModeDisable(void) {
-    maskmode = 0;
-}
-
 /* Set if to use or not the multi line mode. */
 void linenoiseSetMultiLine(int ml) {
    mlmode = ml;
@@ -499,8 +485,6 @@ void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) {
            if (bold == 1 && color == -1) color = 37;
            if (color != -1 || bold != 0)
                snprintf(seq,64,"\033[%d;%d;49m",bold,color);
-            else
-                seq[0] = '\0';
            abAppend(ab,seq,strlen(seq));
            abAppend(ab,hint,hintlen);
            if (color != -1 || bold != 0)
@@ -539,11 +523,7 @@ static void refreshSingleLine(struct linenoiseState *l) {
    abAppend(&ab,seq,strlen(seq));
    /* Write the prompt and the current buffer content */
    abAppend(&ab,l->prompt,strlen(l->prompt));
-    if (maskmode == 1) {
-        while (len--) abAppend(&ab,"*",1);
-    } else {
-        abAppend(&ab,buf,len);
-    }
+    abAppend(&ab,buf,len);
    /* Show hits if any. */
    refreshShowHints(&ab,l,plen);
    /* Erase to right */
@@ -597,12 +577,7 @@ static void refreshMultiLine(struct linenoiseState *l) {

    /* Write the prompt and the current buffer content */
    abAppend(&ab,l->prompt,strlen(l->prompt));
-    if (maskmode == 1) {
-        unsigned int i;
-        for (i = 0; i < l->len; i++) abAppend(&ab,"*",1);
-    } else {
-        abAppend(&ab,l->buf,l->len);
-    }
+    abAppend(&ab,l->buf,l->len);

    /* Show hits if any. */
    refreshShowHints(&ab,l,plen);
@@ -670,8 +645,7 @@ int linenoiseEditInsert(struct linenoiseState *l, char c) {
            if ((!mlmode && l->plen+l->len < l->cols && !hintsCallback)) {
                /* Avoid a full update of the line in the
                 * trivial case. */
-                char d = (maskmode==1) ? '*' : c;
-                if (write(l->ofd,&d,1) == -1) return -1;
+                if (write(l->ofd,&c,1) == -1) return -1;
            } else {
                refreshLine(l);
            }
@@ -65,8 +65,6 @@ int linenoiseHistoryLoad(const char *filename);
 void linenoiseClearScreen(void);
 void linenoiseSetMultiLine(int ml);
 void linenoisePrintKeyCodes(void);
-void linenoiseMaskModeEnable(void);
-void linenoiseMaskModeDisable(void);

 #ifdef __cplusplus
 }
@@ -89,14 +89,12 @@ typedef struct Header {
 } Header;


-static int getnum (lua_State *L, const char **fmt, int df) {
+static int getnum (const char **fmt, int df) {
  if (!isdigit(**fmt))  /* no number? */
    return df;  /* return default value */
  else {
    int a = 0;
    do {
-      if (a > (INT_MAX / 10) || a * 10 > (INT_MAX - (**fmt - '0')))
-        luaL_error(L, "integral size overflow");
      a = a*10 + *((*fmt)++) - '0';
    } while (isdigit(**fmt));
    return a;
@@ -117,9 +115,9 @@ static size_t optsize (lua_State *L, char opt, const char **fmt) {
    case 'f':  return sizeof(float);
    case 'd':  return sizeof(double);
    case 'x': return 1;
-    case 'c': return getnum(L, fmt, 1);
+    case 'c': return getnum(fmt, 1);
    case 'i': case 'I': {
-      int sz = getnum(L, fmt, sizeof(int));
+      int sz = getnum(fmt, sizeof(int));
      if (sz > MAXINTSIZE)
        luaL_error(L, "integral size %d is larger than limit of %d",
                       sz, MAXINTSIZE);
@@ -152,7 +150,7 @@ static void controloptions (lua_State *L, int opt, const char **fmt,
    case '>': h->endian = BIG; return;
    case '<': h->endian = LITTLE; return;
    case '!': {
-      int a = getnum(L, fmt, MAXALIGN);
+      int a = getnum(fmt, MAXALIGN);
      if (!isp2(a))
        luaL_error(L, "alignment %d is not a power of 2", a);
      h->align = a;
@@ -13,16 +13,4 @@ then
 fi

 make -C tests/modules && \
-$TCLSH tests/test_helper.tcl \
--single unit/moduleapi/commandfilter \
--single unit/moduleapi/fork \
--single unit/moduleapi/testrdb \
--single unit/moduleapi/infotest \
--single unit/moduleapi/propagate \
--single unit/moduleapi/hooks \
--single unit/moduleapi/misc \
--single unit/moduleapi/blockonkeys \
--single unit/moduleapi/scan \
--single unit/moduleapi/datatype \
--single unit/moduleapi/auth \
-"${@}"
+$TCLSH tests/test_helper.tcl --single unit/moduleapi/commandfilter "${@}"
@@ -102,18 +102,6 @@ sentinel monitor mymaster 127.0.0.1 6379 2
 #
 # sentinel auth-pass mymaster MySUPER--secret-0123passw0rd

-# sentinel auth-user <master-name> <username>
-#
-# This is useful in order to authenticate to instances having ACL capabilities,
-# that is, running Redis 6.0 or greater. When just auth-pass is provided the
-# Sentinel instance will authenticate to Redis using the old "AUTH <pass>"
-# method. When also an username is provided, it will use "AUTH <user> <pass>".
-# In the Redis servers side, the ACL to provide just minimal access to
-# Sentinel instances, should be configured along the following lines:
-#
-#     user sentinel-user >somepassword +client +subscribe +publish \
-#                        +ping +info +multi +slaveof +config +client +exec on
-
 # sentinel down-after-milliseconds <master-name> <milliseconds>
 #
 # Number of milliseconds the master (or any attached replica or sentinel) should
@@ -124,14 +112,6 @@ sentinel monitor mymaster 127.0.0.1 6379 2
 # Default is 30 seconds.
 sentinel down-after-milliseconds mymaster 30000

-# requirepass <password>
-#
-# You can configure Sentinel itself to require a password, however when doing
-# so Sentinel will try to authenticate with the same password to all the
-# other Sentinels. So you need to configure all your Sentinels in a given
-# group with the same "requirepass" password. Check the following documentation
-# for more info: https://redis.io/topics/sentinel
-
 # sentinel parallel-syncs <master-name> <numreplicas>
 #
 # How many replicas we can reconfigure to point to the new replica simultaneously
@@ -0,0 +1,14 @@
+#pragma once
+#include <functional>
+
+class IStorage
+{
+public:
+    typedef std::function<void(const char *, size_t, const void *, size_t)> callback;
+
+    virtual void insert(const char *key, size_t cchKey, void *data, size_t cb) = 0;
+    virtual void erase(const char *key, size_t cchKey) = 0;
+    virtual void retrieve(const char *key, size_t cchKey, bool fDelete, callback fn) = 0;
+    virtual size_t clear() = 0;
+    virtual void enumerate(callback fn) = 0;
+};
@@ -33,7 +33,6 @@ OPT=$(OPTIMIZATION)
 PREFIX?=/usr/local
 INSTALL_BIN=$(PREFIX)/bin
 INSTALL=install
-PKG_CONFIG?=pkg-config

 # Default allocator defaults to Jemalloc if it's not an ARM
 MALLOC=libc
@@ -48,6 +47,8 @@ endif
 USEASM?=true

 ifneq ($(SANITIZE),)
+	CC=clang
+	CXX=clang++
 	CFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
 	CXXFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
 	LDFLAGS+= -fsanitize=$(SANITIZE)
@@ -75,18 +76,12 @@ endif
 # To get ARM stack traces if Redis crashes we need a special C flag.
 ifneq (,$(filter aarch64 armv,$(uname_M)))
        CFLAGS+=-funwind-tables
-	CXXFLAGS+=-funwind-tables
 else
 ifneq (,$(findstring armv,$(uname_M)))
        CFLAGS+=-funwind-tables
-	CXXFLAGS+=-funwind-tables
 endif
 endif

-ifneq (,$(findstring armv,$(uname_M)))
-	FINAL_LIBS+=-latomic
-endif	
-
 # Backwards compatibility for selecting an allocator
 ifeq ($(USE_TCMALLOC),yes)
 	MALLOC=tcmalloc
@@ -108,40 +103,27 @@ endif
 -include .make-settings

 FINAL_CFLAGS=$(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(REDIS_CFLAGS)
-FINAL_CXXFLAGS=$(CXX_STD) $(WARN) $(OPT) $(DEBUG) $(CXXFLAGS) $(REDIS_CFLAGS)
+FINAL_CXXFLAGS=$(CXX_STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(CXXFLAGS) $(REDIS_CFLAGS)
 FINAL_LDFLAGS=$(LDFLAGS) $(REDIS_LDFLAGS) $(DEBUG)
-FINAL_LIBS+=-lm -lcurl
+FINAL_LIBS=-lm
 DEBUG=-g -ggdb

-# Linux ARM needs -latomic at linking time
-ifneq (,$(filter aarch64 armv,$(uname_M)))
-        FINAL_LIBS+=-latomic
-else
-ifneq (,$(findstring armv,$(uname_M)))
-        FINAL_LIBS+=-latomic
-endif
-endif
-
 ifeq ($(uname_S),SunOS)
 	# SunOS
        ifneq ($(@@),32bit)
 		CFLAGS+= -m64
-		CXXFLAGS+= -m64
 		LDFLAGS+= -m64
 	endif
 	DEBUG=-g
 	DEBUG_FLAGS=-g
-	export CFLAGS CXXFLAGS LDFLAGS DEBUG DEBUG_FLAGS
+	export CFLAGS LDFLAGS DEBUG DEBUG_FLAGS
 	INSTALL=cp -pf
 	FINAL_CFLAGS+= -D__EXTENSIONS__ -D_XPG6
-	FINAL_CXXFLAGS+= -D__EXTENSIONS__ -D_XPG6
 	FINAL_LIBS+= -ldl -lnsl -lsocket -lresolv -lpthread -lrt
 else
 ifeq ($(uname_S),Darwin)
 	# Darwin
 	FINAL_LIBS+= -ldl
-	OPENSSL_CFLAGS=-I/usr/local/opt/openssl/include
-	OPENSSL_LDFLAGS=-L/usr/local/opt/openssl/lib
 else
 ifeq ($(uname_S),AIX)
        # AIX
@@ -153,7 +135,6 @@ ifeq ($(uname_S),OpenBSD)
 	FINAL_LIBS+= -lpthread
 	ifeq ($(USE_BACKTRACE),yes)
 	    FINAL_CFLAGS+= -DUSE_BACKTRACE -I/usr/local/include
-	    FINAL_CXXFLAGS+= -DUSE_BACKTRACE -I/usr/local/include
 	    FINAL_LDFLAGS+= -L/usr/local/lib
 	    FINAL_LIBS+= -lexecinfo
    	endif
@@ -171,7 +152,6 @@ else
 	FINAL_LDFLAGS+= -rdynamic
 	FINAL_LIBS+=-ldl -pthread -lrt -luuid
 	FINAL_CFLAGS += -DMOTD
-	FINAL_CXXFLAGS += -DMOTD
 endif
 endif
 endif
@@ -182,30 +162,6 @@ endif
 FINAL_CFLAGS+= -I../deps/hiredis -I../deps/linenoise -I../deps/lua/src
 FINAL_CXXFLAGS+= -I../deps/hiredis -I../deps/linenoise -I../deps/lua/src 

-# Determine systemd support and/or build preference (defaulting to auto-detection)
-BUILD_WITH_SYSTEMD=no
-# If 'USE_SYSTEMD' in the environment is neither "no" nor "yes", try to
-# auto-detect libsystemd's presence and link accordingly.
-ifneq ($(USE_SYSTEMD),no)
-	LIBSYSTEMD_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libsystemd && echo $$?)
-# If libsystemd cannot be detected, continue building without support for it
-# (unless a later check tells us otherwise)
-ifeq ($(LIBSYSTEMD_PKGCONFIG),0)
-	BUILD_WITH_SYSTEMD=yes
-endif
-endif
-ifeq ($(USE_SYSTEMD),yes)
-ifneq ($(LIBSYSTEMD_PKGCONFIG),0)
-$(error USE_SYSTEMD is set to "$(USE_SYSTEMD)", but $(PKG_CONFIG) cannot find libsystemd)
-endif
-# Force building with libsystemd
-	BUILD_WITH_SYSTEMD=yes
-endif
-ifeq ($(BUILD_WITH_SYSTEMD),yes)
-	FINAL_LIBS+=$(shell $(PKG_CONFIG) --libs libsystemd)
-	FINAL_CFLAGS+= -DHAVE_LIBSYSTEMD
-endif
-
 ifeq ($(MALLOC),tcmalloc)
 	FINAL_CFLAGS+= -DUSE_TCMALLOC
 	FINAL_CXXFLAGS+= -DUSE_TCMALLOC
@@ -232,15 +188,9 @@ ifeq ($(MALLOC),memkind)
 	FINAL_LIBS := ../deps/memkind/src/.libs/libmemkind.a -lnuma $(FINAL_LIBS)
 endif

-ifeq ($(BUILD_TLS),yes)
-    FINAL_CFLAGS+=-DUSE_OPENSSL $(OPENSSL_CFLAGS)
-    FINAL_LDFLAGS+=$(OPENSSL_LDFLAGS)
-    FINAL_LIBS += ../deps/hiredis/libhiredis_ssl.a -lssl -lcrypto
-endif
-
 REDIS_CC=$(QUIET_CC)$(CC) $(FINAL_CFLAGS)
-REDIS_CXX=$(QUIET_CC)$(CXX) $(FINAL_CXXFLAGS)
-KEYDB_AS=$(QUIET_CC) as --64 -g
+REDIS_CXX=$(QUIET_CC)$(CC) $(FINAL_CXXFLAGS)
+REDIS_NASM=$(QUIET_CC)nasm -felf64 
 REDIS_LD=$(QUIET_LINK)$(CXX) $(FINAL_LDFLAGS)
 REDIS_INSTALL=$(QUIET_INSTALL)$(INSTALL)

@@ -252,16 +202,16 @@ MAKECOLOR="\033[32;1m"
 ENDCOLOR="\033[0m"

 ifndef V
-QUIET_CC = @printf '    %b %b\n' $(CCCOLOR)CC$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR);
-QUIET_LINK = @printf '    %b %b\n' $(LINKCOLOR)LINK$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR);
-QUIET_INSTALL = @printf '    %b %b\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR);
+QUIET_CC = @printf '    %b %b\n' $(CCCOLOR)CC$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR) 1>&2;
+QUIET_LINK = @printf '    %b %b\n' $(LINKCOLOR)LINK$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;
+QUIET_INSTALL = @printf '    %b %b\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;
 endif

 REDIS_SERVER_NAME=keydb-server
 REDIS_SENTINEL_NAME=keydb-sentinel
-REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o acl.o storage.o rdb-s3.o fastlock.o new.o tracking.o cron.o connection.o tls.o sha256.o motd.o timeout.o $(ASM_OBJ)
+REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o acl.o storage.o rdb-s3.o fastlock.o new.o tracking.o $(ASM_OBJ)
 REDIS_CLI_NAME=keydb-cli
-REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o redis-cli-cpphelper.o zmalloc.o release.o anet.o ae.o crc64.o siphash.o crc16.o storage-lite.o fastlock.o new.o motd.o $(ASM_OBJ)
+REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o redis-cli-cpphelper.o zmalloc.o release.o anet.o ae.o crc64.o siphash.o crc16.o storage-lite.o fastlock.o new.o $(ASM_OBJ)
 REDIS_BENCHMARK_NAME=keydb-benchmark
 REDIS_BENCHMARK_OBJ=ae.o anet.o redis-benchmark.o adlist.o dict.o zmalloc.o siphash.o redis-benchmark.o storage-lite.o fastlock.o new.o $(ASM_OBJ)
 REDIS_CHECK_RDB_NAME=keydb-check-rdb
@@ -287,13 +237,10 @@ persist-settings: distclean
 	echo OPT=$(OPT) >> .make-settings
 	echo MALLOC=$(MALLOC) >> .make-settings
 	echo CFLAGS=$(CFLAGS) >> .make-settings
-	echo CXXFLAGS=$(CXXFLAGS) >> .make-settings
 	echo LDFLAGS=$(LDFLAGS) >> .make-settings
 	echo REDIS_CFLAGS=$(REDIS_CFLAGS) >> .make-settings
-	echo REDIS_CXXFLAGS=$(REDIS_CXXFLAGS) >> .make-settings
 	echo REDIS_LDFLAGS=$(REDIS_LDFLAGS) >> .make-settings
 	echo PREV_FINAL_CFLAGS=$(FINAL_CFLAGS) >> .make-settings
-	echo PREV_FINAL_CXXFLAGS=$(FINAL_CXXFLAGS) >> .make-settings
 	echo PREV_FINAL_LDFLAGS=$(FINAL_LDFLAGS) >> .make-settings
 	-(cd modules && $(MAKE))
 	-(cd ../deps && $(MAKE) $(DEPENDENCY_TARGETS))
@@ -304,8 +251,6 @@ persist-settings: distclean
 # Clean everything, persist settings and build dependencies if anything changed
 ifneq ($(strip $(PREV_FINAL_CFLAGS)), $(strip $(FINAL_CFLAGS)))
 .make-prerequisites: persist-settings
-else ifneq ($(strip $(PREV_FINAL_CXXFLAGS)), $(strip $(FINAL_CXXFLAGS)))
-.make-prerequisites: persist-settings
 else ifneq ($(strip $(PREV_FINAL_LDFLAGS)), $(strip $(FINAL_LDFLAGS)))
 .make-prerequisites: persist-settings
 else
@@ -331,7 +276,7 @@ $(REDIS_CHECK_AOF_NAME): $(REDIS_SERVER_NAME)

 # keydb-cli
 $(REDIS_CLI_NAME): $(REDIS_CLI_OBJ)
-	$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o $(FINAL_LIBS)
+	$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o $(FINAL_LIBS) -lcurl

 # keydb-benchmark
 $(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)
@@ -340,24 +285,20 @@ $(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)
 dict-benchmark: dict.cpp zmalloc.cpp sds.c siphash.c
 	$(REDIS_CC) $(FINAL_CFLAGS) $^ -D DICT_BENCHMARK_MAIN -o $@ $(FINAL_LIBS)

-DEP = $(REDIS_SERVER_OBJ:%.o=%.d) $(REDIS_CLI_OBJ:%.o=%.d) $(REDIS_BENCHMARK_OBJ:%.o=%.d)
-include $(DEP)
-
 # Because the jemalloc.h header is generated as a part of the jemalloc build,
 # building it should complete before building any other object. Instead of
 # depending on a single artifact, build all dependencies first.
 %.o: %.c .make-prerequisites
-	$(REDIS_CC) -MMD -o $@ -c $<
+	$(REDIS_CC) -c $<

 %.o: %.cpp .make-prerequisites
-	$(REDIS_CXX) -MMD -o $@ -c $<
+	$(REDIS_CXX) -c $<

 %.o: %.asm .make-prerequisites
-	$(KEYDB_AS) $< -o $@
+	$(REDIS_NASM) $<

 clean:
 	rm -rf $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) $(REDIS_CHECK_RDB_NAME) $(REDIS_CHECK_AOF_NAME) *.o *.gcda *.gcno *.gcov redis.info lcov-html Makefile.dep dict-benchmark
-	rm -f $(DEP)

 .PHONY: clean

@@ -395,7 +336,7 @@ bench: $(REDIS_BENCHMARK_NAME)
 	@echo ""
 	@echo "WARNING: if it fails under Linux you probably need to install libc6-dev-i386"
 	@echo ""
-	$(MAKE) CXXFLAGS="-m32" CFLAGS="-m32" LDFLAGS="-m32"
+	$(MAKE) CFLAGS="-m32" LDFLAGS="-m32"

 gcov:
 	$(MAKE) REDIS_CFLAGS="-fprofile-arcs -ftest-coverage -DCOVERAGE_TEST" REDIS_LDFLAGS="-fprofile-arcs -ftest-coverage"
@@ -28,9 +28,6 @@
 */

 #include "server.h"
-extern "C" {
-#include "sha256.h"
-}
 #include <fcntl.h>

 /* =============================================================================
@@ -51,8 +48,6 @@ list *UsersToLoad;  /* This is a list of users found in the configuration file
                       array of SDS pointers: the first is the user name,
                       all the remaining pointers are ACL rules in the same
                       format as ACLSetUser(). */
-list *ACLLog;       /* Our security log, the user is able to inspect that
-                       using the ACL LOG command .*/

 struct ACLCategoryItem {
    const char *name;
@@ -97,10 +92,6 @@ struct ACLUserFlag {
 void ACLResetSubcommandsForCommand(user *u, unsigned long id);
 void ACLResetSubcommands(user *u);
 void ACLAddAllowedSubcommand(user *u, unsigned long id, const char *sub);
-void ACLFreeLogEntry(struct ACLLogEntry *le);
-
-/* The length of the string representation of a hashed password. */
-#define HASH_PASSWORD_LEN SHA256_BLOCK_SIZE*2

 /* =============================================================================
 * Helper functions for the rest of the ACL implementation
@@ -148,25 +139,6 @@ int time_independent_strcmp(char *a, char *b) {
    return diff; /* If zero strings are the same. */
 }

-/* Given an SDS string, returns the SHA256 hex representation as a
- * new SDS string. */
-sds ACLHashPassword(unsigned char *cleartext, size_t len) {
-    SHA256_CTX ctx;
-    unsigned char hash[SHA256_BLOCK_SIZE];
-    char hex[HASH_PASSWORD_LEN];
-    const char *cset = "0123456789abcdef";
-
-    sha256_init(&ctx);
-    sha256_update(&ctx,(unsigned char*)cleartext,len);
-    sha256_final(&ctx,hash);
-
-    for (int j = 0; j < SHA256_BLOCK_SIZE; j++) {
-        hex[j*2] = cset[((hash[j]&0xF0)>>4)];
-        hex[j*2+1] = cset[(hash[j]&0xF)];
-    }
-    return sdsnewlen(hex,HASH_PASSWORD_LEN);
-}
-
 /* =============================================================================
 * Low level ACL API
 * ==========================================================================*/
@@ -188,12 +160,12 @@ int ACLListMatchSds(void *a, void *b) {
    return sdscmp((sds)a,(sds)b) == 0;
 }

-/* Method to free list elements from ACL users password/patterns lists. */
+/* Method to free list elements from ACL users password/ptterns lists. */
 void ACLListFreeSds(const void *item) {
    sdsfree((sds)item);
 }

-/* Method to duplicate list elements from ACL users password/patterns lists. */
+/* Method to duplicate list elements from ACL users password/ptterns lists. */
 void *ACLListDupSds(void *item) {
    return sdsdup((sds)item);
 }
@@ -530,7 +502,7 @@ sds ACLDescribeUser(user *u) {
    listRewind(u->passwords,&li);
    while((ln = listNext(&li))) {
        sds thispass = (sds)listNodeValue(ln);
-        res = sdscatlen(res,"#",1);
+        res = sdscatlen(res,">",1);
        res = sdscatsds(res,thispass);
        res = sdscatlen(res," ",1);
    }
@@ -657,14 +629,7 @@ void ACLAddAllowedSubcommand(user *u, unsigned long id, const char *sub) {
 * ><password>  Add this password to the list of valid password for the user.
 *              For example >mypass will add "mypass" to the list.
 *              This directive clears the "nopass" flag (see later).
- * #<hash>      Add this password hash to the list of valid hashes for
- *              the user. This is useful if you have previously computed
- *              the hash, and don't want to store it in plaintext.
- *              This directive clears the "nopass" flag (see later).
 * <<password>  Remove this password from the list of valid passwords.
- * !<hash>      Remove this hashed password from the list of valid passwords.
- *              This is useful when you want to remove a password just by
- *              hash without knowing its plaintext version at all.
 * nopass       All the set passwords of the user are removed, and the user
 *              is flagged as requiring no password: it means that every
 *              password will work against this user. If this directive is
@@ -700,7 +665,6 @@ void ACLAddAllowedSubcommand(user *u, unsigned long id, const char *sub) {
 * EEXIST: You are adding a key pattern after "*" was already added. This is
 *         almost surely an error on the user side.
 * ENODEV: The password you are trying to remove from the user does not exist.
- * EBADMSG: The hash you are trying to add is not a valid hash. 
 */
 int ACLSetUser(user *u, const char *op, ssize_t oplen) {
    if (oplen == -1) oplen = strlen(op);
@@ -736,48 +700,14 @@ int ACLSetUser(user *u, const char *op, ssize_t oplen) {
    } else if (!strcasecmp(op,"resetpass")) {
        u->flags &= ~USER_FLAG_NOPASS;
        listEmpty(u->passwords);
-    } else if (op[0] == '>' || op[0] == '#') {
-        sds newpass;
-        if (op[0] == '>') {
-            newpass = ACLHashPassword((unsigned char*)op+1,oplen-1);
-        } else {
-            if (oplen != HASH_PASSWORD_LEN + 1) {
-                errno = EBADMSG;
-                return C_ERR;
-            }
-
-            /* Password hashes can only be characters that represent
-             * hexadecimal values, which are numbers and lowercase
-             * characters 'a' through 'f'.
-             */
-            for(int i = 1; i < HASH_PASSWORD_LEN + 1; i++) {
-                char c = op[i];
-                if ((c < 'a' || c > 'f') && (c < '0' || c > '9')) {
-                    errno = EBADMSG;
-                    return C_ERR;
-                }
-            }
-            newpass = sdsnewlen(op+1,oplen-1);
-        }
-
+    } else if (op[0] == '>') {
+        sds newpass = sdsnewlen(op+1,oplen-1);
        listNode *ln = listSearchKey(u->passwords,newpass);
        /* Avoid re-adding the same password multiple times. */
-        if (ln == NULL)
-            listAddNodeTail(u->passwords,newpass);
-        else
-            sdsfree(newpass);
+        if (ln == NULL) listAddNodeTail(u->passwords,newpass);
        u->flags &= ~USER_FLAG_NOPASS;
-    } else if (op[0] == '<' || op[0] == '!') {
-        sds delpass;
-        if (op[0] == '<') {
-            delpass = ACLHashPassword((unsigned char*)op+1,oplen-1);
-        } else {
-            if (oplen != HASH_PASSWORD_LEN + 1) {
-                errno = EBADMSG;
-                return C_ERR;
-            }
-            delpass = sdsnewlen(op+1,oplen-1);
-        }
+    } else if (op[0] == '<') {
+        sds delpass = sdsnewlen(op+1,oplen-1);
        listNode *ln = listSearchKey(u->passwords,delpass);
        sdsfree(delpass);
        if (ln) {
@@ -794,10 +724,7 @@ int ACLSetUser(user *u, const char *op, ssize_t oplen) {
        sds newpat = sdsnewlen(op+1,oplen-1);
        listNode *ln = listSearchKey(u->patterns,newpat);
        /* Avoid re-adding the same pattern multiple times. */
-        if (ln == NULL)
-            listAddNodeTail(u->patterns,newpat);
-        else
-            sdsfree(newpat);
+        if (ln == NULL) listAddNodeTail(u->patterns,newpat);
        u->flags &= ~USER_FLAG_ALLKEYS;
    } else if (op[0] == '+' && op[1] != '@') {
        if (strchr(op,'|') == NULL) {
@@ -895,12 +822,19 @@ const char *ACLSetUserStringError(void) {
    else if (errno == ENODEV)
        errmsg = "The password you are trying to remove from the user does "
                 "not exist";
-    else if (errno == EBADMSG)
-        errmsg = "The password hash must be exactly 64 characters and contain "
-                 "only lowercase hexadecimal characters";
    return errmsg;
 }

+/* Return the first password of the default user or NULL.
+ * This function is needed for backward compatibility with the old
+ * directive "requirepass" when Redis supported a single global
+ * password. */
+sds ACLDefaultUserFirstPassword(void) {
+    if (listLength(DefaultUser->passwords) == 0) return NULL;
+    listNode *first = listFirst(DefaultUser->passwords);
+    return (sds)listNodeValue(first);
+}
+
 /* Initialize the default user, that will always exist for all the process
 * lifetime. */
 void ACLInitDefaultUser(void) {
@@ -915,9 +849,7 @@ void ACLInitDefaultUser(void) {
 void ACLInit(void) {
    Users = raxNew();
    UsersToLoad = listCreate();
-    ACLLog = listCreate();
    ACLInitDefaultUser();
-    g_pserver->requirepass = NULL; /* Only used for backward compatibility. */
 }

 /* Check the username and password pair and return C_OK if they are valid,
@@ -947,15 +879,11 @@ int ACLCheckUserCredentials(robj *username, robj *password) {
    listIter li;
    listNode *ln;
    listRewind(u->passwords,&li);
-    sds hashed = ACLHashPassword((unsigned char*)szFromObj(password),sdslen(szFromObj(password)));
    while((ln = listNext(&li))) {
        sds thispass = (sds)listNodeValue(ln);
-        if (!time_independent_strcmp(hashed, thispass)) {
-            sdsfree(hashed);
+        if (!time_independent_strcmp(szFromObj(password), thispass))
            return C_OK;
-        }
    }
-    sdsfree(hashed);

    /* If we reached this point, no password matched. */
    errno = EINVAL;
@@ -972,10 +900,8 @@ int ACLAuthenticateUser(client *c, robj *username, robj *password) {
    if (ACLCheckUserCredentials(username,password) == C_OK) {
        c->authenticated = 1;
        c->puser = ACLGetUserByName((sds)ptrFromObj(username),sdslen((sds)ptrFromObj(username)));
-        moduleNotifyUserChanged(c);
        return C_OK;
    } else {
-        addACLLogEntry(c,ACL_DENIED_AUTH,0,szFromObj(username));
        return C_ERR;
    }
 }
@@ -1025,14 +951,14 @@ user *ACLGetUserByName(const char *name, size_t namelen) {

 /* Check if the command is ready to be executed in the client 'c', already
 * referenced by c->cmd, and can be executed by this client according to the
- * ACLs associated to the client user c->puser.
+ * ACLs associated to the client user c->user.
 *
 * If the user can execute the command ACL_OK is returned, otherwise
 * ACL_DENIED_CMD or ACL_DENIED_KEY is returned: the first in case the
 * command cannot be executed because the user is not allowed to run such
 * command, the second if the command is denied because the user is trying
 * to access keys that are not among the specified patterns. */
-int ACLCheckCommandPerm(client *c, int *keyidxptr) {
+int ACLCheckCommandPerm(client *c) {
    user *u = c->puser;
    uint64_t id = c->cmd->id;

@@ -1092,7 +1018,6 @@ int ACLCheckCommandPerm(client *c, int *keyidxptr) {
                }
            }
            if (!match) {
-                if (keyidxptr) *keyidxptr = keyidx[j];
                getKeysFreeResult(keyidx);
                return ACL_DENIED_KEY;
            }
@@ -1198,7 +1123,7 @@ int ACLLoadConfiguredUsers(void) {

 /* This function loads the ACL from the specified filename: every line
 * is validated and should be either empty or in the format used to specify
- * users in the keydb.conf configuration or in the ACL file, that is:
+ * users in the redis.conf configuration or in the ACL file, that is:
 *
 *  user <username> ... rules ...
 *
@@ -1422,17 +1347,17 @@ cleanup:

 /* This function is called once the server is already running, modules are
 * loaded, and we are ready to start, in order to load the ACLs either from
- * the pending list of users defined in keydb.conf, or from the ACL file.
+ * the pending list of users defined in redis.conf, or from the ACL file.
 * The function will just exit with an error if the user is trying to mix
 * both the loading methods. */
 void ACLLoadUsersAtStartup(void) {
    if (g_pserver->acl_filename[0] != '\0' && listLength(UsersToLoad) != 0) {
        serverLog(LL_WARNING,
-            "Configuring KeyDB with users defined in keydb.conf and at "
+            "Configuring Redis with users defined in redis.conf and at "
            "the same setting an ACL file path is invalid. This setup "
            "is very likely to lead to configuration errors and security "
            "holes, please define either an ACL file or declare users "
-            "directly in your keydb.conf, but not both.");
+            "directly in your redis.conf, but not both.");
        exit(1);
    }

@@ -1453,131 +1378,6 @@ void ACLLoadUsersAtStartup(void) {
    }
 }

-/* =============================================================================
- * ACL log
- * ==========================================================================*/
-
-#define ACL_LOG_CTX_TOPLEVEL 0
-#define ACL_LOG_CTX_LUA 1
-#define ACL_LOG_CTX_MULTI 2
-#define ACL_LOG_GROUPING_MAX_TIME_DELTA 60000
-
-/* This structure defines an entry inside the ACL log. */
-typedef struct ACLLogEntry {
-    uint64_t count;     /* Number of times this happened recently. */
-    int reason;         /* Reason for denying the command. ACL_DENIED_*. */
-    int context;        /* Toplevel, Lua or MULTI/EXEC? ACL_LOG_CTX_*. */
-    sds object;         /* The key name or command name. */
-    sds username;       /* User the client is authenticated with. */
-    mstime_t ctime;     /* Milliseconds time of last update to this entry. */
-    sds cinfo;          /* Client info (last client if updated). */
-} ACLLogEntry;
-
-/* This function will check if ACL entries 'a' and 'b' are similar enough
- * that we should actually update the existing entry in our ACL log instead
- * of creating a new one. */
-int ACLLogMatchEntry(ACLLogEntry *a, ACLLogEntry *b) {
-    if (a->reason != b->reason) return 0;
-    if (a->context != b->context) return 0;
-    mstime_t delta = a->ctime - b->ctime;
-    if (delta < 0) delta = -delta;
-    if (delta > ACL_LOG_GROUPING_MAX_TIME_DELTA) return 0;
-    if (sdscmp(a->object,b->object) != 0) return 0;
-    if (sdscmp(a->username,b->username) != 0) return 0;
-    return 1;
-}
-
-/* Release an ACL log entry. */
-void ACLFreeLogEntry(ACLLogEntry *leptr) {
-    ACLLogEntry *le = leptr;
-    sdsfree(le->object);
-    sdsfree(le->username);
-    sdsfree(le->cinfo);
-    zfree(le);
-}
-
-/* Adds a new entry in the ACL log, making sure to delete the old entry
- * if we reach the maximum length allowed for the log. This function attempts
- * to find similar entries in the current log in order to bump the counter of
- * the log entry instead of creating many entries for very similar ACL
- * rules issues.
- *
- * The keypos argument is only used when the reason is ACL_DENIED_KEY, since
- * it allows the function to log the key name that caused the problem.
- * Similarly the username is only passed when we failed to authenticate the
- * user with AUTH or HELLO, for the ACL_DENIED_AUTH reason. Otherwise
- * it will just be NULL.
- */
-void addACLLogEntry(client *c, int reason, int keypos, sds username) {
-    /* Create a new entry. */
-    struct ACLLogEntry *le = (ACLLogEntry*)zmalloc(sizeof(*le));
-    le->count = 1;
-    le->reason = reason;
-    le->username = sdsdup(reason == ACL_DENIED_AUTH ? username : c->puser->name);
-    le->ctime = mstime();
-
-    switch(reason) {
-    case ACL_DENIED_CMD: le->object = sdsnew(c->cmd->name); break;
-    case ACL_DENIED_KEY: le->object = sdsnew(szFromObj(c->argv[keypos])); break;
-    case ACL_DENIED_AUTH: le->object = sdsnew(szFromObj(c->argv[0])); break;
-    default: le->object = sdsempty();
-    }
-
-    client *realclient = c;
-    if (realclient->flags & CLIENT_LUA) realclient = g_pserver->lua_caller;
-
-    le->cinfo = catClientInfoString(sdsempty(),realclient);
-    if (c->flags & CLIENT_MULTI) {
-        le->context = ACL_LOG_CTX_MULTI;
-    } else if (c->flags & CLIENT_LUA) {
-        le->context = ACL_LOG_CTX_LUA;
-    } else {
-        le->context = ACL_LOG_CTX_TOPLEVEL;
-    }
-
-    /* Try to match this entry with past ones, to see if we can just
-     * update an existing entry instead of creating a new one. */
-    long toscan = 10; /* Do a limited work trying to find duplicated. */
-    listIter li;
-    listNode *ln;
-    listRewind(ACLLog,&li);
-    ACLLogEntry *match = NULL;
-    while (toscan-- && (ln = listNext(&li)) != NULL) {
-        ACLLogEntry *current = (ACLLogEntry*)listNodeValue(ln);
-        if (ACLLogMatchEntry(current,le)) {
-            match = current;
-            listDelNode(ACLLog,ln);
-            listAddNodeHead(ACLLog,current);
-            break;
-        }
-    }
-
-    /* If there is a match update the entry, otherwise add it as a
-     * new one. */
-    if (match) {
-        /* We update a few fields of the existing entry and bump the
-         * counter of events for this entry. */
-        sdsfree(match->cinfo);
-        match->cinfo = le->cinfo;
-        match->ctime = le->ctime;
-        match->count++;
-
-        /* Release the old entry. */
-        le->cinfo = NULL;
-        ACLFreeLogEntry(le);
-    } else {
-        /* Add it to our list of entires. We'll have to trim the list
-         * to its maximum size. */
-        listAddNodeHead(ACLLog, le);
-        while(listLength(ACLLog) > g_pserver->acllog_max_len) {
-            listNode *ln = listLast(ACLLog);
-            ACLLogEntry *le = (ACLLogEntry*)listNodeValue(ln);
-            ACLFreeLogEntry(le);
-            listDelNode(ACLLog,ln);
-        }
-    }
-}
-
 /* =============================================================================
 * ACL related commands
 * ==========================================================================*/
@@ -1585,7 +1385,6 @@ void addACLLogEntry(client *c, int reason, int keypos, sds username) {
 /* ACL -- show and modify the configuration of ACL users.
 * ACL HELP
 * ACL LOAD
- * ACL SAVE
 * ACL LIST
 * ACL USERS
 * ACL CAT [<category>]
@@ -1594,7 +1393,6 @@ void addACLLogEntry(client *c, int reason, int keypos, sds username) {
 * ACL GETUSER <username>
 * ACL GENPASS
 * ACL WHOAMI
- * ACL LOG [<count> | RESET]
 */
 void aclCommand(client *c) {
    char *sub = szFromObj(c->argv[1]);
@@ -1781,76 +1579,9 @@ void aclCommand(client *c) {
        char pass[32]; /* 128 bits of actual pseudo random data. */
        getRandomHexChars(pass,sizeof(pass));
        addReplyBulkCBuffer(c,pass,sizeof(pass));
-    } else if (!strcasecmp(sub,"log") && (c->argc == 2 || c->argc ==3)) {
-        long count = 10; /* Number of entries to emit by default. */
-
-        /* Parse the only argument that LOG may have: it could be either
-         * the number of entires the user wants to display, or alternatively
-         * the "RESET" command in order to flush the old entires. */
-        if (c->argc == 3) {
-            if (!strcasecmp(szFromObj(c->argv[2]),"reset")) {
-                listSetFreeMethod(ACLLog,(void(*)(const void*))ACLFreeLogEntry);
-                listEmpty(ACLLog);
-                listSetFreeMethod(ACLLog,NULL);
-                addReply(c,shared.ok);
-                return;
-            } else if (getLongFromObjectOrReply(c,c->argv[2],&count,NULL)
-                       != C_OK)
-            {
-                return;
-            }
-            if (count < 0) count = 0;
-        }
-
-        /* Fix the count according to the number of entries we got. */
-        if ((size_t)count > listLength(ACLLog))
-            count = listLength(ACLLog);
-
-        addReplyArrayLen(c,count);
-        listIter li;
-        listNode *ln;
-        listRewind(ACLLog,&li);
-        mstime_t now = mstime();
-        while (count-- && (ln = listNext(&li)) != NULL) {
-            ACLLogEntry *le = (ACLLogEntry*)listNodeValue(ln);
-            addReplyMapLen(c,7);
-            addReplyBulkCString(c,"count");
-            addReplyLongLong(c,le->count);
-
-            addReplyBulkCString(c,"reason");
-            const char *reasonstr = "INVALID_REASON";
-            switch(le->reason) {
-            case ACL_DENIED_CMD: reasonstr="command"; break;
-            case ACL_DENIED_KEY: reasonstr="key"; break;
-            case ACL_DENIED_AUTH: reasonstr="auth"; break;
-            default: reasonstr="unknown";
-            }
-            addReplyBulkCString(c,reasonstr);
-
-            addReplyBulkCString(c,"context");
-            const char *ctxstr;
-            switch(le->context) {
-            case ACL_LOG_CTX_TOPLEVEL: ctxstr="toplevel"; break;
-            case ACL_LOG_CTX_MULTI: ctxstr="multi"; break;
-            case ACL_LOG_CTX_LUA: ctxstr="lua"; break;
-            default: ctxstr="unknown";
-            }
-            addReplyBulkCString(c,ctxstr);
-
-            addReplyBulkCString(c,"object");
-            addReplyBulkCBuffer(c,le->object,sdslen(le->object));
-            addReplyBulkCString(c,"username");
-            addReplyBulkCBuffer(c,le->username,sdslen(le->username));
-            addReplyBulkCString(c,"age-seconds");
-            double age = (double)(now - le->ctime)/1000;
-            addReplyDouble(c,age);
-            addReplyBulkCString(c,"client-info");
-            addReplyBulkCBuffer(c,le->cinfo,sdslen(le->cinfo));
-        }
    } else if (!strcasecmp(sub,"help")) {
        const char *help[] = {
 "LOAD                              -- Reload users from the ACL file.",
-"SAVE                              -- Save the current config to the ACL file."
 "LIST                              -- Show user details in config file format.",
 "USERS                             -- List all the registered usernames.",
 "SETUSER <username> [attribs ...]  -- Create or modify a user.",
@@ -1860,7 +1591,6 @@ void aclCommand(client *c) {
 "CAT <category>                    -- List commands inside category.",
 "GENPASS                           -- Generate a secure user password.",
 "WHOAMI                            -- Return the current connection username.",
-"LOG [<count> | RESET]             -- Show the ACL log entries.",
 NULL
        };
        addReplyHelp(c,help);
@@ -70,7 +70,7 @@ typedef struct list {
 #define listSetMatchMethod(l,m) ((l)->match = (m))

 #define listGetDupMethod(l) ((l)->dup)
-#define listGetFreeMethod(l) ((l)->free)
+#define listGetFree(l) ((l)->free)
 #define listGetMatchMethod(l) ((l)->match)

 /* Prototypes */
@@ -80,11 +80,11 @@ public:
 mutex_wrapper g_lock;

 #else
-fastlock g_lock("AE (global)");
+fastlock g_lock;
 #endif
 thread_local aeEventLoop *g_eventLoopThisThread = NULL;

-#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSERT FAILURE %s: %d\n", __FILE__, __LINE__); *((volatile int*)1) = 1; } while(0)
+#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSER FAILURE\n"); *((volatile int*)0) = 1; } while(0)

 /* Include the best multiplexing layer supported by this system.
 * The following should be ordered by performances, descending. */
@@ -237,11 +237,11 @@ int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
    cmd.clientData = clientData;
    cmd.pctl = nullptr;
    if (fSynchronous)
-    {
        cmd.pctl = new (MALLOC_LOCAL) aeCommandControl();
-        cmd.pctl->mutexcv.lock();
-    }

+    std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
+    if (fSynchronous)
+        cmd.pctl->mutexcv.lock();
    auto size = safe_write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
    if (size != sizeof(cmd))
    {
@@ -252,7 +252,6 @@ int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
    
    if (fSynchronous)
    {
-        std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
        cmd.pctl->cv.wait(ulock);
        ret = cmd.pctl->rval;
        delete cmd.pctl;
@@ -273,8 +272,7 @@ int aePostFunction(aeEventLoop *eventLoop, aePostFunctionProc *proc, void *arg)
    cmd.proc = proc;
    cmd.clientData = arg;
    auto size = write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
-    if (size != sizeof(cmd))
-        return AE_ERR;
+    AE_ASSERT(size == sizeof(cmd));
    return AE_OK;
 }

@@ -291,19 +289,15 @@ int aePostFunction(aeEventLoop *eventLoop, std::function<void()> fn, bool fSynch
    cmd.pfn = new (MALLOC_LOCAL) std::function<void()>(fn);
    cmd.pctl = nullptr;
    if (fSynchronous)
-    {
        cmd.pctl = new (MALLOC_LOCAL) aeCommandControl();
+    std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
+    if (fSynchronous)
        cmd.pctl->mutexcv.lock();
-    }
-
    auto size = write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
-    if (size != sizeof(cmd))
-        return AE_ERR;
    AE_ASSERT(size == sizeof(cmd));
    int ret = AE_OK;
    if (fSynchronous)
    {
-        std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
        cmd.pctl->cv.wait(ulock);
        ret = cmd.pctl->rval;
        delete cmd.pctl;
@@ -327,14 +321,13 @@ aeEventLoop *aeCreateEventLoop(int setsize) {
    eventLoop->maxfd = -1;
    eventLoop->beforesleep = NULL;
    eventLoop->aftersleep = NULL;
-    eventLoop->flags = 0;
    if (aeApiCreate(eventLoop) == -1) goto err;
    /* Events with mask == AE_NONE are not set. So let's initialize the
     * vector with it. */
    for (i = 0; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;

-    fastlock_init(&eventLoop->flock, "event loop");
+    fastlock_init(&eventLoop->flock);
    int rgfd[2];
    if (pipe(rgfd) < 0)
        goto err;
@@ -361,14 +354,6 @@ int aeGetSetSize(aeEventLoop *eventLoop) {
    return eventLoop->setsize;
 }

-/* Tells the next iteration/s of the event processing to set timeout of 0. */
-void aeSetDontWait(aeEventLoop *eventLoop, int noWait) {
-    if (noWait)
-        eventLoop->flags |= AE_DONT_WAIT;
-    else
-        eventLoop->flags &= ~AE_DONT_WAIT;
-}
-
 /* Resize the maximum set size of the event loop.
 * If the requested set size is smaller than the current set size, but
 * there is already a file descriptor in use that is >= the requested
@@ -399,19 +384,10 @@ extern "C" void aeDeleteEventLoop(aeEventLoop *eventLoop) {
    aeApiFree(eventLoop);
    zfree(eventLoop->events);
    zfree(eventLoop->fired);
+    zfree(eventLoop);
    fastlock_free(&eventLoop->flock);
    close(eventLoop->fdCmdRead);
    close(eventLoop->fdCmdWrite);
-
-    /* Free the time events list. */
-    auto *te = eventLoop->timeEventHead;
-    while (te)
-    {
-        auto *teNext = te->next;
-        zfree(te);
-        te = teNext;
-    }
-    zfree(eventLoop);
 }

 extern "C" void aeStop(aeEventLoop *eventLoop) {
@@ -681,7 +657,6 @@ extern "C" void ProcessEventCore(aeEventLoop *eventLoop, aeFileEvent *fe, int ma
        LOCK_IF_NECESSARY(fe, AE_READ_THREADSAFE);
        fe->rfileProc(eventLoop,fd,fe->clientData,mask | (fe->mask & AE_READ_THREADSAFE));
        fired++;
-        fe = &eventLoop->events[fd]; /* Refresh in case of resize. */
    }

    /* Fire the writable event. */
@@ -772,11 +747,6 @@ int aeProcessEvents(aeEventLoop *eventLoop, int flags)
            }
        }

-        if (eventLoop->flags & AE_DONT_WAIT) {
-            tv.tv_sec = tv.tv_usec = 0;
-            tvp = &tv;
-        }
-
        /* Call the multiplexing API, will return only on timeout or when
         * some event fires. */
        numevents = aeApiPoll(eventLoop, tvp);
@@ -124,7 +124,6 @@ typedef struct aeEventLoop {
    int fdCmdWrite;
    int fdCmdRead;
    int cevents;
-    int flags;
 } aeEventLoop;

 /* Prototypes */
@@ -158,7 +157,6 @@ void aeSetBeforeSleepProc(aeEventLoop *eventLoop, aeBeforeSleepProc *beforesleep
 void aeSetAfterSleepProc(aeEventLoop *eventLoop, aeBeforeSleepProc *aftersleep, int flags);
 int aeGetSetSize(aeEventLoop *eventLoop);
 int aeResizeSetSize(aeEventLoop *eventLoop, int setsize);
-void aeSetDontWait(aeEventLoop *eventLoop, int noWait);

 void aeAcquireLock();
 int aeTryAcquireLock(int fWeak);
@@ -125,8 +125,8 @@ static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {

            if (e->events & EPOLLIN) mask |= AE_READABLE;
            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
-            if (e->events & EPOLLERR) mask |= AE_WRITABLE|AE_READABLE;
-            if (e->events & EPOLLHUP) mask |= AE_WRITABLE|AE_READABLE;
+            if (e->events & EPOLLERR) mask |= AE_WRITABLE;
+            if (e->events & EPOLLHUP) mask |= AE_WRITABLE;
            eventLoop->fired[j].fd = e->data.fd;
            eventLoop->fired[j].mask = mask;
        }
@@ -11,11 +11,6 @@ public:

    void arm(client *c) // if a client is passed, then the client is already locked
    {
-        if (m_fArmed)
-            return;
-        
-        serverAssertDebug(!GlobalLocksAcquired());
-
        if (c != nullptr)
        {
            serverAssert(!m_fArmed);
@@ -193,20 +193,6 @@ int anetSendTimeout(char *err, int fd, long long ms) {
    return ANET_OK;
 }

-/* Set the socket receive timeout (SO_RCVTIMEO socket option) to the specified
- * number of milliseconds, or disable it if the 'ms' argument is zero. */
-int anetRecvTimeout(char *err, int fd, long long ms) {
-    struct timeval tv;
-
-    tv.tv_sec = ms/1000;
-    tv.tv_usec = (ms%1000)*1000;
-    if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) == -1) {
-        anetSetError(err, "setsockopt SO_RCVTIMEO: %s", strerror(errno));
-        return ANET_ERR;
-    }
-    return ANET_OK;
-}
-
 /* anetGenericResolve() is called by anetResolve() and anetResolveIP() to
 * do the actual work. It resolves the hostname "host" and set the string
 * representation of the IP address into the buffer pointed by "ipbuf".
@@ -290,8 +276,8 @@ static int anetCreateSocket(char *err, int domain) {
 #define ANET_CONNECT_NONBLOCK 1
 #define ANET_CONNECT_BE_BINDING 2 /* Best effort binding. */
 #define ANET_CONNECT_REUSEPORT 4
-static int anetTcpGenericConnect(char *err, const char *addr, int port,
-                                 const char *source_addr, int flags)
+static int anetTcpGenericConnect(char *err, char *addr, int port,
+                                 char *source_addr, int flags)
 {
    int s = ANET_ERR, rv;
    char portstr[6];  /* strlen("65535") + 1; */
@@ -373,31 +359,31 @@ end:
    }
 }

-int anetTcpConnect(char *err, const char *addr, int port)
+int anetTcpConnect(char *err, char *addr, int port)
 {
    return anetTcpGenericConnect(err,addr,port,NULL,ANET_CONNECT_NONE);
 }

-int anetTcpNonBlockConnect(char *err, const char *addr, int port)
+int anetTcpNonBlockConnect(char *err, char *addr, int port)
 {
    return anetTcpGenericConnect(err,addr,port,NULL,ANET_CONNECT_NONBLOCK);
 }

-int anetTcpNonBlockBindConnect(char *err, const char *addr, int port,
-                               const char *source_addr)
+int anetTcpNonBlockBindConnect(char *err, char *addr, int port,
+                               char *source_addr)
 {
    return anetTcpGenericConnect(err,addr,port,source_addr,
            ANET_CONNECT_NONBLOCK);
 }

-int anetTcpNonBlockBestEffortBindConnect(char *err, const char *addr, int port,
-                                         const char *source_addr)
+int anetTcpNonBlockBestEffortBindConnect(char *err, char *addr, int port,
+                                         char *source_addr)
 {
    return anetTcpGenericConnect(err,addr,port,source_addr,
            ANET_CONNECT_NONBLOCK|ANET_CONNECT_BE_BINDING);
 }

-int anetUnixGenericConnect(char *err, const char *path, int flags)
+int anetUnixGenericConnect(char *err, char *path, int flags)
 {
    int s;
    struct sockaddr_un sa;
@@ -425,12 +411,12 @@ int anetUnixGenericConnect(char *err, const char *path, int flags)
    return s;
 }

-int anetUnixConnect(char *err, const char *path)
+int anetUnixConnect(char *err, char *path)
 {
    return anetUnixGenericConnect(err,path,ANET_CONNECT_NONE);
 }

-int anetUnixNonBlockConnect(char *err, const char *path)
+int anetUnixNonBlockConnect(char *err, char *path)
 {
    return anetUnixGenericConnect(err,path,ANET_CONNECT_NONBLOCK);
 }
@@ -53,12 +53,12 @@ extern "C" {
 #undef ip_len
 #endif

-int anetTcpConnect(char *err, const char *addr, int port);
-int anetTcpNonBlockConnect(char *err, const char *addr, int port);
-int anetTcpNonBlockBindConnect(char *err, const char *addr, int port, const char *source_addr);
-int anetTcpNonBlockBestEffortBindConnect(char *err, const char *addr, int port, const char *source_addr);
-int anetUnixConnect(char *err, const char *path);
-int anetUnixNonBlockConnect(char *err, const char *path);
+int anetTcpConnect(char *err, char *addr, int port);
+int anetTcpNonBlockConnect(char *err, char *addr, int port);
+int anetTcpNonBlockBindConnect(char *err, char *addr, int port, char *source_addr);
+int anetTcpNonBlockBestEffortBindConnect(char *err, char *addr, int port, char *source_addr);
+int anetUnixConnect(char *err, char *path);
+int anetUnixNonBlockConnect(char *err, char *path);
 int anetRead(int fd, char *buf, int count);
 int anetResolve(char *err, char *host, char *ipbuf, size_t ipbuf_len);
 int anetResolveIP(char *err, char *host, char *ipbuf, size_t ipbuf_len);
@@ -74,7 +74,6 @@ int anetEnableTcpNoDelay(char *err, int fd);
 int anetDisableTcpNoDelay(char *err, int fd);
 int anetTcpKeepAlive(char *err, int fd);
 int anetSendTimeout(char *err, int fd, long long ms);
-int anetRecvTimeout(char *err, int fd, long long ms);
 int anetPeerToString(int fd, char *ip, size_t ip_len, int *port);
 int anetKeepAlive(char *err, int fd, int interval);
 int anetSockName(int fd, char *ip, size_t ip_len, int *port);
@@ -124,21 +124,6 @@ void aofChildWriteDiffData(aeEventLoop *el, int fd, void *privdata, int mask) {
    }
 }

-void installAofRewriteEvent()
-{
-    serverTL->fRetrySetAofEvent = false;
-    if (!g_pserver->aof_rewrite_pending) {
-        g_pserver->aof_rewrite_pending = true;
-        int res = aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [] {
-            g_pserver->aof_rewrite_pending = false;
-            if (g_pserver->aof_pipe_write_data_to_child >= 0)
-                aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, g_pserver->aof_pipe_write_data_to_child, AE_WRITABLE, aofChildWriteDiffData, NULL);
-        });
-        if (res != AE_OK)
-            serverTL->fRetrySetAofEvent = true;
-    }
-}
-
 /* Append data to the AOF rewrite buffer, allocating new blocks if needed. */
 void aofRewriteBufferAppend(unsigned char *s, unsigned long len) {
    listNode *ln = listLast(g_pserver->aof_rewrite_buf_blocks);
@@ -180,7 +165,7 @@ void aofRewriteBufferAppend(unsigned char *s, unsigned long len) {

    /* Install a file event to send data to the rewrite child if there is
     * not one already. */
-    installAofRewriteEvent();
+    aeCreateRemoteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, g_pserver->aof_pipe_write_data_to_child, AE_WRITABLE, aofChildWriteDiffData, NULL, FALSE);
 }

 /* Write the buffer (possibly composed of multiple blocks) into the specified
@@ -257,7 +242,6 @@ void stopAppendOnly(void) {
    g_pserver->aof_fd = -1;
    g_pserver->aof_selected_db = -1;
    g_pserver->aof_state = AOF_OFF;
-    g_pserver->aof_rewrite_scheduled = 0;
    killAppendOnlyChild();
 }

@@ -280,9 +264,9 @@ int startAppendOnly(void) {
            strerror(errno));
        return C_ERR;
    }
-    if (hasActiveChildProcess() && g_pserver->aof_child_pid == -1) {
+    if (g_pserver->FRdbSaveInProgress()) {
        g_pserver->aof_rewrite_scheduled = 1;
-        serverLog(LL_WARNING,"AOF was enabled but there is already another background operation. An AOF background was scheduled to start when possible.");
+        serverLog(LL_WARNING,"AOF was enabled but there is already a child process saving an RDB file on disk. An AOF background was scheduled to start when possible.");
    } else {
        /* If there is a pending AOF rewrite, we need to switch it off and
         * start a new one: the old one cannot be reused because it is not
@@ -319,7 +303,9 @@ ssize_t aofWrite(int fd, const char *buf, size_t len) {
        nwritten = write(fd, buf, len);

        if (nwritten < 0) {
-            if (errno == EINTR) continue;
+            if (errno == EINTR) {
+                continue;
+            }
            return totwritten ? totwritten : -1;
        }

@@ -355,9 +341,6 @@ void flushAppendOnlyFile(int force) {
    int sync_in_progress = 0;
    mstime_t latency;

-    if (serverTL->fRetrySetAofEvent)
-        installAofRewriteEvent();
-
    if (sdslen(g_pserver->aof_buf) == 0) {
        /* Check if we need to do fsync even the aof buffer is empty,
         * because previously in AOF_FSYNC_EVERYSEC mode, fsync is
@@ -404,10 +387,6 @@ void flushAppendOnlyFile(int force) {
     * there is much to do about the whole server stopping for power problems
     * or alike */

-    if (g_pserver->aof_flush_sleep && sdslen(g_pserver->aof_buf)) {
-        usleep(g_pserver->aof_flush_sleep);
-    }
-
    latencyStartMonitor(latency);
    nwritten = aofWrite(g_pserver->aof_fd,g_pserver->aof_buf,sdslen(g_pserver->aof_buf));
    latencyEndMonitor(latency);
@@ -418,7 +397,7 @@ void flushAppendOnlyFile(int force) {
     * useful for graphing / monitoring purposes. */
    if (sync_in_progress) {
        latencyAddSampleIfNeeded("aof-write-pending-fsync",latency);
-    } else if (hasActiveChildProcess()) {
+    } else if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) {
        latencyAddSampleIfNeeded("aof-write-active-child",latency);
    } else {
        latencyAddSampleIfNeeded("aof-write-alone",latency);
@@ -514,8 +493,9 @@ void flushAppendOnlyFile(int force) {
 try_fsync:
    /* Don't fsync if no-appendfsync-on-rewrite is set to yes and there are
     * children doing I/O in the background. */
-    if (g_pserver->aof_no_fsync_on_rewrite && hasActiveChildProcess())
-        return;
+    if (g_pserver->aof_no_fsync_on_rewrite &&
+        (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()))
+            return;

    /* Perform the fsync if needed. */
    if (g_pserver->aof_fsync == AOF_FSYNC_ALWAYS) {
@@ -599,59 +579,21 @@ sds catAppendOnlyExpireAtCommand(sds buf, struct redisCommand *cmd, robj *key, r
    return buf;
 }

-sds catAppendOnlyExpireMemberAtCommand(sds buf, struct redisCommand *cmd, robj **argv, const size_t argc) {
-    long long when = 0;
-    int unit = UNIT_SECONDS;
-    bool fAbsolute = false;
-    
-    if (cmd->proc == expireMemberCommand) {
-        if (getLongLongFromObject(argv[3], &when) != C_OK)
-            serverPanic("propogating invalid EXPIREMEMBER command");
-        
-        if (argc == 5) {
-            unit = parseUnitString(szFromObj(argv[4]));
-        }
-    } else if (cmd->proc == expireMemberAtCommand) {
-        if (getLongLongFromObject(argv[3], &when) != C_OK)
-            serverPanic("propogating invalid EXPIREMEMBERAT command");
-        fAbsolute = true;
-    } else if (cmd->proc == pexpireMemberAtCommand) {
-        if (getLongLongFromObject(argv[3], &when) != C_OK)
-            serverPanic("propogating invalid PEXPIREMEMBERAT command");
-        fAbsolute = true;
-        unit = UNIT_MILLISECONDS;
-    } else {
-        serverPanic("Unknown expiremember command");
-    }
-
-    switch (unit)
-    {
-    case UNIT_SECONDS:
-        when *= 1000;
-        break;
-
-    case UNIT_MILLISECONDS:
-        break;
-    }
-
-    if (!fAbsolute)
-        when += mstime();
-    
-    robj *argvNew[4];
-    argvNew[0] = createStringObject("PEXPIREMEMBERAT",15);
-    argvNew[1] = argv[1];
-    argvNew[2] = argv[2];
-    argvNew[3] = createStringObjectFromLongLong(when);
-    buf = catAppendOnlyGenericCommand(buf, 4, argvNew);
-    decrRefCount(argvNew[0]);
-    decrRefCount(argvNew[3]);
-    return buf;
-}
-
-sds catCommandForAofAndActiveReplication(sds buf, struct redisCommand *cmd, robj **argv, int argc)
-{
+void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
+    sds buf = sdsempty();
    robj *tmpargv[3];
-    
+
+    /* The DB this command was targeting is not the same as the last command
+     * we appended. To issue a SELECT command is needed. */
+    if (dictid != g_pserver->aof_selected_db) {
+        char seldb[64];
+
+        snprintf(seldb,sizeof(seldb),"%d",dictid);
+        buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",
+            (unsigned long)strlen(seldb),seldb);
+        g_pserver->aof_selected_db = dictid;
+    }
+
    if (cmd->proc == expireCommand || cmd->proc == pexpireCommand ||
        cmd->proc == expireatCommand) {
        /* Translate EXPIRE/PEXPIRE/EXPIREAT into PEXPIREAT */
@@ -680,10 +622,6 @@ sds catCommandForAofAndActiveReplication(sds buf, struct redisCommand *cmd, robj
        if (pxarg)
            buf = catAppendOnlyExpireAtCommand(buf,cserver.pexpireCommand,argv[1],
                                               pxarg);
-    } else if (cmd->proc == expireMemberCommand || cmd->proc == expireMemberAtCommand ||
-        cmd->proc == pexpireMemberAtCommand) {
-        /* Translate subkey expire commands to PEXPIREMEMBERAT */
-        buf = catAppendOnlyExpireMemberAtCommand(buf, cmd, argv, argc);
    } else {
        /* All the other commands don't need translation or need the
         * same translation already operated in the command vector
@@ -691,25 +629,6 @@ sds catCommandForAofAndActiveReplication(sds buf, struct redisCommand *cmd, robj
        buf = catAppendOnlyGenericCommand(buf,argc,argv);
    }

-    return buf;
-}
-
-void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
-    sds buf = sdsempty();
-
-    /* The DB this command was targeting is not the same as the last command
-     * we appended. To issue a SELECT command is needed. */
-    if (dictid != g_pserver->aof_selected_db) {
-        char seldb[64];
-
-        snprintf(seldb,sizeof(seldb),"%d",dictid);
-        buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",
-            (unsigned long)strlen(seldb),seldb);
-        g_pserver->aof_selected_db = dictid;
-    }
-
-    buf = catCommandForAofAndActiveReplication(buf, cmd, argv, argc);
-
    /* Append to the AOF buffer. This will be flushed on disk just before
     * of re-entering the event loop, so before the client will get a
     * positive reply about the operation performed. */
@@ -732,12 +651,11 @@ void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int a

 /* In Redis commands are always executed in the context of a client, so in
 * order to load the append only file we need to create a fake client. */
-struct client *createAOFClient(void) {
-    struct client *c =(client*) zmalloc(sizeof(*c), MALLOC_LOCAL);
+client *createFakeClient(void) {
+    client *c = (client*)zmalloc(sizeof(*c), MALLOC_LOCAL);

    selectDb(c,0);
-    c->id = CLIENT_ID_AOF; /* So modules can identify it's the AOF client. */
-    c->conn = NULL;
+    c->fd = -1;
    c->iel = IDX_EVENT_LOOP_MAIN;
    c->name = NULL;
    c->querybuf = sdsempty();
@@ -760,7 +678,7 @@ struct client *createAOFClient(void) {
    c->puser = NULL;
    listSetFreeMethod(c->reply,freeClientReplyValue);
    listSetDupMethod(c->reply,dupClientReplyValue);
-    fastlock_init(&c->lock, "fake client");
+    fastlock_init(&c->lock);
    fastlock_lock(&c->lock);
    initClientMultiState(c);
    return c;
@@ -817,8 +735,8 @@ int loadAppendOnlyFile(char *filename) {
     * to the same file we're about to read. */
    g_pserver->aof_state = AOF_OFF;

-    fakeClient = createAOFClient();
-    startLoadingFile(fp, filename, RDBFLAGS_AOF_PREAMBLE);
+    fakeClient = createFakeClient();
+    startLoading(fp);

    /* Check if this AOF file has an RDB preamble. In that case we need to
     * load the RDB file and later continue loading the AOF tail. */
@@ -829,12 +747,12 @@ int loadAppendOnlyFile(char *filename) {
    } else {
        /* RDB preamble. Pass loading the RDB functions. */
        rio rdb;
-        rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;

        serverLog(LL_NOTICE,"Reading RDB preamble from AOF file...");
        if (fseek(fp,0,SEEK_SET) == -1) goto readerr;
        rioInitWithFile(&rdb,fp);
-        if (rdbLoadRio(&rdb,RDBFLAGS_AOF_PREAMBLE,&rsi) != C_OK) {
+        rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
+        if (rdbLoadRio(&rdb,&rsi,1) != C_OK) {
            serverLog(LL_WARNING,"Error reading the RDB preamble of the AOF file, AOF loading aborted");
            goto readerr;
        } else {
@@ -855,7 +773,6 @@ int loadAppendOnlyFile(char *filename) {
        if (!(loops++ % 1000)) {
            loadingProgress(ftello(fp));
            processEventsWhileBlocked(serverTL - g_pserver->rgthreadvar);
-            processModuleLoadingProgressEvent(1);
        }

        if (fgets(buf,sizeof(buf),fp) == NULL) {
@@ -869,26 +786,18 @@ int loadAppendOnlyFile(char *filename) {
        argc = atoi(buf+1);
        if (argc < 1) goto fmterr;

-        /* Load the next command in the AOF as our fake client
-         * argv. */
        argv = (robj**)zmalloc(sizeof(robj*)*argc, MALLOC_LOCAL);
        fakeClient->argc = argc;
        fakeClient->argv = argv;

        for (j = 0; j < argc; j++) {
-            /* Parse the argument len. */
-            char *readres = fgets(buf,sizeof(buf),fp);
-            if (readres == NULL || buf[0] != '$') {
+            if (fgets(buf,sizeof(buf),fp) == NULL) {
                fakeClient->argc = j; /* Free up to j-1. */
                freeFakeClientArgv(fakeClient);
-                if (readres == NULL)
-                    goto readerr;
-                else
-                    goto fmterr;
+                goto readerr;
            }
+            if (buf[0] != '$') goto fmterr;
            len = strtol(buf+1,NULL,10);
-
-            /* Read it into a string object. */
            argsds = sdsnewlen(SDS_NOINIT,len);
            if (len && fread(argsds,len,1,fp) == 0) {
                sdsfree(argsds);
@@ -897,12 +806,10 @@ int loadAppendOnlyFile(char *filename) {
                goto readerr;
            }
            argv[j] = createObject(OBJ_STRING,argsds);
-
-            /* Discard CRLF. */
            if (fread(buf,2,1,fp) == 0) {
                fakeClient->argc = j+1; /* Free up to j. */
                freeFakeClientArgv(fakeClient);
-                goto readerr;
+                goto readerr; /* discard CRLF */
            }
        }

@@ -918,7 +825,7 @@ int loadAppendOnlyFile(char *filename) {
        if (cmd == cserver.multiCommand) valid_before_multi = valid_up_to;

        /* Run the command in the context of a fake client */
-        fakeClient->cmd = fakeClient->lastcmd = cmd;
+        fakeClient->cmd = cmd;
        if (fakeClient->flags & CLIENT_MULTI &&
            fakeClient->cmd->proc != execCommand)
        {
@@ -939,8 +846,6 @@ int loadAppendOnlyFile(char *filename) {
        freeFakeClientArgv(fakeClient);
        fakeClient->cmd = NULL;
        if (g_pserver->aof_load_truncated) valid_up_to = ftello(fp);
-        if (g_pserver->key_load_delay)
-            usleep(g_pserver->key_load_delay);
    }

    /* This point can only be reached when EOF is reached without errors.
@@ -958,7 +863,7 @@ loaded_ok: /* DB loaded, cleanup and return C_OK to the caller. */
    fclose(fp);
    freeFakeClient(fakeClient);
    g_pserver->aof_state = old_aof_state;
-    stopLoading(1);
+    stopLoading();
    aofUpdateCurrentSize();
    g_pserver->aof_rewrite_base_size = g_pserver->aof_current_size;
    g_pserver->aof_fsync_offset = g_pserver->aof_current_size;
@@ -967,7 +872,6 @@ loaded_ok: /* DB loaded, cleanup and return C_OK to the caller. */
 readerr: /* Read error. If feof(fp) is true, fall through to unexpected EOF. */
    if (!feof(fp)) {
        if (fakeClient) freeFakeClient(fakeClient); /* avoid valgrind warning */
-        fclose(fp);
        serverLog(LL_WARNING,"Unrecoverable error reading the append only file: %s", strerror(errno));
        exit(1);
    }
@@ -998,13 +902,11 @@ uxeof: /* Unexpected AOF end of file. */
        }
    }
    if (fakeClient) freeFakeClient(fakeClient); /* avoid valgrind warning */
-    fclose(fp);
-    serverLog(LL_WARNING,"Unexpected end of file reading the append only file. You can: 1) Make a backup of your AOF file, then use ./keydb-check-aof --fix <filename>. 2) Alternatively you can set the 'aof-load-truncated' configuration option to yes and restart the server.");
+    serverLog(LL_WARNING,"Unexpected end of file reading the append only file. You can: 1) Make a backup of your AOF file, then use ./keydb-check-aof --fix <filename>. 2) Alternatively you can set the 'aof-load-truncated' configuration option to yes and restart the g_pserver->");
    exit(1);

 fmterr: /* Format error. */
    if (fakeClient) freeFakeClient(fakeClient); /* avoid valgrind warning */
-    fclose(fp);
    serverLog(LL_WARNING,"Bad file format reading the append only file: make a backup of your AOF file, then use ./keydb-check-aof --fix <filename>");
    exit(1);
 }
@@ -1237,7 +1139,7 @@ int rioWriteBulkStreamID(rio *r,streamID *id) {
    int retval;

    sds replyid = sdscatfmt(sdsempty(),"%U-%U",id->ms,id->seq);
-    retval = rioWriteBulkString(r,replyid,sdslen(replyid));
+    if ((retval = rioWriteBulkString(r,replyid,sdslen(replyid))) == 0) return 0;
    sdsfree(replyid);
    return retval;
 }
@@ -1299,13 +1201,12 @@ int rewriteStreamObject(rio *r, robj *key, robj *o) {
        /* Use the XADD MAXLEN 0 trick to generate an empty stream if
         * the key we are serializing is an empty string, which is possible
         * for the Stream type. */
-        id.ms = 0; id.seq = 1; 
        if (rioWriteBulkCount(r,'*',7) == 0) return 0;
        if (rioWriteBulkString(r,"XADD",4) == 0) return 0;
        if (rioWriteBulkObject(r,key) == 0) return 0;
        if (rioWriteBulkString(r,"MAXLEN",6) == 0) return 0;
        if (rioWriteBulkString(r,"0",1) == 0) return 0;
-        if (rioWriteBulkStreamID(r,&id) == 0) return 0;
+        if (rioWriteBulkStreamID(r,&s->last_id) == 0) return 0;
        if (rioWriteBulkString(r,"x",1) == 0) return 0;
        if (rioWriteBulkString(r,"y",1) == 0) return 0;
    }
@@ -1399,52 +1300,46 @@ ssize_t aofReadDiffFromParent(void) {

 int rewriteAppendOnlyFileRio(rio *aof) {
    dictIterator *di = NULL;
-    dictEntry *de;
    size_t processed = 0;
    int j;

    for (j = 0; j < cserver.dbnum; j++) {
        char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
        redisDb *db = g_pserver->db+j;
-        dict *d = db->pdict;
-        if (dictSize(d) == 0) continue;
-        di = dictGetSafeIterator(d);
+        if (db->size() == 0) continue;

        /* SELECT the new DB */
        if (rioWrite(aof,selectcmd,sizeof(selectcmd)-1) == 0) goto werr;
        if (rioWriteBulkLongLong(aof,j) == 0) goto werr;

        /* Iterate this DB writing every entry */
-        while((de = dictNext(di)) != NULL) {
-            sds keystr;
-            robj key, *o;
+        bool fComplete = db->iterate([&](const char *keystr, robj *o)->bool{
+            robj key;

-            keystr = (sds)dictGetKey(de);
-            o = (robj*)dictGetVal(de);
-            initStaticStringObject(key,keystr);
+            initStaticStringObject(key,(sds)keystr);

-            expireEntry *pexpire = getExpire(db,&key);
+            expireEntry *pexpire = db->getExpire(&key);

            /* Save the key and associated value */
            if (o->type == OBJ_STRING) {
                /* Emit a SET command */
                char cmd[]="*3\r\n$3\r\nSET\r\n";
-                if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
+                if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
                /* Key and value */
-                if (rioWriteBulkObject(aof,&key) == 0) goto werr;
-                if (rioWriteBulkObject(aof,o) == 0) goto werr;
+                if (rioWriteBulkObject(aof,&key) == 0) return false;
+                if (rioWriteBulkObject(aof,o) == 0) return false;
            } else if (o->type == OBJ_LIST) {
-                if (rewriteListObject(aof,&key,o) == 0) goto werr;
+                if (rewriteListObject(aof,&key,o) == 0) return false;
            } else if (o->type == OBJ_SET) {
-                if (rewriteSetObject(aof,&key,o) == 0) goto werr;
+                if (rewriteSetObject(aof,&key,o) == 0) return false;
            } else if (o->type == OBJ_ZSET) {
-                if (rewriteSortedSetObject(aof,&key,o) == 0) goto werr;
+                if (rewriteSortedSetObject(aof,&key,o) == 0) return false;
            } else if (o->type == OBJ_HASH) {
-                if (rewriteHashObject(aof,&key,o) == 0) goto werr;
+                if (rewriteHashObject(aof,&key,o) == 0) return false;
            } else if (o->type == OBJ_STREAM) {
-                if (rewriteStreamObject(aof,&key,o) == 0) goto werr;
+                if (rewriteStreamObject(aof,&key,o) == 0) return false;
            } else if (o->type == OBJ_MODULE) {
-                if (rewriteModuleObject(aof,&key,o) == 0) goto werr;
+                if (rewriteModuleObject(aof,&key,o) == 0) return false;
            } else {
                serverPanic("Unknown object type");
            }
@@ -1454,17 +1349,17 @@ int rewriteAppendOnlyFileRio(rio *aof) {
                    if (subExpire.subkey() == nullptr)
                    {
                        char cmd[]="*3\r\n$9\r\nPEXPIREAT\r\n";
-                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
-                        if (rioWriteBulkObject(aof,&key) == 0) goto werr;
+                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
+                        if (rioWriteBulkObject(aof,&key) == 0) return false;
                    }
                    else
                    {
-                        char cmd[]="*4\r\n$12\r\nPEXPIREMEMBERAT\r\n";
-                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
-                        if (rioWriteBulkObject(aof,&key) == 0) goto werr;
-                        if (rioWrite(aof,subExpire.subkey(),sdslen(subExpire.subkey())) == 0) goto werr;
+                        char cmd[]="*4\r\n$12\r\nEXPIREMEMBER\r\n";
+                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
+                        if (rioWriteBulkObject(aof,&key) == 0) return false;
+                        if (rioWrite(aof,subExpire.subkey(),sdslen(subExpire.subkey())) == 0) return false;
                    }
-                    if (rioWriteBulkLongLong(aof,subExpire.when()) == 0) goto werr; // common
+                    if (rioWriteBulkLongLong(aof,subExpire.when()) == 0) return false; // common
                }
            }
            /* Read some diff from the parent process from time to time. */
@@ -1472,9 +1367,10 @@ int rewriteAppendOnlyFileRio(rio *aof) {
                processed = aof->processed_bytes;
                aofReadDiffFromParent();
            }
-        }
-        dictReleaseIterator(di);
-        di = NULL;
+            return true;
+        });
+        if (!fComplete)
+            goto werr;
    }
    return C_OK;

@@ -1513,11 +1409,14 @@ int rewriteAppendOnlyFile(char *filename) {
    if (g_pserver->aof_rewrite_incremental_fsync)
        rioSetAutoSync(&aof,REDIS_AUTOSYNC_BYTES);

-    startSaving(RDBFLAGS_AOF_PREAMBLE);
-
    if (g_pserver->aof_use_rdb_preamble) {
        int error;
-        if (rdbSaveRio(&aof,&error,RDBFLAGS_AOF_PREAMBLE,NULL) == C_ERR) {
+        std::vector<redisDbPersistentData*> vecpdb;
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+        {
+            vecpdb.push_back(&g_pserver->db[idb]);
+        }
+        if (rdbSaveRio(&aof,vecpdb.data(),&error,RDB_SAVE_AOF_PREAMBLE,NULL) == C_ERR) {
            errno = error;
            goto werr;
        }
@@ -1579,18 +1478,15 @@ int rewriteAppendOnlyFile(char *filename) {
    if (rename(tmpfile,filename) == -1) {
        serverLog(LL_WARNING,"Error moving temp append only file on the final destination: %s", strerror(errno));
        unlink(tmpfile);
-        stopSaving(0);
        return C_ERR;
    }
    serverLog(LL_NOTICE,"SYNC append only file rewrite performed");
-    stopSaving(1);
    return C_OK;

 werr:
    serverLog(LL_WARNING,"Write error writing append only file on disk: %s", strerror(errno));
    fclose(fp);
    unlink(tmpfile);
-    stopSaving(0);
    return C_ERR;
 }

@@ -1660,19 +1556,16 @@ error:

 void aofClosePipes(void) {
    int fdAofAckPipe = g_pserver->aof_pipe_read_ack_from_child;
-    int res = aePostFunction(g_pserver->el_alf_pip_read_ack_from_child, [fdAofAckPipe]{
+    aePostFunction(g_pserver->el_alf_pip_read_ack_from_child, [fdAofAckPipe]{
        aeDeleteFileEventAsync(serverTL->el,fdAofAckPipe,AE_READABLE);
        close (fdAofAckPipe);
    });
-    serverAssert(res == AE_OK);

    int fdAofWritePipe = g_pserver->aof_pipe_write_data_to_child;
-    res = aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [fdAofWritePipe]{
+    aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [fdAofWritePipe]{
        aeDeleteFileEventAsync(serverTL->el,fdAofWritePipe,AE_WRITABLE);
        close(fdAofWritePipe);
    });
-    serverAssert(res == AE_OK);
-    g_pserver->aof_pipe_write_data_to_child = -1;
    
    close(g_pserver->aof_pipe_read_data_from_parent);
    close(g_pserver->aof_pipe_write_ack_to_parent);
@@ -1698,24 +1591,39 @@ void aofClosePipes(void) {
 */
 int rewriteAppendOnlyFileBackground(void) {
    pid_t childpid;
+    long long start;

-    if (hasActiveChildProcess()) return C_ERR;
+    if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) return C_ERR;
    if (aofCreatePipes() != C_OK) return C_ERR;
    openChildInfoPipe();
-    if ((childpid = redisFork()) == 0) {
+    start = ustime();
+    if ((childpid = fork()) == 0) {
        char tmpfile[256];

        /* Child */
+        closeListeningSockets(0);
        redisSetProcTitle("keydb-aof-rewrite");
        snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) getpid());
        if (rewriteAppendOnlyFile(tmpfile) == C_OK) {
-            sendChildCOWInfo(CHILD_INFO_TYPE_AOF, "AOF rewrite");
+            size_t private_dirty = zmalloc_get_private_dirty(-1);
+
+            if (private_dirty) {
+                serverLog(LL_NOTICE,
+                    "AOF rewrite: %zu MB of memory used by copy-on-write",
+                    private_dirty/(1024*1024));
+            }
+
+            g_pserver->child_info_data.cow_size = private_dirty;
+            sendChildInfo(CHILD_INFO_TYPE_AOF);
            exitFromChild(0);
        } else {
            exitFromChild(1);
        }
    } else {
        /* Parent */
+        g_pserver->stat_fork_time = ustime()-start;
+        g_pserver->stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / g_pserver->stat_fork_time / (1024*1024*1024); /* GB per second. */
+        latencyAddSampleIfNeeded("fork",g_pserver->stat_fork_time/1000);
        if (childpid == -1) {
            closeChildInfoPipe();
            serverLog(LL_WARNING,
@@ -1729,6 +1637,7 @@ int rewriteAppendOnlyFileBackground(void) {
        g_pserver->aof_rewrite_scheduled = 0;
        g_pserver->aof_rewrite_time_start = time(NULL);
        g_pserver->aof_child_pid = childpid;
+        updateDictResizePolicy();
        /* We set appendseldb to -1 in order to force the next call to the
         * feedAppendOnlyFile() to issue a SELECT command, so the differences
         * accumulated by the parent into g_pserver->aof_rewrite_buf will start
@@ -1743,14 +1652,13 @@ int rewriteAppendOnlyFileBackground(void) {
 void bgrewriteaofCommand(client *c) {
    if (g_pserver->aof_child_pid != -1) {
        addReplyError(c,"Background append only file rewriting already in progress");
-    } else if (hasActiveChildProcess()) {
+    } else if (g_pserver->FRdbSaveInProgress()) {
        g_pserver->aof_rewrite_scheduled = 1;
        addReplyStatus(c,"Background append only file rewriting scheduled");
    } else if (rewriteAppendOnlyFileBackground() == C_OK) {
        addReplyStatus(c,"Background append only file rewriting started");
    } else {
-        addReplyError(c,"Can't execute an AOF background rewriting. "
-                        "Please check the server logs for more information.");
+        addReply(c,shared.err);
    }
 }

@@ -1889,7 +1797,6 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
            g_pserver->aof_selected_db = -1; /* Make sure SELECT is re-issued */
            aofUpdateCurrentSize();
            g_pserver->aof_rewrite_base_size = g_pserver->aof_current_size;
-            g_pserver->aof_fsync_offset = g_pserver->aof_current_size;

            /* Clear regular AOF buffer since its contents was just written to
             * the new AOF from the background rewrite buffer. */
@@ -1910,15 +1817,14 @@ void backgroundRewriteDoneHandler(int exitcode, int bysignal) {
        serverLog(LL_VERBOSE,
            "Background AOF rewrite signal handler took %lldus", ustime()-now);
    } else if (!bysignal && exitcode != 0) {
-        g_pserver->aof_lastbgrewrite_status = C_ERR;
-
-        serverLog(LL_WARNING,
-            "Background AOF rewrite terminated with error");
-    } else {
        /* SIGUSR1 is whitelisted, so we have a way to kill a child without
         * tirggering an error condition. */
        if (bysignal != SIGUSR1)
            g_pserver->aof_lastbgrewrite_status = C_ERR;
+        serverLog(LL_WARNING,
+            "Background AOF rewrite terminated with error");
+    } else {
+        g_pserver->aof_lastbgrewrite_status = C_ERR;

        serverLog(LL_WARNING,
            "Background AOF rewrite terminated by signal %d", bysignal);
@@ -36,6 +36,7 @@ const char *ascii_logo =
 "                                        Port: %d\n"
 "                                        PID: %ld\n"
 "                                                                     \n"
-"                     %s\n"
+"                     Like KeyDB? Star us on GitHub!                  \n"
 "                                                                     \n"
-"                                                                     \n";
+"                     https://github.com/JohnSully/KeyDB              \n"
+"                                                                     \n\n";
@@ -1,4 +1,3 @@
-#pragma once
 /*
 * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
 * All rights reserved.
@@ -976,9 +976,6 @@ void bitposCommand(client *c) {
 * OVERFLOW [WRAP|SAT|FAIL]
 */

-#define BITFIELD_FLAG_NONE      0
-#define BITFIELD_FLAG_READONLY  (1<<0)
-
 struct bitfieldOp {
    uint64_t offset;    /* Bitfield offset. */
    int64_t i64;        /* Increment amount (INCRBY) or SET value */
@@ -988,10 +985,7 @@ struct bitfieldOp {
    int sign;           /* True if signed, otherwise unsigned op. */
 };

-/* This implements both the BITFIELD command and the BITFIELD_RO command
- * when flags is set to BITFIELD_FLAG_READONLY: in this case only the
- * GET subcommand is allowed, other subcommands will return an error. */
-void bitfieldGeneric(client *c, int flags) {
+void bitfieldCommand(client *c) {
    robj_roptr o;
    size_t bitoffset;
    int j, numops = 0, changes = 0;
@@ -1079,12 +1073,6 @@ void bitfieldGeneric(client *c, int flags) {
            return;
        }
    } else {
-        if (flags & BITFIELD_FLAG_READONLY) {
-            zfree(ops);
-            addReplyError(c, "BITFIELD_RO only supports the GET subcommand");
-            return;
-        }
-
        /* Lookup by making room up to the farest bit reached by
         * this operation. */
        if ((o = lookupStringForBitCommand(c,
@@ -1215,11 +1203,3 @@ void bitfieldGeneric(client *c, int flags) {
    }
    zfree(ops);
 }
-
-void bitfieldCommand(client *c) {
-    bitfieldGeneric(c, BITFIELD_FLAG_NONE);
-}
-
-void bitfieldroCommand(client *c) {
-    bitfieldGeneric(c, BITFIELD_FLAG_READONLY);
-}
@@ -31,6 +31,9 @@
 *
 * API:
 *
+ * getTimeoutFromObjectOrReply() is just an utility function to parse a
+ * timeout argument since blocking operations usually require a timeout.
+ *
 * blockClient() set the CLIENT_BLOCKED flag in the client, and set the
 * specified block type 'btype' filed to one of BLOCKED_* macros.
 *
@@ -65,6 +68,42 @@

 int serveClientBlockedOnList(client *receiver, robj *key, robj *dstkey, redisDb *db, robj *value, int where);

+/* Get a timeout value from an object and store it into 'timeout'.
+ * The final timeout is always stored as milliseconds as a time where the
+ * timeout will expire, however the parsing is performed according to
+ * the 'unit' that can be seconds or milliseconds.
+ *
+ * Note that if the timeout is zero (usually from the point of view of
+ * commands API this means no timeout) the value stored into 'timeout'
+ * is zero. */
+int getTimeoutFromObjectOrReply(client *c, robj *object, mstime_t *timeout, int unit) {
+    long long tval;
+    long double ftval;
+
+    if (unit == UNIT_SECONDS) {
+        if (getLongDoubleFromObjectOrReply(c,object,&ftval,
+            "timeout is not an float or out of range") != C_OK)
+            return C_ERR;
+        tval = (long long) (ftval * 1000.0);
+    } else {
+        if (getLongLongFromObjectOrReply(c,object,&tval,
+            "timeout is not an integer or out of range") != C_OK)
+            return C_ERR;
+    }
+
+    if (tval < 0) {
+        addReplyError(c,"timeout is negative");
+        return C_ERR;
+    }
+
+    if (tval > 0) {
+        tval += mstime();
+    }
+    *timeout = tval;
+
+    return C_OK;
+}
+
 /* Block a client for the specific operation type. Once the CLIENT_BLOCKED
 * flag is set client query buffer is not longer processed, but accumulated,
 * and will be processed when the client is unblocked. */
@@ -74,7 +113,6 @@ void blockClient(client *c, int btype) {
    c->btype = btype;
    g_pserver->blocked_clients++;
    g_pserver->blocked_clients_by_type[btype]++;
-    addClientToTimeoutTable(c);
 }

 /* This function is called in the beforeSleep() function of the event loop
@@ -151,7 +189,6 @@ void unblockClient(client *c) {
    } else if (c->btype == BLOCKED_WAIT) {
        unblockClientWaitingReplicas(c);
    } else if (c->btype == BLOCKED_MODULE) {
-        if (moduleClientIsBlockedOnKeys(c)) unblockClientWaitingData(c);
        unblockClientFromModule(c);
    } else {
        serverPanic("Unknown btype in unblockClient().");
@@ -162,7 +199,6 @@ void unblockClient(client *c) {
    g_pserver->blocked_clients_by_type[c->btype]--;
    c->flags &= ~CLIENT_BLOCKED;
    c->btype = BLOCKED_NONE;
-    removeClientFromTimeoutTable(c);
    queueClientForReprocessing(c);
 }

@@ -173,9 +209,9 @@ void replyToBlockedClientTimedOut(client *c) {
    if (c->btype == BLOCKED_LIST ||
        c->btype == BLOCKED_ZSET ||
        c->btype == BLOCKED_STREAM) {
-        addReplyNullArrayAsync(c);
+        addReplyNullArray(c);
    } else if (c->btype == BLOCKED_WAIT) {
-        addReplyLongLongAsync(c,replicationCountAcksByOffset(c->bpop.reploffset));
+        addReplyLongLong(c,replicationCountAcksByOffset(c->bpop.reploffset));
    } else if (c->btype == BLOCKED_MODULE) {
        moduleBlockedClientTimedOut(c);
    } else {
@@ -211,253 +247,6 @@ void disconnectAllBlockedClients(void) {
    }
 }

-/* Helper function for handleClientsBlockedOnKeys(). This function is called
- * when there may be clients blocked on a list key, and there may be new
- * data to fetch (the key is ready). */
-void serveClientsBlockedOnListKey(robj *o, readyList *rl) {
-    /* We serve clients in the same order they blocked for
-     * this key, from the first blocked to the last. */
-    dictEntry *de = dictFind(rl->db->blocking_keys,rl->key);
-    if (de) {
-        list *clients = (list*)dictGetVal(de);
-        int numclients = listLength(clients);
-
-        while(numclients--) {
-            listNode *clientnode = listFirst(clients);
-            client *receiver = (client*)clientnode->value;
-            std::unique_lock<decltype(receiver->lock)> lock(receiver->lock);
-
-            if (receiver->btype != BLOCKED_LIST) {
-                /* Put at the tail, so that at the next call
-                 * we'll not run into it again. */
-                listDelNode(clients,clientnode);
-                listAddNodeTail(clients,receiver);
-                continue;
-            }
-
-            robj *dstkey = receiver->bpop.target;
-            int where = (receiver->lastcmd &&
-                         receiver->lastcmd->proc == blpopCommand) ?
-                         LIST_HEAD : LIST_TAIL;
-            robj *value = listTypePop(o,where);
-
-            if (value) {
-                /* Protect receiver->bpop.target, that will be
-                 * freed by the next unblockClient()
-                 * call. */
-                if (dstkey) incrRefCount(dstkey);
-                unblockClient(receiver);
-
-                if (serveClientBlockedOnList(receiver,
-                    rl->key,dstkey,rl->db,value,
-                    where) == C_ERR)
-                {
-                    /* If we failed serving the client we need
-                     * to also undo the POP operation. */
-                    listTypePush(o,value,where);
-                }
-
-                if (dstkey) decrRefCount(dstkey);
-                decrRefCount(value);
-            } else {
-                break;
-            }
-        }
-    }
-
-    if (listTypeLength(o) == 0) {
-        dbDelete(rl->db,rl->key);
-        notifyKeyspaceEvent(NOTIFY_GENERIC,"del",rl->key,rl->db->id);
-    }
-    /* We don't call signalModifiedKey() as it was already called
-     * when an element was pushed on the list. */
-}
-
-/* Helper function for handleClientsBlockedOnKeys(). This function is called
- * when there may be clients blocked on a sorted set key, and there may be new
- * data to fetch (the key is ready). */
-void serveClientsBlockedOnSortedSetKey(robj *o, readyList *rl) {
-    /* We serve clients in the same order they blocked for
-     * this key, from the first blocked to the last. */
-    dictEntry *de = dictFind(rl->db->blocking_keys,rl->key);
-    if (de) {
-        list *clients = (list*)dictGetVal(de);
-        int numclients = listLength(clients);
-        unsigned long zcard = zsetLength(o);
-
-        while(numclients-- && zcard) {
-            listNode *clientnode = listFirst(clients);
-            client *receiver = (client*)clientnode->value;
-            std::unique_lock<decltype(receiver->lock)> lock(receiver->lock);
-
-            if (receiver->btype != BLOCKED_ZSET) {
-                /* Put at the tail, so that at the next call
-                 * we'll not run into it again. */
-                listDelNode(clients,clientnode);
-                listAddNodeTail(clients,receiver);
-                continue;
-            }
-
-            int where = (receiver->lastcmd &&
-                         receiver->lastcmd->proc == bzpopminCommand)
-                         ? ZSET_MIN : ZSET_MAX;
-            unblockClient(receiver);
-            genericZpopCommand(receiver,&rl->key,1,where,1,NULL);
-            zcard--;
-
-            /* Replicate the command. */
-            robj *argv[2];
-            struct redisCommand *cmd = where == ZSET_MIN ?
-                                       cserver.zpopminCommand :
-                                       cserver.zpopmaxCommand;
-            argv[0] = createStringObject(cmd->name,strlen(cmd->name));
-            argv[1] = rl->key;
-            incrRefCount(rl->key);
-            propagate(cmd,receiver->db->id,
-                      argv,2,PROPAGATE_AOF|PROPAGATE_REPL);
-            decrRefCount(argv[0]);
-            decrRefCount(argv[1]);
-        }
-    }
-}
-
-/* Helper function for handleClientsBlockedOnKeys(). This function is called
- * when there may be clients blocked on a stream key, and there may be new
- * data to fetch (the key is ready). */
-void serveClientsBlockedOnStreamKey(robj *o, readyList *rl) {
-    dictEntry *de = dictFind(rl->db->blocking_keys,rl->key);
-    stream *s = (stream*)ptrFromObj(o);
-
-    /* We need to provide the new data arrived on the stream
-     * to all the clients that are waiting for an offset smaller
-     * than the current top item. */
-    if (de) {
-        list *clients = (list*)dictGetVal(de);
-        listNode *ln;
-        listIter li;
-        listRewind(clients,&li);
-
-        while((ln = listNext(&li))) {
-            client *receiver = (client*)listNodeValue(ln);
-            if (receiver->btype != BLOCKED_STREAM) continue;
-            std::unique_lock<decltype(receiver->lock)> lock(receiver->lock);
-            streamID *gt = (streamID*)dictFetchValue(receiver->bpop.keys,
-                                          rl->key);
-
-            /* If we blocked in the context of a consumer
-             * group, we need to resolve the group and update the
-             * last ID the client is blocked for: this is needed
-             * because serving other clients in the same consumer
-             * group will alter the "last ID" of the consumer
-             * group, and clients blocked in a consumer group are
-             * always blocked for the ">" ID: we need to deliver
-             * only new messages and avoid unblocking the client
-             * otherwise. */
-            streamCG *group = NULL;
-            if (receiver->bpop.xread_group) {
-                group = streamLookupCG(s,
-                        szFromObj(receiver->bpop.xread_group));
-                /* If the group was not found, send an error
-                 * to the consumer. */
-                if (!group) {
-                    addReplyErrorAsync(receiver,
-                        "-NOGROUP the consumer group this client "
-                        "was blocked on no longer exists");
-                    unblockClient(receiver);
-                    continue;
-                } else {
-                    *gt = group->last_id;
-                }
-            }
-
-            if (streamCompareID(&s->last_id, gt) > 0) {
-                streamID start = *gt;
-                streamIncrID(&start);
-
-                /* Lookup the consumer for the group, if any. */
-                streamConsumer *consumer = NULL;
-                int noack = 0;
-
-                if (group) {
-                    consumer = streamLookupConsumer(group,
-                               szFromObj(receiver->bpop.xread_consumer),
-                               1);
-                    noack = receiver->bpop.xread_group_noack;
-                }
-
-                /* Emit the two elements sub-array consisting of
-                 * the name of the stream and the data we
-                 * extracted from it. Wrapped in a single-item
-                 * array, since we have just one key. */
-                if (receiver->resp == 2) {
-                    addReplyArrayLenAsync(receiver,1);
-                    addReplyArrayLenAsync(receiver,2);
-                } else {
-                    addReplyMapLenAsync(receiver,1);
-                }
-                addReplyBulkAsync(receiver,rl->key);
-
-                streamPropInfo pi = {
-                    rl->key,
-                    receiver->bpop.xread_group
-                };
-                streamReplyWithRange(receiver,s,&start,NULL,
-                                     receiver->bpop.xread_count,
-                                     0, group, consumer, noack, &pi);
-
-                /* Note that after we unblock the client, 'gt'
-                 * and other receiver->bpop stuff are no longer
-                 * valid, so we must do the setup above before
-                 * this call. */
-                unblockClient(receiver);
-            }
-        }
-    }
-}
-
-/* Helper function for handleClientsBlockedOnKeys(). This function is called
- * in order to check if we can serve clients blocked by modules using
- * RM_BlockClientOnKeys(), when the corresponding key was signaled as ready:
- * our goal here is to call the RedisModuleBlockedClient reply() callback to
- * see if the key is really able to serve the client, and in that case,
- * unblock it. */
-void serveClientsBlockedOnKeyByModule(readyList *rl) {
-    dictEntry *de;
-
-    /* We serve clients in the same order they blocked for
-     * this key, from the first blocked to the last. */
-    de = dictFind(rl->db->blocking_keys,rl->key);
-    if (de) {
-        list *clients = (list*)dictGetVal(de);
-        int numclients = listLength(clients);
-
-        while(numclients--) {
-            listNode *clientnode = listFirst(clients);
-            client *receiver = (client*)clientnode->value;
-
-            /* Put at the tail, so that at the next call
-             * we'll not run into it again: clients here may not be
-             * ready to be served, so they'll remain in the list
-             * sometimes. We want also be able to skip clients that are
-             * not blocked for the MODULE type safely. */
-            listDelNode(clients,clientnode);
-            listAddNodeTail(clients,receiver);
-
-            if (receiver->btype != BLOCKED_MODULE) continue;
-
-            /* Note that if *this* client cannot be served by this key,
-             * it does not mean that another client that is next into the
-             * list cannot be served as well: they may be blocked by
-             * different modules with different triggers to consider if a key
-             * is ready or not. This means we can't exit the loop but need
-             * to continue after the first failure. */
-            if (!moduleTryServeClientBlockedOnKey(receiver, rl->key)) continue;
-
-            moduleUnblockClient(receiver);
-        }
-    }
-}
-
 /* This function should be called by Redis every time a single command,
 * a MULTI/EXEC block, or a Lua script, terminated its execution after
 * being called by a client. It handles serving clients blocked in
@@ -499,32 +288,215 @@ void handleClientsBlockedOnKeys(void) {
             * we can safely call signalKeyAsReady() against this key. */
            dictDelete(rl->db->ready_keys,rl->key);

-            /* Even if we are not inside call(), increment the call depth
-             * in order to make sure that keys are expired against a fixed
-             * reference time, and not against the wallclock time. This
-             * way we can lookup an object multiple times (BRPOPLPUSH does
-             * that) without the risk of it being freed in the second
-             * lookup, invalidating the first one.
-             * See https://github.com/antirez/redis/pull/6554. */
-            serverTL->fixed_time_expire++;
-            updateCachedTime(0);
-
            /* Serve clients blocked on list key. */
            robj *o = lookupKeyWrite(rl->db,rl->key);
+            if (o != NULL && o->type == OBJ_LIST) {
+                dictEntry *de;

-            if (o != NULL) {
-                if (o->type == OBJ_LIST)
-                    serveClientsBlockedOnListKey(o,rl);
-                else if (o->type == OBJ_ZSET)
-                    serveClientsBlockedOnSortedSetKey(o,rl);
-                else if (o->type == OBJ_STREAM)
-                    serveClientsBlockedOnStreamKey(o,rl);
-                /* We want to serve clients blocked on module keys
-                 * regardless of the object type: we don't know what the
-                 * module is trying to accomplish right now. */
-                serveClientsBlockedOnKeyByModule(rl);
+                /* We serve clients in the same order they blocked for
+                 * this key, from the first blocked to the last. */
+                de = dictFind(rl->db->blocking_keys,rl->key);
+                if (de) {
+                    list *clients = (list*)dictGetVal(de);
+                    int numclients = listLength(clients);
+
+                    while(numclients--) {
+                        listNode *clientnode = listFirst(clients);
+                        client *receiver = (client*)clientnode->value;
+                        std::unique_lock<decltype(client::lock)> lock(receiver->lock);
+
+                        if (receiver->btype != BLOCKED_LIST) {
+                            /* Put at the tail, so that at the next call
+                             * we'll not run into it again. */
+                            listDelNode(clients,clientnode);
+                            listAddNodeTail(clients,receiver);
+                            continue;
+                        }
+
+                        robj *dstkey = receiver->bpop.target;
+                        int where = (receiver->lastcmd &&
+                                     receiver->lastcmd->proc == blpopCommand) ?
+                                     LIST_HEAD : LIST_TAIL;
+                        robj *value = listTypePop(o,where);
+
+                        if (value) {
+                            /* Protect receiver->bpop.target, that will be
+                             * freed by the next unblockClient()
+                             * call. */
+                            if (dstkey) incrRefCount(dstkey);
+                            fastlock_lock(&receiver->lock);
+                            unblockClient(receiver);
+
+                            if (serveClientBlockedOnList(receiver,
+                                rl->key,dstkey,rl->db,value,
+                                where) == C_ERR)
+                            {
+                                /* If we failed serving the client we need
+                                 * to also undo the POP operation. */
+                                listTypePush(o,value,where);
+                            }
+
+                            if (dstkey) decrRefCount(dstkey);
+                            fastlock_unlock(&receiver->lock);
+                            decrRefCount(value);
+                        } else {
+                            break;
+                        }
+                    }
+                }
+
+                if (listTypeLength(o) == 0) {
+                    dbDelete(rl->db,rl->key);
+                    notifyKeyspaceEvent(NOTIFY_GENERIC,"del",rl->key,rl->db->id);
+                }
+                /* We don't call signalModifiedKey() as it was already called
+                 * when an element was pushed on the list. */
+            }
+
+            /* Serve clients blocked on sorted set key. */
+            else if (o != NULL && o->type == OBJ_ZSET) {
+                dictEntry *de;
+
+                /* We serve clients in the same order they blocked for
+                 * this key, from the first blocked to the last. */
+                de = dictFind(rl->db->blocking_keys,rl->key);
+                if (de) {
+                    list *clients = (list*)dictGetVal(de);
+                    int numclients = listLength(clients);
+                    unsigned long zcard = zsetLength(o);
+
+                    while(numclients-- && zcard) {
+                        listNode *clientnode = listFirst(clients);
+                        client *receiver = (client*)clientnode->value;
+
+                        if (receiver->btype != BLOCKED_ZSET) {
+                            /* Put at the tail, so that at the next call
+                             * we'll not run into it again. */
+                            listDelNode(clients,clientnode);
+                            listAddNodeTail(clients,receiver);
+                            continue;
+                        }
+
+                        fastlock_lock(&receiver->lock);
+                        int where = (receiver->lastcmd &&
+                                     receiver->lastcmd->proc == bzpopminCommand)
+                                     ? ZSET_MIN : ZSET_MAX;
+                        unblockClient(receiver);
+                        genericZpopCommand(receiver,&rl->key,1,where,1,NULL);
+                        zcard--;
+
+                        /* Replicate the command. */
+                        robj *argv[2];
+                        struct redisCommand *cmd = where == ZSET_MIN ?
+                                                   cserver.zpopminCommand :
+                                                   cserver.zpopmaxCommand;
+                        argv[0] = createStringObject(cmd->name,strlen(cmd->name));
+                        argv[1] = rl->key;
+                        incrRefCount(rl->key);
+                        propagate(cmd,receiver->db->id,
+                                  argv,2,PROPAGATE_AOF|PROPAGATE_REPL);
+                        fastlock_unlock(&receiver->lock);
+                        decrRefCount(argv[0]);
+                        decrRefCount(argv[1]);
+                    }
+                }
+            }
+
+            /* Serve clients blocked on stream key. */
+            else if (o != NULL && o->type == OBJ_STREAM) {
+                dictEntry *de = dictFind(rl->db->blocking_keys,rl->key);
+                stream *s = (stream*)ptrFromObj(o);
+
+                /* We need to provide the new data arrived on the stream
+                 * to all the clients that are waiting for an offset smaller
+                 * than the current top item. */
+                if (de) {
+                    list *clients = (list*)dictGetVal(de);
+                    listNode *ln;
+                    listIter li;
+                    listRewind(clients,&li);
+
+                    while((ln = listNext(&li))) {
+                        client *receiver = (client*)listNodeValue(ln);
+                        if (receiver->btype != BLOCKED_STREAM) continue;
+                        streamID *gt = (streamID*)dictFetchValue(receiver->bpop.keys,
+                                                      rl->key);
+
+                        /* If we blocked in the context of a consumer
+                         * group, we need to resolve the group and update the
+                         * last ID the client is blocked for: this is needed
+                         * because serving other clients in the same consumer
+                         * group will alter the "last ID" of the consumer
+                         * group, and clients blocked in a consumer group are
+                         * always blocked for the ">" ID: we need to deliver
+                         * only new messages and avoid unblocking the client
+                         * otherwise. */
+                        streamCG *group = NULL;
+                        if (receiver->bpop.xread_group) {
+                            group = streamLookupCG(s,
+                                    szFromObj(receiver->bpop.xread_group));
+                            /* If the group was not found, send an error
+                             * to the consumer. */
+                            if (!group) {
+                                fastlock_lock(&receiver->lock);
+                                addReplyErrorAsync(receiver,
+                                    "-NOGROUP the consumer group this client "
+                                    "was blocked on no longer exists");
+                                unblockClient(receiver);
+                                fastlock_unlock(&receiver->lock);
+                                continue;
+                            } else {
+                                *gt = group->last_id;
+                            }
+                        }
+
+                        if (streamCompareID(&s->last_id, gt) > 0) {
+                            streamID start = *gt;
+                            start.seq++; /* Can't overflow, it's an uint64_t */
+
+                            /* Lookup the consumer for the group, if any. */
+                            streamConsumer *consumer = NULL;
+                            int noack = 0;
+
+                            if (group) {
+                                consumer = streamLookupConsumer(group,
+                                           szFromObj(receiver->bpop.xread_consumer),
+                                           1);
+                                noack = receiver->bpop.xread_group_noack;
+                            }
+
+                            fastlock_lock(&receiver->lock);
+
+                            /* Emit the two elements sub-array consisting of
+                             * the name of the stream and the data we
+                             * extracted from it. Wrapped in a single-item
+                             * array, since we have just one key. */
+                            if (receiver->resp == 2) {
+                                addReplyArrayLenAsync(receiver,1);
+                                addReplyArrayLenAsync(receiver,2);
+                            } else {
+                                addReplyMapLenAsync(receiver,1);
+                            }
+                            addReplyBulkAsync(receiver,rl->key);
+
+                            streamPropInfo pi = {
+                                rl->key,
+                                receiver->bpop.xread_group
+                            };
+                            streamReplyWithRange(receiver,s,&start,NULL,
+                                                 receiver->bpop.xread_count,
+                                                 0, group, consumer, noack, &pi);
+
+                            /* Note that after we unblock the client, 'gt'
+                             * and other receiver->bpop stuff are no longer
+                             * valid, so we must do the setup above before
+                             * this call. */
+                            unblockClient(receiver);
+                            fastlock_unlock(&receiver->lock);
+                        }
+                    }
+                }
            }
-            serverTL->fixed_time_expire--;

            /* Free this item. */
            decrRefCount(rl->key);
@@ -649,7 +621,7 @@ void unblockClientWaitingData(client *c) {
 * the same key again and again in the list in case of multiple pushes
 * made by a script or in the context of MULTI/EXEC.
 *
- * The list will be finally processed by handleClientsBlockedOnKeys() */
+ * The list will be finally processed by handleClientsBlockedOnLists() */
 void signalKeyAsReady(redisDb *db, robj *key) {
    readyList *rl;

@@ -80,8 +80,6 @@ void receiveChildInfo(void) {
            g_pserver->stat_rdb_cow_bytes = g_pserver->child_info_data.cow_size;
        } else if (g_pserver->child_info_data.process_type == CHILD_INFO_TYPE_AOF) {
            g_pserver->stat_aof_cow_bytes = g_pserver->child_info_data.cow_size;
-        } else if (g_pserver->child_info_data.process_type == CHILD_INFO_TYPE_MODULE) {
-            g_pserver->stat_module_cow_bytes = g_pserver->child_info_data.cow_size;
        }
    }
 }
@@ -49,7 +49,7 @@ clusterNode *myself = NULL;
 clusterNode *createClusterNode(char *nodename, int flags);
 int clusterAddNode(clusterNode *node);
 void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
-void clusterReadHandler(connection *conn);
+void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void clusterSendPing(clusterLink *link, int type);
 void clusterSendFail(char *nodename);
 void clusterSendFailoverAuthIfNeeded(clusterNode *node, clusterMsg *request);
@@ -146,7 +146,6 @@ int clusterLoadConfig(char *filename) {
        /* Handle the special "vars" line. Don't pretend it is the last
         * line even if it actually is when generated by Redis. */
        if (strcasecmp(argv[0],"vars") == 0) {
-            if (!(argc % 2)) goto fmterr;
            for (j = 1; j < argc; j += 2) {
                if (strcasecmp(argv[j],"currentEpoch") == 0) {
                    g_pserver->cluster->currentEpoch =
@@ -165,10 +164,7 @@ int clusterLoadConfig(char *filename) {
        }

        /* Regular config lines have at least eight fields */
-        if (argc < 8) {
-            sdsfreesplitres(argv,argc);
-            goto fmterr;
-        }
+        if (argc < 8) goto fmterr;

        /* Create this node if it does not exist */
        n = clusterLookupNode(argv[0]);
@@ -177,10 +173,7 @@ int clusterLoadConfig(char *filename) {
            clusterAddNode(n);
        }
        /* Address and port */
-        if ((p = strrchr(argv[1],':')) == NULL) {
-            sdsfreesplitres(argv,argc);
-            goto fmterr;
-        }
+        if ((p = strrchr(argv[1],':')) == NULL) goto fmterr;
        *p = '\0';
        memcpy(n->ip,argv[1],strlen(argv[1])+1);
        char *port = p+1;
@@ -261,10 +254,7 @@ int clusterLoadConfig(char *filename) {
                *p = '\0';
                direction = p[1]; /* Either '>' or '<' */
                slot = atoi(argv[j]+1);
-                if (slot < 0 || slot >= CLUSTER_SLOTS) {
-                    sdsfreesplitres(argv,argc);
-                    goto fmterr;
-                }
+                if (slot < 0 || slot >= CLUSTER_SLOTS) goto fmterr;
                p += 3;
                cn = clusterLookupNode(p);
                if (!cn) {
@@ -284,12 +274,8 @@ int clusterLoadConfig(char *filename) {
            } else {
                start = stop = atoi(argv[j]);
            }
-            if (start < 0 || start >= CLUSTER_SLOTS ||
-                stop < 0 || stop >= CLUSTER_SLOTS)
-            {
-                sdsfreesplitres(argv,argc);
-                goto fmterr;
-            }
+            if (start < 0 || start >= CLUSTER_SLOTS) goto fmterr;
+            if (stop < 0 || stop >= CLUSTER_SLOTS) goto fmterr;
            while(start <= stop) clusterAddSlot(n, start++);
        }

@@ -309,15 +295,6 @@ int clusterLoadConfig(char *filename) {
    if (clusterGetMaxEpoch() > g_pserver->cluster->currentEpoch) {
        g_pserver->cluster->currentEpoch = clusterGetMaxEpoch();
    }
-
-    if (dictSize(g_pserver->cluster->nodes) > 1 && cserver.thread_min_client_threshold < 100)
-    {
-        // Because we expect the individual load of a client to be much less in a cluster (it will spread over multiple server)
-        //  we can increase the grouping of clients on a single thread within reason
-        cserver.thread_min_client_threshold *= dictSize(g_pserver->cluster->nodes);
-        cserver.thread_min_client_threshold = std::min(cserver.thread_min_client_threshold, 200);
-        serverLog(LL_NOTICE, "Expanding min-clients-per-thread to %d due to cluster", cserver.thread_min_client_threshold);
-    }
    return C_OK;

 fmterr:
@@ -512,8 +489,7 @@ void clusterInit(void) {
    /* Port sanity check II
     * The other handshake port check is triggered too late to stop
     * us from trying to use a too-high cluster port number. */
-    int port = g_pserver->tls_cluster ? g_pserver->tls_port : g_pserver->port;
-    if (port > (65535-CLUSTER_PORT_INCR)) {
+    if (g_pserver->port > (65535-CLUSTER_PORT_INCR)) {
        serverLog(LL_WARNING, "Redis port number too high. "
                   "Cluster communication port is 10,000 port "
                   "numbers higher than your Redis port. "
@@ -521,7 +497,8 @@ void clusterInit(void) {
                   "lower than 55535.");
        exit(1);
    }
-    if (listenToPort(port+CLUSTER_PORT_INCR,
+
+    if (listenToPort(g_pserver->port+CLUSTER_PORT_INCR,
        g_pserver->cfd,&g_pserver->cfd_count, 0 /*fReusePort*/, 0 /*fFirstListen*/) == C_ERR)
    {
        exit(1);
@@ -543,8 +520,8 @@ void clusterInit(void) {

    /* Set myself->port / cport to my listening ports, we'll just need to
     * discover the IP address via MEET messages. */
-    myself->port = port;
-    myself->cport = port+CLUSTER_PORT_INCR;
+    myself->port = g_pserver->port;
+    myself->cport = g_pserver->port+CLUSTER_PORT_INCR;
    if (g_pserver->cluster_announce_port)
        myself->port = g_pserver->cluster_announce_port;
    if (g_pserver->cluster_announce_bus_port)
@@ -632,7 +609,7 @@ clusterLink *createClusterLink(clusterNode *node) {
    link->sndbuf = sdsempty();
    link->rcvbuf = sdsempty();
    link->node = node;
-    link->conn = NULL;
+    link->fd = -1;
    return link;
 }

@@ -640,57 +617,23 @@ clusterLink *createClusterLink(clusterNode *node) {
 * This function will just make sure that the original node associated
 * with this link will have the 'link' field set to NULL. */
 void freeClusterLink(clusterLink *link) {
-    if (ielFromEventLoop(serverTL->el) != IDX_EVENT_LOOP_MAIN)
-    {
-        // we can't perform this operation on this thread, queue it on the main thread
-        if (link->node)
-            link->node->link = NULL;
-        link->node = nullptr;
-        int res = aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [link]{
-            freeClusterLink(link);
-        });
-        serverAssert(res == AE_OK);
-        return;
-    }
-    if (link->conn) {
-        connClose(link->conn);
-        link->conn = NULL;
+    if (link->fd != -1) {
+        aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, link->fd, AE_READABLE|AE_WRITABLE);
    }
    sdsfree(link->sndbuf);
    sdsfree(link->rcvbuf);
    if (link->node)
        link->node->link = NULL;
+    close(link->fd);
    zfree(link);
 }

-static void clusterConnAcceptHandler(connection *conn) {
-    clusterLink *link;
-
-    if (connGetState(conn) != CONN_STATE_CONNECTED) {
-        serverLog(LL_VERBOSE,
-                "Error accepting cluster node connection: %s", connGetLastError(conn));
-        connClose(conn);
-        return;
-    }
-
-    /* Create a link object we use to handle the connection.
-     * It gets passed to the readable handler when data is available.
-     * Initiallly the link->node pointer is set to NULL as we don't know
-     * which node is, but the right node is references once we know the
-     * node identity. */
-    link = createClusterLink(NULL);
-    link->conn = conn;
-    connSetPrivateData(conn, link);
-
-    /* Register read handler */
-    connSetReadHandler(conn, clusterReadHandler);
-}
-
 #define MAX_CLUSTER_ACCEPTS_PER_CALL 1000
 void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
    int cport, cfd;
    int max = MAX_CLUSTER_ACCEPTS_PER_CALL;
    char cip[NET_IP_STR_LEN];
+    clusterLink *link;
    UNUSED(el);
    UNUSED(mask);
    UNUSED(privdata);
@@ -707,25 +650,19 @@ void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
                    "Error accepting cluster node: %s", serverTL->neterr);
            return;
        }
-
-        connection *conn = g_pserver->tls_cluster ? connCreateAcceptedTLS(cfd,1) : connCreateAcceptedSocket(cfd);
-        connNonBlock(conn);
-        connEnableTcpNoDelay(conn);
+        anetNonBlock(NULL,cfd);
+        anetEnableTcpNoDelay(NULL,cfd);

        /* Use non-blocking I/O for cluster messages. */
-        serverLog(LL_VERBOSE,"Accepting cluster node connection from %s:%d", cip, cport);
-
-        /* Accept the connection now.  connAccept() may call our handler directly
-         * or schedule it for later depending on connection implementation.
-         */
-        if (connAccept(conn, clusterConnAcceptHandler) == C_ERR) {
-            if (connGetState(conn) == CONN_STATE_ERROR)
-                serverLog(LL_VERBOSE,
-                        "Error accepting cluster node connection: %s",
-                        connGetLastError(conn));
-            connClose(conn);
-            return;
-        }
+        serverLog(LL_VERBOSE,"Accepted cluster node %s:%d", cip, cport);
+        /* Create a link object we use to handle the connection.
+         * It gets passed to the readable handler when data is available.
+         * Initiallly the link->node pointer is set to NULL as we don't know
+         * which node is, but the right node is references once we know the
+         * node identity. */
+        link = createClusterLink(NULL);
+        link->fd = cfd;
+        aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,cfd,AE_READABLE,clusterReadHandler,link);
    }
 }

@@ -1526,7 +1463,7 @@ void nodeIp2String(char *buf, clusterLink *link, char *announced_ip) {
        memcpy(buf,announced_ip,NET_IP_STR_LEN);
        buf[NET_IP_STR_LEN-1] = '\0'; /* We are not sure the input is sane. */
    } else {
-        connPeerToString(link->conn, buf, NET_IP_STR_LEN, NULL);
+        anetPeerToString(link->fd, buf, NET_IP_STR_LEN, NULL);
    }
 }

@@ -1834,7 +1771,7 @@ int clusterProcessPacket(clusterLink *link) {
        {
            char ip[NET_IP_STR_LEN];

-            if (connSockName(link->conn,ip,sizeof(ip),NULL) != -1 &&
+            if (anetSockName(link->fd,ip,sizeof(ip),NULL) != -1 &&
                strcmp(ip,myself->ip))
            {
                memcpy(myself->ip,ip,NET_IP_STR_LEN);
@@ -2201,77 +2138,35 @@ void handleLinkIOError(clusterLink *link) {
 /* Send data. This is handled using a trivial send buffer that gets
 * consumed by write(). We don't try to optimize this for speed too much
 * as this is a very low traffic channel. */
-void clusterWriteHandler(connection *conn) {
-    serverAssert(ielFromEventLoop(serverTL->el) == IDX_EVENT_LOOP_MAIN);
-    clusterLink *link = (clusterLink*)connGetPrivateData(conn);
+void clusterWriteHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
+    clusterLink *link = (clusterLink*) privdata;
    ssize_t nwritten;
+    UNUSED(el);
+    UNUSED(mask);

-    nwritten = connWrite(conn, link->sndbuf, sdslen(link->sndbuf));
+    nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
    if (nwritten <= 0) {
        serverLog(LL_DEBUG,"I/O error writing to node link: %s",
-            (nwritten == -1) ? connGetLastError(conn) : "short write");
+            (nwritten == -1) ? strerror(errno) : "short write");
        handleLinkIOError(link);
        return;
    }
    sdsrange(link->sndbuf,nwritten,-1);
    if (sdslen(link->sndbuf) == 0)
-        connSetWriteHandler(link->conn, NULL);
-}
-
-/* A connect handler that gets called when a connection to another node
- * gets established.
- */
-void clusterLinkConnectHandler(connection *conn) {
-    clusterLink *link = (clusterLink*)connGetPrivateData(conn);
-    clusterNode *node = link->node;
-
-    /* Check if connection succeeded */
-    if (connGetState(conn) != CONN_STATE_CONNECTED) {
-        serverLog(LL_VERBOSE, "Connection with Node %.40s at %s:%d failed: %s",
-                node->name, node->ip, node->cport,
-                connGetLastError(conn));
-        freeClusterLink(link);
-        return;
-    }
-
-    /* Register a read handler from now on */
-    connSetReadHandler(conn, clusterReadHandler);
-
-    /* Queue a PING in the new connection ASAP: this is crucial
-     * to avoid false positives in failure detection.
-     *
-     * If the node is flagged as MEET, we send a MEET message instead
-     * of a PING one, to force the receiver to add us in its node
-     * table. */
-    mstime_t old_ping_sent = node->ping_sent;
-    clusterSendPing(link, node->flags & CLUSTER_NODE_MEET ?
-            CLUSTERMSG_TYPE_MEET : CLUSTERMSG_TYPE_PING);
-    if (old_ping_sent) {
-        /* If there was an active ping before the link was
-         * disconnected, we want to restore the ping time, otherwise
-         * replaced by the clusterSendPing() call. */
-        node->ping_sent = old_ping_sent;
-    }
-    /* We can clear the flag after the first packet is sent.
-     * If we'll never receive a PONG, we'll never send new packets
-     * to this node. Instead after the PONG is received and we
-     * are no longer in meet/handshake status, we want to send
-     * normal PING packets. */
-    node->flags &= ~CLUSTER_NODE_MEET;
-
-    serverLog(LL_DEBUG,"Connecting with Node %.40s at %s:%d",
-            node->name, node->ip, node->cport);
+        aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, link->fd, AE_WRITABLE);
 }

 /* Read data. Try to read the first field of the header first to check the
 * full length of the packet. When a whole packet is in memory this function
 * will call the function to process the packet. And so forth. */
-void clusterReadHandler(connection *conn) {
-    clusterMsg buf[1];
+void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
+    char buf[sizeof(clusterMsg)];
    ssize_t nread;
    clusterMsg *hdr;
-    clusterLink *link = (clusterLink*)connGetPrivateData(conn);
+    clusterLink *link = (clusterLink*) privdata;
    unsigned int readlen, rcvbuflen;
+    UNUSED(el);
+    UNUSED(mask);

    while(1) { /* Read as long as there is data to read. */
        rcvbuflen = sdslen(link->rcvbuf);
@@ -2299,13 +2194,13 @@ void clusterReadHandler(connection *conn) {
            if (readlen > sizeof(buf)) readlen = sizeof(buf);
        }

-        nread = connRead(conn,buf,readlen);
-        if (nread == -1 && (connGetState(conn) == CONN_STATE_CONNECTED)) return; /* No more data ready. */
+        nread = read(fd,buf,readlen);
+        if (nread == -1 && errno == EAGAIN) return; /* No more data ready. */

        if (nread <= 0) {
            /* I/O error... */
            serverLog(LL_DEBUG,"I/O error reading from node link: %s",
-                (nread == 0) ? "connection closed" : connGetLastError(conn));
+                (nread == 0) ? "connection closed" : strerror(errno));
            handleLinkIOError(link);
            return;
        } else {
@@ -2333,13 +2228,9 @@ void clusterReadHandler(connection *conn) {
 * the link to be invalidated, so it is safe to call this function
 * from event handlers that will do stuff with the same link later. */
 void clusterSendMessage(clusterLink *link, unsigned char *msg, size_t msglen) {
-    serverAssert(GlobalLocksAcquired());
    if (sdslen(link->sndbuf) == 0 && msglen != 0)
-    {
-        aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [link] {
-            connSetWriteHandlerWithBarrier(link->conn, clusterWriteHandler, 1);
-        });
-    }
+        aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_WRITABLE|AE_BARRIER,
+                    clusterWriteHandler,link);

    link->sndbuf = sdscatlen(link->sndbuf, msg, msglen);

@@ -2405,12 +2296,11 @@ void clusterBuildMessageHdr(clusterMsg *hdr, int type) {
    }

    /* Handle cluster-announce-port as well. */
-    int port = g_pserver->tls_cluster ? g_pserver->tls_port : g_pserver->port;
    int announced_port = g_pserver->cluster_announce_port ?
-                         g_pserver->cluster_announce_port : port;
+                         g_pserver->cluster_announce_port : g_pserver->port;
    int announced_cport = g_pserver->cluster_announce_bus_port ?
                          g_pserver->cluster_announce_bus_port :
-                          (port + CLUSTER_PORT_INCR);
+                          (g_pserver->port + CLUSTER_PORT_INCR);

    memcpy(hdr->myslots,master->slots,sizeof(hdr->myslots));
    memset(hdr->slaveof,0,CLUSTER_NAMELEN);
@@ -2647,8 +2537,7 @@ void clusterBroadcastPong(int target) {
 *
 * If link is NULL, then the message is broadcasted to the whole cluster. */
 void clusterSendPublish(clusterLink *link, robj *channel, robj *message) {
-    unsigned char *payload;
-    clusterMsg buf[1];
+    unsigned char buf[sizeof(clusterMsg)], *payload;
    clusterMsg *hdr = (clusterMsg*) buf;
    uint32_t totlen;
    uint32_t channel_len, message_len;
@@ -2668,7 +2557,7 @@ void clusterSendPublish(clusterLink *link, robj *channel, robj *message) {

    /* Try to use the local buffer if possible */
    if (totlen < sizeof(buf)) {
-        payload = (unsigned char*)buf;
+        payload = buf;
    } else {
        payload = (unsigned char*)zmalloc(totlen, MALLOC_LOCAL);
        memcpy(payload,hdr,sizeof(*hdr));
@@ -2685,7 +2574,7 @@ void clusterSendPublish(clusterLink *link, robj *channel, robj *message) {

    decrRefCount(channel);
    decrRefCount(message);
-    if (payload != (unsigned char*)buf) zfree(payload);
+    if (payload != buf) zfree(payload);
 }

 /* Send a FAIL message to all the nodes we are able to contact.
@@ -2694,7 +2583,7 @@ void clusterSendPublish(clusterLink *link, robj *channel, robj *message) {
 * we switch the node state to CLUSTER_NODE_FAIL and ask all the other
 * nodes to do the same ASAP. */
 void clusterSendFail(char *nodename) {
-    clusterMsg buf[1];
+    unsigned char buf[sizeof(clusterMsg)];
    clusterMsg *hdr = (clusterMsg*) buf;

    clusterBuildMessageHdr(hdr,CLUSTERMSG_TYPE_FAIL);
@@ -2706,7 +2595,7 @@ void clusterSendFail(char *nodename) {
 * slots configuration. The node name, slots bitmap, and configEpoch info
 * are included. */
 void clusterSendUpdate(clusterLink *link, clusterNode *node) {
-    clusterMsg buf[1];
+    unsigned char buf[sizeof(clusterMsg)];
    clusterMsg *hdr = (clusterMsg*) buf;

    if (link == NULL) return;
@@ -2714,7 +2603,7 @@ void clusterSendUpdate(clusterLink *link, clusterNode *node) {
    memcpy(hdr->data.update.nodecfg.nodename,node->name,CLUSTER_NAMELEN);
    hdr->data.update.nodecfg.configEpoch = htonu64(node->configEpoch);
    memcpy(hdr->data.update.nodecfg.slots,node->slots,sizeof(node->slots));
-    clusterSendMessage(link,(unsigned char*)buf,ntohl(hdr->totlen));
+    clusterSendMessage(link,buf,ntohl(hdr->totlen));
 }

 /* Send a MODULE message.
@@ -2722,8 +2611,7 @@ void clusterSendUpdate(clusterLink *link, clusterNode *node) {
 * If link is NULL, then the message is broadcasted to the whole cluster. */
 void clusterSendModule(clusterLink *link, uint64_t module_id, uint8_t type,
                       unsigned char *payload, uint32_t len) {
-    unsigned char *heapbuf;
-    clusterMsg buf[1];
+    unsigned char buf[sizeof(clusterMsg)], *heapbuf;
    clusterMsg *hdr = (clusterMsg*) buf;
    uint32_t totlen;

@@ -2738,7 +2626,7 @@ void clusterSendModule(clusterLink *link, uint64_t module_id, uint8_t type,

    /* Try to use the local buffer if possible */
    if (totlen < sizeof(buf)) {
-        heapbuf = (unsigned char*)buf;
+        heapbuf = buf;
    } else {
        heapbuf = (unsigned char*)zmalloc(totlen, MALLOC_LOCAL);
        memcpy(heapbuf,hdr,sizeof(*hdr));
@@ -2751,7 +2639,7 @@ void clusterSendModule(clusterLink *link, uint64_t module_id, uint8_t type,
    else
        clusterBroadcastMessage(heapbuf,totlen);

-    if (heapbuf != (unsigned char*)buf) zfree(heapbuf);
+    if (heapbuf != buf) zfree(heapbuf);
 }

 /* This function gets a cluster node ID string as target, the same way the nodes
@@ -2795,7 +2683,7 @@ void clusterPropagatePublish(robj *channel, robj *message) {
 * Note that we send the failover request to everybody, master and slave nodes,
 * but only the masters are supposed to reply to our query. */
 void clusterRequestFailoverAuth(void) {
-    clusterMsg buf[1];
+    unsigned char buf[sizeof(clusterMsg)];
    clusterMsg *hdr = (clusterMsg*) buf;
    uint32_t totlen;

@@ -2811,7 +2699,7 @@ void clusterRequestFailoverAuth(void) {

 /* Send a FAILOVER_AUTH_ACK message to the specified node. */
 void clusterSendFailoverAuth(clusterNode *node) {
-    clusterMsg buf[1];
+    unsigned char buf[sizeof(clusterMsg)];
    clusterMsg *hdr = (clusterMsg*) buf;
    uint32_t totlen;

@@ -2819,12 +2707,12 @@ void clusterSendFailoverAuth(clusterNode *node) {
    clusterBuildMessageHdr(hdr,CLUSTERMSG_TYPE_FAILOVER_AUTH_ACK);
    totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
    hdr->totlen = htonl(totlen);
-    clusterSendMessage(node->link,(unsigned char*)buf,totlen);
+    clusterSendMessage(node->link,buf,totlen);
 }

 /* Send a MFSTART message to the specified node. */
 void clusterSendMFStart(clusterNode *node) {
-    clusterMsg buf[1];
+    unsigned char buf[sizeof(clusterMsg)];
    clusterMsg *hdr = (clusterMsg*) buf;
    uint32_t totlen;

@@ -2832,7 +2720,7 @@ void clusterSendMFStart(clusterNode *node) {
    clusterBuildMessageHdr(hdr,CLUSTERMSG_TYPE_MFSTART);
    totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
    hdr->totlen = htonl(totlen);
-    clusterSendMessage(node->link,(unsigned char*)buf,totlen);
+    clusterSendMessage(node->link,buf,totlen);
 }

 /* Vote for the node asking for our vote if there are the conditions. */
@@ -3396,7 +3284,7 @@ void clusterHandleSlaveMigration(int max_slaves) {
 void resetManualFailover(void) {
    if (g_pserver->cluster->mf_end && clientsArePaused()) {
        g_pserver->clients_pause_end_time = 0;
-        unpauseClientsIfNecessary();
+        clientsArePaused(); /* Just use the side effect of the function. */
    }
    g_pserver->cluster->mf_end = 0; /* No manual failover in progress. */
    g_pserver->cluster->mf_can_start = 0;
@@ -3515,11 +3403,13 @@ void clusterCron(void) {
        }

        if (node->link == NULL) {
-            clusterLink *link = createClusterLink(node);
-            link->conn = g_pserver->tls_cluster ? connCreateTLS() : connCreateSocket();
-            connSetPrivateData(link->conn, link);
-            if (connConnect(link->conn, node->ip, node->cport, NET_FIRST_BIND_ADDR,
-                        clusterLinkConnectHandler) == -1) {
+            int fd;
+            mstime_t old_ping_sent;
+            clusterLink *link;
+
+            fd = anetTcpNonBlockBindConnect(serverTL->neterr, node->ip,
+                node->cport, NET_FIRST_BIND_ADDR);
+            if (fd == -1) {
                /* We got a synchronous error from connect before
                 * clusterSendPing() had a chance to be called.
                 * If node->ping_sent is zero, failure detection can't work,
@@ -3529,11 +3419,37 @@ void clusterCron(void) {
                serverLog(LL_DEBUG, "Unable to connect to "
                    "Cluster Node [%s]:%d -> %s", node->ip,
                    node->cport, serverTL->neterr);
-
-                freeClusterLink(link);
                continue;
            }
+            link = createClusterLink(node);
+            link->fd = fd;
            node->link = link;
+            aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_READABLE,
+                    clusterReadHandler,link);
+            /* Queue a PING in the new connection ASAP: this is crucial
+             * to avoid false positives in failure detection.
+             *
+             * If the node is flagged as MEET, we send a MEET message instead
+             * of a PING one, to force the receiver to add us in its node
+             * table. */
+            old_ping_sent = node->ping_sent;
+            clusterSendPing(link, node->flags & CLUSTER_NODE_MEET ?
+                    CLUSTERMSG_TYPE_MEET : CLUSTERMSG_TYPE_PING);
+            if (old_ping_sent) {
+                /* If there was an active ping before the link was
+                 * disconnected, we want to restore the ping time, otherwise
+                 * replaced by the clusterSendPing() call. */
+                node->ping_sent = old_ping_sent;
+            }
+            /* We can clear the flag after the first packet is sent.
+             * If we'll never receive a PONG, we'll never send new packets
+             * to this node. Instead after the PONG is received and we
+             * are no longer in meet/handshake status, we want to send
+             * normal PING packets. */
+            node->flags &= ~CLUSTER_NODE_MEET;
+
+            serverLog(LL_DEBUG,"Connecting with Node %.40s at %s:%d",
+                    node->name, node->ip, node->cport);
        }
    }
    dictReleaseIterator(di);
@@ -3994,7 +3910,7 @@ int verifyClusterConfigWithData(void) {

    /* Make sure we only have keys in DB0. */
    for (j = 1; j < cserver.dbnum; j++) {
-        if (dictSize(g_pserver->db[j].pdict)) return C_ERR;
+        if (g_pserver->db[j].size()) return C_ERR;
    }

    /* Check that all the slots we see populated memory have a corresponding
@@ -4238,76 +4154,57 @@ void clusterReplyMultiBulkSlots(client *c) {
    dictIterator *di = dictGetSafeIterator(g_pserver->cluster->nodes);
    while((de = dictNext(di)) != NULL) {
        clusterNode *node = (clusterNode*)dictGetVal(de);
-        int start = -1;
+        int j = 0, start = -1;

        /* Skip slaves (that are iterated when producing the output of their
         * master) and  masters not serving any slot. */
        if (!nodeIsMaster(node) || node->numslots == 0) continue;
-        
-        static_assert((CLUSTER_SLOTS % (sizeof(uint32_t)*8)) == 0, "code below assumes the bitfield is a multiple of sizeof(unsinged)");

-        for (unsigned iw = 0; iw < (CLUSTER_SLOTS/sizeof(uint32_t)/8); ++iw)
-        {
-            uint32_t wordCur = reinterpret_cast<uint32_t*>(node->slots)[iw];
-            if (iw != ((CLUSTER_SLOTS/sizeof(uint32_t)/8)-1))
-            {
-                if (start == -1 && wordCur == 0)
-                    continue;
-                if (start != -1 && (wordCur+1)==0)
-                    continue;
+        for (j = 0; j < CLUSTER_SLOTS; j++) {
+            int bit, i;
+
+            if ((bit = clusterNodeGetSlotBit(node,j)) != 0) {
+                if (start == -1) start = j;
            }
+            if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
+                int nested_elements = 3; /* slots (2) + master addr (1). */
+                void *nested_replylen = addReplyDeferredLen(c);

-            unsigned ibitStartLoop = iw*sizeof(uint32_t)*8;
-    
-            for (unsigned j = ibitStartLoop; j < (iw+1)*sizeof(uint32_t)*8; j++) {
-                int i;
-                int bit = (int)(wordCur & 1);
-                wordCur >>= 1;
-                if (bit != 0) {
-                    if (start == -1) start = j;
+                if (bit && j == CLUSTER_SLOTS-1) j++;
+
+                /* If slot exists in output map, add to it's list.
+                 * else, create a new output map for this slot */
+                if (start == j-1) {
+                    addReplyLongLong(c, start); /* only one slot; low==high */
+                    addReplyLongLong(c, start);
+                } else {
+                    addReplyLongLong(c, start); /* low */
+                    addReplyLongLong(c, j-1);   /* high */
                }
-                if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
-                    int nested_elements = 3; /* slots (2) + master addr (1). */
-                    void *nested_replylen = addReplyDeferredLen(c);
+                start = -1;

-                    if (bit && j == CLUSTER_SLOTS-1) j++;
+                /* First node reply position is always the master */
+                addReplyArrayLen(c, 3);
+                addReplyBulkCString(c, node->ip);
+                addReplyLongLong(c, node->port);
+                addReplyBulkCBuffer(c, node->name, CLUSTER_NAMELEN);

-                    /* If slot exists in output map, add to it's list.
-                    * else, create a new output map for this slot */
-                    if (start == j-1) {
-                        addReplyLongLong(c, start); /* only one slot; low==high */
-                        addReplyLongLong(c, start);
-                    } else {
-                        addReplyLongLong(c, start); /* low */
-                        addReplyLongLong(c, j-1);   /* high */
-                    }
-                    start = -1;
-
-                    /* First node reply position is always the master */
+                /* Remaining nodes in reply are replicas for slot range */
+                for (i = 0; i < node->numslaves; i++) {
+                    /* This loop is copy/pasted from clusterGenNodeDescription()
+                     * with modifications for per-slot node aggregation */
+                    if (nodeFailed(node->slaves[i])) continue;
                    addReplyArrayLen(c, 3);
-                    addReplyBulkCString(c, node->ip);
-                    addReplyLongLong(c, node->port);
-                    addReplyBulkCBuffer(c, node->name, CLUSTER_NAMELEN);
-
-                    /* Remaining nodes in reply are replicas for slot range */
-                    for (i = 0; i < node->numslaves; i++) {
-                        /* This loop is copy/pasted from clusterGenNodeDescription()
-                        * with modifications for per-slot node aggregation */
-                        if (nodeFailed(node->slaves[i])) continue;
-                        addReplyArrayLen(c, 3);
-                        addReplyBulkCString(c, node->slaves[i]->ip);
-                        addReplyLongLong(c, node->slaves[i]->port);
-                        addReplyBulkCBuffer(c, node->slaves[i]->name, CLUSTER_NAMELEN);
-                        nested_elements++;
-                    }
-                    setDeferredArrayLen(c, nested_replylen, nested_elements);
-                    num_masters++;
+                    addReplyBulkCString(c, node->slaves[i]->ip);
+                    addReplyLongLong(c, node->slaves[i]->port);
+                    addReplyBulkCBuffer(c, node->slaves[i]->name, CLUSTER_NAMELEN);
+                    nested_elements++;
                }
+                setDeferredArrayLen(c, nested_replylen, nested_elements);
+                num_masters++;
            }
        }
-        serverAssert(start == -1);
    }
-    
    dictReleaseIterator(di);
    setDeferredArrayLen(c, slot_replylen, num_masters);
 }
@@ -4329,7 +4226,7 @@ void clusterCommand(client *c) {
 "FORGET <node-id> -- Remove a node from the cluster.",
 "GETKEYSINSLOT <slot> <count> -- Return key names stored by current node in a slot.",
 "FLUSHSLOTS -- Delete current node own slots information.",
-"INFO - Return information about the cluster.",
+"INFO - Return onformation about the cluster.",
 "KEYSLOT <key> -- Return the hash slot for <key>.",
 "MEET <ip> <port> [bus-port] -- Connect nodes into a working cluster.",
 "MYID -- Return the node id.",
@@ -4340,7 +4237,6 @@ void clusterCommand(client *c) {
 "SET-config-epoch <epoch> - Set config epoch of current node.",
 "SETSLOT <slot> (importing|migrating|stable|node <node-id>) -- Set slot state.",
 "REPLICAS <node-id> -- Return <node-id> replicas.",
-"SAVECONFIG - Force saving cluster configuration on disk.",
 "SLOTS -- Return information about slots range mappings. Each range is made of:",
 "    start, end, master and replicas IP addresses, ports and ids",
 NULL
@@ -4376,9 +4272,12 @@ NULL
        }
    } else if (!strcasecmp(szFromObj(c->argv[1]),"nodes") && c->argc == 2) {
        /* CLUSTER NODES */
-        sds nodes = clusterGenNodesDescription(0);
-        addReplyVerbatim(c,nodes,sdslen(nodes),"txt");
-        sdsfree(nodes);
+        robj *o;
+        sds ci = clusterGenNodesDescription(0);
+
+        o = createObject(OBJ_STRING,ci);
+        addReplyBulk(c,o);
+        decrRefCount(o);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"myid") && c->argc == 2) {
        /* CLUSTER MYID */
        addReplyBulkCBuffer(c,myself->name, CLUSTER_NAMELEN);
@@ -4387,7 +4286,7 @@ NULL
        clusterReplyMultiBulkSlots(c);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"flushslots") && c->argc == 2) {
        /* CLUSTER FLUSHSLOTS */
-        if (dictSize(g_pserver->db[0].pdict) != 0) {
+        if (g_pserver->db[0].size() != 0) {
            addReplyError(c,"DB must be empty to perform CLUSTER FLUSHSLOTS.");
            return;
        }
@@ -4620,8 +4519,10 @@ NULL
            "cluster_stats_messages_received:%lld\r\n", tot_msg_received);

        /* Produce the reply protocol. */
-        addReplyVerbatim(c,info,sdslen(info),"txt");
-        sdsfree(info);
+        addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
+            (unsigned long)sdslen(info)));
+        addReplySds(c,info);
+        addReply(c,shared.crlf);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"saveconfig") && c->argc == 2) {
        int retval = clusterSaveConfig(1);

@@ -4720,7 +4621,7 @@ NULL
         * slots nor keys to accept to replicate some other node.
         * Slaves can switch to another master without issues. */
        if (nodeIsMaster(myself) &&
-            (myself->numslots != 0 || dictSize(g_pserver->db[0].pdict) != 0)) {
+            (myself->numslots != 0 || g_pserver->db[0].size() != 0)) {
            addReplyError(c,
                "To set a master the node must be empty and "
                "without assigned slots.");
@@ -4877,7 +4778,7 @@ NULL

        /* Slaves can be reset while containing data, but not master nodes
         * that must be empty. */
-        if (nodeIsMaster(myself) && dictSize(c->db->pdict) != 0) {
+        if (nodeIsMaster(myself) && c->db->size() != 0) {
            addReplyError(c,"CLUSTER RESET can't be called with "
                            "master nodes containing keys");
            return;
@@ -4893,6 +4794,7 @@ NULL
 /* -----------------------------------------------------------------------------
 * DUMP, RESTORE and MIGRATE commands
 * -------------------------------------------------------------------------- */
+ssize_t rdbSaveAuxFieldStrStr(rio *rdb, const char *key, const char *val);

 /* Generates a DUMP-format representation of the object 'o', adding it to the
 * io stream pointed by 'rio'. This function can't fail. */
@@ -4905,6 +4807,9 @@ void createDumpPayload(rio *payload, robj_roptr o, robj *key) {
    rioInitWithBuffer(payload,sdsempty());
    serverAssert(rdbSaveObjectType(payload,o));
    serverAssert(rdbSaveObject(payload,o,key));
+    char szT[32];
+    snprintf(szT, 32, "%" PRIu64, o->mvcc_tstamp);
+    serverAssert(rdbSaveAuxFieldStrStr(payload,"mvcc-tstamp", szT) != -1);

    /* Write the footer, this is how it looks like:
     * ----------------+---------------------+---------------+
@@ -4952,7 +4857,7 @@ int verifyDumpPayload(unsigned char *p, size_t len) {
 * DUMP is actually not used by Redis Cluster but it is the obvious
 * complement of RESTORE and can be useful for different applications. */
 void dumpCommand(client *c) {
-    robj_roptr o;
+    robj_roptr o, dumpobj;
    rio payload;

    /* Check if the key is here. */
@@ -4965,7 +4870,9 @@ void dumpCommand(client *c) {
    createDumpPayload(&payload,o,c->argv[1]);

    /* Transfer to the client */
-    addReplyBulkSds(c,payload.io.buffer.ptr);
+    dumpobj = createObject(OBJ_STRING,payload.io.buffer.ptr);
+    addReplyBulk(c,dumpobj);
+    decrRefCount(dumpobj);
    return;
 }

@@ -5038,6 +4945,21 @@ void restoreCommand(client *c) {
        addReplyError(c,"Bad data format");
        return;
    }
+    if (rdbLoadType(&payload) == RDB_OPCODE_AUX)
+    {
+        robj *auxkey, *auxval;
+        if ((auxkey = rdbLoadStringObject(&payload)) == NULL) goto eoferr;
+        if ((auxval = rdbLoadStringObject(&payload)) == NULL) {
+            decrRefCount(auxkey);
+            goto eoferr;
+        }
+        if (strcasecmp(szFromObj(auxkey), "mvcc-tstamp") == 0) {
+            obj->mvcc_tstamp = strtoull(szFromObj(auxval), nullptr, 10);
+        }
+        decrRefCount(auxkey);
+        decrRefCount(auxval);
+    }
+eoferr:

    /* Remove the old key if needed. */
    if (replace) dbDelete(c->db,c->argv[1]);
@@ -5048,9 +4970,8 @@ void restoreCommand(client *c) {
        if (!absttl) ttl+=mstime();
        setExpire(c,c->db,c->argv[1],nullptr,ttl);
    }
-    objectSetLRUOrLFU(obj,lfu_freq,lru_idle,lru_clock,1000);
+    objectSetLRUOrLFU(obj,lfu_freq,lru_idle,lru_clock);
    signalModifiedKey(c->db,c->argv[1]);
-    notifyKeyspaceEvent(NOTIFY_GENERIC,"restore",c->argv[1],c->db->id);
    addReply(c,shared.ok);
    g_pserver->dirty++;
 }
@@ -5065,7 +4986,7 @@ void restoreCommand(client *c) {
 #define MIGRATE_SOCKET_CACHE_TTL 10 /* close cached sockets after 10 sec. */

 typedef struct migrateCachedSocket {
-    connection *conn;
+    int fd;
    long last_dbid;
    time_t last_use_time;
 } migrateCachedSocket;
@@ -5082,7 +5003,7 @@ typedef struct migrateCachedSocket {
 * should be called so that the connection will be created from scratch
 * the next time. */
 migrateCachedSocket* migrateGetSocket(client *c, robj *host, robj *port, long timeout) {
-    connection *conn;
+    int fd;
    sds name = sdsempty();
    migrateCachedSocket *cs;

@@ -5102,26 +5023,34 @@ migrateCachedSocket* migrateGetSocket(client *c, robj *host, robj *port, long ti
        /* Too many items, drop one at random. */
        dictEntry *de = dictGetRandomKey(g_pserver->migrate_cached_sockets);
        cs = (migrateCachedSocket*)dictGetVal(de);
-        connClose(cs->conn);
+        close(cs->fd);
        zfree(cs);
        dictDelete(g_pserver->migrate_cached_sockets,dictGetKey(de));
    }

    /* Create the socket */
-    conn = g_pserver->tls_cluster ? connCreateTLS() : connCreateSocket();
-    if (connBlockingConnect(conn, szFromObj(c->argv[1]), atoi(szFromObj(c->argv[2])), timeout)
-            != C_OK) {
-        addReplySds(c,
-            sdsnew("-IOERR error or timeout connecting to the client\r\n"));
-        connClose(conn);
+    fd = anetTcpNonBlockConnect(serverTL->neterr,szFromObj(c->argv[1]),
+                                atoi(szFromObj(c->argv[2])));
+    if (fd == -1) {
        sdsfree(name);
+        addReplyErrorFormat(c,"Can't connect to target node: %s",
+            serverTL->neterr);
+        return NULL;
+    }
+    anetEnableTcpNoDelay(serverTL->neterr,fd);
+
+    /* Check if it connects within the specified timeout. */
+    if ((aeWait(fd,AE_WRITABLE,timeout) & AE_WRITABLE) == 0) {
+        sdsfree(name);
+        addReplySds(c,
+            sdsnew("-IOERR error or timeout connecting to the client\r\n"));
+        close(fd);
        return NULL;
    }
-    connEnableTcpNoDelay(conn);

    /* Add to the cache and return it to the caller. */
    cs = (migrateCachedSocket*)zmalloc(sizeof(*cs), MALLOC_LOCAL);
-    cs->conn = conn;
+    cs->fd = fd;
    cs->last_dbid = -1;
    cs->last_use_time = g_pserver->unixtime;
    dictAdd(g_pserver->migrate_cached_sockets,name,cs);
@@ -5142,7 +5071,7 @@ void migrateCloseSocket(robj *host, robj *port) {
        return;
    }

-    connClose(cs->conn);
+    close(cs->fd);
    zfree(cs);
    dictDelete(g_pserver->migrate_cached_sockets,name);
    sdsfree(name);
@@ -5156,7 +5085,7 @@ void migrateCloseTimedoutSockets(void) {
        migrateCachedSocket *cs = (migrateCachedSocket*)dictGetVal(de);

        if ((g_pserver->unixtime - cs->last_use_time) > MIGRATE_SOCKET_CACHE_TTL) {
-            connClose(cs->conn);
+            close(cs->fd);
            zfree(cs);
            dictDelete(g_pserver->migrate_cached_sockets,dictGetKey(de));
        }
@@ -5284,7 +5213,7 @@ try_again:
    /* Create RESTORE payload and generate the protocol to call the command. */
    for (j = 0; j < num_keys; j++) {
        long long ttl = 0;
-        expireEntry *pexpire = getExpire(c->db,kv[j]);
+        expireEntry *pexpire = c->db->getExpire(kv[j]);
        long long expireat = -1;
        if (pexpire != nullptr)
            pexpire->FGetPrimaryExpire(&expireat);
@@ -5348,7 +5277,7 @@ try_again:

        while ((towrite = sdslen(buf)-pos) > 0) {
            towrite = (towrite > (64*1024) ? (64*1024) : towrite);
-            nwritten = connSyncWrite(cs->conn,buf+pos,towrite,timeout);
+            nwritten = syncWrite(cs->fd,buf+pos,towrite,timeout);
            if (nwritten != (signed)towrite) {
                write_error = 1;
                goto socket_err;
@@ -5359,11 +5288,11 @@ try_again:


    /* Read the AUTH reply if needed. */
-    if (password && connSyncReadLine(cs->conn, buf0, sizeof(buf0), timeout) <= 0)
+    if (password && syncReadLine(cs->fd, buf0, sizeof(buf0), timeout) <= 0)
        goto socket_err;

    /* Read the SELECT reply if needed. */
-    if (select && connSyncReadLine(cs->conn, buf1, sizeof(buf1), timeout) <= 0)
+    if (select && syncReadLine(cs->fd, buf1, sizeof(buf1), timeout) <= 0)
        goto socket_err;

    /* Allocate the new argument vector that will replace the current command,
@@ -5374,7 +5303,7 @@ try_again:

    /* Read the RESTORE replies. */
    for (j = 0; j < num_keys; j++) {
-        if (connSyncReadLine(cs->conn, buf2, sizeof(buf2), timeout) <= 0) {
+        if (syncReadLine(cs->fd, buf2, sizeof(buf2), timeout) <= 0) {
            socket_error = 1;
            break;
        }
@@ -5399,7 +5328,6 @@ try_again:
                /* No COPY option: remove the local key, signal the change. */
                dbDelete(c->db,kv[j]);
                signalModifiedKey(c->db,kv[j]);
-                notifyKeyspaceEvent(NOTIFY_GENERIC,"del",kv[j],c->db->id);
                g_pserver->dirty++;

                /* Populate the argument vector to replace the old one. */
@@ -5565,8 +5493,8 @@ void readwriteCommand(client *c) {
 * already "down" but it is fragile to rely on the update of the global state,
 * so we also handle it here.
 *
- * CLUSTER_REDIR_DOWN_STATE and CLUSTER_REDIR_DOWN_RO_STATE if the cluster is
- * down but the user attempts to execute a command that addresses one or more keys. */
+ * CLUSTER_REDIR_DOWN_STATE if the cluster is down but the user attempts to
+ * execute a command that addresses one or more keys. */
 clusterNode *getNodeByQuery(client *c, struct redisCommand *cmd, robj **argv, int argc, int *hashslot, int *error_code) {
    clusterNode *n = NULL;
    robj *firstkey = NULL;
@@ -5689,27 +5617,10 @@ clusterNode *getNodeByQuery(client *c, struct redisCommand *cmd, robj **argv, in
     * without redirections or errors in all the cases. */
    if (n == NULL) return myself;

-    /* Cluster is globally down but we got keys? We only serve the request
-     * if it is a read command and when allow_reads_when_down is enabled. */
+    /* Cluster is globally down but we got keys? We can't serve the request. */
    if (g_pserver->cluster->state != CLUSTER_OK) {
-        if (!g_pserver->cluster_allow_reads_when_down) {
-            /* The cluster is configured to block commands when the
-             * cluster is down. */
-            if (error_code) *error_code = CLUSTER_REDIR_DOWN_STATE;
-            return NULL;
-        } else if (!(cmd->flags & CMD_READONLY) && !(cmd->proc == evalCommand)
-                && !(cmd->proc == evalShaCommand))
-        {
-            /* The cluster is configured to allow read only commands
-             * but this command is neither readonly, nor EVAL or
-             * EVALSHA. */
-            if (error_code) *error_code = CLUSTER_REDIR_DOWN_RO_STATE;
-            return NULL;
-        } else {
-            /* Fall through and allow the command to be executed:
-             * this happens when g_pserver->cluster_allow_reads_when_down is
-             * true and the command is a readonly command or EVAL / EVALSHA. */
-        }
+        if (error_code) *error_code = CLUSTER_REDIR_DOWN_STATE;
+        return NULL;
    }

    /* Return the hashslot by reference. */
@@ -5778,8 +5689,6 @@ void clusterRedirectClient(client *c, clusterNode *n, int hashslot, int error_co
        addReplySds(c,sdsnew("-TRYAGAIN Multiple keys request during rehashing of slot\r\n"));
    } else if (error_code == CLUSTER_REDIR_DOWN_STATE) {
        addReplySds(c,sdsnew("-CLUSTERDOWN The cluster is down\r\n"));
-    } else if (error_code == CLUSTER_REDIR_DOWN_RO_STATE) {
-        addReplySds(c,sdsnew("-CLUSTERDOWN The cluster is down and only accepts read commands\r\n"));
    } else if (error_code == CLUSTER_REDIR_DOWN_UNBOUND) {
        addReplySds(c,sdsnew("-CLUSTERDOWN Hash slot not served\r\n"));
    } else if (error_code == CLUSTER_REDIR_MOVED ||
@@ -5815,10 +5724,7 @@ int clusterRedirectBlockedClientIfNeeded(client *c) {
        dictEntry *de;
        dictIterator *di;

-        /* If the cluster is down, unblock the client with the right error.
-         * If the cluster is configured to allow reads on cluster down, we
-         * still want to emit this error since a write will be required
-         * to unblock them which may never come.  */
+        /* If the cluster is down, unblock the client with the right error. */
        if (g_pserver->cluster->state == CLUSTER_FAIL) {
            clusterRedirectClient(c,NULL,0,CLUSTER_REDIR_DOWN_STATE);
            return 1;
@@ -17,10 +17,15 @@ extern "C" {

 /* The following defines are amount of time, sometimes expressed as
 * multiplicators of the node timeout value (when ending with MULT). */
+#define CLUSTER_DEFAULT_NODE_TIMEOUT 15000
+#define CLUSTER_DEFAULT_SLAVE_VALIDITY 10 /* Slave max data age factor. */
+#define CLUSTER_DEFAULT_REQUIRE_FULL_COVERAGE 1
+#define CLUSTER_DEFAULT_SLAVE_NO_FAILOVER 0 /* Failover by default. */
 #define CLUSTER_FAIL_REPORT_VALIDITY_MULT 2 /* Fail report validity. */
 #define CLUSTER_FAIL_UNDO_TIME_MULT 2 /* Undo fail if master is back. */
 #define CLUSTER_FAIL_UNDO_TIME_ADD 10 /* Some additional time. */
 #define CLUSTER_FAILOVER_DELAY 5 /* Seconds */
+#define CLUSTER_DEFAULT_MIGRATION_BARRIER 1
 #define CLUSTER_MF_TIMEOUT 5000 /* Milliseconds to do a manual failover. */
 #define CLUSTER_MF_PAUSE_MULT 2 /* Master pause manual failover mult. */
 #define CLUSTER_SLAVE_MIGRATION_DELAY 5000 /* Delay for slave migration. */
@@ -33,14 +38,13 @@ extern "C" {
 #define CLUSTER_REDIR_MOVED 4         /* -MOVED redirection required. */
 #define CLUSTER_REDIR_DOWN_STATE 5    /* -CLUSTERDOWN, global state. */
 #define CLUSTER_REDIR_DOWN_UNBOUND 6  /* -CLUSTERDOWN, unbound slot. */
-#define CLUSTER_REDIR_DOWN_RO_STATE 7 /* -CLUSTERDOWN, allow reads. */

 struct clusterNode;

 /* clusterLink encapsulates everything needed to talk with a remote node. */
 typedef struct clusterLink {
    mstime_t ctime;             /* Link creation time */
-    connection *conn;           /* Connection to remote node */
+    int fd;                     /* TCP socket file descriptor */
    sds sndbuf;                 /* Packet send buffer */
    sds rcvbuf;                 /* Packet reception buffer */
    struct clusterNode *node;   /* Node related to this link if any, or NULL */
@@ -30,7 +30,16 @@ public:
        zfree(m_data);
    }

-    compactvector(compactvector &) noexcept = delete;
+    compactvector(const compactvector &src)
+    {
+        m_celem = src.m_celem;
+        m_max = src.m_max;
+        m_data = (T*)zmalloc(sizeof(T) * m_max, MALLOC_LOCAL);
+        for (size_t ielem = 0; ielem < m_celem; ++ielem)
+        {
+            new (m_data+ielem) T(src[ielem]);
+        }
+    }

    compactvector(compactvector &&src) noexcept
    {
@@ -42,7 +51,6 @@ public:
        src.m_max = 0;
    }

-    compactvector &operator=(const compactvector&) noexcept = delete;
    compactvector &operator=(compactvector &&src) noexcept
    {
        zfree(m_data);
@@ -1,431 +0,0 @@
-/*
- * Copyright (c) 2019, Redis Labs
- * 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 "server.h"
-#include "connhelpers.h"
-
-/* The connections module provides a lean abstraction of network connections
- * to avoid direct socket and async event management across the Redis code base.
- *
- * It does NOT provide advanced connection features commonly found in similar
- * libraries such as complete in/out buffer management, throttling, etc. These
- * functions remain in networking.c.
- *
- * The primary goal is to allow transparent handling of TCP and TLS based
- * connections. To do so, connections have the following properties:
- *
- * 1. A connection may live before its corresponding socket exists.  This
- *    allows various context and configuration setting to be handled before
- *    establishing the actual connection.
- * 2. The caller may register/unregister logical read/write handlers to be
- *    called when the connection has data to read from/can accept writes.
- *    These logical handlers may or may not correspond to actual AE events,
- *    depending on the implementation (for TCP they are; for TLS they aren't).
- */
-
-extern ConnectionType CT_Socket;
-
-/* When a connection is created we must know its type already, but the
- * underlying socket may or may not exist:
- *
- * - For accepted connections, it exists as we do not model the listen/accept
- *   part; So caller calls connCreateSocket() followed by connAccept().
- * - For outgoing connections, the socket is created by the connection module
- *   itself; So caller calls connCreateSocket() followed by connConnect(),
- *   which registers a connect callback that fires on connected/error state
- *   (and after any transport level handshake was done).
- *
- * NOTE: An earlier version relied on connections being part of other structs
- * and not independently allocated. This could lead to further optimizations
- * like using container_of(), etc.  However it was discontinued in favor of
- * this approach for these reasons:
- *
- * 1. In some cases conns are created/handled outside the context of the
- * containing struct, in which case it gets a bit awkward to copy them.
- * 2. Future implementations may wish to allocate arbitrary data for the
- * connection.
- * 3. The container_of() approach is anyway risky because connections may
- * be embedded in different structs, not just client.
- */
-
-connection *connCreateSocket() {
-    connection *conn = (connection*)zcalloc(sizeof(connection), MALLOC_LOCAL);
-    conn->type = &CT_Socket;
-    conn->fd = -1;
-
-    return conn;
-}
-
-/* Create a new socket-type connection that is already associated with
- * an accepted connection.
- *
- * The socket is not read for I/O until connAccept() was called and
- * invoked the connection-level accept handler.
- */
-connection *connCreateAcceptedSocket(int fd) {
-    connection *conn = connCreateSocket();
-    conn->fd = fd;
-    conn->state = CONN_STATE_ACCEPTING;
-    return conn;
-}
-
-static int connSocketConnect(connection *conn, const char *addr, int port, const char *src_addr,
-        ConnectionCallbackFunc connect_handler) {
-    int fd = anetTcpNonBlockBestEffortBindConnect(NULL,addr,port,src_addr);
-    if (fd == -1) {
-        conn->state = CONN_STATE_ERROR;
-        conn->last_errno = errno;
-        return C_ERR;
-    }
-
-    conn->fd = fd;
-    conn->state = CONN_STATE_CONNECTING;
-
-    conn->conn_handler = connect_handler;
-    aeCreateFileEvent(serverTL->el, conn->fd, AE_WRITABLE,
-            conn->type->ae_handler, conn);
-
-    return C_OK;
-}
-
-/* Returns true if a write handler is registered */
-int connHasWriteHandler(connection *conn) {
-    return conn->write_handler != NULL;
-}
-
-/* Returns true if a read handler is registered */
-int connHasReadHandler(connection *conn) {
-    return conn->read_handler != NULL;
-}
-
-/* Associate a private data pointer with the connection */
-void connSetPrivateData(connection *conn, void *data) {
-    conn->private_data = data;
-}
-
-/* Get the associated private data pointer */
-void *connGetPrivateData(connection *conn) {
-    return conn->private_data;
-}
-
-/* ------ Pure socket connections ------- */
-
-/* A very incomplete list of implementation-specific calls.  Much of the above shall
- * move here as we implement additional connection types.
- */
-
-/* Close the connection and free resources. */
-static void connSocketClose(connection *conn) {
-    if (conn->fd != -1) {
-        aeDeleteFileEvent(serverTL->el,conn->fd,AE_READABLE);
-        aeDeleteFileEvent(serverTL->el,conn->fd,AE_WRITABLE);
-        close(conn->fd);
-        conn->fd = -1;
-    }
-
-    /* If called from within a handler, schedule the close but
-     * keep the connection until the handler returns.
-     */
-    if (connHasRefs(conn)) {
-        conn->flags |= CONN_FLAG_CLOSE_SCHEDULED;
-        return;
-    }
-
-    zfree(conn);
-}
-
-static int connSocketWrite(connection *conn, const void *data, size_t data_len) {
-    int ret = write(conn->fd, data, data_len);
-    if (ret < 0 && errno != EAGAIN) {
-        conn->last_errno = errno;
-        conn->state = CONN_STATE_ERROR;
-    }
-
-    return ret;
-}
-
-static int connSocketRead(connection *conn, void *buf, size_t buf_len) {
-    int ret = read(conn->fd, buf, buf_len);
-    if (!ret) {
-        conn->state = CONN_STATE_CLOSED;
-    } else if (ret < 0 && errno != EAGAIN) {
-        conn->last_errno = errno;
-        conn->state = CONN_STATE_ERROR;
-    }
-
-    return ret;
-}
-
-static int connSocketAccept(connection *conn, ConnectionCallbackFunc accept_handler) {
-    int ret = C_OK;
-
-    if (conn->state != CONN_STATE_ACCEPTING) return C_ERR;
-    conn->state = CONN_STATE_CONNECTED;
-
-    connIncrRefs(conn);
-    if (!callHandler(conn, accept_handler)) ret = C_ERR;
-    connDecrRefs(conn);
-
-    return ret;
-}
-
-/* Register a write handler, to be called when the connection is writable.
- * If NULL, the existing handler is removed.
- *
- * The barrier flag indicates a write barrier is requested, resulting with
- * CONN_FLAG_WRITE_BARRIER set. This will ensure that the write handler is
- * always called before and not after the read handler in a single event
- * loop.
- */
-static int connSocketSetWriteHandler(connection *conn, ConnectionCallbackFunc func, int barrier, bool fThreadSafe) {
-    if (func == conn->write_handler) return C_OK;
-
-    conn->write_handler = func;
-    if (barrier)
-        conn->flags |= CONN_FLAG_WRITE_BARRIER;
-    else
-        conn->flags &= ~CONN_FLAG_WRITE_BARRIER;
-
-    int flags = AE_WRITABLE;
-    if (fThreadSafe)
-        flags |= AE_WRITE_THREADSAFE;
-
-    if (!conn->write_handler)
-        aeDeleteFileEvent(serverTL->el,conn->fd,AE_WRITABLE);
-    else
-        if (aeCreateFileEvent(serverTL->el,conn->fd,flags,
-                    conn->type->ae_handler,conn) == AE_ERR) return C_ERR;
-    return C_OK;
-}
-
-/* Register a read handler, to be called when the connection is readable.
- * If NULL, the existing handler is removed.
- */
-static int connSocketSetReadHandler(connection *conn, ConnectionCallbackFunc func, bool fThreadSafe) {
-    if (func == conn->read_handler) return C_OK;
-
-    int flags = AE_READABLE;
-    if (fThreadSafe)
-        flags |= AE_READ_THREADSAFE;
-
-    conn->read_handler = func;
-    if (!conn->read_handler)
-        aeDeleteFileEvent(serverTL->el,conn->fd,AE_READABLE);
-    else
-        if (aeCreateFileEvent(serverTL->el,conn->fd,
-                    flags,conn->type->ae_handler,conn) == AE_ERR) return C_ERR;
-    return C_OK;
-}
-
-static const char *connSocketGetLastError(connection *conn) {
-    return strerror(conn->last_errno);
-}
-
-static void connSocketEventHandler(struct aeEventLoop *el, int fd, void *clientData, int mask)
-{
-    UNUSED(el);
-    UNUSED(fd);
-    connection *conn = (connection*)clientData;
-
-    if (conn->state == CONN_STATE_CONNECTING &&
-            (mask & AE_WRITABLE) && conn->conn_handler) {
-
-        if (connGetSocketError(conn)) {
-            conn->last_errno = errno;
-            conn->state = CONN_STATE_ERROR;
-        } else {
-            conn->state = CONN_STATE_CONNECTED;
-        }
-
-        if (!conn->write_handler) aeDeleteFileEvent(serverTL->el,conn->fd,AE_WRITABLE);
-
-        if (!callHandler(conn, conn->conn_handler)) return;
-        conn->conn_handler = NULL;
-    }
-
-    /* Normally we execute the readable event first, and the writable
-     * event later. This is useful as sometimes we may be able
-     * to serve the reply of a query immediately after processing the
-     * query.
-     *
-     * However if WRITE_BARRIER is set in the mask, our application is
-     * asking us to do the reverse: never fire the writable event
-     * after the readable. In such a case, we invert the calls.
-     * This is useful when, for instance, we want to do things
-     * in the beforeSleep() hook, like fsync'ing a file to disk,
-     * before replying to a client. */
-    int invert = conn->flags & CONN_FLAG_WRITE_BARRIER;
-
-    int call_write = (mask & AE_WRITABLE) && conn->write_handler;
-    int call_read = (mask & AE_READABLE) && conn->read_handler;
-
-    /* Handle normal I/O flows */
-    if (!invert && call_read) {
-        if (!callHandler(conn, conn->read_handler)) return;
-    }
-    /* Fire the writable event. */
-    if (call_write) {
-        if (!callHandler(conn, conn->write_handler)) return;
-    }
-    /* If we have to invert the call, fire the readable event now
-     * after the writable one. */
-    if (invert && call_read) {
-        if (!callHandler(conn, conn->read_handler)) return;
-    }
-}
-
-static int connSocketBlockingConnect(connection *conn, const char *addr, int port, long long timeout) {
-    int fd = anetTcpNonBlockConnect(NULL,addr,port);
-    if (fd == -1) {
-        conn->state = CONN_STATE_ERROR;
-        conn->last_errno = errno;
-        return C_ERR;
-    }
-
-    if ((aeWait(fd, AE_WRITABLE, timeout) & AE_WRITABLE) == 0) {
-        conn->state = CONN_STATE_ERROR;
-        conn->last_errno = ETIMEDOUT;
-    }
-
-    conn->fd = fd;
-    conn->state = CONN_STATE_CONNECTED;
-    return C_OK;
-}
-
-/* Connection-based versions of syncio.c functions.
- * NOTE: This should ideally be refactored out in favor of pure async work.
- */
-
-static ssize_t connSocketSyncWrite(connection *conn, const char *ptr, ssize_t size, long long timeout) {
-    return syncWrite(conn->fd, ptr, size, timeout);
-}
-
-static ssize_t connSocketSyncRead(connection *conn, char *ptr, ssize_t size, long long timeout) {
-    return syncRead(conn->fd, ptr, size, timeout);
-}
-
-static ssize_t connSocketSyncReadLine(connection *conn, char *ptr, ssize_t size, long long timeout) {
-    return syncReadLine(conn->fd, ptr, size, timeout);
-}
-
-
-ConnectionType CT_Socket = {
-    connSocketEventHandler,
-    connSocketConnect,
-    connSocketWrite,
-    connSocketRead,
-    connSocketClose,
-    connSocketAccept,
-    connSocketSetWriteHandler,
-    connSocketSetReadHandler,
-    connSocketGetLastError,
-    connSocketBlockingConnect,
-    connSocketSyncWrite,
-    connSocketSyncRead,
-    connSocketSyncReadLine
-};
-
-
-int connGetSocketError(connection *conn) {
-    int sockerr = 0;
-    socklen_t errlen = sizeof(sockerr);
-
-    if (getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &sockerr, &errlen) == -1)
-        sockerr = errno;
-    return sockerr;
-}
-
-int connPeerToString(connection *conn, char *ip, size_t ip_len, int *port) {
-    return anetPeerToString(conn ? conn->fd : -1, ip, ip_len, port);
-}
-
-int connFormatPeer(connection *conn, char *buf, size_t buf_len) {
-    return anetFormatPeer(conn ? conn->fd : -1, buf, buf_len);
-}
-
-int connSockName(connection *conn, char *ip, size_t ip_len, int *port) {
-    return anetSockName(conn->fd, ip, ip_len, port);
-}
-
-int connBlock(connection *conn) {
-    if (conn->fd == -1) return C_ERR;
-    return anetBlock(NULL, conn->fd);
-}
-
-int connNonBlock(connection *conn) {
-    if (conn->fd == -1) return C_ERR;
-    return anetNonBlock(NULL, conn->fd);
-}
-
-int connEnableTcpNoDelay(connection *conn) {
-    if (conn->fd == -1) return C_ERR;
-    return anetEnableTcpNoDelay(NULL, conn->fd);
-}
-
-int connDisableTcpNoDelay(connection *conn) {
-    if (conn->fd == -1) return C_ERR;
-    return anetDisableTcpNoDelay(NULL, conn->fd);
-}
-
-int connKeepAlive(connection *conn, int interval) {
-    if (conn->fd == -1) return C_ERR;
-    return anetKeepAlive(NULL, conn->fd, interval);
-}
-
-int connSendTimeout(connection *conn, long long ms) {
-    return anetSendTimeout(NULL, conn->fd, ms);
-}
-
-int connRecvTimeout(connection *conn, long long ms) {
-    return anetRecvTimeout(NULL, conn->fd, ms);
-}
-
-int connGetState(connection *conn) {
-    return conn->state;
-}
-
-void connSetThreadAffinity(connection *conn, int cpu) {
-#ifdef HAVE_SO_INCOMING_CPU
-    if (setsockopt(conn->fd, SOL_SOCKET, SO_INCOMING_CPU, &cpu, sizeof(cpu)) != 0)
-    {
-        serverLog(LL_WARNING, "Failed to set socket affinity");
-    }
-#endif
-}
-
-/* Return a text that describes the connection, suitable for inclusion
- * in CLIENT LIST and similar outputs.
- *
- * For sockets, we always return "fd=<fdnum>" to maintain compatibility.
- */
-const char *connGetInfo(connection *conn, char *buf, size_t buf_len) {
-    snprintf(buf, buf_len-1, "fd=%i", conn->fd);
-    return buf;
-}
-
@@ -1,230 +0,0 @@
-
-/*
- * Copyright (c) 2019, Redis Labs
- * 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 __REDIS_CONNECTION_H
-#define __REDIS_CONNECTION_H
-
-#define CONN_INFO_LEN   32
-
-struct aeEventLoop;
-typedef struct connection connection;
-
-typedef enum {
-    CONN_STATE_NONE = 0,
-    CONN_STATE_CONNECTING,
-    CONN_STATE_ACCEPTING,
-    CONN_STATE_CONNECTED,
-    CONN_STATE_CLOSED,
-    CONN_STATE_ERROR
-} ConnectionState;
-
-#define CONN_FLAG_CLOSE_SCHEDULED   (1<<0)      /* Closed scheduled by a handler */
-#define CONN_FLAG_WRITE_BARRIER     (1<<1)      /* Write barrier requested */
-#define CONN_FLAG_READ_THREADSAFE        (1<<2)
-#define CONN_FLAG_WRITE_THREADSAFE       (1<<3)
-
-typedef void (*ConnectionCallbackFunc)(struct connection *conn);
-
-typedef struct ConnectionType {
-    void (*ae_handler)(struct aeEventLoop *el, int fd, void *clientData, int mask);
-    int (*connect)(struct connection *conn, const char *addr, int port, const char *source_addr, ConnectionCallbackFunc connect_handler);
-    int (*write)(struct connection *conn, const void *data, size_t data_len);
-    int (*read)(struct connection *conn, void *buf, size_t buf_len);
-    void (*close)(struct connection *conn);
-    int (*accept)(struct connection *conn, ConnectionCallbackFunc accept_handler);
-    int (*set_write_handler)(struct connection *conn, ConnectionCallbackFunc handler, int barrier, bool fThreadSafe);
-    int (*set_read_handler)(struct connection *conn, ConnectionCallbackFunc handler, bool fThreadSafe);
-    const char *(*get_last_error)(struct connection *conn);
-    int (*blocking_connect)(struct connection *conn, const char *addr, int port, long long timeout);
-    ssize_t (*sync_write)(struct connection *conn, const char *ptr, ssize_t size, long long timeout);
-    ssize_t (*sync_read)(struct connection *conn, char *ptr, ssize_t size, long long timeout);
-    ssize_t (*sync_readline)(struct connection *conn, char *ptr, ssize_t size, long long timeout);
-} ConnectionType;
-
-struct connection {
-    ConnectionType *type;
-    ConnectionState state;
-    short int flags;
-    short int refs;
-    int last_errno;
-    void *private_data;
-    ConnectionCallbackFunc conn_handler;
-    ConnectionCallbackFunc write_handler;
-    ConnectionCallbackFunc read_handler;
-    int fd;
-};
-
-/* The connection module does not deal with listening and accepting sockets,
- * so we assume we have a socket when an incoming connection is created.
- *
- * The fd supplied should therefore be associated with an already accept()ed
- * socket.
- *
- * connAccept() may directly call accept_handler(), or return and call it
- * at a later time. This behavior is a bit awkward but aims to reduce the need
- * to wait for the next event loop, if no additional handshake is required.
- *
- * IMPORTANT: accept_handler may decide to close the connection, calling connClose().
- * To make this safe, the connection is only marked with CONN_FLAG_CLOSE_SCHEDULED
- * in this case, and connAccept() returns with an error.
- *
- * connAccept() callers must always check the return value and on error (C_ERR)
- * a connClose() must be called.
- */
-
-static inline int connAccept(connection *conn, ConnectionCallbackFunc accept_handler) {
-    return conn->type->accept(conn, accept_handler);
-}
-
-/* Establish a connection.  The connect_handler will be called when the connection
- * is established, or if an error has occured.
- *
- * The connection handler will be responsible to set up any read/write handlers
- * as needed.
- *
- * If C_ERR is returned, the operation failed and the connection handler shall
- * not be expected.
- */
-static inline int connConnect(connection *conn, const char *addr, int port, const char *src_addr,
-        ConnectionCallbackFunc connect_handler) {
-    return conn->type->connect(conn, addr, port, src_addr, connect_handler);
-}
-
-/* Blocking connect.
- *
- * NOTE: This is implemented in order to simplify the transition to the abstract
- * connections, but should probably be refactored out of cluster.c and replication.c,
- * in favor of a pure async implementation.
- */
-static inline int connBlockingConnect(connection *conn, const char *addr, int port, long long timeout) {
-    return conn->type->blocking_connect(conn, addr, port, timeout);
-}
-
-/* Write to connection, behaves the same as write(2).
- *
- * Like write(2), a short write is possible. A -1 return indicates an error.
- *
- * The caller should NOT rely on errno. Testing for an EAGAIN-like condition, use
- * connGetState() to see if the connection state is still CONN_STATE_CONNECTED.
- */
-static inline int connWrite(connection *conn, const void *data, size_t data_len) {
-    return conn->type->write(conn, data, data_len);
-}
-
-/* Read from the connection, behaves the same as read(2).
- * 
- * Like read(2), a short read is possible.  A return value of 0 will indicate the
- * connection was closed, and -1 will indicate an error.
- *
- * The caller should NOT rely on errno. Testing for an EAGAIN-like condition, use
- * connGetState() to see if the connection state is still CONN_STATE_CONNECTED.
- */
-static inline int connRead(connection *conn, void *buf, size_t buf_len) {
-    return conn->type->read(conn, buf, buf_len);
-}
-
-/* Register a write handler, to be called when the connection is writable.
- * If NULL, the existing handler is removed.
- */
-static inline int connSetWriteHandler(connection *conn, ConnectionCallbackFunc func, bool fThreadSafe = false) {
-    return conn->type->set_write_handler(conn, func, 0, fThreadSafe);
-}
-
-/* Register a read handler, to be called when the connection is readable.
- * If NULL, the existing handler is removed.
- */
-static inline int connSetReadHandler(connection *conn, ConnectionCallbackFunc func, bool fThreadSafe = false) {
-    return conn->type->set_read_handler(conn, func, fThreadSafe);
-}
-
-/* Set a write handler, and possibly enable a write barrier, this flag is
- * cleared when write handler is changed or removed.
- * With barroer enabled, we never fire the event if the read handler already
- * fired in the same event loop iteration. Useful when you want to persist
- * things to disk before sending replies, and want to do that in a group fashion. */
-static inline int connSetWriteHandlerWithBarrier(connection *conn, ConnectionCallbackFunc func, int barrier, bool fThreadSafe = false) {
-    return conn->type->set_write_handler(conn, func, barrier, fThreadSafe);
-}
-
-static inline void connClose(connection *conn) {
-    conn->type->close(conn);
-}
-
-/* Returns the last error encountered by the connection, as a string.  If no error,
- * a NULL is returned.
- */
-static inline const char *connGetLastError(connection *conn) {
-    return conn->type->get_last_error(conn);
-}
-
-static inline ssize_t connSyncWrite(connection *conn, const char *ptr, ssize_t size, long long timeout) {
-    return conn->type->sync_write(conn, ptr, size, timeout);
-}
-
-static inline ssize_t connSyncRead(connection *conn, char *ptr, ssize_t size, long long timeout) {
-    return conn->type->sync_read(conn, ptr, size, timeout);
-}
-
-static inline ssize_t connSyncReadLine(connection *conn, char *ptr, ssize_t size, long long timeout) {
-    return conn->type->sync_readline(conn, ptr, size, timeout);
-}
-
-connection *connCreateSocket();
-connection *connCreateAcceptedSocket(int fd);
-
-connection *connCreateTLS();
-connection *connCreateAcceptedTLS(int fd, int require_auth);
-
-void connSetPrivateData(connection *conn, void *data);
-void *connGetPrivateData(connection *conn);
-int connGetState(connection *conn);
-int connHasWriteHandler(connection *conn);
-int connHasReadHandler(connection *conn);
-int connGetSocketError(connection *conn);
-void connSetThreadAffinity(connection *conn, int cpu);
-
-/* anet-style wrappers to conns */
-int connBlock(connection *conn);
-int connNonBlock(connection *conn);
-int connEnableTcpNoDelay(connection *conn);
-int connDisableTcpNoDelay(connection *conn);
-int connKeepAlive(connection *conn, int interval);
-int connSendTimeout(connection *conn, long long ms);
-int connRecvTimeout(connection *conn, long long ms);
-int connPeerToString(connection *conn, char *ip, size_t ip_len, int *port);
-int connFormatPeer(connection *conn, char *buf, size_t buf_len);
-int connSockName(connection *conn, char *ip, size_t ip_len, int *port);
-const char *connGetInfo(connection *conn, char *buf, size_t buf_len);
-
-/* Helpers for tls special considerations */
-int tlsHasPendingData();
-void tlsProcessPendingData();
-
-#endif  /* __REDIS_CONNECTION_H */
@@ -1,88 +0,0 @@
-
-/*
- * Copyright (c) 2019, Redis Labs
- * 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 __REDIS_CONNHELPERS_H
-#define __REDIS_CONNHELPERS_H
-
-#include "connection.h"
-
-/* These are helper functions that are common to different connection
- * implementations (currently sockets in connection.c and TLS in tls.c).
- *
- * Currently helpers implement the mechanisms for invoking connection
- * handlers and tracking connection references, to allow safe destruction
- * of connections from within a handler.
- */
-
-/* Incremenet connection references.
- *
- * Inside a connection handler, we guarantee refs >= 1 so it is always
- * safe to connClose().
- *
- * In other cases where we don't want to prematurely lose the connection,
- * it can go beyond 1 as well; currently it is only done by connAccept().
- */
-static inline void connIncrRefs(connection *conn) {
-    conn->refs++;
-}
-
-/* Decrement connection references.
- *
- * Note that this is not intended to provide any automatic free logic!
- * callHandler() takes care of that for the common flows, and anywhere an
- * explicit connIncrRefs() is used, the caller is expected to take care of
- * that.
- */
-
-static inline void connDecrRefs(connection *conn) {
-    conn->refs--;
-}
-
-static inline int connHasRefs(connection *conn) {
-    return conn->refs;
-}
-
-/* Helper for connection implementations to call handlers:
- * 1. Increment refs to protect the connection.
- * 2. Execute the handler (if set).
- * 3. Decrement refs and perform deferred close, if refs==0.
- */
-static inline int callHandler(connection *conn, ConnectionCallbackFunc handler) {
-    connIncrRefs(conn);
-    if (handler) handler(conn);
-    connDecrRefs(conn);
-    if (conn->flags & CONN_FLAG_CLOSE_SCHEDULED) {
-        if (!connHasRefs(conn)) connClose(conn);
-        return 0;
-    }
-    return 1;
-}
-
-#endif  /* __REDIS_CONNHELPERS_H */
@@ -1,147 +0,0 @@
-#include "server.h"
-#include "cron.h"
-
-void freeCronObject(robj_roptr o)
-{
-    delete reinterpret_cast<const cronjob*>(ptrFromObj(o));
-}
-
-// CRON [name] [single shot] [optional: start] [delay] [script] [numkeys] [key N] [arg N]
-void cronCommand(client *c)
-{
-    int arg_offset = 0;
-    static const int ARG_NAME = 1;
-    static const int ARG_SINGLESHOT = 2;
-    static const int ARG_EXPIRE = 3;
-    #define ARG_SCRIPT (4+arg_offset)
-    #define ARG_NUMKEYS (5+arg_offset)
-    #define ARG_KEYSTART (6+arg_offset)
-
-    bool fSingleShot = false;
-    if (strcasecmp("single", szFromObj(c->argv[ARG_SINGLESHOT])) == 0) {
-        fSingleShot = true;
-    } else {
-        if (strcasecmp("repeat", szFromObj(c->argv[ARG_SINGLESHOT])) != 0) {
-            addReply(c, shared.syntaxerr);
-            return;
-        }
-    }
-
-    long long interval;
-    if (getLongLongFromObjectOrReply(c, c->argv[ARG_EXPIRE], &interval, "missing expire time") != C_OK)
-        return;
-
-    long long base = g_pserver->mstime;
-    if (getLongLongFromObject(c->argv[ARG_EXPIRE+1], &base) == C_OK) {
-        arg_offset++;
-        std::swap(base, interval);
-    }
-
-    if (interval <= 0)
-    {
-        addReplyError(c, "interval must be positive");
-        return;
-    }
-
-    long numkeys = 0;
-    if (c->argc > ARG_NUMKEYS)
-    {
-        if (getLongFromObjectOrReply(c, c->argv[ARG_NUMKEYS], &numkeys, NULL) != C_OK)
-            return;
-        
-        if (c->argc < (6 + numkeys)) {
-            addReplyError(c, "Missing arguments or numkeys is too big");
-        }
-    }
-
-    std::unique_ptr<cronjob> spjob = std::make_unique<cronjob>();
-    spjob->script = sdsstring(sdsdup(szFromObj(c->argv[ARG_SCRIPT])));
-    spjob->interval = (uint64_t)interval;
-    spjob->startTime = (uint64_t)base;
-    spjob->fSingleShot = fSingleShot;
-    spjob->dbNum = c->db - g_pserver->db;
-    for (long i = 0; i < numkeys; ++i)
-        spjob->veckeys.emplace_back(sdsdup(szFromObj(c->argv[ARG_KEYSTART+i])));
-    for (long i = ARG_KEYSTART + numkeys; i < c->argc; ++i)
-        spjob->vecargs.emplace_back(sdsdup(szFromObj(c->argv[i])));
-
-    robj *o = createObject(OBJ_CRON, spjob.release());
-    setKey(c->db, c->argv[ARG_NAME], o);
-    decrRefCount(o);
-    // use an expire to trigger execution.  Note: We use a subkey expire here so legacy clients don't delete it.
-    setExpire(c, c->db, c->argv[ARG_NAME], c->argv[ARG_NAME], base + interval);
-    ++g_pserver->dirty;
-    addReply(c, shared.ok);
-}
-
-void executeCronJobExpireHook(const char *key, robj *o)
-{
-    serverAssert(o->type == OBJ_CRON);
-    cronjob *job = (cronjob*)ptrFromObj(o);
-    
-    client *cFake = createClient(nullptr, IDX_EVENT_LOOP_MAIN);
-    cFake->lock.lock();
-    cFake->authenticated = 1;
-    cFake->puser = nullptr;
-    selectDb(cFake, job->dbNum);
-    serverAssert(cFake->argc == 0);
-
-    // Setup the args for the EVAL command
-    cFake->cmd = lookupCommandByCString("EVAL");
-    cFake->argc = 3 + job->veckeys.size() + job->vecargs.size();
-    cFake->argv = (robj**)zmalloc(sizeof(robj*) * cFake->argc, MALLOC_LOCAL);
-    cFake->argv[0] = createStringObject("EVAL", 4);
-    cFake->argv[1] = createStringObject(job->script.get(), job->script.size());
-    cFake->argv[2] = createStringObjectFromLongLong(job->veckeys.size());
-    for (size_t i = 0; i < job->veckeys.size(); ++i)
-        cFake->argv[3+i] = createStringObject(job->veckeys[i].get(), job->veckeys[i].size());
-    for (size_t i = 0; i < job->vecargs.size(); ++i)
-        cFake->argv[3+job->veckeys.size()+i] = createStringObject(job->vecargs[i].get(), job->vecargs[i].size());
-
-    int lua_replicate_backup = g_pserver->lua_always_replicate_commands;
-    g_pserver->lua_always_replicate_commands = 0;
-    evalCommand(cFake);
-    g_pserver->lua_always_replicate_commands = lua_replicate_backup;
-
-    if (g_pserver->aof_state != AOF_OFF)
-        feedAppendOnlyFile(cFake->cmd,cFake->db->id,cFake->argv,cFake->argc);
-    // Active replicas do their own expiries, do not propogate
-    if (!g_pserver->fActiveReplica)
-        replicationFeedSlaves(g_pserver->slaves,cFake->db->id,cFake->argv,cFake->argc);
-
-    resetClient(cFake);
-
-    robj *keyobj = createStringObject(key,sdslen(key));
-    int dbId = job->dbNum;
-    if (job->fSingleShot)
-    {
-        dbSyncDelete(cFake->db, keyobj);
-    }
-    else
-    {
-        job->startTime += job->interval;
-        if (job->startTime < (uint64_t)g_pserver->mstime)
-        {
-            // If we are more than one interval in the past then fast forward to
-            //  the first interval still in the future.  If startTime wasn't zero align
-            //  this to the original startTime, if it was zero align to now
-            if (job->startTime == job->interval)
-            {   // startTime was 0
-                job->startTime = g_pserver->mstime + job->interval;
-            }
-            else
-            {
-                auto delta = g_pserver->mstime - job->startTime;
-                auto multiple = (delta / job->interval)+1;
-                job->startTime += job->interval * multiple;
-            }
-        }
-        setExpire(cFake, cFake->db, keyobj, keyobj, job->startTime);
-    }
-
-    notifyKeyspaceEvent(NOTIFY_KEYEVENT, "CRON Executed", keyobj, dbId);
-    decrRefCount(keyobj);
-
-    // o is invalid at this point
-    freeClient(cFake);
-}
@@ -1,16 +0,0 @@
-#pragma once
-
-struct cronjob
-{
-    sdsstring script;
-    uint64_t interval;
-    uint64_t startTime;
-    std::vector<sdsstring> veckeys;
-    std::vector<sdsstring> vecargs;
-    int dbNum = 0;
-    bool fSingleShot = false;
-};
-
-void freeCronObject(robj_roptr o);
-void executeCronJobExpireHook(const char *key, robj *o);
-void cronCommand(client *c);
@@ -31,7 +31,6 @@
 #include "server.h"
 #include "sha1.h"   /* SHA1 is used for DEBUG DIGEST */
 #include "crc64.h"
-#include "cron.h"

 #include <arpa/inet.h>
 #include <signal.h>
@@ -56,7 +55,7 @@ typedef ucontext_t sigcontext_t;
 #endif
 #endif

-int g_fInCrash = false;
+bool g_fInCrash = false;

 /* ================================= Debugging ============================== */

@@ -127,7 +126,7 @@ void mixStringObjectDigest(unsigned char *digest, robj_roptr o) {
 void xorObjectDigest(redisDb *db, robj_roptr keyobj, unsigned char *digest, robj_roptr o) {
    uint32_t aux = htonl(o->type);
    mixDigest(digest,&aux,sizeof(aux));
-    expireEntry *pexpire = getExpire(db,keyobj);
+    expireEntry *pexpire = db->getExpire(keyobj);
    long long expiretime = -1;
    char buf[128];

@@ -252,10 +251,6 @@ void xorObjectDigest(redisDb *db, robj_roptr keyobj, unsigned char *digest, robj
            mt->digest(&md,mv->value);
            xorDigest(digest,md.x,sizeof(md.x));
        }
-    } else if (o->type == OBJ_CRON) {
-        cronjob *job = (cronjob*)ptrFromObj(o);
-        mixDigest(digest, &job->interval, sizeof(job->interval));
-        mixDigest(digest, job->script.get(), job->script.size());
    } else {
        serverPanic("Unknown object type");
    }
@@ -271,8 +266,6 @@ void xorObjectDigest(redisDb *db, robj_roptr keyobj, unsigned char *digest, robj
 * a different digest. */
 void computeDatasetDigest(unsigned char *final) {
    unsigned char digest[20];
-    dictIterator *di = NULL;
-    dictEntry *de;
    int j;
    uint32_t aux;

@@ -281,8 +274,7 @@ void computeDatasetDigest(unsigned char *final) {
    for (j = 0; j < cserver.dbnum; j++) {
        redisDb *db = g_pserver->db+j;

-        if (dictSize(db->pdict) == 0) continue;
-        di = dictGetSafeIterator(db->pdict);
+        if (db->size() == 0) continue;

        /* hash the DB id, so the same dataset moved in a different
         * DB will lead to a different digest */
@@ -290,77 +282,24 @@ void computeDatasetDigest(unsigned char *final) {
        mixDigest(final,&aux,sizeof(aux));

        /* Iterate this DB writing every entry */
-        while((de = dictNext(di)) != NULL) {
-            sds key;
-            robj *keyobj, *o;
+        db->iterate([&](const char *key, robj *o)->bool {
+            robj *keyobj;

            memset(digest,0,20); /* This key-val digest */
-            key = (sds)dictGetKey(de);
            keyobj = createStringObject(key,sdslen(key));

            mixDigest(digest,key,sdslen(key));

-            o = (robj*)dictGetVal(de);
            xorObjectDigest(db,keyobj,digest,o);

            /* We can finally xor the key-val digest to the final digest */
            xorDigest(final,digest,20);
            decrRefCount(keyobj);
-        }
-        dictReleaseIterator(di);
+            return true;
+        });
    }
 }

-#ifdef USE_JEMALLOC
-void mallctl_int(client *c, robj **argv, int argc) {
-    int ret;
-    /* start with the biggest size (int64), and if that fails, try smaller sizes (int32, bool) */
-    int64_t old = 0, val;
-    if (argc > 1) {
-        long long ll;
-        if (getLongLongFromObjectOrReply(c, argv[1], &ll, NULL) != C_OK)
-            return;
-        val = ll;
-    }
-    size_t sz = sizeof(old);
-    while (sz > 0) {
-        if ((ret=je_mallctl(szFromObj(argv[0]), &old, &sz, argc > 1? &val: NULL, argc > 1?sz: 0))) {
-            if (ret==EINVAL) {
-                /* size might be wrong, try a smaller one */
-                sz /= 2;
-#if BYTE_ORDER == BIG_ENDIAN
-                val <<= 8*sz;
-#endif
-                continue;
-            }
-            addReplyErrorFormat(c,"%s", strerror(ret));
-            return;
-        } else {
-#if BYTE_ORDER == BIG_ENDIAN
-            old >>= 64 - 8*sz;
-#endif
-            addReplyLongLong(c, old);
-            return;
-        }
-    }
-    addReplyErrorFormat(c,"%s", strerror(EINVAL));
-}
-
-void mallctl_string(client *c, robj **argv, int argc) {
-    int ret;
-    char *old;
-    size_t sz = sizeof(old);
-    /* for strings, it seems we need to first get the old value, before overriding it. */
-    if ((ret=je_mallctl(szFromObj(argv[0]), &old, &sz, NULL, 0))) {
-        addReplyErrorFormat(c,"%s", strerror(ret));
-        return;
-    }
-    addReplyBulkCString(c, old);
-    if(argc > 1)
-        je_mallctl(szFromObj(argv[0]), NULL, 0, &argv[1]->m_ptr, sizeof(char*));
-}
-#endif
-
 void debugCommand(client *c) {
    if (c->argc == 2 && !strcasecmp(szFromObj(c->argv[1]),"help")) {
        const char *help[] = {
@@ -369,7 +308,6 @@ void debugCommand(client *c) {
 "CRASH-AND-RECOVER <milliseconds> -- Hard crash and restart after <milliseconds> delay.",
 "DIGEST -- Output a hex signature representing the current DB content.",
 "DIGEST-VALUE <key-1> ... <key-N>-- Output a hex signature of the values of all the specified keys.",
-"DEBUG PROTOCOL [string|integer|double|bignum|null|array|set|map|attrib|push|verbatim|true|false]",
 "ERROR <string> -- Return a Redis protocol error with <string> as message. Useful for clients unit tests to simulate Redis errors.",
 "LOG <message> -- write message to the server log.",
 "HTSTATS <dbid> -- Return hash table statistics of the specified Redis database.",
@@ -377,7 +315,6 @@ void debugCommand(client *c) {
 "LOADAOF -- Flush the AOF buffers on disk and reload the AOF in memory.",
 "LUA-ALWAYS-REPLICATE-COMMANDS <0|1> -- Setting it to 1 makes Lua replication defaulting to replicating single commands, without the script having to enable effects replication.",
 "OBJECT <key> -- Show low level info about key and associated value.",
-"OOM -- Crash the server simulating an out-of-memory error.",
 "PANIC -- Crash the server simulating a panic.",
 "POPULATE <count> [prefix] [size] -- Create <count> string keys named key:<num>. If a prefix is specified is used instead of the 'key' prefix.",
 "RELOAD -- Save the RDB on disk and reload it back in memory.",
@@ -385,15 +322,10 @@ void debugCommand(client *c) {
 "SDSLEN <key> -- Show low level SDS string info representing key and value.",
 "SEGFAULT -- Crash the server with sigsegv.",
 "SET-ACTIVE-EXPIRE <0|1> -- Setting it to 0 disables expiring keys in background when they are not accessed (otherwise the Redis behavior). Setting it to 1 reenables back the default.",
-"AOF-FLUSH-SLEEP <microsec> -- Server will sleep before flushing the AOF, this is used for testing",
 "SLEEP <seconds> -- Stop the server for <seconds>. Decimals allowed.",
 "STRUCTSIZE -- Return the size of different Redis core C structures.",
 "ZIPLIST <key> -- Show low level info about the ziplist encoding.",
 "STRINGMATCH-TEST -- Run a fuzz tester against the stringmatchlen() function.",
-#ifdef USE_JEMALLOC
-"MALLCTL <key> [<val>] -- Get or set a malloc tunning integer.",
-"MALLCTL-STR <key> [<val>] -- Get or set a malloc tunning string.",
-#endif
 NULL
        };
        addReplyHelp(c, help);
@@ -427,13 +359,14 @@ NULL
    } else if (!strcasecmp(szFromObj(c->argv[1]),"reload")) {
        rdbSaveInfo rsi, *rsiptr;
        rsiptr = rdbPopulateSaveInfo(&rsi);
-        if (rdbSave(rsiptr) != C_OK) {
+        if (rdbSave(nullptr, rsiptr) != C_OK) {
            addReply(c,shared.err);
            return;
        }
        emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);
        protectClient(c);
-        int ret = rdbLoadFile(g_pserver->rdb_filename,NULL,RDBFLAGS_NONE);
+        rdbSaveInfo rsiDft = RDB_SAVE_INFO_INIT;
+        int ret = rdbLoad(&rsiDft);
        unprotectClient(c);
        if (ret != C_OK) {
            addReplyError(c,"Error trying to load the RDB dump");
@@ -455,15 +388,14 @@ NULL
        serverLog(LL_WARNING,"Append Only File loaded by DEBUG LOADAOF");
        addReply(c,shared.ok);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"object") && c->argc == 3) {
-        dictEntry *de;
        robj *val;
        const char *strenc;

-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
+        val = c->db->find(c->argv[2]);
+        if (val == NULL) {
            addReply(c,shared.nokeyerr);
            return;
        }
-        val = (robj*)dictGetVal(de);
        strenc = strEncoding(val->encoding);

        char extra[138] = {0};
@@ -507,16 +439,14 @@ NULL
            strenc, rdbSavedObjectLen(val),
            val->lru, estimateObjectIdleTime(val)/1000, extra);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"sdslen") && c->argc == 3) {
-        dictEntry *de;
-        robj *val;
-        sds key;
+        auto itr = c->db->find(c->argv[2]);
+        robj *val = itr.val();
+        const char *key = itr.key();

-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
+        if (val == NULL) {
            addReply(c,shared.nokeyerr);
            return;
        }
-        val = (robj*)dictGetVal(de);
-        key = (sds)dictGetKey(de);

        if (val->type != OBJ_STRING || !sdsEncodedObject(val)) {
            addReplyError(c,"Not an sds encoded string.");
@@ -526,16 +456,16 @@ NULL
                "val_sds_len:%lld, val_sds_avail:%lld, val_zmalloc: %lld",
                (long long) sdslen(key),
                (long long) sdsavail(key),
-                (long long) sdsZmallocSize(key),
+                (long long) sdsZmallocSize((sds)key),
                (long long) sdslen(szFromObj(val)),
                (long long) sdsavail(szFromObj(val)),
                (long long) getStringObjectSdsUsedMemory(val));
        }
    } else if (!strcasecmp(szFromObj(c->argv[1]),"ziplist") && c->argc == 3) {
-        robj *o;
+        robj_roptr o;

        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))
-                == NULL) return;
+                == nullptr) return;

        if (o->encoding != OBJ_ENCODING_ZIPLIST) {
            addReplyError(c,"Not an sds encoded string.");
@@ -551,7 +481,7 @@ NULL

        if (getLongFromObjectOrReply(c, c->argv[2], &keys, NULL) != C_OK)
            return;
-        dictExpand(c->db->pdict,keys);
+        c->db->expand(keys);
        for (j = 0; j < keys; j++) {
            long valsize = 0;
            snprintf(buf,sizeof(buf),"%s:%lu",
@@ -602,8 +532,8 @@ NULL
        }
    } else if (!strcasecmp(szFromObj(c->argv[1]),"protocol") && c->argc == 3) {
        /* DEBUG PROTOCOL [string|integer|double|bignum|null|array|set|map|
-         *                 attrib|push|verbatim|true|false] */
-        const char *name = szFromObj(c->argv[2]);
+         *                 attrib|push|verbatim|true|false|state|err|bloberr] */
+        char *name = szFromObj(c->argv[2]);
        if (!strcasecmp(name,"string")) {
            addReplyBulkCString(c,"Hello World");
        } else if (!strcasecmp(name,"integer")) {
@@ -650,7 +580,7 @@ NULL
        } else if (!strcasecmp(name,"verbatim")) {
            addReplyVerbatim(c,"This is a verbatim\nstring",25,"txt");
        } else {
-            addReplyError(c,"Wrong protocol type name. Please use one of the following: string|integer|double|bignum|null|array|set|map|attrib|push|verbatim|true|false");
+            addReplyError(c,"Wrong protocol type name. Please use one of the following: string|integer|double|bignum|null|array|set|map|attrib|push|verbatim|true|false|state|err|bloberr");
        }
    } else if (!strcasecmp(szFromObj(c->argv[1]),"sleep") && c->argc == 3) {
        double dtime = strtod(szFromObj(c->argv[2]),NULL);
@@ -666,11 +596,6 @@ NULL
    {
        g_pserver->active_expire_enabled = atoi(szFromObj(c->argv[2]));
        addReply(c,shared.ok);
-    } else if (!strcasecmp(szFromObj(c->argv[1]),"aof-flush-sleep") &&
-               c->argc == 3)
-    {
-        g_pserver->aof_flush_sleep = atoi(szFromObj(c->argv[2]));
-        addReply(c,shared.ok);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"lua-always-replicate-commands") &&
               c->argc == 3)
    {
@@ -699,32 +624,28 @@ NULL
        sds stats = sdsempty();
        char buf[4096];

-        if (getLongFromObjectOrReply(c, c->argv[2], &dbid, NULL) != C_OK) {
-            sdsfree(stats);
+        if (getLongFromObjectOrReply(c, c->argv[2], &dbid, NULL) != C_OK)
            return;
-        }
        if (dbid < 0 || dbid >= cserver.dbnum) {
-            sdsfree(stats);
            addReplyError(c,"Out of range database");
            return;
        }

        stats = sdscatprintf(stats,"[Dictionary HT]\n");
-        dictGetStats(buf,sizeof(buf),g_pserver->db[dbid].pdict);
+        g_pserver->db[dbid].getStats(buf,sizeof(buf));
        stats = sdscat(stats,buf);

        stats = sdscatprintf(stats,"[Expires set]\n");
-        g_pserver->db[dbid].setexpire->getstats(buf, sizeof(buf));
+        g_pserver->db[dbid].getExpireStats(buf, sizeof(buf));
        stats = sdscat(stats, buf);

-        addReplyVerbatim(c,stats,sdslen(stats),"txt");
-        sdsfree(stats);
+        addReplyBulkSds(c,stats);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"htstats-key") && c->argc == 3) {
-        robj *o;
+        robj_roptr o;
        dict *ht = NULL;

        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))
-                == NULL) return;
+                == nullptr) return;

        /* Get the hash table reference from the object, if possible. */
        switch (o->encoding) {
@@ -745,7 +666,7 @@ NULL
        } else {
            char buf[4096];
            dictGetStats(buf,sizeof(buf),ht);
-            addReplyVerbatim(c,buf,strlen(buf),"txt");
+            addReplyBulkCString(c,buf);
        }
    } else if (!strcasecmp(szFromObj(c->argv[1]),"change-repl-id") && c->argc == 2) {
        serverLog(LL_WARNING,"Changing replication IDs after receiving DEBUG change-repl-id");
@@ -755,35 +676,9 @@ NULL
    } else if (!strcasecmp(szFromObj(c->argv[1]),"stringmatch-test") && c->argc == 2) {
        stringmatchlen_fuzz_test();
        addReplyStatus(c,"Apparently Redis did not crash: test passed");
-    } else if (!strcasecmp(szFromObj(c->argv[1]), "force-master") && c->argc == 3) {
+    } else if (!strcasecmp(szFromObj(c->argv[1]), "force-master") && c->argc == 2) {
        c->flags |= CLIENT_MASTER | CLIENT_MASTER_FORCE_REPLY;
-        if (!strcasecmp(szFromObj(c->argv[2]), "yes"))
-        {
-            redisMaster *mi = (redisMaster*)zcalloc(sizeof(redisMaster), MALLOC_LOCAL);
-            mi->master = c;
-            listAddNodeHead(g_pserver->masters, mi);
-        }
-        else if (strcasecmp(szFromObj(c->argv[2]), "flagonly")) // if we didn't set flagonly assume its an unset
-        {
-            serverAssert(c->flags & CLIENT_MASTER);
-            if (listLength(g_pserver->masters))
-            {
-                redisMaster *mi = (redisMaster*)listNodeValue(listFirst(g_pserver->masters));
-                serverAssert(mi->master == c);
-                listDelNode(g_pserver->masters, listFirst(g_pserver->masters));
-                zfree(mi);
-            }
-            c->flags &= ~(CLIENT_MASTER | CLIENT_MASTER_FORCE_REPLY);
-        }
        addReply(c, shared.ok);
-#ifdef USE_JEMALLOC
-    } else if(!strcasecmp(szFromObj(c->argv[1]),"mallctl") && c->argc >= 3) {
-        mallctl_int(c, c->argv+2, c->argc-2);
-        return;
-    } else if(!strcasecmp(szFromObj(c->argv[1]),"mallctl-str") && c->argc >= 3) {
-        mallctl_string(c, c->argv+2, c->argc-2);
-        return;
-#endif
    } else {
        addReplySubcommandSyntaxError(c);
        return;
@@ -807,12 +702,11 @@ void _serverAssert(const char *estr, const char *file, int line) {

 void _serverAssertPrintClientInfo(const client *c) {
    int j;
-    char conninfo[CONN_INFO_LEN];

    bugReportStart();
    serverLog(LL_WARNING,"=== ASSERTION FAILED CLIENT CONTEXT ===");
-    serverLog(LL_WARNING,"client->flags = %llu", (unsigned long long) c->flags);
-    serverLog(LL_WARNING,"client->conn = %s", connGetInfo(c->conn, conninfo, sizeof(conninfo)));
+    serverLog(LL_WARNING,"client->flags = %llu", static_cast<unsigned long long>(c->flags));
+    serverLog(LL_WARNING,"client->fd = %d", c->fd);
    serverLog(LL_WARNING,"client->argc = %d", c->argc);
    for (j=0; j < c->argc; j++) {
        char buf[128];
@@ -851,8 +745,6 @@ void serverLogObjectDebugInfo(robj_roptr o) {
        serverLog(LL_WARNING,"Sorted set size: %d", (int) zsetLength(o));
        if (o->encoding == OBJ_ENCODING_SKIPLIST)
            serverLog(LL_WARNING,"Skiplist level: %d", (int) ((const zset*)ptrFromObj(o))->zsl->level);
-    } else if (o->type == OBJ_STREAM) {
-        serverLog(LL_WARNING,"Stream size: %d", (int) streamLength(o));
    }
 }

@@ -1221,33 +1113,6 @@ void logRegisters(ucontext_t *uc) {
        (unsigned long) uc->uc_mcontext.mc_cs
    );
    logStackContent((void**)uc->uc_mcontext.mc_rsp);
-#elif defined(__aarch64__) /* Linux AArch64 */
-    serverLog(LL_WARNING,
-	      "\n"
-	      "X18:%016lx X19:%016lx\nX20:%016lx X21:%016lx\n"
-	      "X22:%016lx X23:%016lx\nX24:%016lx X25:%016lx\n"
-	      "X26:%016lx X27:%016lx\nX28:%016lx X29:%016lx\n"
-	      "X30:%016lx\n"
-	      "pc:%016lx sp:%016lx\npstate:%016lx fault_address:%016lx\n",
-	      (unsigned long) uc->uc_mcontext.regs[18],
-	      (unsigned long) uc->uc_mcontext.regs[19],
-	      (unsigned long) uc->uc_mcontext.regs[20],
-	      (unsigned long) uc->uc_mcontext.regs[21],
-	      (unsigned long) uc->uc_mcontext.regs[22],
-	      (unsigned long) uc->uc_mcontext.regs[23],
-	      (unsigned long) uc->uc_mcontext.regs[24],
-	      (unsigned long) uc->uc_mcontext.regs[25],
-	      (unsigned long) uc->uc_mcontext.regs[26],
-	      (unsigned long) uc->uc_mcontext.regs[27],
-	      (unsigned long) uc->uc_mcontext.regs[28],
-	      (unsigned long) uc->uc_mcontext.regs[29],
-	      (unsigned long) uc->uc_mcontext.regs[30],
-	      (unsigned long) uc->uc_mcontext.pc,
-	      (unsigned long) uc->uc_mcontext.sp,
-	      (unsigned long) uc->uc_mcontext.pstate,
-	      (unsigned long) uc->uc_mcontext.fault_address
-		      );
-	      logStackContent((void**)uc->uc_mcontext.sp);
 #else
    serverLog(LL_WARNING,
        "  Dumping of registers not supported for this OS/arch");
@@ -1382,12 +1247,10 @@ void logCurrentClient(void) {
     * selected DB, and if so print info about the associated object. */
    if (cc->argc >= 1) {
        robj *val, *key;
-        dictEntry *de;

        key = getDecodedObject(cc->argv[1]);
-        de = dictFind(cc->db->pdict, ptrFromObj(key));
-        if (de) {
-            val = (robj*)dictGetVal(de);
+        val = cc->db->find(key);
+        if (val) {
            serverLog(LL_WARNING,"key '%s' found in DB containing the following object:", (char*)ptrFromObj(key));
            serverLogObjectDebugInfo(val);
        }
@@ -1531,12 +1394,6 @@ void sigsegvHandler(int sig, siginfo_t *info, void *secret) {
    /* Log dump of processor registers */
    logRegisters(uc);

-    /* Log Modules INFO */
-    serverLogRaw(LL_WARNING|LL_RAW, "\n------ MODULES INFO OUTPUT ------\n");
-    infostring = modulesCollectInfo(sdsempty(), NULL, 1, 0);
-    serverLogRaw(LL_WARNING|LL_RAW, infostring);
-    sdsfree(infostring);
-
 #if defined(HAVE_PROC_MAPS)
    /* Test memory */
    serverLogRaw(LL_WARNING|LL_RAW, "\n------ FAST MEMORY TEST ------\n");
@@ -5,8 +5,8 @@
 * We do that by scanning the keyspace and for each pointer we have, we can try to
 * ask the allocator if moving it to a new address will help reduce fragmentation.
 *
- * Copyright (c) 2020, Oran Agra
- * Copyright (c) 2020, Redis Labs, Inc
+ * Copyright (c) 2017, Oran Agra
+ * Copyright (c) 2017, Redis Labs, Inc
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -48,7 +48,7 @@ extern "C" int je_get_defrag_hint(void* ptr, int *bin_util, int *run_util);
 /* forward declarations*/
 void defragDictBucketCallback(void *privdata, dictEntry **bucketref);
 dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, uint64_t hash, long *defragged);
-bool replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey);
+void replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey);

 /* Defrag helper for generic allocations.
 *
@@ -373,7 +373,7 @@ long activeDefragSdsListAndDict(list *l, dict *d, int dict_val_type) {
            if ((newele = activeDefragStringOb(ele, &defragged)))
                de->v.val = newele, defragged++;
        } else if (dict_val_type == DEFRAG_SDS_DICT_VAL_VOID_PTR) {
-            void *newptr, *ptr = dictGetVal(de);
+            void *newptr, *ptr = ln->value;
            if ((newptr = activeDefragAlloc(ptr)))
                ln->value = newptr, defragged++;
        }
@@ -407,7 +407,7 @@ dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sd
    return NULL;
 }

-bool replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey) {
+void replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey) {
    auto itr = set.find(oldkey);
    if (itr != set.end())
    {
@@ -415,38 +415,28 @@ bool replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey) {
        eNew.setKeyUnsafe(newkey);
        set.erase(itr);
        set.insert(eNew);
-        serverAssert(set.find(newkey) != set.end());
-        return true;
    }
-    return false;
-}
-
-long activeDefragQuickListNode(quicklist *ql, quicklistNode **node_ref) {
-    quicklistNode *newnode, *node = *node_ref;
-    long defragged = 0;
-    unsigned char *newzl;
-    if ((newnode = (quicklistNode*)activeDefragAlloc(node))) {
-        if (newnode->prev)
-            newnode->prev->next = newnode;
-        else
-            ql->head = newnode;
-        if (newnode->next)
-            newnode->next->prev = newnode;
-        else
-            ql->tail = newnode;
-        *node_ref = node = newnode;
-        defragged++;
-    }
-    if ((newzl = (unsigned char*)activeDefragAlloc(node->zl)))
-        defragged++, node->zl = newzl;
-    return defragged;
 }

 long activeDefragQuickListNodes(quicklist *ql) {
-    quicklistNode *node = ql->head;
+    quicklistNode *node = ql->head, *newnode;
    long defragged = 0;
+    unsigned char *newzl;
    while (node) {
-        defragged += activeDefragQuickListNode(ql, &node);
+        if ((newnode = (quicklistNode*)activeDefragAlloc(node))) {
+            if (newnode->prev)
+                newnode->prev->next = newnode;
+            else
+                ql->head = newnode;
+            if (newnode->next)
+                newnode->next->prev = newnode;
+            else
+                ql->tail = newnode;
+            node = newnode;
+            defragged++;
+        }
+        if ((newzl = (unsigned char*)activeDefragAlloc(node->zl)))
+            defragged++, node->zl = newzl;
        node = node->next;
    }
    return defragged;
@@ -460,48 +450,12 @@ void defragLater(redisDb *db, dictEntry *kde) {
    listAddNodeTail(db->defrag_later, key);
 }

-/* returns 0 if no more work needs to be been done, and 1 if time is up and more work is needed. */
-long scanLaterList(robj *ob, unsigned long *cursor, long long endtime, long long *defragged) {
+long scanLaterList(robj *ob) {
    quicklist *ql = (quicklist*)ptrFromObj(ob);
-    quicklistNode *node;
-    long iterations = 0;
-    int bookmark_failed = 0;
    if (ob->type != OBJ_LIST || ob->encoding != OBJ_ENCODING_QUICKLIST)
        return 0;
-
-    if (*cursor == 0) {
-        /* if cursor is 0, we start new iteration */
-        node = ql->head;
-    } else {
-        node = quicklistBookmarkFind(ql, "_AD");
-        if (!node) {
-            /* if the bookmark was deleted, it means we reached the end. */
-            *cursor = 0;
-            return 0;
-        }
-        node = node->next;
-    }
-
-    (*cursor)++;
-    while (node) {
-        (*defragged) += activeDefragQuickListNode(ql, &node);
-        g_pserver->stat_active_defrag_scanned++;
-        if (++iterations > 128 && !bookmark_failed) {
-            if (ustime() > endtime) {
-                if (!quicklistBookmarkCreate(&ql, "_AD", node)) {
-                    bookmark_failed = 1;
-                } else {
-                    ob->m_ptr = ql; /* bookmark creation may have re-allocated the quicklist */
-                    return 1;
-                }
-            }
-            iterations = 0;
-        }
-        node = node->next;
-    }
-    quicklistBookmarkDelete(ql, "_AD");
-    *cursor = 0;
-    return bookmark_failed? 1: 0;
+    g_pserver->stat_active_defrag_scanned+=ql->len;
+    return activeDefragQuickListNodes(ql);
 }

 typedef struct {
@@ -694,8 +648,7 @@ int scanLaterStraemListpacks(robj *ob, unsigned long *cursor, long long endtime,
        void *newdata = activeDefragAlloc(ri.data);
        if (newdata)
            raxSetData(ri.node, ri.data=newdata), (*defragged)++;
-        g_pserver->stat_active_defrag_scanned++;
-        if (++iterations > 128) {
+        if (++iterations > 16) {
            if (ustime() > endtime) {
                serverAssert(ri.key_len==sizeof(last));
                memcpy(last,ri.key,ri.key_len);
@@ -824,22 +777,18 @@ long defragKey(redisDb *db, dictEntry *de) {
    long defragged = 0;
    sds newsds;

-    ob = (robj*)dictGetVal(de);
-
    /* Try to defrag the key name. */
    newsds = activeDefragSds(keysds);
    if (newsds)
-    {
        defragged++, de->key = newsds;
-        if (!db->setexpire->empty()) {
-            bool fReplaced = replaceSateliteOSetKeyPtr(*db->setexpire, keysds, newsds);
-            serverAssert(fReplaced == ob->FExpires());
-        } else {
-            serverAssert(!ob->FExpires());
-        }
+    if (!db->setexpire()->empty()) {
+        replaceSateliteOSetKeyPtr(*const_cast<expireset*>(db->setexpire()), keysds, newsds);
    }

    /* Try to defrag robj and / or string value. */
+    ob = (robj*)dictGetVal(de);
+    if (ob == nullptr)
+        return defragged;
    if ((newob = activeDefragStringOb(ob, &defragged))) {
        de->v.val = newob;
        ob = newob;
@@ -892,7 +841,6 @@ long defragKey(redisDb *db, dictEntry *de) {
    } else {
        serverPanic("Unknown object type");
    }
-
    return defragged;
 }

@@ -907,7 +855,7 @@ void defragScanCallback(void *privdata, const dictEntry *de) {
    g_pserver->stat_active_defrag_scanned++;
 }

-/* Defrag scan callback for each hash table bicket,
+/* Defrag scan callback for each hash table bucket,
 * used in order to defrag the dictEntry allocations. */
 void defragDictBucketCallback(void *privdata, dictEntry **bucketref) {
    UNUSED(privdata); /* NOTE: this function is also used by both activeDefragCycle and scanLaterHash, etc. don't use privdata */
@@ -956,11 +904,11 @@ long defragOtherGlobals() {

 /* returns 0 more work may or may not be needed (see non-zero cursor),
 * and 1 if time is up and more work is needed. */
-int defragLaterItem(dictEntry *de, unsigned long *cursor, long long endtime) {
-    if (de) {
-        robj *ob = (robj*)dictGetVal(de);
+int defragLaterItem(robj *ob, unsigned long *cursor, long long endtime) {
+    if (ob) {
        if (ob->type == OBJ_LIST) {
-            return scanLaterList(ob, cursor, endtime, &g_pserver->stat_active_defrag_hits);
+            g_pserver->stat_active_defrag_hits += scanLaterList(ob);
+            *cursor = 0; /* list has no scan, we must finish it in one go */
        } else if (ob->type == OBJ_SET) {
            g_pserver->stat_active_defrag_hits += scanLaterSet(ob, cursor);
        } else if (ob->type == OBJ_ZSET) {
@@ -978,12 +926,10 @@ int defragLaterItem(dictEntry *de, unsigned long *cursor, long long endtime) {
    return 0;
 }

-/* static variables serving defragLaterStep to continue scanning a key from were we stopped last time. */
-static sds defrag_later_current_key = NULL;
-static unsigned long defrag_later_cursor = 0;
-
 /* returns 0 if no more work needs to be been done, and 1 if time is up and more work is needed. */
 int defragLaterStep(redisDb *db, long long endtime) {
+    static sds current_key = NULL;
+    static unsigned long cursor = 0;
    unsigned int iterations = 0;
    unsigned long long prev_defragged = g_pserver->stat_active_defrag_hits;
    unsigned long long prev_scanned = g_pserver->stat_active_defrag_scanned;
@@ -991,15 +937,16 @@ int defragLaterStep(redisDb *db, long long endtime) {

    do {
        /* if we're not continuing a scan from the last call or loop, start a new one */
-        if (!defrag_later_cursor) {
+        if (!cursor) {
            listNode *head = listFirst(db->defrag_later);

            /* Move on to next key */
-            if (defrag_later_current_key) {
-                serverAssert(defrag_later_current_key == head->value);
+            if (current_key) {
+                serverAssert(current_key == head->value);
+                sdsfree((sds)head->value);
                listDelNode(db->defrag_later, head);
-                defrag_later_cursor = 0;
-                defrag_later_current_key = NULL;
+                cursor = 0;
+                current_key = NULL;
            }

            /* stop if we reached the last one. */
@@ -1008,18 +955,23 @@ int defragLaterStep(redisDb *db, long long endtime) {
                return 0;

            /* start a new key */
-            defrag_later_current_key = (sds)head->value;
-            defrag_later_cursor = 0;
+            current_key = (sds)head->value;
+            cursor = 0;
        }

        /* each time we enter this function we need to fetch the key from the dict again (if it still exists) */
-        dictEntry *de = dictFind(db->pdict, defrag_later_current_key);
+        robj *o = db->find(current_key);
        key_defragged = g_pserver->stat_active_defrag_hits;
        do {
            int quit = 0;
-            if (defragLaterItem(de, &defrag_later_cursor, endtime))
+            if (defragLaterItem(o, &cursor, endtime))
                quit = 1; /* time is up, we didn't finish all the work */

+            /* Don't start a new BIG key in this loop, this is because the
+             * next key can be a list, and scanLaterList must be done in once cycle */
+            if (!cursor)
+                quit = 1;
+
            /* Once in 16 scan iterations, 512 pointer reallocations, or 64 fields
             * (if we have a lot of pointers in one hash bucket, or rehashing),
             * check if we reached the time limit. */
@@ -1037,7 +989,7 @@ int defragLaterStep(redisDb *db, long long endtime) {
                prev_defragged = g_pserver->stat_active_defrag_hits;
                prev_scanned = g_pserver->stat_active_defrag_scanned;
            }
-        } while(defrag_later_cursor);
+        } while(cursor);
        if(key_defragged != g_pserver->stat_active_defrag_hits)
            g_pserver->stat_active_defrag_key_hits++;
        else
@@ -1094,22 +1046,7 @@ void activeDefragCycle(void) {
    mstime_t latency;
    int quit = 0;

-    if (!cserver.active_defrag_enabled) {
-        if (g_pserver->active_defrag_running) {
-            /* if active defrag was disabled mid-run, start from fresh next time. */
-            g_pserver->active_defrag_running = 0;
-            if (db)
-                listEmpty(db->defrag_later);
-            defrag_later_current_key = NULL;
-            defrag_later_cursor = 0;
-            current_db = -1;
-            cursor = 0;
-            db = NULL;
-        }
-        return;
-    }
-
-    if (hasActiveChildProcess())
+    if (g_pserver->aof_child_pid!=-1 || g_pserver->FRdbSaveInProgress())
        return; /* Defragging memory while there's a fork will just do damage. */

    /* Once a second, check if we the fragmentation justfies starting a scan
@@ -1176,7 +1113,8 @@ void activeDefragCycle(void) {
                break; /* this will exit the function and we'll continue on the next cycle */
            }

-            cursor = dictScan(db->pdict, cursor, defragScanCallback, defragDictBucketCallback, db);
+            // we actually look at the objects too but defragScanCallback can handle missing values
+            cursor = dictScan(db->dictUnsafeKeyOnly(), cursor, defragScanCallback, defragDictBucketCallback, db);

            /* Once in 16 scan iterations, 512 pointer reallocations. or 64 keys
             * (if we have a lot of pointers in one hash bucket or rehasing),
@@ -134,7 +134,7 @@ int _dictInit(dict *d, dictType *type,
 * but with the invariant of a USED/BUCKETS ratio near to <= 1 */
 int dictResize(dict *d)
 {
-    unsigned long minimal;
+    int minimal;

    if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;
    minimal = d->ht[0].used;
@@ -871,10 +871,6 @@ unsigned long dictScan(dict *d,

    if (dictSize(d) == 0) return 0;

-    /* Having a safe iterator means no rehashing can happen, see _dictRehashStep.
-     * This is needed in case the scan callback tries to do dictFind or alike. */
-    d->iterators++;
-
    if (!dictIsRehashing(d)) {
        t0 = &(d->ht[0]);
        m0 = t0->sizemask;
@@ -941,9 +937,6 @@ unsigned long dictScan(dict *d,
        } while (v & (m0 ^ m1));
    }

-    /* undo the ++ at the top */
-    d->iterators--;
-
    return v;
 }

@@ -87,7 +87,7 @@ unsigned int LRU_CLOCK(void) {

 /* Given an object returns the min number of milliseconds the object was never
 * requested, using an approximated LRU algorithm. */
-unsigned long long estimateObjectIdleTime(robj *o) {
+unsigned long long estimateObjectIdleTime(robj_roptr o) {
    unsigned long long lruclock = LRU_CLOCK();
    if (lruclock >= o->lru) {
        return (lruclock - o->lru) * LRU_CLOCK_RESOLUTION;
@@ -252,19 +252,20 @@ struct visitFunctor
        return count < g_pserver->maxmemory_samples;
    }
 };
-void evictionPoolPopulate(int dbid, dict *dbdict, expireset *setexpire, struct evictionPoolEntry *pool)
+void evictionPoolPopulate(int dbid, redisDb *db, expireset *setexpire, struct evictionPoolEntry *pool)
 {
    if (setexpire != nullptr)
    {
-        visitFunctor visitor { dbid, dbdict, pool, 0 };
+        visitFunctor visitor { dbid, db->dictUnsafeKeyOnly(), pool, 0 };
        setexpire->random_visit(visitor);
    }
    else
    {
        dictEntry **samples = (dictEntry**)alloca(g_pserver->maxmemory_samples * sizeof(dictEntry*));
-        int count = dictGetSomeKeys(dbdict,samples,g_pserver->maxmemory_samples);
+        int count = dictGetSomeKeys(db->dictUnsafeKeyOnly(),samples,g_pserver->maxmemory_samples);
        for (int j = 0; j < count; j++) {
            robj *o = (robj*)dictGetVal(samples[j]);
+            serverAssert(o != nullptr); // BUG!!! We have to get the info we need here without permanently rehydrating the obj
            processEvictionCandidate(dbid, (sds)dictGetKey(samples[j]), o, nullptr, pool);
        }
    }
@@ -460,10 +461,9 @@ int getMaxmemoryState(size_t *total, size_t *logical, size_t *tofree, float *lev
 * was freed to return back under the limit, the function returns C_ERR. */
 int freeMemoryIfNeeded(void) {
    serverAssert(GlobalLocksAcquired());
-    int keys_freed = 0;
    /* By default replicas should ignore maxmemory
     * and just be masters exact copies. */
-    if (listLength(g_pserver->masters) && g_pserver->repl_slave_ignore_maxmemory && !g_pserver->fActiveReplica) return C_OK;
+    if (listLength(g_pserver->masters) && g_pserver->repl_slave_ignore_maxmemory) return C_OK;

    size_t mem_reported, mem_tofree, mem_freed;
    mstime_t latency, eviction_latency;
@@ -484,7 +484,7 @@ int freeMemoryIfNeeded(void) {

    latencyStartMonitor(latency);
    while (mem_freed < mem_tofree) {
-        int j, k, i;
+        int j, k, i, keys_freed = 0;
        static unsigned int next_db = 0;
        sds bestkey = NULL;
        int bestdbid;
@@ -505,16 +505,16 @@ int freeMemoryIfNeeded(void) {
                    db = g_pserver->db+i;
                    if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS)
                    {
-                        if ((keys = dictSize(db->pdict)) != 0) {
-                            evictionPoolPopulate(i, db->pdict, nullptr, pool);
+                        if ((keys = db->size()) != 0) {
+                            evictionPoolPopulate(i, db, nullptr, pool);
                            total_keys += keys;
                        }
                    }
                    else
                    {
-                        keys = db->setexpire->size();
+                        keys = db->expireSize();
                        if (keys != 0)
-                            evictionPoolPopulate(i, db->pdict, db->setexpire, pool);
+                            evictionPoolPopulate(i, db, db->setexpireUnsafe(), pool);
                        total_keys += keys;
                    }
                }
@@ -526,9 +526,9 @@ int freeMemoryIfNeeded(void) {
                    bestdbid = pool[k].dbid;
                    sds key = nullptr;

-                    dictEntry *de = dictFind(g_pserver->db[pool[k].dbid].pdict,pool[k].key);
-                    if (de != nullptr && (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS || ((robj*)dictGetVal(de))->FExpires()))
-                        key = (sds)dictGetKey(de);
+                    auto itr = g_pserver->db[pool[k].dbid].find(pool[k].key);
+                    if (itr != nullptr && (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS || itr.val()->FExpires()))
+                        key = itr.key();

                    /* Remove the entry from the pool. */
                    if (pool[k].key != pool[k].cached)
@@ -560,18 +560,18 @@ int freeMemoryIfNeeded(void) {
                db = g_pserver->db+j;
                if (g_pserver->maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM)
                {
-                    if (dictSize(db->pdict) != 0) {
-                        dictEntry *de = dictGetRandomKey(db->pdict);
-                        bestkey = (sds)dictGetKey(de);
+                    if (db->size() != 0) {
+                        auto itr = db->random();
+                        bestkey = itr.key();
                        bestdbid = j;
                        break;
                    }
                }
                else
                {
-                    if (!db->setexpire->empty())
+                    if (db->expireSize())
                    {
-                        bestkey = (sds)db->setexpire->random_value().key();
+                        bestkey = (sds)db->random_expire().key();
                        bestdbid = j;
                        break;
                    }
@@ -582,16 +582,17 @@ int freeMemoryIfNeeded(void) {
        /* Finally remove the selected key. */
        if (bestkey) {
            db = g_pserver->db+bestdbid;
+
            robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
            propagateExpire(db,keyobj,g_pserver->lazyfree_lazy_eviction);
            /* We compute the amount of memory freed by db*Delete() alone.
-             * It is possible that actually the memory needed to propagate
-             * the DEL in AOF and replication link is greater than the one
-             * we are freeing removing the key, but we can't account for
-             * that otherwise we would never exit the loop.
-             *
-             * AOF and Output buffer memory will be freed eventually so
-             * we only care about memory used by the key space. */
+            * It is possible that actually the memory needed to propagate
+            * the DEL in AOF and replication link is greater than the one
+            * we are freeing removing the key, but we can't account for
+            * that otherwise we would never exit the loop.
+            *
+            * AOF and Output buffer memory will be freed eventually so
+            * we only care about memory used by the key space. */
            delta = (long long) zmalloc_used_memory();
            latencyStartMonitor(eviction_latency);
            if (g_pserver->lazyfree_lazy_eviction)
@@ -610,25 +611,27 @@ int freeMemoryIfNeeded(void) {
            keys_freed++;

            /* When the memory to free starts to be big enough, we may
-             * start spending so much time here that is impossible to
-             * deliver data to the slaves fast enough, so we force the
-             * transmission here inside the loop. */
+            * start spending so much time here that is impossible to
+            * deliver data to the slaves fast enough, so we force the
+            * transmission here inside the loop. */
            if (slaves) flushSlavesOutputBuffers();

            /* Normally our stop condition is the ability to release
-             * a fixed, pre-computed amount of memory. However when we
-             * are deleting objects in another thread, it's better to
-             * check, from time to time, if we already reached our target
-             * memory, since the "mem_freed" amount is computed only
-             * across the dbAsyncDelete() call, while the thread can
-             * release the memory all the time. */
+            * a fixed, pre-computed amount of memory. However when we
+            * are deleting objects in another thread, it's better to
+            * check, from time to time, if we already reached our target
+            * memory, since the "mem_freed" amount is computed only
+            * across the dbAsyncDelete() call, while the thread can
+            * release the memory all the time. */
            if (g_pserver->lazyfree_lazy_eviction && !(keys_freed % 16)) {
                if (getMaxmemoryState(NULL,NULL,NULL,NULL) == C_OK) {
                    /* Let's satisfy our stop condition. */
                    mem_freed = mem_tofree;
                }
            }
-        } else {
+        }
+
+        if (!keys_freed) {
            latencyEndMonitor(latency);
            latencyAddSampleIfNeeded("eviction-cycle",latency);
            goto cant_free; /* nothing to free... */
@@ -31,7 +31,6 @@
 */

 #include "server.h"
-#include "cron.h"

 void activeExpireCycleExpireFullKey(redisDb *db, const char *key) {
    robj *keyobj = createStringObject(key,sdslen(key));
@@ -75,13 +74,8 @@ void activeExpireCycleExpire(redisDb *db, expireEntry &e, long long now) {
    }

    expireEntryFat *pfat = e.pfatentry();
-    dictEntry *de = dictFind(db->pdict, e.key());
-    robj *val = (robj*)dictGetVal(de);
+    robj *val = db->find(e.key());
    int deleted = 0;
-
-    robj objKey;
-    initStaticStringObject(objKey, (char*)e.key());
-
    while (!pfat->FEmpty())
    {
        if (pfat->nextExpireEntry().when > now)
@@ -105,66 +99,33 @@ void activeExpireCycleExpire(redisDb *db, expireEntry &e, long long now) {
                }
            }
            break;
-
-        case OBJ_HASH:
-            if (hashTypeDelete(val,(sds)pfat->nextExpireEntry().spsubkey.get())) {
-                deleted++;
-                if (hashTypeLength(val) == 0) {
-                    activeExpireCycleExpireFullKey(db, e.key());
-                    return;
-                }
-            }
-            break;
-
-        case OBJ_ZSET:
-            if (zsetDel(val,(sds)pfat->nextExpireEntry().spsubkey.get())) {
-                deleted++;
-                if (zsetLength(val) == 0) {
-                    activeExpireCycleExpireFullKey(db, e.key());
-                    return;
-                }
-            }
-            break;
-
-        case OBJ_CRON:
-            executeCronJobExpireHook(e.key(), val);
-            return;
-
        case OBJ_LIST:
+        case OBJ_ZSET:
+        case OBJ_HASH:
        default:
            serverAssert(false);
        }
-        
-        robj objSubkey;
-        initStaticStringObject(objSubkey, (char*)pfat->nextExpireEntry().spsubkey.get());
-        propagateSubkeyExpire(db, val->type, &objKey, &objSubkey);
-        
        pfat->popfrontExpireEntry();
    }

    if (deleted)
    {
-        if (!pfat->FEmpty())
-        {
-            // We need to resort the expire entry since it may no longer be in the correct position
-            auto itr = db->setexpire->find(e.key());
-            expireEntry eT = std::move(e);
-            db->setexpire->erase(itr);
-            db->setexpire->insert(eT);
-        }
-
+        robj objT;
        switch (val->type)
        {
        case OBJ_SET:
-            signalModifiedKey(db,&objKey);
-            notifyKeyspaceEvent(NOTIFY_SET,"srem",&objKey,db->id);
+            initStaticStringObject(objT, (char*)e.key());
+            signalModifiedKey(db,&objT);
+            notifyKeyspaceEvent(NOTIFY_SET,"srem",&objT,db->id);
            break;
        }
    }

    if (pfat->FEmpty())
    {
-        removeExpire(db, &objKey);
+        robj *keyobj = createStringObject(e.key(),sdslen(e.key()));
+        removeExpire(db, keyobj);
+        decrRefCount(keyobj);
    }
 }

@@ -195,11 +156,10 @@ void expireMemberCore(client *c, robj *key, robj *subkey, long long basetime, lo

    /* No key, return zero. */
    robj *val = lookupKeyWriteOrReply(c, key, shared.czero);
-    if (val == NULL) {
+    if (val == nullptr) {
        return;
    }

-    double dblT;
    switch (val->type)
    {
    case OBJ_SET:
@@ -209,28 +169,13 @@ void expireMemberCore(client *c, robj *key, robj *subkey, long long basetime, lo
        }
        break;

-    case OBJ_HASH:
-        if (!hashTypeExists(val, szFromObj(subkey))) {
-            addReply(c,shared.czero);
-            return;
-        }
-        break;
-
-    case OBJ_ZSET:
-        if (zsetScore(val, szFromObj(subkey), &dblT) == C_ERR) {
-            addReply(c,shared.czero);
-            return;
-        }
-        break;
-
    default:
        addReplyError(c, "object type is unsupported");
        return;
    }

    setExpire(c, c->db, key, subkey, when);
-    signalModifiedKey(c->db, key);
-    g_pserver->dirty++;
+
    addReply(c, shared.cone);
 }

@@ -262,14 +207,6 @@ void expireMemberAtCommand(client *c)
    expireMemberCore(c, c->argv[1], c->argv[2], 0, when, UNIT_SECONDS);
 }

-void pexpireMemberAtCommand(client *c)
-{
-    long long when;
-    if (getLongLongFromObjectOrReply(c, c->argv[3], &when, NULL) != C_OK)
-        return;
-
-    expireMemberCore(c, c->argv[1], c->argv[2], 0, when, UNIT_MILLISECONDS);
-}

 /* Try to expire a few timed out keys. The algorithm used is adaptive and
 * will use few CPU cycles if there are few expiring keys, otherwise
@@ -358,7 +295,7 @@ void activeExpireCycle(int type) {
        now = mstime();

        /* If there is nothing to expire try next DB ASAP. */
-        if (db->setexpire->empty())
+        if (db->setexpireUnsafe()->empty())
        {
            db->avg_ttl = 0;
            db->last_expire_set = now;
@@ -368,7 +305,7 @@ void activeExpireCycle(int type) {
        size_t expired = 0;
        size_t tried = 0;
        long long check = ACTIVE_EXPIRE_CYCLE_FAST_DURATION;    // assume a check is roughly 1us.  It isn't but good enough
-        db->expireitr = db->setexpire->enumerate(db->expireitr, now, [&](expireEntry &e) __attribute__((always_inline)) {
+        db->expireitr = db->setexpireUnsafe()->enumerate(db->expireitr, now, [&](expireEntry &e) __attribute__((always_inline)) {
            if (e.when() < now)
            {
                activeExpireCycleExpire(db, e, now);
@@ -468,16 +405,16 @@ void expireSlaveKeys(void) {
                redisDb *db = g_pserver->db+dbid;

                // the expire is hashed based on the key pointer, so we need the point in the main db
-                dictEntry *deMain = dictFind(db->pdict, keyname);
-                auto itr = db->setexpire->end();
-                if (deMain != nullptr)
-                    itr = db->setexpire->find((sds)dictGetKey(deMain));
+                auto itrDB = db->find(keyname);
+                auto itrExpire = db->setexpire()->end();
+                if (itrDB != nullptr)
+                    itrExpire = db->setexpireUnsafe()->find(itrDB.key());
                int expired = 0;

-                if (itr != db->setexpire->end())
+                if (itrExpire != db->setexpire()->end())
                {
-                    if (itr->when() < start) {
-                        activeExpireCycleExpire(g_pserver->db+dbid,*itr,start);
+                    if (itrExpire->when() < start) {
+                        activeExpireCycleExpire(g_pserver->db+dbid,*itrExpire,start);
                        expired = 1;
                    }
                }
@@ -486,7 +423,7 @@ void expireSlaveKeys(void) {
                 * corresponding bit in the new bitmap we set as value.
                 * At the end of the loop if the bitmap is zero, it means we
                 * no longer need to keep track of this key. */
-                if (itr != db->setexpire->end() && !expired) {
+                if (itrExpire != db->setexpire()->end() && !expired) {
                    noexpire++;
                    new_dbids |= (uint64_t)1 << dbid;
                }
@@ -597,7 +534,7 @@ void expireGenericCommand(client *c, long long basetime, int unit) {
     *
     * Instead we take the other branch of the IF statement setting an expire
     * (possibly in the past) and wait for an explicit DEL from the master. */
-    if (when <= mstime() && !g_pserver->loading && (!listLength(g_pserver->masters) || g_pserver->fActiveReplica)) {
+    if (when <= mstime() && !g_pserver->loading && !listLength(g_pserver->masters)) {
        robj *aux;

        int deleted = g_pserver->lazyfree_lazy_expire ? dbAsyncDelete(c->db,key) :
@@ -654,7 +591,7 @@ void ttlGenericCommand(client *c, int output_ms) {

    /* The key exists. Return -1 if it has no expire, or the actual
        * TTL value otherwise. */
-    expireEntry *pexpire = getExpire(c->db,c->argv[1]);
+    expireEntry *pexpire = c->db->getExpire(c->argv[1]);

    if (c->argc == 2) {
        // primary expire    
@@ -710,7 +647,7 @@ void persistCommand(client *c) {
                addReply(c,shared.czero);
            }
        } else if (c->argc == 3) {
-            if (removeSubkeyExpire(c->db, c->argv[1], c->argv[2])) {
+            if (c->db->removeSubkeyExpire(c->argv[1], c->argv[2])) {
                addReply(c,shared.cone);
                g_pserver->dirty++;
            } else {
@@ -27,7 +27,6 @@
 * POSSIBILITY OF SUCH DAMAGE.
 */

-#include "fmacros.h"
 #include "fastlock.h"
 #include <unistd.h>
 #include <sys/syscall.h>
@@ -37,14 +36,10 @@
 #include <assert.h>
 #include <pthread.h>
 #include <limits.h>
-#include <map>
 #ifdef __linux__
 #include <linux/futex.h>
 #endif
 #include <string.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include "config.h"

 #ifdef __APPLE__
 #include <TargetConditionals.h>
@@ -62,12 +57,6 @@
 #define UNUSED(x) ((void)x)
 #endif

-#ifdef HAVE_BACKTRACE
-#include <ucontext.h>
-__attribute__((weak)) void logStackTrace(ucontext_t *) {}
-#endif
-
-extern int g_fInCrash;

 /****************************************************
 *
@@ -81,10 +70,6 @@ extern int g_fInCrash;
    #define __has_feature(x) 0
 #endif

-#ifdef __linux__
-extern "C" void unlock_futex(struct fastlock *lock, uint16_t ifutex);
-#endif
-
 #if __has_feature(thread_sanitizer)

    /* Report that a lock has been created at address "lock". */
@@ -140,21 +125,26 @@ extern "C" void unlock_futex(struct fastlock *lock, uint16_t ifutex);

 #endif

-#pragma weak _serverPanic
-extern "C"  __attribute__((weak)) void _serverPanic(const char * /*file*/, int /*line*/, const char * /*msg*/, ...)
+static_assert(sizeof(pid_t) <= sizeof(fastlock::m_pidOwner), "fastlock::m_pidOwner not large enough");
+uint64_t g_longwaits = 0;
+
+uint64_t fastlock_getlongwaitcount()
 {
-    *((char*)-1) = 'x';
+    uint64_t rval;
+    __atomic_load(&g_longwaits, &rval, __ATOMIC_RELAXED);
+    return rval;
 }

-#pragma weak serverLog
-__attribute__((weak)) void serverLog(int , const char *fmt, ...)
+#ifndef ASM_SPINLOCK
+#ifdef __linux__
+static int futex(volatile unsigned *uaddr, int futex_op, int val,
+    const struct timespec *timeout, int val3)
 {
-    va_list args;
-    va_start(args, fmt);
-    vprintf(fmt, args);
-    va_end(args);
-    printf("\n");
+    return syscall(SYS_futex, uaddr, futex_op, val,
+                    timeout, uaddr, val3);
 }
+#endif
+#endif

 extern "C" pid_t gettid()
 {
@@ -173,146 +163,13 @@ extern "C" pid_t gettid()
    return pidCache;
 }

-void printTrace()
-{
-#ifdef HAVE_BACKTRACE
-    serverLog(3 /*LL_WARNING*/, "printing backtrace for thread %d", gettid());
-    ucontext_t ctxt;
-    getcontext(&ctxt);
-    logStackTrace(&ctxt);
-#endif
-}
-
-
-#ifdef __linux__
-static int futex(volatile unsigned *uaddr, int futex_op, int val,
-    const struct timespec *timeout, int val3)
-{
-    return syscall(SYS_futex, uaddr, futex_op, val,
-                    timeout, uaddr, val3);
-}
-#endif
-
-class DeadlockDetector
-{
-    std::map<pid_t, fastlock *> m_mapwait;
-    fastlock m_lock { "deadlock detector" };
-public:
-    void registerwait(fastlock *lock, pid_t thispid)
-    {
-        static volatile bool fInDeadlock = false;
-
-        if (lock == &m_lock || g_fInCrash)
-            return;
-        fastlock_lock(&m_lock);
-        
-        if (fInDeadlock)
-        {
-            printTrace();
-            fastlock_unlock(&m_lock);
-            return;
-        }
-
-        m_mapwait.insert(std::make_pair(thispid, lock));
-
-        // Detect cycles
-        pid_t pidCheck = thispid;
-        size_t cchecks = 0;
-        for (;;)
-        {
-            auto itr = m_mapwait.find(pidCheck);
-            if (itr == m_mapwait.end())
-                break;
-
-            __atomic_load(&itr->second->m_pidOwner, &pidCheck, __ATOMIC_RELAXED);
-            if (pidCheck == thispid)
-            {
-                // Deadlock detected, printout some debugging info and crash
-                serverLog(3 /*LL_WARNING*/, "\n\n");
-                serverLog(3 /*LL_WARNING*/, "!!! ERROR: Deadlock detected !!!");
-                pidCheck = thispid;
-                for (;;)
-                {
-                    auto itr = m_mapwait.find(pidCheck);
-                    serverLog(3 /* LL_WARNING */, "\t%d: (%p) %s", pidCheck, itr->second, itr->second->szName);
-                    __atomic_load(&itr->second->m_pidOwner, &pidCheck, __ATOMIC_RELAXED);
-                    if (pidCheck == thispid)
-                        break;
-                }
-                // Wake All sleeping threads so they can print their callstacks
-#ifdef HAVE_BACKTRACE
-#ifdef __linux__
-                int mask = -1;
-                fInDeadlock = true;
-                fastlock_unlock(&m_lock);
-                futex(&lock->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask);
-                futex(&itr->second->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask);
-                sleep(2);
-                fastlock_lock(&m_lock);
-                printTrace();
-#endif
-#endif
-                serverLog(3 /*LL_WARNING*/, "!!! KeyDB Will Now Crash !!!");
-                _serverPanic(__FILE__, __LINE__, "Deadlock detected");
-            }
-
-            if (cchecks > m_mapwait.size())
-                break;  // There is a cycle but we're not in it
-            ++cchecks;
-        }
-        fastlock_unlock(&m_lock);
-    }
-
-    void clearwait(fastlock *lock, pid_t thispid)
-    {
-        if (lock == &m_lock || g_fInCrash)
-            return;
-        fastlock_lock(&m_lock);
-        m_mapwait.erase(thispid);
-        fastlock_unlock(&m_lock);
-    }
-};
-
-DeadlockDetector g_dlock;
-
-static_assert(sizeof(pid_t) <= sizeof(fastlock::m_pidOwner), "fastlock::m_pidOwner not large enough");
-uint64_t g_longwaits = 0;
-
-extern "C" void fastlock_panic(struct fastlock *lock)
-{
-    _serverPanic(__FILE__, __LINE__, "fastlock lock/unlock mismatch for: %s", lock->szName);
-}
-
-uint64_t fastlock_getlongwaitcount()
-{
-    uint64_t rval;
-    __atomic_load(&g_longwaits, &rval, __ATOMIC_RELAXED);
-    return rval;
-}
-
-extern "C" void fastlock_sleep(fastlock *lock, pid_t pid, unsigned wake, unsigned mask)
-{
-#ifdef __linux__
-    g_dlock.registerwait(lock, pid);
-    __atomic_fetch_or(&lock->futex, mask, __ATOMIC_ACQUIRE);
-    futex(&lock->m_ticket.u, FUTEX_WAIT_BITSET_PRIVATE, wake, nullptr, mask);
-    __atomic_fetch_and(&lock->futex, ~mask, __ATOMIC_RELEASE);
-    g_dlock.clearwait(lock, pid);
-#endif
-    __atomic_fetch_add(&g_longwaits, 1, __ATOMIC_RELAXED);
-}
-
-extern "C" void fastlock_init(struct fastlock *lock, const char *name)
+extern "C" void fastlock_init(struct fastlock *lock)
 {
    lock->m_ticket.m_active = 0;
    lock->m_ticket.m_avail = 0;
    lock->m_depth = 0;
    lock->m_pidOwner = -1;
    lock->futex = 0;
-    int cch = strlen(name);
-    cch = std::min<int>(cch, sizeof(lock->szName)-1);
-    memcpy(lock->szName, name, cch);
-    lock->szName[cch] = '\0';
    ANNOTATE_RWLOCK_CREATE(lock);
 }

@@ -327,12 +184,12 @@ extern "C" void fastlock_lock(struct fastlock *lock)
        return;
    }

-    int tid = gettid();
    unsigned myticket = __atomic_fetch_add(&lock->m_ticket.m_avail, 1, __ATOMIC_RELEASE);
+#ifdef __linux__
    unsigned mask = (1U << (myticket % 32));
-    unsigned cloops = 0;
+#endif
+    int cloops = 0;
    ticket ticketT;
-
    for (;;)
    {
        __atomic_load(&lock->m_ticket.u, &ticketT.u, __ATOMIC_ACQUIRE);
@@ -340,17 +197,21 @@ extern "C" void fastlock_lock(struct fastlock *lock)
            break;

 #if defined(__i386__) || defined(__amd64__)
-        __asm__ __volatile__ ("pause");
-#elif defined(__aarch64__)
-        __asm__ __volatile__ ("yield");
+        __asm__ ("pause");
 #endif
-        if ((++cloops % 0x100000) == 0)
+        if ((++cloops % 1024*1024) == 0)
        {
-            fastlock_sleep(lock, tid, ticketT.u, mask);
+#ifdef __linux__
+            __atomic_fetch_or(&lock->futex, mask, __ATOMIC_ACQUIRE);
+            futex(&lock->m_ticket.u, FUTEX_WAIT_BITSET_PRIVATE, ticketT.u, nullptr, mask);
+            __atomic_fetch_and(&lock->futex, ~mask, __ATOMIC_RELEASE);
+#endif
+            __atomic_fetch_add(&g_longwaits, 1, __ATOMIC_RELAXED);
        }
    }

    lock->m_depth = 1;
+    int tid = gettid();
    __atomic_store(&lock->m_pidOwner, &tid, __ATOMIC_RELEASE);
    ANNOTATE_RWLOCK_ACQUIRED(lock, true);
    std::atomic_thread_fence(std::memory_order_acquire);
@@ -377,7 +238,7 @@ extern "C" int fastlock_trylock(struct fastlock *lock, int fWeak)

    struct ticket ticket_expect { { { active, active } } };
    struct ticket ticket_setiflocked { { { active, next } } };
-    if (__atomic_compare_exchange(&lock->m_ticket.u, &ticket_expect.u, &ticket_setiflocked.u, fWeak /*weak*/, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
+    if (__atomic_compare_exchange(&lock->m_ticket, &ticket_expect, &ticket_setiflocked, fWeak /*weak*/, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
    {
        lock->m_depth = 1;
        tid = gettid();
@@ -388,6 +249,31 @@ extern "C" int fastlock_trylock(struct fastlock *lock, int fWeak)
    return false;
 }

+#ifdef __linux__
+#define ROL32(v, shift) ((v << shift) | (v >> (32-shift)))
+void unlock_futex(struct fastlock *lock, uint16_t ifutex)
+{
+    unsigned mask = (1U << (ifutex % 32));
+    unsigned futexT;
+    __atomic_load(&lock->futex, &futexT, __ATOMIC_RELAXED);
+    futexT &= mask;
+    
+    if (futexT == 0)
+        return;
+    
+    for (;;)
+    {
+        __atomic_load(&lock->futex, &futexT, __ATOMIC_ACQUIRE);
+        futexT &= mask;
+        if (!futexT)
+            break;
+
+        if (futex(&lock->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask) == 1)
+            break;
+    }
+}
+#endif
+
 extern "C" void fastlock_unlock(struct fastlock *lock)
 {
    --lock->m_depth;
@@ -410,26 +296,6 @@ extern "C" void fastlock_unlock(struct fastlock *lock)
 }
 #endif

-#ifdef __linux__
-#define ROL32(v, shift) ((v << shift) | (v >> (32-shift)))
-extern "C" void unlock_futex(struct fastlock *lock, uint16_t ifutex)
-{
-    unsigned mask = (1U << (ifutex % 32));
-    unsigned futexT;
-    
-    for (;;)
-    {
-        __atomic_load(&lock->futex, &futexT, __ATOMIC_ACQUIRE);
-        futexT &= mask;
-        if (!futexT)
-            break;
-
-        if (futex(&lock->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask) == 1)
-            break;
-    }
-}
-#endif
-
 extern "C" void fastlock_free(struct fastlock *lock)
 {
    // NOP
@@ -459,4 +325,4 @@ void fastlock_lock_recursive(struct fastlock *lock, int nesting)
 {
    fastlock_lock(lock);
    lock->m_depth = nesting;
-}
+}
@@ -1,6 +1,5 @@
 #pragma once
 #include <inttypes.h>
-#include <stddef.h>

 #ifdef __cplusplus
 extern "C" {
@@ -8,7 +7,7 @@ extern "C" {

 /* Begin C API */
 struct fastlock;
-void fastlock_init(struct fastlock *lock, const char *name);
+void fastlock_init(struct fastlock *lock);
 void fastlock_lock(struct fastlock *lock);
 int fastlock_trylock(struct fastlock *lock, int fWeak);
 void fastlock_unlock(struct fastlock *lock);
@@ -41,31 +40,29 @@ struct ticket

 struct fastlock
 {
+    volatile struct ticket m_ticket;
+
    volatile int m_pidOwner;
    volatile int m_depth;
-    char szName[56];
-    /* Volatile data on seperate cache line */
-    volatile struct ticket m_ticket;
    unsigned futex;
-    char padding[56];   // ensure ticket and futex are on their own independent cache line

 #ifdef __cplusplus
-    fastlock(const char *name)
+    fastlock()
    {
-        fastlock_init(this, name);
+        fastlock_init(this);
    }

-    inline void lock()
+    void lock()
    {
        fastlock_lock(this);
    }

-    inline bool try_lock(bool fWeak = false)
+    bool try_lock(bool fWeak = false)
    {
        return !!fastlock_trylock(this, fWeak);
    }

-    inline void unlock()
+    void unlock()
    {
        fastlock_unlock(this);
    }
@@ -83,5 +80,3 @@ struct fastlock
    bool fOwnLock();   // true if this thread owns the lock, NOTE: not 100% reliable, use for debugging only
 #endif
 };
-
-static_assert(offsetof(struct fastlock, m_ticket) == 64, "ensure padding is correct");
@@ -1,152 +1,157 @@
-.intel_syntax noprefix
-.text
+section .text

-.extern gettid
-.extern fastlock_sleep
+extern gettid
+extern sched_yield
+extern g_longwaits

-#	This is the first use of assembly in this codebase, a valid question is WHY?
-#	The spinlock we implement here is performance critical, and simply put GCC
-#	emits awful code.  The original C code is left in fastlock.cpp for reference
-#	and x-plat.
+;	This is the first use of assembly in this codebase, a valid question is WHY?
+;	The spinlock we implement here is performance critical, and simply put GCC
+;	emits awful code.  The original C code is left in fastlock.cpp for reference
+;	and x-plat.

-.ALIGN 16
-.global fastlock_lock
-.type   fastlock_lock,@function
+ALIGN 16
+global fastlock_lock
 fastlock_lock:
-	.cfi_startproc
-	.cfi_def_cfa rsp, 8
-	# RDI points to the struct:
-	#	int32_t m_pidOwner
-	#	int32_t m_depth
-	# [rdi+64] ...
-	#	uint16_t active
-	#	uint16_t avail
+	; RDI points to the struct:
+	;	uint16_t active
+	;	uint16_t avail
+	;	int32_t m_pidOwner
+	;	int32_t m_depth
 	
-	# First get our TID and put it in ecx
-	push rdi                # we need our struct pointer (also balance the stack for the call)
-	.cfi_adjust_cfa_offset 8
-	call gettid             # get our thread ID (TLS is nasty in ASM so don't bother inlining)
-	mov esi, eax            # back it up in esi
-	pop rdi                 # get our pointer back
-	.cfi_adjust_cfa_offset -8
+	; First get our TID and put it in ecx
+	push rdi                ; we need our struct pointer (also balance the stack for the call)
+	call gettid             ; get our thread ID (TLS is nasty in ASM so don't bother inlining)
+	mov esi, eax            ; back it up in esi
+	pop rdi                 ; get our pointer back

-	cmp [rdi], esi          # Is the TID we got back the owner of the lock?
-	je .LLocked             # Don't spin in that case
+	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
+	je .LLocked             ; Don't spin in that case

-	xor eax, eax            # eliminate partial register dependency
-	inc eax                 # we want to add one
-	lock xadd [rdi+66], ax  # do the xadd, ax contains the value before the addition
-	# ax now contains the ticket
-	# OK Start the wait loop
-	xor ecx, ecx
-.ALIGN 16
+	xor eax, eax            ; eliminate partial register dependency
+	inc eax                 ; we want to add one
+	lock xadd [rdi+2], ax   ; do the xadd, ax contains the value before the addition
+	; ax now contains the ticket
+ALIGN 16
 .LLoop:
-	mov edx, [rdi+64]
-	cmp dx, ax              # is our ticket up?
-	je .LLocked             # leave the loop
+	mov edx, [rdi]
+	cmp dx, ax              ; is our ticket up?
+	je .LLocked             ; leave the loop
 	pause
-	add ecx, 0x1000         # Have we been waiting a long time? (oflow if we have)
-	                        #	1000h is set so we overflow on the 1024*1024'th iteration (like the C code)
-	jnc .LLoop              # If so, give up our timeslice to someone who's doing real work
-	# Like the compiler, you're probably thinking: "Hey! I should take these pushs out of the loop"
-	#	But the compiler doesn't know that we rarely hit this, and when we do we know the lock is
-	#	taking a long time to be released anyways.  We optimize for the common case of short
-	#	lock intervals.  That's why we're using a spinlock in the first place
-	# If we get here we're going to sleep in the kernel with a futex
-	push rdi
+	add ecx, 1000h          ; Have we been waiting a long time? (oflow if we have)
+	                        ;	1000h is set so we overflow on the 1024*1024'th iteration (like the C code)
+	jnc .LLoop              ; If so, give up our timeslice to someone who's doing real work
+	; Like the compiler, you're probably thinking: "Hey! I should take these pushs out of the loop"
+	;	But the compiler doesn't know that we rarely hit this, and when we do we know the lock is
+	;	taking a long time to be released anyways.  We optimize for the common case of short
+	;	lock intervals.  That's why we're using a spinlock in the first place
+	; If we get here we're going to sleep in the kernel with a futex
 	push rsi
 	push rax
-	.cfi_adjust_cfa_offset 24
-	# Setup the syscall args
-
-                            # rdi ARG1 futex (already in rdi)
-	                        # rsi ARG2 tid (already in esi)
-                            # rdx ARG3 ticketT.u (already in edx)
-	bts ecx, eax            # rcx ARG4 mask
-	call fastlock_sleep
-	# cleanup and continue
+	; Setup the syscall args
+                            ; rdi ARG1 futex (already in rdi)
+	mov esi, (9 | 128)      ; rsi ARG2 FUTEX_WAIT_BITSET_PRIVATE
+                            ; rdx ARG3 ticketT.u (already in edx)
+	xor r10d, r10d          ; r10 ARG4 NULL
+	mov r8, rdi	            ; r8 ARG5 dup rdi
+	xor r9d, r9d
+	bts r9d, eax            ; r9 ARG6 mask
+	mov eax, 202            ; sys_futex
+	; Do the syscall
+	lock or [rdi+12], r9d   ; inform the unlocking thread we're waiting
+	syscall	                ; wait for the futex
+	not r9d	                ; convert our flag into a mask of bits not to touch
+	lock and [rdi+12], r9d  ; clear the flag in the futex control mask
+	; cleanup and continue
+	mov rcx, g_longwaits
+	inc qword [rcx]         ; increment our long wait counter
 	pop rax
 	pop rsi
-	pop rdi
-	.cfi_adjust_cfa_offset -24
-	xor ecx, ecx            # Reset our loop counter
-	jmp .LLoop              # Get back in the game
-.ALIGN 16
+	xor ecx, ecx            ; Reset our loop counter
+	jmp .LLoop              ; Get back in the game
+ALIGN 16
 .LLocked:
-	mov [rdi], esi          # lock->m_pidOwner = gettid()
-	inc dword ptr [rdi+4]   # lock->m_depth++
+	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
+	inc dword [rdi+8]       ; lock->m_depth++
 	ret
-.cfi_endproc

-.ALIGN 16
-.global fastlock_trylock
-.type   fastlock_trylock,@function
+ALIGN 16
+global fastlock_trylock
 fastlock_trylock:
-	# RDI points to the struct:
-	#	int32_t m_pidOwner
-	#	int32_t m_depth
-	# [rdi+64] ...
-	#	uint16_t active
-	#	uint16_t avail
+	; RDI points to the struct:
+	;	uint16_t active
+	;	uint16_t avail
+	;	int32_t m_pidOwner
+	;	int32_t m_depth
 	
-	# First get our TID and put it in ecx
-	push rdi                # we need our struct pointer (also balance the stack for the call)
-	call gettid             # get our thread ID (TLS is nasty in ASM so don't bother inlining)
-	mov esi, eax            # back it up in esi
-	pop rdi                 # get our pointer back
+	; First get our TID and put it in ecx
+	push rdi                ; we need our struct pointer (also balance the stack for the call)
+	call gettid             ; get our thread ID (TLS is nasty in ASM so don't bother inlining)
+	mov esi, eax            ; back it up in esi
+	pop rdi                 ; get our pointer back

-	cmp [rdi], esi          # Is the TID we got back the owner of the lock?
-	je .LRecursive          # Don't spin in that case
+	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
+	je .LRecursive          ; Don't spin in that case

-	mov eax, [rdi+64]       # get both active and avail counters
-	mov ecx, eax            # duplicate in ecx
-	ror ecx, 16             # swap upper and lower 16-bits
-	cmp eax, ecx            # are the upper and lower 16-bits the same?
-	jnz .LAlreadyLocked     #	If not return failure
+	mov eax, [rdi]          ; get both active and avail counters
+	mov ecx, eax            ; duplicate in ecx
+	ror ecx, 16             ; swap upper and lower 16-bits
+	cmp eax, ecx            ; are the upper and lower 16-bits the same?
+	jnz .LAlreadyLocked     ;	If not return failure

-	# at this point we know eax+ecx have [avail][active] and they are both the same
-	add ecx, 0x10000            # increment avail, ecx is now our wanted value
-	lock cmpxchg [rdi+64], ecx  #	If rdi still contains the value in eax, put in ecx (inc avail)
-	jnz .LAlreadyLocked         # If Z is not set then someone locked it while we were preparing
+	; at this point we know eax+ecx have [avail][active] and they are both the same
+	add ecx, 10000h         ; increment avail, ecx is now our wanted value
+	lock cmpxchg [rdi], ecx ;	If rdi still contains the value in eax, put in ecx (inc avail)
+	jnz .LAlreadyLocked     ; If Z is not set then someone locked it while we were preparing
 	xor eax, eax
-	inc eax                     # return SUCCESS! (eax=1)
-	mov [rdi], esi              # lock->m_pidOwner = gettid()
-	mov dword ptr [rdi+4], eax  # lock->m_depth = 1
+	inc eax                 ; return SUCCESS! (eax=1)
+	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
+	mov dword [rdi+8], eax  ; lock->m_depth = 1
 	ret
-.ALIGN 16
+ALIGN 16
 .LRecursive:
 	xor eax, eax
-	inc eax                 # return SUCCESS! (eax=1)
-	inc dword ptr [rdi+4]   # lock->m_depth++
+	inc eax                 ; return SUCCESS! (eax=1)
+	inc dword [rdi+8]       ; lock->m_depth++
 	ret
-.ALIGN 16
+ALIGN 16
 .LAlreadyLocked:
-	xor eax, eax            # return 0
+	xor eax, eax            ; return 0;
 	ret

-.ALIGN 16
-.global fastlock_unlock
-.type   fastlock_unlock,@function
+ALIGN 16
+global fastlock_unlock
 fastlock_unlock:
-	# RDI points to the struct:
-	#	int32_t m_pidOwner
-	#	int32_t m_depth
-	# [rdi+64] ...
-	#	uint16_t active
-	#	uint16_t avail
-	sub dword ptr [rdi+4], 1     # decrement m_depth, don't use dec because it partially writes the flag register and we don't know its state
-	jnz .LDone                   # if depth is non-zero this is a recursive unlock, and we still hold it
-	mov dword ptr [rdi], -1      # pidOwner = -1 (we don't own it anymore)
-	mov esi, [rdi+64]            # get current active (this one)
-	inc esi                      # bump it to the next thread
-	mov word ptr [rdi+64], si    # give up our ticket (note: lock is not required here because the spinlock itself guards this variable)
-	mfence                       # sync other threads
-	# At this point the lock is removed, however we must wake up any pending futexs
-	mov edx, [rdi+64+4]          # load the futex mask
-	bt edx, esi                  # is the next thread waiting on a futex?
-	jc unlock_futex              # unlock the futex if necessary
-	ret                          # if not we're done.
-.ALIGN 16
+	; RDI points to the struct:
+	;	uint16_t active
+	;	uint16_t avail
+	;	int32_t m_pidOwner
+	;	int32_t m_depth
+	push r11
+	sub dword [rdi+8], 1         ; decrement m_depth, don't use dec because it partially writes the flag register and we don't know its state
+	jnz .LDone                   ; if depth is non-zero this is a recursive unlock, and we still hold it
+	mov dword [rdi+4], -1        ; pidOwner = -1 (we don't own it anymore)
+	mov ecx, [rdi]               ; get current active (this one)
+	inc ecx                      ; bump it to the next thread
+	mov [rdi], cx                ; give up our ticket (note: lock is not required here because the spinlock itself guards this variable)
+	; At this point the lock is removed, however we must wake up any pending futexs
+	mov r9d, 1                   ; eax is the bitmask for 2 threads
+	rol r9d, cl                  ; place the mask in the right spot for the next 2 threads
+ALIGN 16
+.LRetryWake:
+	mov r11d, [rdi+12]           ; load the futex mask
+	and r11d, r9d                ; are any threads waiting on a futex?
+	jz .LDone                    ; if not we're done.
+	; we have to wake the futexs
+                                 ; rdi ARG1 futex (already in rdi)
+	mov esi, (10 | 128)          ; rsi ARG2 FUTEX_WAKE_BITSET_PRIVATE
+	mov edx, 0x7fffffff          ; rdx ARG3 INT_MAX (number of threads to wake)
+	xor r10d, r10d               ; r10 ARG4 NULL
+	mov r8, rdi                  ; r8 ARG5 dup rdi
+                                 ; r9 ARG6 mask (already set above)
+	mov eax, 202                 ; sys_futex
+	syscall
+	cmp eax, 1                   ; did we wake as many as we expected?
+	jnz .LRetryWake
 .LDone:
-	js fastlock_panic            # panic if we made m_depth negative
+	pop r11
 	ret
@@ -465,8 +465,8 @@ void georadiusGeneric(client *c, int flags) {
    int storedist = 0; /* 0 for STORE, 1 for STOREDIST. */

    /* Look up the requested zset */
-    robj_roptr zobj = nullptr;
-    if ((zobj = lookupKeyReadOrReply(c, key, shared.emptyarray)) == nullptr ||
+    robj_roptr zobj;
+    if ((zobj = lookupKeyReadOrReply(c, key, shared.null[c->resp])) == nullptr ||
        checkType(c, zobj, OBJ_ZSET)) {
        return;
    }
@@ -566,7 +566,7 @@ void georadiusGeneric(client *c, int flags) {

    /* If no matching results, the user gets an empty reply. */
    if (ga->used == 0 && storekey == NULL) {
-        addReply(c,shared.emptyarray);
+        addReplyNull(c);
        geoArrayFree(ga);
        return;
    }
@@ -737,15 +737,7 @@ void geohashCommand(client *c) {
            char buf[12];
            int i;
            for (i = 0; i < 11; i++) {
-                int idx;
-                if (i == 10) {
-                    /* We have just 52 bits, but the API used to output
-                     * an 11 bytes geohash. For compatibility we assume
-                     * zero. */
-                    idx = 0;
-                } else {
-                    idx = (hash.bits >> (52-((i+1)*5))) & 0x1f;
-                }
+                int idx = (hash.bits >> (52-((i+1)*5))) & 0x1f;
                buf[i] = geoalphabet[idx];
            }
            buf[11] = '\0';
@@ -46,13 +46,13 @@
 #define ECCENT (sqrt(1.0 - (RATIO *RATIO)))
 #define COM (0.5 * ECCENT)

-/// @brief The usual PI/180 constant
-const double DEG_TO_RAD = 0.017453292519943295769236907684886;
 /// @brief Earth's quatratic mean radius for WGS-84
 const double EARTH_RADIUS_IN_METERS = 6372797.560856;

 const double MERCATOR_MAX = 20037726.37;
+#if 0 //unused
 const double MERCATOR_MIN = -20037726.37;
+#endif

 static inline double deg_rad(double ang) { return ang * D_R; }
 static inline double rad_deg(double ang) { return ang / D_R; }
@@ -1168,13 +1168,7 @@ struct commandHelp {
    "destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]",
    "Add multiple sorted sets and store the resulting sorted set in a new key",
    4,
-    "2.0.0" },
-    { "KEYDB.CRON",
-    "name [single/repeat] [optional: start] delay script numkeys [key N] [arg N]",
-    "Run a specified script after start + delay, optionally repeating every delay interval.  The job may be cancelled by deleting the key associated with the job (name parameter)",
-    10,
-    "6.5.2"
-    }
+    "2.0.0" }
 };

 #endif
@@ -709,7 +709,8 @@ int hllSparseSet(robj *o, long index, uint8_t count) {
        p += oplen;
        first += span;
    }
-    if (span == 0 || p >= end) return -1; /* Invalid format. */
+    if (span == 0) return -1; /* Invalid format. */
+    if (p >= end) return -1; /* Invalid format. */

    next = HLL_SPARSE_IS_XZERO(p) ? p+2 : p+1;
    if (next >= end) next = NULL;
@@ -1252,7 +1253,7 @@ void pfcountCommand(client *c) {
            if (o == nullptr) continue; /* Assume empty HLL for non existing var.*/
            if (isHLLObjectOrReply(c,o) != C_OK) return;

-            /* Merge with this HLL with our 'max' HLL by setting max[i]
+            /* Merge with this HLL with our 'max' HHL by setting max[i]
             * to MAX(max[i],hll[i]). */
            if (hllMerge(registers,HLL_REGISTERS,o) == C_ERR) {
                addReplySds(c,sdsnew(invalid_hll_err));
@@ -1339,7 +1340,7 @@ void pfmergeCommand(client *c) {
        hdr = (hllhdr*)ptrFromObj(o);
        if (hdr->encoding == HLL_DENSE) use_dense = 1;

-        /* Merge with this HLL with our 'max' HLL by setting max[i]
+        /* Merge with this HLL with our 'max' HHL by setting max[i]
         * to MAX(max[i],hll[i]). */
        if (hllMerge(max,sizeof(max),o) == C_ERR) {
            addReplySds(c,sdsnew(invalid_hll_err));
@@ -1548,7 +1549,6 @@ void pfdebugCommand(client *c) {
        sds decoded = sdsempty();

        if (hdr->encoding != HLL_SPARSE) {
-            sdsfree(decoded);
            addReplyError(c,"HLL encoding is not sparse");
            return;
        }
@@ -85,7 +85,7 @@ int THPGetAnonHugePagesSize(void) {
 /* ---------------------------- Latency API --------------------------------- */

 /* Latency monitor initialization. We just need to create the dictionary
- * of time series, each time serie is created on demand in order to avoid
+ * of time series, each time serie is craeted on demand in order to avoid
 * having a fixed list to maintain. */
 void latencyMonitorInit(void) {
    g_pserver->latency_events = dictCreate(&latencyTimeSeriesDictType,NULL);
@@ -599,7 +599,7 @@ NULL
        event = (char*)dictGetKey(de);

        graph = latencyCommandGenSparkeline(event,ts);
-        addReplyVerbatim(c,graph,sdslen(graph),"txt");
+        addReplyBulkCString(c,graph);
        sdsfree(graph);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"latest") && c->argc == 2) {
        /* LATENCY LATEST */
@@ -608,7 +608,7 @@ NULL
        /* LATENCY DOCTOR */
        sds report = createLatencyReport();

-        addReplyVerbatim(c,report,sdslen(report),"txt");
+        addReplyBulkCBuffer(c,report,sdslen(report));
        sdsfree(report);
    } else if (!strcasecmp(szFromObj(c->argv[1]),"reset") && c->argc >= 2) {
        /* LATENCY RESET */
@@ -51,18 +51,18 @@ size_t lazyfreeGetFreeEffort(robj *obj) {
 * a lazy free list instead of being freed synchronously. The lazy free list
 * will be reclaimed in a different bio.c thread. */
 #define LAZYFREE_THRESHOLD 64
-int dbAsyncDelete(redisDb *db, robj *key) {
+bool redisDbPersistentData::asyncDelete(robj *key) {
    /* If the value is composed of a few allocations, to free in a lazy way
     * is actually just slower... So under a certain limit we just free
     * the object synchronously. */
-    dictEntry *de = dictUnlink(db->pdict,ptrFromObj(key));
+    dictEntry *de = dictUnlink(m_pdict,ptrFromObj(key));
    if (de) {
        robj *val = (robj*)dictGetVal(de);
        if (val->FExpires())
        {
            /* Deleting an entry from the expires dict will not free the sds of
             * the key, because it is shared with the main dictionary. */
-            removeExpireCore(db,key,de);
+            removeExpire(key,dict_iter(de));
        }

        size_t free_effort = lazyfreeGetFreeEffort(val);
@@ -78,21 +78,25 @@ int dbAsyncDelete(redisDb *db, robj *key) {
        if (free_effort > LAZYFREE_THRESHOLD && val->getrefcount(std::memory_order_relaxed) == 1) {
            atomicIncr(lazyfree_objects,1);
            bioCreateBackgroundJob(BIO_LAZY_FREE,val,NULL,NULL);
-            dictSetVal(db->pdict,de,NULL);
+            dictSetVal(m_pdict,de,NULL);
        }
    }

    /* Release the key-val pair, or just the key if we set the val
     * field to NULL in order to lazy free it later. */
    if (de) {
-        dictFreeUnlinkedEntry(db->pdict,de);
+        dictFreeUnlinkedEntry(m_pdict,de);
        if (g_pserver->cluster_enabled) slotToKeyDel(key);
-        return 1;
+        return true;
    } else {
-        return 0;
+        return false;
    }
 }

+int dbAsyncDelete(redisDb *db, robj *key) {
+    return db->asyncDelete(key);
+}
+
 /* Free an object, if the object is huge enough, free it in async way. */
 void freeObjAsync(robj *o) {
    size_t free_effort = lazyfreeGetFreeEffort(o);
@@ -107,12 +111,15 @@ void freeObjAsync(robj *o) {
 /* Empty a Redis DB asynchronously. What the function does actually is to
 * create a new empty set of hash tables and scheduling the old ones for
 * lazy freeing. */
-void emptyDbAsync(redisDb *db) {
-    dict *oldht1 = db->pdict;
-    auto *set = db->setexpire;
-    db->setexpire = new (MALLOC_LOCAL) expireset();
-    db->expireitr = db->setexpire->end();
-    db->pdict = dictCreate(&dbDictType,NULL);
+void redisDbPersistentData::emptyDbAsync() {
+    dict *oldht1 = m_pdict;
+    auto *set = m_setexpire;
+    m_setexpire = new (MALLOC_LOCAL) expireset();
+    m_pdict = dictCreate(&dbDictType,this);
+    if (m_pstorage != nullptr)
+        m_pstorage->clear();
+    if (m_fTrackingChanges)
+        m_fAllChanged = true;
    atomicIncr(lazyfree_objects,dictSize(oldht1));
    bioCreateBackgroundJob(BIO_LAZY_FREE,NULL,oldht1,set);
 }
@@ -52,8 +52,8 @@
 static int is_leap_year(time_t year) {
    if (year % 4) return 0;         /* A year not divisible by 4 is not leap. */
    else if (year % 100) return 1;  /* If div by 4 and not 100 is surely leap. */
-    else if (year % 400) return 0;  /* If div by 100 *and* not by 400 is not leap. */
-    else return 1;                  /* If div by 100 and 400 is leap. */
+    else if (year % 400) return 0;  /* If div by 100 *and* 400 is not leap. */
+    else return 1;                  /* If div by 100 and not by 400 is leap. */
 }

 void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst) {
@@ -1,188 +0,0 @@
-/*
- * Copyright (c) 2018, Salvatore Sanfilippo <antirez at gmail dot com>
- * 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.
- *
- * ----------------------------------------------------------------------------
- *
- * This file implements the LOLWUT command. The command should do something
- * fun and interesting, and should be replaced by a new implementation at
- * each new version of Redis.
- */
-
-#include "server.h"
-#include "lolwut.h"
-#include <math.h>
-
-void lolwut5Command(client *c);
-void lolwut6Command(client *c);
-
-/* The default target for LOLWUT if no matching version was found.
- * This is what unstable versions of Redis will display. */
-void lolwutUnstableCommand(client *c) {
-    sds rendered = sdsnew("Redis ver. ");
-    rendered = sdscat(rendered,REDIS_VERSION);
-    rendered = sdscatlen(rendered,"\n",1);
-    addReplyVerbatim(c,rendered,sdslen(rendered),"txt");
-    sdsfree(rendered);
-}
-
-/* LOLWUT [VERSION <version>] [... version specific arguments ...] */
-void lolwutCommand(client *c) {
-    char *v = REDIS_VERSION;
-    char verstr[64];
-
-    if (c->argc >= 3 && !strcasecmp(c->argv[1]->ptr,"version")) {
-        long ver;
-        if (getLongFromObjectOrReply(c,c->argv[2],&ver,NULL) != C_OK) return;
-        snprintf(verstr,sizeof(verstr),"%u.0.0",(unsigned int)ver);
-        v = verstr;
-
-        /* Adjust argv/argc to filter the "VERSION ..." option, since the
-         * specific LOLWUT version implementations don't know about it
-         * and expect their arguments. */
-        c->argv += 2;
-        c->argc -= 2;
-    }
-
-    if ((v[0] == '5' && v[1] == '.' && v[2] != '9') ||
-        (v[0] == '4' && v[1] == '.' && v[2] == '9'))
-        lolwut5Command(c);
-    else if ((v[0] == '6' && v[1] == '.' && v[2] != '9') ||
-             (v[0] == '5' && v[1] == '.' && v[2] == '9'))
-        lolwut6Command(c);
-    else
-        lolwutUnstableCommand(c);
-
-    /* Fix back argc/argv in case of VERSION argument. */
-    if (v == verstr) {
-        c->argv -= 2;
-        c->argc += 2;
-    }
-}
-
-/* ========================== LOLWUT Canvase ===============================
- * Many LOWUT versions will likely print some computer art to the screen.
- * This is the case with LOLWUT 5 and LOLWUT 6, so here there is a generic
- * canvas implementation that can be reused.  */
-
-/* Allocate and return a new canvas of the specified size. */
-lwCanvas *lwCreateCanvas(int width, int height, int bgcolor) {
-    lwCanvas *canvas = zmalloc(sizeof(*canvas));
-    canvas->width = width;
-    canvas->height = height;
-    canvas->pixels = zmalloc(width*height);
-    memset(canvas->pixels,bgcolor,width*height);
-    return canvas;
-}
-
-/* Free the canvas created by lwCreateCanvas(). */
-void lwFreeCanvas(lwCanvas *canvas) {
-    zfree(canvas->pixels);
-    zfree(canvas);
-}
-
-/* Set a pixel to the specified color. Color is 0 or 1, where zero means no
- * dot will be displyed, and 1 means dot will be displayed.
- * Coordinates are arranged so that left-top corner is 0,0. You can write
- * out of the size of the canvas without issues. */
-void lwDrawPixel(lwCanvas *canvas, int x, int y, int color) {
-    if (x < 0 || x >= canvas->width ||
-        y < 0 || y >= canvas->height) return;
-    canvas->pixels[x+y*canvas->width] = color;
-}
-
-/* Return the value of the specified pixel on the canvas. */
-int lwGetPixel(lwCanvas *canvas, int x, int y) {
-    if (x < 0 || x >= canvas->width ||
-        y < 0 || y >= canvas->height) return 0;
-    return canvas->pixels[x+y*canvas->width];
-}
-
-/* Draw a line from x1,y1 to x2,y2 using the Bresenham algorithm. */
-void lwDrawLine(lwCanvas *canvas, int x1, int y1, int x2, int y2, int color) {
-    int dx = abs(x2-x1);
-    int dy = abs(y2-y1);
-    int sx = (x1 < x2) ? 1 : -1;
-    int sy = (y1 < y2) ? 1 : -1;
-    int err = dx-dy, e2;
-
-    while(1) {
-        lwDrawPixel(canvas,x1,y1,color);
-        if (x1 == x2 && y1 == y2) break;
-        e2 = err*2;
-        if (e2 > -dy) {
-            err -= dy;
-            x1 += sx;
-        }
-        if (e2 < dx) {
-            err += dx;
-            y1 += sy;
-        }
-    }
-}
-
-/* Draw a square centered at the specified x,y coordinates, with the specified
- * rotation angle and size. In order to write a rotated square, we use the
- * trivial fact that the parametric equation:
- *
- *  x = sin(k)
- *  y = cos(k)
- *
- * Describes a circle for values going from 0 to 2*PI. So basically if we start
- * at 45 degrees, that is k = PI/4, with the first point, and then we find
- * the other three points incrementing K by PI/2 (90 degrees), we'll have the
- * points of the square. In order to rotate the square, we just start with
- * k = PI/4 + rotation_angle, and we are done.
- *
- * Of course the vanilla equations above will describe the square inside a
- * circle of radius 1, so in order to draw larger squares we'll have to
- * multiply the obtained coordinates, and then translate them. However this
- * is much simpler than implementing the abstract concept of 2D shape and then
- * performing the rotation/translation transformation, so for LOLWUT it's
- * a good approach. */
-void lwDrawSquare(lwCanvas *canvas, int x, int y, float size, float angle, int color) {
-    int px[4], py[4];
-
-    /* Adjust the desired size according to the fact that the square inscribed
-     * into a circle of radius 1 has the side of length SQRT(2). This way
-     * size becomes a simple multiplication factor we can use with our
-     * coordinates to magnify them. */
-    size /= 1.4142135623;
-    size = round(size);
-
-    /* Compute the four points. */
-    float k = M_PI/4 + angle;
-    for (int j = 0; j < 4; j++) {
-        px[j] = round(sin(k) * size + x);
-        py[j] = round(cos(k) * size + y);
-        k += M_PI/2;
-    }
-
-    /* Draw the square. */
-    for (int j = 0; j < 4; j++)
-        lwDrawLine(canvas,px[j],py[j],px[(j+1)%4],py[(j+1)%4],color);
-}
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2018-2019, Salvatore Sanfilippo <antirez at gmail dot com>
- * 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.
- */
-
-/* This structure represents our canvas. Drawing functions will take a pointer
- * to a canvas to write to it. Later the canvas can be rendered to a string
- * suitable to be printed on the screen, using unicode Braille characters. */
-
-/* This represents a very simple generic canvas in order to draw stuff.
- * It's up to each LOLWUT versions to translate what they draw to the
- * screen, depending on the result to accomplish. */
-typedef struct lwCanvas {
-    int width;
-    int height;
-    char *pixels;
-} lwCanvas;
-
-/* Drawing functions implemented inside lolwut.c. */
-lwCanvas *lwCreateCanvas(int width, int height, int bgcolor);
-void lwFreeCanvas(lwCanvas *canvas);
-void lwDrawPixel(lwCanvas *canvas, int x, int y, int color);
-int lwGetPixel(lwCanvas *canvas, int x, int y);
-void lwDrawLine(lwCanvas *canvas, int x1, int y1, int x2, int y2, int color);
-void lwDrawSquare(lwCanvas *canvas, int x, int y, float size, float angle, int color);
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) 2018, Salvatore Sanfilippo <antirez at gmail dot com>
- * 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.
- *
- * ----------------------------------------------------------------------------
- *
- * This file implements the LOLWUT command. The command should do something
- * fun and interesting, and should be replaced by a new implementation at
- * each new version of Redis.
- */
-
-#include "server.h"
-#include "lolwut.h"
-#include <math.h>
-
-/* Translate a group of 8 pixels (2x4 vertical rectangle) to the corresponding
- * braille character. The byte should correspond to the pixels arranged as
- * follows, where 0 is the least significant bit, and 7 the most significant
- * bit:
- *
- *   0 3
- *   1 4
- *   2 5
- *   6 7
- *
- * The corresponding utf8 encoded character is set into the three bytes
- * pointed by 'output'.
- */
-#include <stdio.h>
-void lwTranslatePixelsGroup(int byte, char *output) {
-    int code = 0x2800 + byte;
-    /* Convert to unicode. This is in the U0800-UFFFF range, so we need to
-     * emit it like this in three bytes:
-     * 1110xxxx 10xxxxxx 10xxxxxx. */
-    output[0] = 0xE0 | (code >> 12);          /* 1110-xxxx */
-    output[1] = 0x80 | ((code >> 6) & 0x3F);  /* 10-xxxxxx */
-    output[2] = 0x80 | (code & 0x3F);         /* 10-xxxxxx */
-}
-
-/* Schotter, the output of LOLWUT of Redis 5, is a computer graphic art piece
- * generated by Georg Nees in the 60s. It explores the relationship between
- * caos and order.
- *
- * The function creates the canvas itself, depending on the columns available
- * in the output display and the number of squares per row and per column
- * requested by the caller. */
-lwCanvas *lwDrawSchotter(int console_cols, int squares_per_row, int squares_per_col) {
-    /* Calculate the canvas size. */
-    int canvas_width = console_cols*2;
-    int padding = canvas_width > 4 ? 2 : 0;
-    float square_side = (float)(canvas_width-padding*2) / squares_per_row;
-    int canvas_height = square_side * squares_per_col + padding*2;
-    lwCanvas *canvas = lwCreateCanvas(canvas_width, canvas_height, 0);
-
-    for (int y = 0; y < squares_per_col; y++) {
-        for (int x = 0; x < squares_per_row; x++) {
-            int sx = x * square_side + square_side/2 + padding;
-            int sy = y * square_side + square_side/2 + padding;
-            /* Rotate and translate randomly as we go down to lower
-             * rows. */
-            float angle = 0;
-            if (y > 1) {
-                float r1 = (float)rand() / RAND_MAX / squares_per_col * y;
-                float r2 = (float)rand() / RAND_MAX / squares_per_col * y;
-                float r3 = (float)rand() / RAND_MAX / squares_per_col * y;
-                if (rand() % 2) r1 = -r1;
-                if (rand() % 2) r2 = -r2;
-                if (rand() % 2) r3 = -r3;
-                angle = r1;
-                sx += r2*square_side/3;
-                sy += r3*square_side/3;
-            }
-            lwDrawSquare(canvas,sx,sy,square_side,angle,1);
-        }
-    }
-
-    return canvas;
-}
-
-/* Converts the canvas to an SDS string representing the UTF8 characters to
- * print to the terminal in order to obtain a graphical representaiton of the
- * logical canvas. The actual returned string will require a terminal that is
- * width/2 large and height/4 tall in order to hold the whole image without
- * overflowing or scrolling, since each Barille character is 2x4. */
-static sds renderCanvas(lwCanvas *canvas) {
-    sds text = sdsempty();
-    for (int y = 0; y < canvas->height; y += 4) {
-        for (int x = 0; x < canvas->width; x += 2) {
-            /* We need to emit groups of 8 bits according to a specific
-             * arrangement. See lwTranslatePixelsGroup() for more info. */
-            int byte = 0;
-            if (lwGetPixel(canvas,x,y)) byte |= (1<<0);
-            if (lwGetPixel(canvas,x,y+1)) byte |= (1<<1);
-            if (lwGetPixel(canvas,x,y+2)) byte |= (1<<2);
-            if (lwGetPixel(canvas,x+1,y)) byte |= (1<<3);
-            if (lwGetPixel(canvas,x+1,y+1)) byte |= (1<<4);
-            if (lwGetPixel(canvas,x+1,y+2)) byte |= (1<<5);
-            if (lwGetPixel(canvas,x,y+3)) byte |= (1<<6);
-            if (lwGetPixel(canvas,x+1,y+3)) byte |= (1<<7);
-            char unicode[3];
-            lwTranslatePixelsGroup(byte,unicode);
-            text = sdscatlen(text,unicode,3);
-        }
-        if (y != canvas->height-1) text = sdscatlen(text,"\n",1);
-    }
-    return text;
-}
-
-/* The LOLWUT command:
- *
- * LOLWUT [terminal columns] [squares-per-row] [squares-per-col]
- *
- * By default the command uses 66 columns, 8 squares per row, 12 squares
- * per column.
- */
-void lolwut5Command(client *c) {
-    long cols = 66;
-    long squares_per_row = 8;
-    long squares_per_col = 12;
-
-    /* Parse the optional arguments if any. */
-    if (c->argc > 1 &&
-        getLongFromObjectOrReply(c,c->argv[1],&cols,NULL) != C_OK)
-        return;
-
-    if (c->argc > 2 &&
-        getLongFromObjectOrReply(c,c->argv[2],&squares_per_row,NULL) != C_OK)
-        return;
-
-    if (c->argc > 3 &&
-        getLongFromObjectOrReply(c,c->argv[3],&squares_per_col,NULL) != C_OK)
-        return;
-
-    /* Limits. We want LOLWUT to be always reasonably fast and cheap to execute
-     * so we have maximum number of columns, rows, and output resulution. */
-    if (cols < 1) cols = 1;
-    if (cols > 1000) cols = 1000;
-    if (squares_per_row < 1) squares_per_row = 1;
-    if (squares_per_row > 200) squares_per_row = 200;
-    if (squares_per_col < 1) squares_per_col = 1;
-    if (squares_per_col > 200) squares_per_col = 200;
-
-    /* Generate some computer art and reply. */
-    lwCanvas *canvas = lwDrawSchotter(cols,squares_per_row,squares_per_col);
-    sds rendered = renderCanvas(canvas);
-    rendered = sdscat(rendered,
-        "\nGeorg Nees - schotter, plotter on paper, 1968. Redis ver. ");
-    rendered = sdscat(rendered,REDIS_VERSION);
-    rendered = sdscatlen(rendered,"\n",1);
-    addReplyVerbatim(c,rendered,sdslen(rendered),"txt");
-    sdsfree(rendered);
-    lwFreeCanvas(canvas);
-}
@@ -1,201 +0,0 @@
-/*
- * Copyright (c) 2019, Salvatore Sanfilippo <antirez at gmail dot com>
- * 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.
- *
- * ----------------------------------------------------------------------------
- *
- * This file implements the LOLWUT command. The command should do something
- * fun and interesting, and should be replaced by a new implementation at
- * each new version of Redis.
- *
- * Thanks to Michele Hiki Falcone for the original image that ispired
- * the image, part of his game, Plaguemon.
- *
- * Thanks to the Shhh computer art collective for the help in tuning the
- * output to have a better artistic effect.
- */
-
-#include "server.h"
-#include "lolwut.h"
-
-/* Render the canvas using the four gray levels of the standard color
- * terminal: they match very well to the grayscale display of the gameboy. */
-static sds renderCanvas(lwCanvas *canvas) {
-    sds text = sdsempty();
-    for (int y = 0; y < canvas->height; y++) {
-        for (int x = 0; x < canvas->width; x++) {
-            int color = lwGetPixel(canvas,x,y);
-            char *ce; /* Color escape sequence. */
-
-            /* Note that we set both the foreground and background color.
-             * This way we are able to get a more consistent result among
-             * different terminals implementations. */
-            switch(color) {
-            case 0: ce = "0;30;40m"; break;    /* Black */
-            case 1: ce = "0;90;100m"; break;   /* Gray 1 */
-            case 2: ce = "0;37;47m"; break;    /* Gray 2 */
-            case 3: ce = "0;97;107m"; break;   /* White */
-            default: ce = "0;30;40m"; break;   /* Just for safety. */
-            }
-            text = sdscatprintf(text,"\033[%s \033[0m",ce);
-        }
-        if (y != canvas->height-1) text = sdscatlen(text,"\n",1);
-    }
-    return text;
-}
-
-/* Draw a skyscraper on the canvas, according to the parameters in the
- * 'skyscraper' structure. Window colors are random and are always one
- * of the two grays. */
-struct skyscraper {
-    int xoff;       /* X offset. */
-    int width;      /* Pixels width. */
-    int height;     /* Pixels height. */
-    int windows;    /* Draw windows if true. */
-    int color;      /* Color of the skyscraper. */
-};
-
-void generateSkyscraper(lwCanvas *canvas, struct skyscraper *si) {
-    int starty = canvas->height-1;
-    int endy = starty - si->height + 1;
-    for (int y = starty; y >= endy; y--) {
-        for (int x = si->xoff; x < si->xoff+si->width; x++) {
-            /* The roof is four pixels less wide. */
-            if (y == endy && (x <= si->xoff+1 || x >= si->xoff+si->width-2))
-                continue;
-            int color = si->color;
-            /* Alter the color if this is a place where we want to
-             * draw a window. We check that we are in the inner part of the
-             * skyscraper, so that windows are far from the borders. */
-            if (si->windows &&
-                x > si->xoff+1 &&
-                x < si->xoff+si->width-2 &&
-                y > endy+1 &&
-                y < starty-1)
-            {
-                /* Calculate the x,y position relative to the start of
-                 * the window area. */
-                int relx = x - (si->xoff+1);
-                int rely = y - (endy+1);
-
-                /* Note that we want the windows to be two pixels wide
-                 * but just one pixel tall, because terminal "pixels"
-                 * (characters) are not square. */
-                if (relx/2 % 2 && rely % 2) {
-                    do {
-                        color = 1 + rand() % 2;
-                    } while (color == si->color);
-                    /* Except we want adjacent pixels creating the same
-                     * window to be the same color. */
-                    if (relx % 2) color = lwGetPixel(canvas,x-1,y);
-                }
-            }
-            lwDrawPixel(canvas,x,y,color);
-        }
-    }
-}
-
-/* Generate a skyline inspired by the parallax backgrounds of 8 bit games. */
-void generateSkyline(lwCanvas *canvas) {
-    struct skyscraper si;
-
-    /* First draw the background skyscraper without windows, using the
-     * two different grays. We use two passes to make sure that the lighter
-     * ones are always in the background. */
-    for (int color = 2; color >= 1; color--) {
-        si.color = color;
-        for (int offset = -10; offset < canvas->width;) {
-            offset += rand() % 8;
-            si.xoff = offset;
-            si.width = 10 + rand()%9;
-            if (color == 2)
-                si.height = canvas->height/2 + rand()%canvas->height/2;
-            else
-                si.height = canvas->height/2 + rand()%canvas->height/3;
-            si.windows = 0;
-            generateSkyscraper(canvas, &si);
-            if (color == 2)
-                offset += si.width/2;
-            else
-                offset += si.width+1;
-        }
-    }
-
-    /* Now draw the foreground skyscraper with the windows. */
-    si.color = 0;
-    for (int offset = -10; offset < canvas->width;) {
-        offset += rand() % 8;
-        si.xoff = offset;
-        si.width = 5 + rand()%14;
-        if (si.width % 4) si.width += (si.width % 3);
-        si.height = canvas->height/3 + rand()%canvas->height/2;
-        si.windows = 1;
-        generateSkyscraper(canvas, &si);
-        offset += si.width+5;
-    }
-}
-
-/* The LOLWUT 6 command:
- *
- * LOLWUT [columns] [rows]
- *
- * By default the command uses 80 columns, 40 squares per row
- * per column.
- */
-void lolwut6Command(client *c) {
-    long cols = 80;
-    long rows = 20;
-
-    /* Parse the optional arguments if any. */
-    if (c->argc > 1 &&
-        getLongFromObjectOrReply(c,c->argv[1],&cols,NULL) != C_OK)
-        return;
-
-    if (c->argc > 2 &&
-        getLongFromObjectOrReply(c,c->argv[2],&rows,NULL) != C_OK)
-        return;
-
-    /* Limits. We want LOLWUT to be always reasonably fast and cheap to execute
-     * so we have maximum number of columns, rows, and output resulution. */
-    if (cols < 1) cols = 1;
-    if (cols > 1000) cols = 1000;
-    if (rows < 1) rows = 1;
-    if (rows > 1000) rows = 1000;
-
-    /* Generate the city skyline and reply. */
-    lwCanvas *canvas = lwCreateCanvas(cols,rows,3);
-    generateSkyline(canvas);
-    sds rendered = renderCanvas(canvas);
-    rendered = sdscat(rendered,
-        "\nDedicated to the 8 bit game developers of past and present.\n"
-        "Original 8 bit image from Plaguemon by hikikomori. Redis ver. ");
-    rendered = sdscat(rendered,REDIS_VERSION);
-    rendered = sdscatlen(rendered,"\n",1);
-    addReplyVerbatim(c,rendered,sdslen(rendered),"txt");
-    sdsfree(rendered);
-    lwFreeCanvas(canvas);
-}
@@ -3,7 +3,7 @@ GIT_SHA1=`(git show-ref --head --hash=8 2> /dev/null || echo 00000000) | head -n
 GIT_DIRTY=`git diff --no-ext-diff 2> /dev/null | wc -l`
 BUILD_ID=`uname -n`"-"`date +%s`
 if [ -n "$SOURCE_DATE_EPOCH" ]; then
-  BUILD_ID=$(date -u -d "@$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u -r "$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u +%s)
+  BUILD_ID=$(date -u -d "@$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u -r "$SOURCE_DATE_EPOCH" +%s 2>/dev/null || date -u %s)
 fi
 test -f release.h || touch release.h
 (cat release.h | grep SHA1 | grep $GIT_SHA1) && \
Author	SHA1	Message	Date
John Sully	c50a3d0bbd	Remove performance zapping test code	2019-10-21 01:48:58 -04:00
John Sully	5eb84db03a	reenable optimized string dup code	2019-10-21 00:08:38 -04:00
John Sully	bd9d8e05b0	Forkless background save. NOT OPTIMIZED	2019-10-20 23:54:05 -04:00
John Sully	2ab4c6b99e	Factor out dependencies on rdb_child_pid which will be going away	2019-10-17 23:10:45 -04:00
John Sully	c12be59475	Dependencies for forkless RDB saving	2019-10-17 22:53:50 -04:00
John Sully	fcdda67d87	Ensure RDB saving only uses data from the persistent data struct, and cleanup inheritance	2019-10-17 17:20:47 -04:00
John Sully	dfdd41f15c	Support serializing all types	2019-10-16 14:23:28 -04:00
John Sully	e8debc83e8	Cleanup inheritance	2019-10-16 13:45:36 -04:00
John Sully	88152a8f4f	Merge branch 'unstable' into advanced_db	2019-10-16 13:23:19 -04:00
John Sully	c4f086ae93	Fix clang warnings	2019-10-13 15:48:55 -04:00
John Sully	3f0c1f94eb	Fix failing travis CI build	2019-10-13 15:41:53 -04:00
John Sully	f6855bc34d	Merge branch 'advanced_db' of https://github.com/JohnSully/redis2 into advanced_db	2019-10-13 15:35:30 -04:00
John Sully	898efbfc0c	Add the IStorage interface and wire it up	2019-10-13 15:24:08 -04:00
John Sully	8d63f5b560	Isolate the persistent parts of the database from the runtime parts	2019-10-13 15:24:08 -04:00
John Sully	024365521c	Hide the database dict	2019-10-13 15:13:01 -04:00
John Sully	cbd4b4df19	Add the IStorage interface and wire it up	2019-09-20 14:52:22 -04:00
John Sully	08995b065c	Isolate the persistent parts of the database from the runtime parts	2019-09-19 22:36:29 -04:00
John Sully	065846a9c3	Hide the database dict	2019-09-19 17:44:42 -04:00