DOC-4996 hiredis docs

content/develop/clients/_index.md

@@ -19,7 +19,7 @@ weight: 30
 
 Use the Redis client libraries to connect to Redis servers from
 your own code. We document the following client libraries
-for six main languages:
+for seven main languages:
 
 | Language | Client name | Docs | Supported |
 | :-- | :-- | :-- | :-- |
@@ -31,6 +31,7 @@ for six main languages:
 | [Java](https://www.java.com/en/) | [`Lettuce`](https://github.com/redis/lettuce) | [`Lettuce` guide]({{< relref "/develop/clients/lettuce" >}}) | Yes |
 | [Go](https://go.dev/) | [`go-redis`](https://github.com/redis/go-redis) | [`go-redis` guide]({{< relref "/develop/clients/go" >}}) | Yes |
 | [PHP](https://www.php.net/)| [`Predis`](https://github.com/predis/predis) | [`Predis` guide]({{< relref "/develop/clients/php" >}}) | No |
+| [C](https://en.wikipedia.org/wiki/C_(programming_language)) | [`hiredis`](https://github.com/redis/hiredis) | [`hiredis` guide]({{< relref "/develop/clients/hiredis" >}}) | Yes |
 
 We also provide several higher-level
 [object mapping (OM)]({{< relref "/develop/clients/om-clients" >}})
@@ -46,7 +47,6 @@ Redis does not document directly:
 
 | Language | Client name | Github | Docs |
 | :-- | :-- | :-- | :-- |
-| C | hiredis | https://github.com/redis/hiredis | https://github.com/redis/hiredis |
 | [C++](https://en.wikipedia.org/wiki/C%2B%2B) | Boost.Redis | https://github.com/boostorg/redis | https://www.boost.org/doc/libs/develop/libs/redis/doc/html/index.html |
 | [Dart](https://dart.dev/) | redis_dart_link | https://github.com/toolsetlink/redis_dart_link | https://github.com/toolsetlink/redis_dart_link |
 | [PHP](https://www.php.net/) | PhpRedis extension | https://github.com/phpredis/phpredis | https://github.com/phpredis/phpredis/blob/develop/README.md |

content/develop/clients/client-side-caching.md

@@ -13,7 +13,7 @@ categories:
 description: Server-assisted, client-side caching in Redis
 linkTitle: Client-side caching
 title: Client-side caching introduction
-weight: 20
+weight: 30
 ---
 
 *Client-side caching* reduces network traffic between

content/develop/clients/hiredis/_index.md

@@ -0,0 +1,133 @@
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your C application to a Redis database.
+linkTitle: hiredis (C)
+title: hiredis guide (C)
+weight: 9
+---
+
+[`hiredis`](https://github.com/redis/hiredis) is the
+[C language](https://en.wikipedia.org/wiki/C_(programming_language))
+client for Redis.
+The sections below explain how to install `hiredis` and connect your application
+to a Redis database.
+
+`hiredis` requires a running Redis or [Redis Stack]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) server. See [Getting started]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis installation instructions.
+
+## Build and install
+
+Clone or download the `hiredis` source from the [Github repository](https://github.com/redis/hiredis).
+Then, in a terminal, go into the `hiredis` folder and run the `make` command to build
+the dynamically-loaded library for `hiredis` (this has the name `libhiredis.dylib` on
+MacOS and `libhiredis.so` on Linux). You can copy this library to your
+project folder or run `sudo make install` to install it to `/usr/local/lib`.
+You should also copy the header files `hiredis.h`, `alloc.h`, `read.h`, and
+`sds.h` to your project.
+
+## Connect and test
+
+The code in the example below connects to the server, stores and retrieves
+a string key using [`SET`]({{< relref "/commands/set" >}}) and
+[`GET`]({{< relref "/commands/get" >}}), and then finally closes the
+connection. An explanation of the code follows the example.
+
+```c
+#include <stdio.h>
+
+#include "hiredis.h"
+
+int main() {
+    // The `redisContext` type represents the connection
+    // to the Redis server. Here, we connect to the
+    // default host and port.
+    redisContext *c = redisConnect("127.0.0.1", 6379);
+
+    // Check if the context is null or if a specific
+    // error occurred.
+    if (c == NULL || c->err) {
+        if (c != NULL) {
+            printf("Error: %s\n", c->errstr);
+            // handle error
+        } else {
+            printf("Can't allocate redis context\n");
+        }
+
+        exit(1);
+    }
+
+    // Set a string key.
+    redisReply *reply = redisCommand(c, "SET foo bar");
+    printf("Reply: %s\n", reply->str); // >>> Reply: OK
+    freeReplyObject(reply);
+
+    // Get the key we have just stored.
+    reply = redisCommand(c, "GET foo");
+    printf("Reply: %s\n", reply->str); // >>> Reply: bar
+    freeReplyObject(reply);
+
+    // Close the connection.
+    redisFree(c);
+}
+```
+
+For a real project, you would build your code with a makefile, but for
+this simple test, you can just place it in a file called `main.c` and
+build it with the following command (assuming you used `make install` to
+install the `libhiredis` library):
+
+```bash
+cc main.c -L/usr/local/lib -lhiredis
+```
+
+The default executable filename is `a.out`. If you run this file from
+the terminal, you should see the following output:
+
+```
+% ./a.out                             
+Reply: OK
+Reply: bar
+```
+
+The code first uses `redisConnect()` to open the connection for
+all subsequent commands to use. See
+[Connect]({{< relref "/develop/clients/hiredis/connect" >}}) for
+more information about connecting to Redis.
+
+The `redisCommand()` function
+issues commands to the server, each of which returns a
+`redisReply` pointer. Here, the reply is a string, which you can
+access using the `str` field of the reply. The `redisCommand()`
+call allocates memory for the reply, so you should free this
+with `freeReplyObject()` when you have finished using it.
+See [Issue commands]({{< relref "/develop/clients/hiredis/issue-commands" >}})
+and [Handle replies]({{< relref "/develop/clients/hiredis/handle-replies" >}})
+for more information.
+
+Finally, you should close the connection to Redis with a
+call to `redisFree()`. This is not strictly necessary
+for this short test program, but real-world code will typically
+open and use many connections. You must free them after using them
+to prevent errors.
+
+## More information
+
+The [`hiredis`](https://github.com/redis/hiredis) Github repository contains
+examples and details that may be useful if you are using `hiredis` to
+implement a higher-level client for another programming language. There are
+also examples showing how to use `hiredis` from a
+[C++ application](https://github.com/redis/hiredis/blob/master/examples/example-qt.cpp)
+created with [Qt](https://www.qt.io/) and how to use the
+[asynchronous API](https://github.com/redis/hiredis?tab=readme-ov-file#asynchronous-api)
+with the [libev](https://software.schmorp.de/pkg/libev.html) and
+[libevent](https://libevent.org/) libraries.
+
+See the other pages in this section for more information and examples.

content/develop/clients/hiredis/connect.md

@@ -0,0 +1,65 @@
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect to the server with `hiredis`.
+linkTitle: Connect
+title: Connect
+weight: 1
+---
+
+## Basic synchronous connection
+
+The example below creates a simple synchronous connection to a local
+Redis server and tests the connection, before closing it with
+`redisFree()`. The `redisConnect()` function takes just a hostname
+and port as its arguments, and returns a context object.
+
+```c
+#include <stdio.h>
+
+#include "hiredis.h"
+    .
+    .
+    .
+
+// The `redisContext` type represents the connection
+// to the Redis server. Here, we connect to the
+// default host and port.
+redisContext *c = redisConnect("127.0.0.1", 6379);
+
+// Check if the context is null or if a specific
+// error occurred.
+if (c == NULL || c->err) {
+    if (c != NULL) {
+        printf("Error: %s\n", c->errstr);
+        // handle error
+    } else {
+        printf("Can't allocate redis context\n");
+    }
+
+    exit(1);
+}
+
+// Set a string key.
+redisReply *reply = redisCommand(c, "SET foo bar");
+printf("Reply: %s\n", reply->str); // >>> Reply: OK
+freeReplyObject(reply);
+
+// Get the key we have just stored.
+reply = redisCommand(c, "GET foo");
+printf("Reply: %s\n", reply->str); // >>> Reply: bar
+freeReplyObject(reply);
+
+// Close the connection.
+redisFree(c);
+```
+
+