C Programming
made by https://0x3d.site
GitHub - redis/hiredis: Minimalistic C client for Redis >= 1.2Minimalistic C client for Redis >= 1.2. Contribute to redis/hiredis development by creating an account on GitHub.
Visit Site
GitHub - redis/hiredis: Minimalistic C client for Redis >= 1.2
This Readme reflects the latest changed in the master branch. See v1.0.0 for the Readme and documentation for the latest release (API/ABI history).
HIREDIS
Hiredis is a minimalistic C client library for the Redis database.
It is minimalistic because it just adds minimal support for the protocol, but at the same time it uses a high level printf-alike API in order to make it much higher level than otherwise suggested by its minimal code base and the lack of explicit bindings for every Redis command.
Apart from supporting sending commands and receiving replies, it comes with a reply parser that is decoupled from the I/O layer. It is a stream parser designed for easy reusability, which can for instance be used in higher level language bindings for efficient reply parsing.
Hiredis only supports the binary-safe Redis protocol, so you can use it with any Redis version >= 1.2.0.
The library comes with multiple APIs. There is the synchronous API, the asynchronous API and the reply parsing API.
Upgrading to > 1.2.0 (PRERELEASE)
-
After v1.2.0 we modified how we invoke
poll(2)
to wait for connections to complete, such that we will now retry the call if it is interrupted by a signal until:a) The connection succeeds or fails. b) The overall connection timeout is reached.
In previous versions, an interrupted
poll(2)
call would cause the connection to fail withc->err
set toREDIS_ERR_IO
andc->errstr
set topoll(2): Interrupted system call
.
Upgrading to 1.1.0
Almost all users will simply need to recompile their applications against the newer version of hiredis.
NOTE: Hiredis can now return nan
in addition to -inf
and inf
in a REDIS_REPLY_DOUBLE
.
Applications that deal with RESP3
doubles should make sure to account for this.
Upgrading to 1.0.2
NOTE: v1.0.1 erroneously bumped SONAME, which is why it is skipped here.
Version 1.0.2 is simply 1.0.0 with a fix for CVE-2021-32765. They are otherwise identical.
Upgrading to 1.0.0
Version 1.0.0 marks the first stable release of Hiredis.
It includes some minor breaking changes, mostly to make the exposed API more uniform and self-explanatory.
It also bundles the updated sds
library, to sync up with upstream and Redis.
For code changes see the Changelog.
Note: As described below, a few member names have been changed but most applications should be able to upgrade with minor code changes and recompiling.
IMPORTANT: Breaking changes from 0.14.1
-> 1.0.0
redisContext
has two additional members (free_privdata
, andprivctx
).redisOptions.timeout
has been renamed toredisOptions.connect_timeout
, and we've addedredisOptions.command_timeout
.redisReplyObjectFunctions.createArray
now takessize_t
instead ofint
for its length parameter.
IMPORTANT: Breaking changes when upgrading from 0.13.x -> 0.14.x
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
.
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.
Upgrading from <0.9.0
Version 0.9.0 is a major overhaul of hiredis in every aspect. However, upgrading existing
code using hiredis should not be a big pain. The key thing to keep in mind when
upgrading is that hiredis >= 0.9.0 uses a redisContext*
to keep state, in contrast to
the stateless 0.0.1 that only has a file descriptor to work with.
Synchronous API
To consume the synchronous API, there are only a few function calls that need to be introduced:
redisContext *redisConnect(const char *ip, int port);
void *redisCommand(redisContext *c, const char *format, ...);
void freeReplyObject(void *reply);
Connecting
The function redisConnect
is used to create a so-called redisContext
. The
context is where Hiredis holds state for a connection. The redisContext
struct has an integer err
field that is non-zero when the connection is in
an error state. The field errstr
will contain a string with a description of
the error. More information on errors can be found in the Errors section.
After trying to connect to Redis using redisConnect
you should
check the err
field to see if establishing the connection was successful:
redisContext *c = redisConnect("127.0.0.1", 6379);
if (c == NULL || c->err) {
if (c) {
printf("Error: %s\n", c->errstr);
// handle error
} else {
printf("Can't allocate redis context\n");
}
}
One can also use redisConnectWithOptions
which takes a redisOptions
argument
that can be configured with endpoint information as well as many different flags
to change how the redisContext
will be configured.
redisOptions opt = {0};
/* One can set the endpoint with one of our helper macros */
if (tcp) {
REDIS_OPTIONS_SET_TCP(&opt, "localhost", 6379);
} else {
REDIS_OPTIONS_SET_UNIX(&opt, "/tmp/redis.sock");
}
/* And privdata can be specified with another helper */
REDIS_OPTIONS_SET_PRIVDATA(&opt, myPrivData, myPrivDataDtor);
/* Finally various options may be set via the `options` member, as described below */
opt->options |= REDIS_OPT_PREFER_IPV4;
If a connection is lost, int redisReconnect(redisContext *c)
can be used to restore the connection using the same endpoint and options as the given context.
Configurable redisOptions flags
There are several flags you may set in the redisOptions
struct to change default behavior. You can specify the flags via the redisOptions->options
member.
Flag | Description |
---|---|
REDIS_OPT_NONBLOCK | Tells hiredis to make a non-blocking connection. |
REDIS_OPT_REUSEADDR | Tells hiredis to set the SO_REUSEADDR socket option |
REDIS_OPT_PREFER_IPV4REDIS_OPT_PREFER_IPV6REDIS_OPT_PREFER_IP_UNSPEC | Informs hiredis to either prefer IPv4 or IPv6 when invoking getaddrinfo. REDIS_OPT_PREFER_IP_UNSPEC will cause hiredis to specify AF_UNSPEC in the getaddrinfo call, which means both IPv4 and IPv6 addresses will be searched simultaneously.Hiredis prefers IPv4 by default. |
REDIS_OPT_NO_PUSH_AUTOFREE | Tells hiredis to not install the default RESP3 PUSH handler (which just intercepts and frees the replies). This is useful in situations where you want to process these messages in-band. |
REDIS_OPT_NOAUTOFREEREPLIES | ASYNC: tells hiredis not to automatically invoke freeReplyObject after executing the reply callback. |
REDIS_OPT_NOAUTOFREE | ASYNC: Tells hiredis not to automatically free the redisAsyncContext on connection/communication failure, but only if the user makes an explicit call to redisAsyncDisconnect or redisAsyncFree |
Note: A redisContext
is not thread-safe.
Other configuration using socket options
The following socket options are applied directly to the underlying socket.
The values are not stored in the redisContext
, so they are not automatically applied when reconnecting using redisReconnect()
.
These functions return REDIS_OK
on success.
On failure, REDIS_ERR
is returned and the underlying connection is closed.
To configure these for an asynchronous context (see Asynchronous API below), use ac->c
to get the redisContext out of an asyncRedisContext.
int redisEnableKeepAlive(redisContext *c);
int redisEnableKeepAliveWithInterval(redisContext *c, int interval);
Enables TCP keepalive by setting the following socket options (with some variations depending on OS):
SO_KEEPALIVE
;TCP_KEEPALIVE
orTCP_KEEPIDLE
, value configurable using theinterval
parameter, default 15 seconds;TCP_KEEPINTVL
set to 1/3 ofinterval
;TCP_KEEPCNT
set to 3.
int redisSetTcpUserTimeout(redisContext *c, unsigned int timeout);
Set the TCP_USER_TIMEOUT
Linux-specific socket option which is as described in the tcp
man page:
When the value is greater than 0, it specifies the maximum amount of time in milliseconds that trans mitted data may remain unacknowledged before TCP will forcibly close the corresponding connection and return ETIMEDOUT to the application. If the option value is specified as 0, TCP will use the system default.
Sending commands
There are several ways to issue commands to Redis. The first that will be introduced is
redisCommand
. This function takes a format similar to printf. In the simplest form,
it is used like this:
reply = redisCommand(context, "SET foo bar");
The specifier %s
interpolates a string in the command, and uses strlen
to
determine the length of the string:
reply = redisCommand(context, "SET foo %s", value);
When you need to pass binary safe strings in a command, the %b
specifier can be
used. Together with a pointer to the string, it requires a size_t
length argument
of the string:
reply = redisCommand(context, "SET foo %b", value, (size_t) valuelen);
Internally, Hiredis splits the command in different arguments and will convert it to the protocol used to communicate with Redis. One or more spaces separates arguments, so you can use the specifiers anywhere in an argument:
reply = redisCommand(context, "SET key:%s %s", myid, value);
Using replies
The return value of redisCommand
holds a reply when the command was
successfully executed. When an error occurs, the return value is NULL
and
the err
field in the context will be set (see section on Errors).
Once an error is returned the context cannot be reused and you should set up
a new connection.
The standard replies that redisCommand
are of the type redisReply
. The
type
field in the redisReply
should be used to test what kind of reply
was received:
RESP2
-
REDIS_REPLY_STATUS
:- The command replied with a status reply. The status string can be accessed using
reply->str
. The length of this string can be accessed usingreply->len
.
- The command replied with a status reply. The status string can be accessed using
-
REDIS_REPLY_ERROR
:- The command replied with an error. The error string can be accessed identical to
REDIS_REPLY_STATUS
.
- The command replied with an error. The error string can be accessed identical to
-
REDIS_REPLY_INTEGER
:- The command replied with an integer. The integer value can be accessed using the
reply->integer
field of typelong long
.
- The command replied with an integer. The integer value can be accessed using the
-
REDIS_REPLY_NIL
:- The command replied with a nil object. There is no data to access.
-
REDIS_REPLY_STRING
:- A bulk (string) reply. The value of the reply can be accessed using
reply->str
. The length of this string can be accessed usingreply->len
.
- A bulk (string) reply. The value of the reply can be accessed using
-
REDIS_REPLY_ARRAY
:- A multi bulk reply. The number of elements in the multi bulk reply is stored in
reply->elements
. Every element in the multi bulk reply is aredisReply
object as well and can be accessed viareply->element[..index..]
. Redis may reply with nested arrays but this is fully supported.
- A multi bulk reply. The number of elements in the multi bulk reply is stored in
RESP3
Hiredis also supports every new RESP3
data type which are as follows. For more information about the protocol see the RESP3
specification.
-
REDIS_REPLY_DOUBLE
:- The command replied with a double-precision floating point number.
The value is stored as a string in the
str
member, and can be converted withstrtod
or similar.
- The command replied with a double-precision floating point number.
The value is stored as a string in the
-
REDIS_REPLY_BOOL
:- A boolean true/false reply.
The value is stored in the
integer
member and will be either0
or1
.
- A boolean true/false reply.
The value is stored in the
-
REDIS_REPLY_MAP
:- An array with the added invariant that there will always be an even number of elements.
The MAP is functionally equivalent to
REDIS_REPLY_ARRAY
except for the previously mentioned invariant.
- An array with the added invariant that there will always be an even number of elements.
The MAP is functionally equivalent to
-
REDIS_REPLY_SET
:- An array response where each entry is unique. Like the MAP type, the data is identical to an array response except there are no duplicate values.
-
REDIS_REPLY_PUSH
:- An array that can be generated spontaneously by Redis.
This array response will always contain at least two subelements. The first contains the type of
PUSH
message (e.g.message
, orinvalidate
), and the second being a sub-array with thePUSH
payload itself.
- An array that can be generated spontaneously by Redis.
This array response will always contain at least two subelements. The first contains the type of
-
REDIS_REPLY_ATTR
:- An array structurally identical to a
MAP
but intended as meta-data about a reply. As of Redis 6.0.6 this reply type is not used in Redis
- An array structurally identical to a
-
REDIS_REPLY_BIGNUM
:- A string representing an arbitrarily large signed or unsigned integer value.
The number will be encoded as a string in the
str
member ofredisReply
.
- A string representing an arbitrarily large signed or unsigned integer value.
The number will be encoded as a string in the
-
REDIS_REPLY_VERB
:- A verbatim string, intended to be presented to the user without modification.
The string payload is stored in the
str
member, and type data is stored in thevtype
member (e.g.txt
for raw text ormd
for markdown).
- A verbatim string, intended to be presented to the user without modification.
The string payload is stored in the
Replies should be freed using the freeReplyObject()
function.
Note that this function will take care of freeing sub-reply objects
contained in arrays and nested arrays, so there is no need for the user to
free the sub replies (it is actually harmful and will corrupt the memory).
Important: the current version of hiredis (1.0.0) frees replies when the
asynchronous API is used. This means you should not call freeReplyObject
when
you use this API. The reply is cleaned up by hiredis after the callback
returns. We may introduce a flag to make this configurable in future versions of the library.
Cleaning up
To disconnect and free the context the following function can be used:
void redisFree(redisContext *c);
This function immediately closes the socket and then frees the allocations done in creating the context.
Sending commands (continued)
Together with redisCommand
, the function redisCommandArgv
can be used to issue commands.
It has the following prototype:
void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
It takes the number of arguments argc
, an array of strings argv
and the lengths of the
arguments argvlen
. For convenience, argvlen
may be set to NULL
and the function will
use strlen(3)
on every argument to determine its length. Obviously, when any of the arguments
need to be binary safe, the entire array of lengths argvlen
should be provided.
The return value has the same semantic as redisCommand
.
Pipelining
To explain how Hiredis supports pipelining in a blocking connection, there needs to be understanding of the internal execution flow.
When any of the functions in the redisCommand
family is called, Hiredis first formats the
command according to the Redis protocol. The formatted command is then put in the output buffer
of the context. This output buffer is dynamic, so it can hold any number of commands.
After the command is put in the output buffer, redisGetReply
is called. This function has the
following two execution paths:
- The input buffer is non-empty:
- Try to parse a single reply from the input buffer and return it
- If no reply could be parsed, continue at 2
- The input buffer is empty:
- Write the entire output buffer to the socket
- Read from the socket until a single reply could be parsed
The function redisGetReply
is exported as part of the Hiredis API and can be used when a reply
is expected on the socket. To pipeline commands, the only thing that needs to be done is
filling up the output buffer. For this cause, two commands can be used that are identical
to the redisCommand
family, apart from not returning a reply:
void redisAppendCommand(redisContext *c, const char *format, ...);
void redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
After calling either function one or more times, redisGetReply
can be used to receive the
subsequent replies. The return value for this function is either REDIS_OK
or REDIS_ERR
, where
the latter means an error occurred while reading a reply. Just as with the other commands,
the err
field in the context can be used to find out what the cause of this error is.
The following examples shows a simple pipeline (resulting in only a single call to write(2)
and
a single call to read(2)
):
redisReply *reply;
redisAppendCommand(context,"SET foo bar");
redisAppendCommand(context,"GET foo");
redisGetReply(context,(void**)&reply); // reply for SET
freeReplyObject(reply);
redisGetReply(context,(void**)&reply); // reply for GET
freeReplyObject(reply);
This API can also be used to implement a blocking subscriber:
reply = redisCommand(context,"SUBSCRIBE foo");
freeReplyObject(reply);
while(redisGetReply(context,(void *)&reply) == REDIS_OK) {
// consume message
freeReplyObject(reply);
}
Errors
When a function call is not successful, depending on the function either NULL
or REDIS_ERR
is
returned. The err
field inside the context will be non-zero and set to one of the
following constants:
-
REDIS_ERR_IO
: There was an I/O error while creating the connection, trying to write to the socket or read from the socket. If you includederrno.h
in your application, you can use the globalerrno
variable to find out what is wrong. -
REDIS_ERR_EOF
: The server closed the connection which resulted in an empty read. -
REDIS_ERR_PROTOCOL
: There was an error while parsing the protocol. -
REDIS_ERR_OTHER
: Any other error. Currently, it is only used when a specified hostname to connect to cannot be resolved.
In every case, the errstr
field in the context will be set to hold a string representation
of the error.
Asynchronous API
Hiredis comes with an asynchronous API that works easily with any event library. Examples are bundled that show using Hiredis with libev and libevent.
Connecting
The function redisAsyncConnect
can be used to establish a non-blocking connection to
Redis. It returns a pointer to the newly created redisAsyncContext
struct. The err
field
should be checked after creation to see if there were errors creating the connection.
Because the connection that will be created is non-blocking, the kernel is not able to
instantly return if the specified host and port is able to accept a connection.
In case of error, it is the caller's responsibility to free the context using redisAsyncFree()
Note: A redisAsyncContext
is not thread-safe.
An application function creating a connection might look like this:
void appConnect(myAppData *appData)
{
redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
if (c->err) {
printf("Error: %s\n", c->errstr);
// handle error
redisAsyncFree(c);
c = NULL;
} else {
appData->context = c;
appData->connecting = 1;
c->data = appData; /* store application pointer for the callbacks */
redisAsyncSetConnectCallback(c, appOnConnect);
redisAsyncSetDisconnectCallback(c, appOnDisconnect);
}
}
The asynchronous context should hold a connect callback function that is called when the connection attempt completes, either successfully or with an error. It can also hold a disconnect callback function that is called when the connection is disconnected (either because of an error or per user request). Both callbacks should have the following prototype:
void(const redisAsyncContext *c, int status);
On a connect, the status
argument is set to REDIS_OK
if the connection attempt succeeded. In this
case, the context is ready to accept commands. If it is called with REDIS_ERR
then the
connection attempt failed. The err
field in the context can be accessed to find out the cause of the error.
After a failed connection attempt, the context object is automatically freed by the library after calling
the connect callback. This may be a good point to create a new context and retry the connection.
On a disconnect, the status
argument is set to REDIS_OK
when disconnection was initiated by the
user, or REDIS_ERR
when the disconnection was caused by an error. When it is REDIS_ERR
, the err
field in the context can be accessed to find out the cause of the error.
The context object is always freed after the disconnect callback fired. When a reconnect is needed, the disconnect callback is a good point to do so.
Setting the connect or disconnect callbacks can only be done once per context. For subsequent calls the
api will return REDIS_ERR
. The function to set the callbacks have the following prototype:
/* Alternatively you can use redisAsyncSetConnectCallbackNC which will be passed a non-const
redisAsyncContext* on invocation (e.g. allowing writes to the privdata member). */
int redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCallback *fn);
int redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconnectCallback *fn);
ac->data
may be used to pass user data to both callbacks. A typical implementation
might look something like this:
void appOnConnect(redisAsyncContext *c, int status)
{
myAppData *appData = (myAppData*)c->data; /* get my application specific context*/
appData->connecting = 0;
if (status == REDIS_OK) {
appData->connected = 1;
} else {
appData->connected = 0;
appData->err = c->err;
appData->context = NULL; /* avoid stale pointer when callback returns */
}
appAttemptReconnect();
}
void appOnDisconnect(redisAsyncContext *c, int status)
{
myAppData *appData = (myAppData*)c->data; /* get my application specific context*/
appData->connected = 0;
appData->err = c->err;
appData->context = NULL; /* avoid stale pointer when callback returns */
if (status == REDIS_OK) {
appNotifyDisconnectCompleted(mydata);
} else {
appNotifyUnexpectedDisconnect(mydata);
appAttemptReconnect();
}
}
Sending commands and their callbacks
In an asynchronous context, commands are automatically pipelined due to the nature of an event loop. Therefore, unlike the synchronous API, there is only a single way to send commands. Because commands are sent to Redis asynchronously, issuing a command requires a callback function that is called when the reply is received. Reply callbacks should have the following prototype:
void(redisAsyncContext *c, void *reply, void *privdata);
The privdata
argument can be used to curry arbitrary data to the callback from the point where
the command is initially queued for execution.
The functions that can be used to issue commands in an asynchronous context are:
int redisAsyncCommand(
redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,
const char *format, ...);
int redisAsyncCommandArgv(
redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,
int argc, const char **argv, const size_t *argvlen);
Both functions work like their blocking counterparts. The return value is REDIS_OK
when the command
was successfully added to the output buffer and REDIS_ERR
otherwise. Example: when the connection
is being disconnected per user-request, no new commands may be added to the output buffer and REDIS_ERR
is
returned on calls to the redisAsyncCommand
family.
If the reply for a command with a NULL
callback is read, it is immediately freed. When the callback
for a command is non-NULL
, the memory is freed immediately following the callback: the reply is only
valid for the duration of the callback.
All pending callbacks are called with a NULL
reply when the context encountered an error.
For every command issued, with the exception of SUBSCRIBE and PSUBSCRIBE, the callback is
called exactly once. Even if the context object id disconnected or deleted, every pending callback
will be called with a NULL
reply.
For SUBSCRIBE and PSUBSCRIBE, the callbacks may be called repeatedly until an unsubscribe
message arrives. This will be the last invocation of the callback. In case of error, the callbacks
may receive a final NULL
reply instead.
Disconnecting
An asynchronous connection can be terminated using:
void redisAsyncDisconnect(redisAsyncContext *ac);
When this function is called, the connection is not immediately terminated. Instead, new
commands are no longer accepted and the connection is only terminated when all pending commands
have been written to the socket, their respective replies have been read and their respective
callbacks have been executed. After this, the disconnection callback is executed with the
REDIS_OK
status and the context object is freed.
The connection can be forcefully disconnected using
void redisAsyncFree(redisAsyncContext *ac);
In this case, nothing more is written to the socket, all pending callbacks are called with a NULL
reply and the disconnection callback is called with REDIS_OK
, after which the context object
is freed.
Hooking it up to event library X
There are a few hooks that need to be set on the context object after it is created.
See the adapters/
directory for bindings to libev and libevent.
Reply parsing API
Hiredis comes with a reply parsing API that makes it easy for writing higher level language bindings.
The reply parsing API consists of the following functions:
redisReader *redisReaderCreate(void);
void redisReaderFree(redisReader *reader);
int redisReaderFeed(redisReader *reader, const char *buf, size_t len);
int redisReaderGetReply(redisReader *reader, void **reply);
The same set of functions are used internally by hiredis when creating a normal Redis context, the above API just exposes it to the user for a direct usage.
Usage
The function redisReaderCreate
creates a redisReader
structure that holds a
buffer with unparsed data and state for the protocol parser.
Incoming data -- most likely from a socket -- can be placed in the internal
buffer of the redisReader
using redisReaderFeed
. This function will make a
copy of the buffer pointed to by buf
for len
bytes. This data is parsed
when redisReaderGetReply
is called. This function returns an integer status
and a reply object (as described above) via void **reply
. The returned status
can be either REDIS_OK
or REDIS_ERR
, where the latter means something went
wrong (either a protocol error, or an out of memory error).
The parser limits the level of nesting for multi bulk payloads to 7. If the multi bulk nesting level is higher than this, the parser returns an error.
Customizing replies
The function redisReaderGetReply
creates redisReply
and makes the function
argument reply
point to the created redisReply
variable. For instance, if
the response of type REDIS_REPLY_STATUS
then the str
field of redisReply
will hold the status as a vanilla C string. However, the functions that are
responsible for creating instances of the redisReply
can be customized by
setting the fn
field on the redisReader
struct. This should be done
immediately after creating the redisReader
.
For example, hiredis-rb uses customized reply object functions to create Ruby objects.
Reader max buffer
Both when using the Reader API directly or when using it indirectly via a normal Redis context, the redisReader structure uses a buffer in order to accumulate data from the server. Usually this buffer is destroyed when it is empty and is larger than 16 KiB in order to avoid wasting memory in unused buffers
However when working with very big payloads destroying the buffer may slow
down performances considerably, so it is possible to modify the max size of
an idle buffer changing the value of the maxbuf
field of the reader structure
to the desired value. The special value of 0 means that there is no maximum
value for an idle buffer, so the buffer will never get freed.
For instance if you have a normal Redis context you can set the maximum idle buffer to zero (unlimited) just with:
context->reader->maxbuf = 0;
This should be done only in order to maximize performances when working with
large payloads. The context should be set back to REDIS_READER_MAX_BUF
again
as soon as possible in order to prevent allocation of useless memory.
Reader max array elements
By default the hiredis reply parser sets the maximum number of multi-bulk elements to 2^32 - 1 or 4,294,967,295 entries. If you need to process multi-bulk replies with more than this many elements you can set the value higher or to zero, meaning unlimited with:
context->reader->maxelements = 0;
SSL/TLS Support
Building
SSL/TLS support is not built by default and requires an explicit flag:
make USE_SSL=1
This requires OpenSSL development package (e.g. including header files to be available.
When enabled, SSL/TLS support is built into extra libhiredis_ssl.a
and
libhiredis_ssl.so
static/dynamic libraries. This leaves the original libraries
unaffected so no additional dependencies are introduced.
Using it
First, you'll need to make sure you include the SSL header file:
#include <hiredis/hiredis.h>
#include <hiredis/hiredis_ssl.h>
You will also need to link against libhiredis_ssl
, in addition to
libhiredis
and add -lssl -lcrypto
to satisfy its dependencies.
Hiredis implements SSL/TLS on top of its normal redisContext
or
redisAsyncContext
, so you will need to establish a connection first and then
initiate an SSL/TLS handshake.
Hiredis OpenSSL Wrappers
Before Hiredis can negotiate an SSL/TLS connection, it is necessary to initialize OpenSSL and create a context. You can do that in two ways:
- Work directly with the OpenSSL API to initialize the library's global context
and create
SSL_CTX *
andSSL *
contexts. With anSSL *
object you can callredisInitiateSSL()
. - Work with a set of Hiredis-provided wrappers around OpenSSL, create a
redisSSLContext
object to hold configuration and useredisInitiateSSLWithContext()
to initiate the SSL/TLS handshake.
/* An Hiredis SSL context. It holds SSL configuration and can be reused across
* many contexts.
*/
redisSSLContext *ssl_context;
/* An error variable to indicate what went wrong, if the context fails to
* initialize.
*/
redisSSLContextError ssl_error = REDIS_SSL_CTX_NONE;
/* Initialize global OpenSSL state.
*
* You should call this only once when your app initializes, and only if
* you don't explicitly or implicitly initialize OpenSSL it elsewhere.
*/
redisInitOpenSSL();
/* Create SSL context */
ssl_context = redisCreateSSLContext(
"cacertbundle.crt", /* File name of trusted CA/ca bundle file, optional */
"/path/to/certs", /* Path of trusted certificates, optional */
"client_cert.pem", /* File name of client certificate file, optional */
"client_key.pem", /* File name of client private key, optional */
"redis.mydomain.com", /* Server name to request (SNI), optional */
&ssl_error);
if(ssl_context == NULL || ssl_error != REDIS_SSL_CTX_NONE) {
/* Handle error and abort... */
/* e.g.
printf("SSL error: %s\n",
(ssl_error != REDIS_SSL_CTX_NONE) ?
redisSSLContextGetError(ssl_error) : "Unknown error");
// Abort
*/
}
/* Create Redis context and establish connection */
c = redisConnect("localhost", 6443);
if (c == NULL || c->err) {
/* Handle error and abort... */
}
/* Negotiate SSL/TLS */
if (redisInitiateSSLWithContext(c, ssl_context) != REDIS_OK) {
/* Handle error, in c->err / c->errstr */
}
RESP3 PUSH replies
Redis 6.0 introduced PUSH replies with the reply-type >
. These messages are generated spontaneously and can arrive at any time, so must be handled using callbacks.
Default behavior
Hiredis installs handlers on redisContext
and redisAsyncContext
by default, which will intercept and free any PUSH replies detected. This means existing code will work as-is after upgrading to Redis 6 and switching to RESP3
.
Custom PUSH handler prototypes
The callback prototypes differ between redisContext
and redisAsyncContext
.
redisContext
void my_push_handler(void *privdata, void *reply) {
/* Handle the reply */
/* Note: We need to free the reply in our custom handler for
blocking contexts. This lets us keep the reply if
we want. */
freeReplyObject(reply);
}
redisAsyncContext
void my_async_push_handler(redisAsyncContext *ac, void *reply) {
/* Handle the reply */
/* Note: Because async hiredis always frees replies, you should
not call freeReplyObject in an async push callback. */
}
Installing a custom handler
There are two ways to set your own PUSH handlers.
-
Set
push_cb
orasync_push_cb
in theredisOptions
struct and connect withredisConnectWithOptions
orredisAsyncConnectWithOptions
.redisOptions = {0}; REDIS_OPTIONS_SET_TCP(&options, "127.0.0.1", 6379); options->push_cb = my_push_handler; redisContext *context = redisConnectWithOptions(&options);
-
Call
redisSetPushCallback
orredisAsyncSetPushCallback
on a connected context.redisContext *context = redisConnect("127.0.0.1", 6379); redisSetPushCallback(context, my_push_handler);
Note
redisSetPushCallback
andredisAsyncSetPushCallback
both return any currently configured handler, making it easy to override and then return to the old value.
Specifying no handler
If you have a unique use-case where you don't want hiredis to automatically intercept and free PUSH replies, you will want to configure no handler at all. This can be done in two ways.
-
Set the
REDIS_OPT_NO_PUSH_AUTOFREE
flag inredisOptions
and leave the callback function pointerNULL
.redisOptions = {0}; REDIS_OPTIONS_SET_TCP(&options, "127.0.0.1", 6379); options->options |= REDIS_OPT_NO_PUSH_AUTOFREE; redisContext *context = redisConnectWithOptions(&options);
-
Call
redisSetPushCallback
withNULL
once connected.redisContext *context = redisConnect("127.0.0.1", 6379); redisSetPushCallback(context, NULL);
Note: With no handler configured, calls to
redisCommand
may generate more than one reply, so this strategy is only applicable when there's some kind of blockingredisGetReply()
loop (e.g.MONITOR
orSUBSCRIBE
workloads).
Allocator injection
Hiredis uses a pass-thru structure of function pointers defined in alloc.h that contain the currently configured allocation and deallocation functions. By default they just point to libc (malloc
, calloc
, realloc
, etc).
Overriding
One can override the allocators like so:
hiredisAllocFuncs myfuncs = {
.mallocFn = my_malloc,
.callocFn = my_calloc,
.reallocFn = my_realloc,
.strdupFn = my_strdup,
.freeFn = my_free,
};
// Override allocators (function returns current allocators if needed)
hiredisAllocFuncs orig = hiredisSetAllocators(&myfuncs);
To reset the allocators to their default libc function simply call:
hiredisResetAllocators();
AUTHORS
Salvatore Sanfilippo (antirez at gmail),
Pieter Noordhuis (pcnoordhuis at gmail)
Michael Grunder (michael dot grunder at gmail)
Hiredis is released under the BSD license.
More Resourcesto explore the angular.
mail [email protected] to add your project or resources here 🔥.
- 1Create new page · clibs/clib Wiki
https://github.com/clibs/clib/wiki/Packages.
Package manager for the C programming language. Contribute to clibs/clib development by creating an account on GitHub.
- 2utf8proc/LICENSE.md at master · JuliaStrings/utf8proc
https://github.com/JuliaStrings/utf8proc/blob/master/LICENSE.md
a clean C library for processing UTF-8 Unicode data - JuliaStrings/utf8proc
- 3ape_tag_libs/c at master · jeremyevans/ape_tag_libs
https://github.com/jeremyevans/ape_tag_libs/tree/master/c
Libaries for reading/writing APEv2 tags in many languages - jeremyevans/ape_tag_libs
- 4Build software better, together
https://github.com/clibs/clib.
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 5Small strings compression library
https://github.com/antirez/smaz
Small strings compression library. Contribute to antirez/smaz development by creating an account on GitHub.
- 6cmathl/LICENSE at master · ScientificC/cmathl
https://github.com/ScientificC/cmathl/blob/master/LICENSE
A pure-C math library with a great variety of mathematical functions. Seeks to be close to C89/C90 compliant for portability. - ScientificC/cmathl
- 7Minimal unit testing framework for C
https://github.com/siu/minunit
Minimal unit testing framework for C. Contribute to siu/minunit development by creating an account on GitHub.
- 8📚 single header utf8 string functions for C and C++
https://github.com/sheredom/utf8.h
📚 single header utf8 string functions for C and C++ - sheredom/utf8.h
- 9A template system for Emacs
https://github.com/joaotavora/yasnippet
A template system for Emacs. Contribute to joaotavora/yasnippet development by creating an account on GitHub.
- 10Asynchronous networking for C
https://github.com/rxi/dyad
Asynchronous networking for C . Contribute to rxi/dyad development by creating an account on GitHub.
- 11Super Light Regexp engine for C/C++
https://github.com/cesanta/slre
Super Light Regexp engine for C/C++. Contribute to cesanta/slre development by creating an account on GitHub.
- 12Netstring for C
https://github.com/liteserver/netstring-c
Netstring for C. Contribute to liteserver/netstring-c development by creating an account on GitHub.
- 13A protocol buffers library for C
https://github.com/cloudwu/pbc
A protocol buffers library for C. Contribute to cloudwu/pbc development by creating an account on GitHub.
- 14Pblog is a small, low overhead, structured logging library
https://github.com/google/pblog
Pblog is a small, low overhead, structured logging library - google/pblog
- 15Parser combinators for binary formats, in C. Yes, in C. What? Don't look at me like that.
https://github.com/abiggerhammer/hammer
Parser combinators for binary formats, in C. Yes, in C. What? Don't look at me like that. - abiggerhammer/hammer
- 16libelf
https://github.com/WolfgangSt/libelf
libelf. Contribute to WolfgangSt/libelf development by creating an account on GitHub.
- 17Open MPI main development repository
https://github.com/open-mpi/ompi
Open MPI main development repository. Contribute to open-mpi/ompi development by creating an account on GitHub.
- 18Your friendly e-mail address validation library.
https://github.com/dertuxmalwieder/libvldmail
Your friendly e-mail address validation library. Contribute to dertuxmalwieder/libvldmail development by creating an account on GitHub.
- 19A shebang-friendly script for "interpreting" single C99, C11, and C++ files, including rcfile support.
https://github.com/RhysU/c99sh
A shebang-friendly script for "interpreting" single C99, C11, and C++ files, including rcfile support. - RhysU/c99sh
- 20Minimal Huffman coder/decoder
https://github.com/adamierymenko/huffandpuff
Minimal Huffman coder/decoder. Contribute to adamierymenko/huffandpuff development by creating an account on GitHub.
- 21C library/compiler for the Cap'n Proto serialization/RPC protocol
https://github.com/jmckaskill/c-capnproto
C library/compiler for the Cap'n Proto serialization/RPC protocol - jmckaskill/c-capnproto
- 22C-code generator for docopt language.
https://github.com/docopt/docopt.c
C-code generator for docopt language. Contribute to docopt/docopt.c development by creating an account on GitHub.
- 23syntastic/LICENCE at master · vim-syntastic/syntastic
https://github.com/vim-syntastic/syntastic/blob/master/LICENCE
Syntax checking hacks for vim. Contribute to vim-syntastic/syntastic development by creating an account on GitHub.
- 24tiny recursive descent expression parser, compiler, and evaluation engine for math expressions
https://github.com/codeplea/tinyexpr
tiny recursive descent expression parser, compiler, and evaluation engine for math expressions - codeplea/tinyexpr
- 25libonion - Coralbits S.L.
https://www.coralbits.com/libonion/
Lightweight C library to add web server functionality to your program libonion is a lightweight library to help you create webservers in C programming language. These webservers may be a web application, a means of expanding your own application to give it web functionality or even a fully featured webserver. The user can create new […]
- 26http request/response parser for c
https://github.com/nodejs/http-parser
http request/response parser for c. Contribute to nodejs/http-parser development by creating an account on GitHub.
- 27commonmark-spec/LICENSE at master · commonmark/commonmark-spec
https://github.com/commonmark/commonmark-spec/blob/master/LICENSE
CommonMark spec, with reference implementations in C and JavaScript - commonmark/commonmark-spec
- 28A tool for use with clang to analyze #includes in C and C++ source files
https://github.com/include-what-you-use/include-what-you-use
A tool for use with clang to analyze #includes in C and C++ source files - include-what-you-use/include-what-you-use
- 29A non-backtracking NFA/DFA-based Perl-compatible regex engine matching on large data streams
https://github.com/openresty/sregex
A non-backtracking NFA/DFA-based Perl-compatible regex engine matching on large data streams - openresty/sregex
- 30A portable foreign-function interface library.
https://github.com/libffi/libffi
A portable foreign-function interface library. Contribute to libffi/libffi development by creating an account on GitHub.
- 31Universal configuration library parser
https://github.com/vstakhov/libucl
Universal configuration library parser. Contribute to vstakhov/libucl development by creating an account on GitHub.
- 32On the fly syntax checking for GNU Emacs
https://github.com/flycheck/flycheck
On the fly syntax checking for GNU Emacs. Contribute to flycheck/flycheck development by creating an account on GitHub.
- 33A Linux packet crafting tool.
https://github.com/rafael-santiago/pig
A Linux packet crafting tool. Contribute to rafael-santiago/pig development by creating an account on GitHub.
- 34A New Kind of Instant Messaging
https://tox.chat/
Whether it's corporations or governments, there's just too much digital spying going on today. Tox is an easy to use application that connects you with friends and family without anyone else listening in. While other big-name services require you to pay for features, Tox is totally free and comes without advertising — forever.
- 35A simple C library for working with KD-Trees
https://github.com/jtsiomb/kdtree
A simple C library for working with KD-Trees. Contribute to jtsiomb/kdtree development by creating an account on GitHub.
- 36A mini C library for interacting with the Twitter OAuth api.
https://github.com/sinemetu1/twitc
A mini C library for interacting with the Twitter OAuth api. - sinemetu1/twitc
- 37Main gperftools repository
https://github.com/gperftools/gperftools
Main gperftools repository. Contribute to gperftools/gperftools development by creating an account on GitHub.
- 38Lint C-based files using Clang.
https://github.com/AtomLinter/linter-clang
Lint C-based files using Clang. Contribute to AtomLinter/linter-clang development by creating an account on GitHub.
- 39WAFer is a C language-based software platform for scalable server-side and networking applications. Think node.js for C programmers.
https://github.com/riolet/WAFer
WAFer is a C language-based software platform for scalable server-side and networking applications. Think node.js for C programmers. - riolet/WAFer
- 40ini file parser
https://github.com/ndevilla/iniparser
ini file parser. Contribute to ndevilla/iniparser development by creating an account on GitHub.
- 41simple neural network library in ANSI C
https://github.com/codeplea/genann
simple neural network library in ANSI C. Contribute to codeplea/genann development by creating an account on GitHub.
- 42An eventing framework for building high performance and high scalability systems in C.
https://github.com/facebookarchive/libphenom
An eventing framework for building high performance and high scalability systems in C. - facebookarchive/libphenom
- 43A cross-platform protocol library to communicate with iOS devices
https://github.com/libimobiledevice/libimobiledevice
A cross-platform protocol library to communicate with iOS devices - libimobiledevice/libimobiledevice
- 44H2O - the optimized HTTP/1, HTTP/2, HTTP/3 server
https://github.com/h2o/h2o/
H2O - the optimized HTTP/1, HTTP/2, HTTP/3 server. Contribute to h2o/h2o development by creating an account on GitHub.
- 45A portable MQTT C client for embedded systems and PCs alike.
https://github.com/LiamBindle/MQTT-C
A portable MQTT C client for embedded systems and PCs alike. - LiamBindle/MQTT-C
- 46Binary Serialization
https://github.com/liteserver/binn
Binary Serialization. Contribute to liteserver/binn development by creating an account on GitHub.
- 47Package manager for the C programming language.
https://github.com/clibs/clib
Package manager for the C programming language. Contribute to clibs/clib development by creating an account on GitHub.
- 48Yet another INI parser
https://github.com/madmurphy/libconfini
Yet another INI parser. Contribute to madmurphy/libconfini development by creating an account on GitHub.
- 49C-Library for unit testing.
https://github.com/rafael-santiago/cutest
C-Library for unit testing. Contribute to rafael-santiago/cutest development by creating an account on GitHub.
- 50A Parser Combinator library for C
https://github.com/orangeduck/mpc
A Parser Combinator library for C. Contribute to orangeduck/mpc development by creating an account on GitHub.
- 51An implementation of the MessagePack serialization format in C / msgpack.org[C]
https://github.com/camgunz/cmp
An implementation of the MessagePack serialization format in C / msgpack.org[C] - camgunz/cmp
- 52Platform independent Near Field Communication (NFC) library
https://github.com/nfc-tools/libnfc
Platform independent Near Field Communication (NFC) library - nfc-tools/libnfc
- 53Lightweight exception implementation for C
https://github.com/ThrowTheSwitch/CException
Lightweight exception implementation for C. Contribute to ThrowTheSwitch/CException development by creating an account on GitHub.
- 54CommonMark spec, with reference implementations in C and JavaScript
https://github.com/commonmark/commonmark-spec
CommonMark spec, with reference implementations in C and JavaScript - commonmark/commonmark-spec
- 55AddressSanitizer, ThreadSanitizer, MemorySanitizer
https://github.com/google/sanitizers
AddressSanitizer, ThreadSanitizer, MemorySanitizer - google/sanitizers
- 56a clean C library for processing UTF-8 Unicode data
https://github.com/JuliaStrings/utf8proc
a clean C library for processing UTF-8 Unicode data - JuliaStrings/utf8proc
- 57nanomsg library
https://github.com/nanomsg/nanomsg
nanomsg library. Contribute to nanomsg/nanomsg development by creating an account on GitHub.
- 58libusb/COPYING at master · libusb/libusb
https://github.com/libusb/libusb/blob/master/COPYING
A cross-platform library to access USB devices . Contribute to libusb/libusb development by creating an account on GitHub.
- 59Protocol Buffers implementation in C
https://github.com/protobuf-c/protobuf-c
Protocol Buffers implementation in C. Contribute to protobuf-c/protobuf-c development by creating an account on GitHub.
- 60An HTML5 parsing library in pure C99
https://github.com/google/gumbo-parser
An HTML5 parsing library in pure C99. Contribute to google/gumbo-parser development by creating an account on GitHub.
- 61Wrapper library for the BSD sockets API with a nicer C99 interface
https://github.com/silentbicycle/socket99
Wrapper library for the BSD sockets API with a nicer C99 interface - silentbicycle/socket99
- 62Compile and execute C "scripts" in one go!
https://github.com/ryanmjacobs/c
Compile and execute C "scripts" in one go! Contribute to ryanmjacobs/c development by creating an account on GitHub.
- 63The approximate regex matching library and agrep command line tool.
https://github.com/laurikari/tre/
The approximate regex matching library and agrep command line tool. - laurikari/tre
- 64MPack - A C encoder/decoder for the MessagePack serialization format / msgpack.org[C]
https://github.com/ludocode/mpack
MPack - A C encoder/decoder for the MessagePack serialization format / msgpack.org[C] - ludocode/mpack
- 65ARCHIVED - libbson has moved to https://github.com/mongodb/mongo-c-driver/tree/master/src/libbson
https://github.com/mongodb/libbson
ARCHIVED - libbson has moved to https://github.com/mongodb/mongo-c-driver/tree/master/src/libbson - mongodb/libbson
- 66A cross platform C99 library to get cpu features at runtime.
https://github.com/google/cpu_features
A cross platform C99 library to get cpu features at runtime. - google/cpu_features
- 67RabbitMQ C client
https://github.com/alanxz/rabbitmq-c
RabbitMQ C client. Contribute to alanxz/rabbitmq-c development by creating an account on GitHub.
- 68Home - OpenMP
https://www.openmp.org/
yes
- 69Simple Dynamic Strings library for C
https://github.com/antirez/sds
Simple Dynamic Strings library for C. Contribute to antirez/sds development by creating an account on GitHub.
- 70OpenCL - The Open Standard for Parallel Programming of Heterogeneous Systems
https://www.khronos.org/opencl/
OpenCL™ (Open Computing Language) is an open, royalty-free standard for cross-platform, parallel programming of diverse accelerators found in supercomputers, cloud servers, personal computers, mobile devices and embedded platforms. OpenCL greatly improves the speed and responsiveness of a wide spectrum of applications in numerous market categories including professional creative tools,
- 71Syntax checking hacks for vim
https://github.com/vim-syntastic/syntastic
Syntax checking hacks for vim. Contribute to vim-syntastic/syntastic development by creating an account on GitHub.
- 72aosp-mirror/platform_bionic
https://github.com/aosp-mirror/platform_bionic
Contribute to aosp-mirror/platform_bionic development by creating an account on GitHub.
- 73regexp4 engine (C-lang)
https://github.com/nasciiboy/recursiveregexpraptor-4
regexp4 engine (C-lang). Contribute to nasciiboy/RecursiveRegexpRaptor-4 development by creating an account on GitHub.
- 74libgit2/COPYING at main · libgit2/libgit2
https://github.com/libgit2/libgit2/blob/master/COPYING
A cross-platform, linkable library implementation of Git that you can use in your application. - libgit2/libgit2
- 75capstone/LICENSE.TXT at master · capstone-engine/capstone
https://github.com/aquynh/capstone/blob/master/LICENSE.TXT
Capstone disassembly/disassembler framework for ARM, ARM64 (ARMv8), Alpha, BPF, Ethereum VM, HPPA, LoongArch, M68K, M680X, Mips, MOS65XX, PPC, RISC-V(rv32G/rv64G), SH, Sparc, SystemZ, TMS320C64X, T...
- 76An implementation of the TLS/SSL protocols
https://github.com/awslabs/s2n
An implementation of the TLS/SSL protocols. Contribute to aws/s2n-tls development by creating an account on GitHub.
- 77Capstone disassembly/disassembler framework for ARM, ARM64 (ARMv8), Alpha, BPF, Ethereum VM, HPPA, LoongArch, M68K, M680X, Mips, MOS65XX, PPC, RISC-V(rv32G/rv64G), SH, Sparc, SystemZ, TMS320C64X, TriCore, Webassembly, XCore and X86.
https://github.com/aquynh/capstone
Capstone disassembly/disassembler framework for ARM, ARM64 (ARMv8), Alpha, BPF, Ethereum VM, HPPA, LoongArch, M68K, M680X, Mips, MOS65XX, PPC, RISC-V(rv32G/rv64G), SH, Sparc, SystemZ, TMS320C64X, T...
- 78Atom-linter extension to lint C/C++ source files using gcc/g++
https://github.com/hebaishi/linter-gcc
Atom-linter extension to lint C/C++ source files using gcc/g++ - AtomLinter/linter-gcc
- 79🚀 Making multi-player gamedev simpler since 2017
https://github.com/librg/librg
🚀 Making multi-player gamedev simpler since 2017. Contribute to zpl-c/librg development by creating an account on GitHub.
- 80Public domain cross platform lock free thread caching 16-byte aligned memory allocator implemented in C
https://github.com/rampantpixels/rpmalloc
Public domain cross platform lock free thread caching 16-byte aligned memory allocator implemented in C - mjansson/rpmalloc
- 81The 2-Clause BSD License
https://opensource.org/licenses/BSD-2-Clause
Note: This license has also been called the “Simplified BSD License” and the “FreeBSD License”. See also the 3-clause BSD License. Copyright <YEAR> <COPYRIGHT HOLDER> Redistribution and use in source…
- 82ICU - International Components for Unicode
http://site.icu-project.org/
News 2024-04-17: ICU 75 is now available. It updates to CLDR 45 (beta blog) locale data with new locales and various additions and corrections. C++ code now requires C++17 and is being made more robust. The CLDR MessageFormat 2.0 specification is now in technology preview, together with a
- 83Understanding and Using C Pointers
http://shop.oreilly.com/product/0636920028000.do
Improve your programming through a solid understanding of C pointers and memory management. With this practical book, you’ll learn how pointers provide the mechanism to dynamically manipulate memory, enhance support … - Selection from Understanding and Using C Pointers [Book]
- 8421st Century C, 2nd Edition
http://shop.oreilly.com/product/0636920033677.do
Throw out your old ideas of C, and relearn a programming language that’s substantially outgrown its origins. With this revised edition of 21st Century C, you’ll discover up-to-date techniques … - Selection from 21st Century C, 2nd Edition [Book]
- 85Jens Gustedt / P99 - macros and functions for C99 · GitLab
http://p99.gforge.inria.fr/
P99 is a suite of macro and function definitions that ease the programming in C99, aka C 1999. By using new tools from C99 we implement default arguments...
- 86C Pocket Reference
http://shop.oreilly.com/product/9780596004361.do
C is one of the oldest programming languages and still one of the most widely used. Whether you're an experienced C programmer or you're new to the language, you know … - Selection from C Pocket Reference [Book]
- 87Head First C
http://shop.oreilly.com/product/0636920015482.do
Ever wished you could learn C from a book? Head First C provides a complete learning experience for C and structured imperative programming. With a unique method that goes beyond … - Selection from Head First C [Book]
- 88Throw The Switch
http://www.throwtheswitch.org/
Unit Testing (TDD) Embedded C Code. Making Awesome and Reliable Firmware in C Doesn't Have to Suck.
- 89Projects
http://source.icu-project.org/repos/icu/icu/tags/latest/LICENSE
Projects The Unicode StandardThe Unicode Standard is a character coding system designed to support the worldwide interchange, processing, and display of the written texts of the diverse languages and technical disciplines of the modern world. In addition, it supports classical and historical texts of many written languages. Unicode CLDR (Common Locale
- 90A fast build tool
https://buck.build/
This project is no longer actively maintained. Please see https://buck2.build for the build system that replaces it. Old content continues below for historical purposes. Buck is a build system developed and used by Facebook. It encourages the creation of small, reusable modules consisting of code and resources, and supports a variety of languages.
- 91Build software better, together
https://github.com/eug/awesome-opengl.
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 92Home
https://github.com/json-c/json-c/wiki
https://github.com/json-c/json-c is the official code repository for json-c. See the wiki for release tarballs for download. API docs at http://json-c.github.io/json-c/ - json-c/json-c
- 93Home
https://github.com/rib/cogl-web/wiki
The cogl3d.org website content. Contribute to rib/cogl-web development by creating an account on GitHub.
- 94qtbase/LICENSE.GPL3-EXCEPT at 5.11 · qt/qtbase
https://github.com/qt/qtbase/blob/5.11/LICENSE.GPL3-EXCEPT
Qt Base (Core, Gui, Widgets, Network, ...). Contribute to qt/qtbase development by creating an account on GitHub.
- 95Build software better, together
https://github.com/vinjn/awesome-vulkan.
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 96Home
https://github.com/netmail-open/wjelement/wiki
advanced, flexible JSON manipulation in C. Contribute to netmail-open/wjelement development by creating an account on GitHub.
- 97C99 heightmap utilities.
https://github.com/prideout/heman
C99 heightmap utilities. Contribute to prideout/heman development by creating an account on GitHub.
- 98Read-only mirror of official repo on openldap.org. Issues and pull requests here are ignored. Use OpenLDAP ITS for issues.
https://github.com/LMDB/lmdb
Read-only mirror of official repo on openldap.org. Issues and pull requests here are ignored. Use OpenLDAP ITS for issues. - LMDB/lmdb
- 99contiki/LICENSE at master · contiki-os/contiki
https://github.com/contiki-os/contiki/blob/master/LICENSE
The official git repository for Contiki, the open source OS for the Internet of Things - contiki-os/contiki
- 100Intel® Implicit SPMD Program Compiler
https://github.com/ispc/ispc
Intel® Implicit SPMD Program Compiler. Contribute to ispc/ispc development by creating an account on GitHub.
- 101Pure C Game Engine
https://github.com/orangeduck/Corange
Pure C Game Engine. Contribute to orangeduck/Corange development by creating an account on GitHub.
- 102LCUI/LICENSE.TXT at develop · lc-soft/LCUI
https://github.com/lc-soft/LCUI/blob/develop/LICENSE.TXT
C library for building user interfaces. Contribute to lc-soft/LCUI development by creating an account on GitHub.
- 103Parallel, indexed xz compressor
https://github.com/vasi/pixz
Parallel, indexed xz compressor. Contribute to vasi/pixz development by creating an account on GitHub.
- 104Quake GPL Source Release
https://github.com/id-Software/Quake
Quake GPL Source Release. Contribute to id-Software/Quake development by creating an account on GitHub.
- 105a small build system with a focus on speed
https://github.com/ninja-build/ninja
a small build system with a focus on speed. Contribute to ninja-build/ninja development by creating an account on GitHub.
- 106Quake 2 GPL Source Release
https://github.com/id-Software/Quake-2
Quake 2 GPL Source Release. Contribute to id-Software/Quake-2 development by creating an account on GitHub.
- 107libui/LICENSE at master · andlabs/libui
https://github.com/andlabs/libui/blob/master/LICENSE
Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports. - andlabs/libui
- 108stb single-file public domain libraries for C/C++
https://github.com/nothings/stb
stb single-file public domain libraries for C/C++. Contribute to nothings/stb development by creating an account on GitHub.
- 109Murmur3 hash in C
https://github.com/PeterScott/murmur3
Murmur3 hash in C. Contribute to PeterScott/murmur3 development by creating an account on GitHub.
- 110Lightweight JSON library written in C.
https://github.com/kgabis/parson
Lightweight JSON library written in C. Contribute to kgabis/parson development by creating an account on GitHub.
- 111Brotli compression format
https://github.com/google/brotli
Brotli compression format. Contribute to google/brotli development by creating an account on GitHub.
- 112xmake/LICENSE.md at master · xmake-io/xmake
https://github.com/xmake-io/xmake/blob/master/LICENSE.md
🔥 A cross-platform build utility based on Lua. Contribute to xmake-io/xmake development by creating an account on GitHub.
- 113Premake
https://github.com/premake/premake-core
Premake. Contribute to premake/premake-core development by creating an account on GitHub.
- 114Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports.
https://github.com/andlabs/libui
Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports. - andlabs/libui
- 115A single-header ANSI C gui library
https://github.com/vurtun/nuklear
A single-header ANSI C gui library. Contribute to vurtun/nuklear development by creating an account on GitHub.
- 116Visual Studio Code - Code Editing. Redefined
https://code.visualstudio.com/
Visual Studio Code is a code editor redefined and optimized for building and debugging modern web and cloud applications. Visual Studio Code is free and available on your favorite platform - Linux, macOS, and Windows.
- 117The GTK Project - A free and open-source cross-platform widget toolkit
https://www.gtk.org/gtk-doc/
GTK is a free and open-source cross-platform widget toolkit for creating graphical user interfaces.
- 118NIH Utility Library
https://github.com/keybuk/libnih
NIH Utility Library. Contribute to keybuk/libnih development by creating an account on GitHub.
- 119raylib
https://www.raylib.com/
raylib is a simple and easy-to-use library to enjoy videogames programming.
- 120The GTK Project - A free and open-source cross-platform widget toolkit
https://www.gtk.org/
GTK is a free and open-source cross-platform widget toolkit for creating graphical user interfaces.
- 121Easy to use, modular, header only, macro based, generic and type-safe Data Structures in C
https://github.com/LeoVen/C-Macro-Collections
Easy to use, modular, header only, macro based, generic and type-safe Data Structures in C - LeoVen/C-Macro-Collections
- 122advanced, flexible JSON manipulation in C
https://github.com/netmail-open/wjelement/
advanced, flexible JSON manipulation in C. Contribute to netmail-open/wjelement development by creating an account on GitHub.
- 123Simple hash table implementation for C.
https://github.com/watmough/jwHash
Simple hash table implementation for C. Contribute to watmough/jwHash development by creating an account on GitHub.
- 124ioquake3
https://ioquake3.org/
Play Quake 3, mods, new games, or make your own!
- 125OpenGL ES - The Standard for Embedded Accelerated 3D Graphics
https://www.khronos.org/opengles/
OpenGL ES is a royalty-free, cross-platform API for full-function 2D and 3D graphics on embedded systems - including consoles, phones, appliances and vehicles.
- 126OpenGL SC - OpenGL graphics for the safety critical industry
https://www.khronos.org/openglsc/
The open standard OpenGL SC Safety Critical Profile is defined to meet the unique needs of the safety-critical market for avionics, industrial, military, medical and automotive applications including D0178-B certification.
- 127Minimalistic C client for Redis >= 1.2
https://github.com/redis/hiredis
Minimalistic C client for Redis >= 1.2. Contribute to redis/hiredis development by creating an account on GitHub.
- 128A fast compressor/decompressor
https://github.com/google/snappy
A fast compressor/decompressor. Contribute to google/snappy development by creating an account on GitHub.
- 129PostgreSQL
https://www.postgresql.org/
The world's most advanced open source database.
- 130Improved JPEG encoder.
https://github.com/mozilla/mozjpeg
Improved JPEG encoder. Contribute to mozilla/mozjpeg development by creating an account on GitHub.
- 131💩 Colour ASCII Art Library
https://github.com/cacalabs/libcaca
💩 Colour ASCII Art Library. Contribute to cacalabs/libcaca development by creating an account on GitHub.
- 132I Do Not Know C
https://kukuruku.co/post/i-do-not-know-c/
The purpose of this article is to make everyone (especially C programmers) say: “I do not know C”. I want to show that the dark corners of C are much closer than it seems, and even trivial code lines may contain undefined behavior. The article is organized as a set of questions and answers. All the examples are separate files of the source code. 1. int i; int i = 10; Q: Is this code correct?
- 133GIFLIB
https://sourceforge.net/projects/giflib/
Download GIFLIB for free. A library and utilities for processing GIFs. giflib is a library for reading and writing gif images. It is API and ABI compatible with libungif which was in wide use while the LZW compression algorithm was patented.
- 134Redis - The Real-time Data Platform
https://redis.io/
Developers love Redis. Unlock the full potential of the Redis database with Redis Enterprise and start building blazing fast apps.
- 135The Developer Data Platform
https://www.mongodb.com/.
Get your ideas to market faster with a developer data platform built on the leading modern database. MongoDB makes working with data easy.
- 136C library for building user interfaces
https://github.com/lc-soft/LCUI/
C library for building user interfaces. Contribute to lc-soft/LCUI development by creating an account on GitHub.
- 137qt-creator/LICENSE.GPL3-EXCEPT at master · qt-creator/qt-creator
https://github.com/qt-creator/qt-creator/blob/master/LICENSE.GPL3-EXCEPT
A cross-platform Qt IDE. Contribute to qt-creator/qt-creator development by creating an account on GitHub.
- 138Learning C with gdb - Blog - Recurse Center
https://www.recurse.com/blog/5-learning-c-with-gdb
The Recurse Center is a self-directed, community-driven educational retreat for programmers in New York City.
- 139Introduction to "Fun" C (using GCC)
https://gist.github.com/eatonphil/21b3d6569f24ad164365
Introduction to "Fun" C (using GCC). GitHub Gist: instantly share code, notes, and snippets.
- 140Open Source Database (RDBMS) for the Enterprise | MariaDB
https://mariadb.com/
MariaDB provides enterprise open source database and cloud managed database services to support scalability, mission-critical deployments, and more.
- 141Introduction to OpenMP - Tim Mattson (Intel)
https://www.youtube.com/playlist?list=PLLX-Q6B8xqZ8n8bwjGdzBJ25X2utwnoEG
Introduction to OpenMP - Tim Mattson (Intel) The OpenMP ARB thanks the University Program Office at Intel for permission to make this tutorial available. Sli...
- 142ispc/LICENSE.txt at main · ispc/ispc
https://github.com/ispc/ispc/blob/master/LICENSE.txt
Intel® Implicit SPMD Program Compiler. Contribute to ispc/ispc development by creating an account on GitHub.
- 143amazon-freertos/LICENSE at main · aws/amazon-freertos
https://github.com/aws/amazon-freertos/blob/master/LICENSE
DEPRECATED - See README.md. Contribute to aws/amazon-freertos development by creating an account on GitHub.
- 144AI-Enhanced Data Solutions with Database 23ai
https://www.oracle.com/database/berkeley-db/
Discover advanced database features like AI, security, and cloud solutions, and optimize your data with Oracle's robust technologies.
- 145qlibc/LICENSE at main · wolkykim/qlibc
https://github.com/wolkykim/qlibc/blob/master/LICENSE
qLibc is a simple and yet powerful C library providing generic data structures and algorithms. - wolkykim/qlibc
- 146One of the fastest hash functions
https://github.com/leo-yuriev/t1ha
One of the fastest hash functions. Contribute to erthink/t1ha development by creating an account on GitHub.
- 147Sunsetting Atom
https://atom.io/
We are archiving Atom and all projects under the Atom organization for an official sunset on December 15, 2022.
- 148Home | Vulkan | Cross platform 3D Graphics
https://www.khronos.org/vulkan/
Vulkan is a next generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in PCs, consoles, mobile phones and embedded platforms.
- 149Mbed TLS
https://tls.mbed.org/
Project implements cryptographic primitives, X.509 certificate manipulation and the SSL/TLS and DTLS protocols.
- 150Situs SBOBET Online Link Daftar SBOBET88 Login Indonesia
http://anjuta.org/
SBOBET88 adalah situs judi bola resmi partner Betwin188 agen sbobet online mobile terpercaya 2024, penyedia link daftar sbobet login indonesia 24jam.
- 151C library for encoding, decoding and manipulating JSON data
http://www.digip.org/jansson/
C library for encoding, decoding and manipulating JSON data - akheron/jansson
- 152Developer Tools & IDE | The Eclipse Foundation
http://www.eclipse.org/ide/
Our community is innovating on the next generation of cloud native developer tools, including the Eclipse IDE which is the leading open platform for …
Related Articlesto learn about angular.
- 1Getting Started with C Programming: Beginner’s Guide
- 2Functions and Pointers in C: Write Efficient Code
- 3Memory Management in C: malloc and free
- 4File Handling in C: Reading and Writing Files with fopen and fwrite
- 5Data Structures in C: Linked Lists, Stacks, and Queues
- 6Multithreading in C: POSIX Threads (Pthreads)
- 7Getting Started with C Programming for Embedded Systems
- 8IoT Applications with C: Beginner’s Guide
- 9Optimizing C Code: Speed and Efficiency
- 10Common C Programming Pitfalls
FAQ'sto learn more about Angular JS.
mail [email protected] to add more queries here 🔍.
- 1
what can you do with c programming
- 2
why was the c programming language invented
- 3
where to download c programming language
- 4
which app is best for c programming in laptop
- 5
how c programming language was developed
- 6
how many days need to learn c programming
- 7
do you pronounce the c in schedule
- 8
which software is best for c programming
- 9
when was c programming language invented
- 10
what is c times c
- 11
what are arrays in c programming
- 13
who is the father of c language mcq
- 14
will c be replaced
- 15
was c written in assembly
- 16
what c programming is used for
- 17
how to do c programming in visual studio code
- 18
why c programming is called structured programming
- 19
which compiler is best for c programming
- 20
what c programming language is used for
- 21
will c++ ever die
- 22
is c programming language object oriented
- 23
when did c programming language come out
- 24
is c programming language case sensitive
- 25
why should i learn c programming language
- 26
why c programming is used
- 27
what is array in c programming
- 28
what can c programming be used for
- 29
who is the programming language c
- 30
which software is used for c programming
- 31
when c is called structured programming language
- 32
why c programming is called c
- 33
is c the first programming language
- 34
who developed c programming language
- 35
why should i learn c programming
- 36
who is the father of c programming
- 37
when c programming was developed
- 38
is c programming language
- 39
is c programming the same as c++
- 40
when was the c programming language developed
- 41
how to do c programming in mobile
- 42
how long will it take to learn c programming
- 43
who is the founder of c programming
- 45
how to use vs code for c programming
- 46
will c ever be replaced
- 47
who invented c programming
- 48
who uses c programming language
- 49
what does c programming look like
- 50
which is the best website to learn c programming
- 51
is c programming language still used
- 52
what are pointers in c programming
- 53
what is structure in c programming
- 54
who created c programming language
- 55
should i learn c programming first
- 56
who wrote c programming language
- 57
who made c programming language
- 58
what can c be used for
- 59
what are variables in c programming
- 60
how difficult is c programming
- 61
can c code run in c++
- 62
what are strings in c programming
- 63
who is the father of c
- 64
where to practice c programming
- 65
how c programming language works
- 66
is c programming hard
- 67
what is string in c programming
- 68
is c dead programming language
- 69
where to start c programming
- 70
what are structures in c programming
- 71
how c programming works
- 72
which book is best for c programming
- 73
what does c programming language look like
- 74
what did == mean in c programming
- 75
will c# replace c++
- 76
how to do c programming in laptop
- 77
where to learn c programming
- 78
how much time is required to learn c programming
- 79
do c programming online
- 80
is c programming worth learning
- 81
what are c programming languages
- 83
is c written in c
- 84
would i like programming
- 85
where to do c programming
- 86
what is pointer in c programming
- 87
what does c programming do
- 88
do c programming language
- 89
how to learn c programming
- 90
what are the features of c programming language
- 91
which ide is best for c programming
- 92
why c is called structured programming language
- 93
where to do c programming in laptop
- 94
is programming in c hard
- 95
who is the father of c programming language
- 96
whose line is it anyway cw schedule
- 97
is c programming still used
- 98
why c programming language
- 99
how to use code blocks for c programming
- 100
what does mean in c programming
- 101
does c programming have classes
- 102
can computers program themselves
- 103
how to do c programming in windows
- 104
what does c programming stand for
- 105
is c programming free
- 106
what are the data types in c programming
- 107
which programming language should i learn after c
- 108
how to start c programming
- 109
will c language die
- 110
what is an compiler in c programming
- 111
where should we do c programming
- 112
where was c programming invented
- 113
who made the c programming language
- 114
which software for c programming
- 115
where c programming is used
- 116
where can i learn c programming for free
- 117
how to do c programming in vs code
- 118
what is c as a programming language
- 119
does c have object oriented programming
- 120
why is c called a mid-level programming language
- 121
can c++ do everything c can
- 122
where is c programming language used
- 123
how does c programming language work
- 124
what are functions in c programming
- 125
do c programming in terminal
- 126
what are keywords in c programming
- 127
can c and c++ be mixed
- 128
why c programming is important
- 129
how to do c programming in ubuntu
- 130
how to practice c programming
- 131
what is embedded c programming
- 132
is c programming case sensitive
- 133
how long does it take to learn c programming
- 134
who is father of c language
- 135
what c programming language
- 136
why c programming is named as c
- 137
why learn c programming
- 138
when was c programming developed
- 139
is c programming easy
- 140
how does c programming work
- 141
is c good for beginners
- 142
which c programming language to learn
- 143
is c programming easy to learn
- 144
why is c named c
- 145
what does c stand for in programming
- 146
when was c programming language created
- 147
what is function in c programming
- 148
why was c invented
- 149
how to download c programming
- 150
what does void mean in c programming
More Sitesto check out once you're finished browsing here.
https://www.0x3d.site/
0x3d is designed for aggregating information.
https://nodejs.0x3d.site/
NodeJS Online Directory
https://cross-platform.0x3d.site/
Cross Platform Online Directory
https://open-source.0x3d.site/
Open Source Online Directory
https://analytics.0x3d.site/
Analytics Online Directory
https://javascript.0x3d.site/
JavaScript Online Directory
https://golang.0x3d.site/
GoLang Online Directory
https://python.0x3d.site/
Python Online Directory
https://swift.0x3d.site/
Swift Online Directory
https://rust.0x3d.site/
Rust Online Directory
https://scala.0x3d.site/
Scala Online Directory
https://ruby.0x3d.site/
Ruby Online Directory
https://clojure.0x3d.site/
Clojure Online Directory
https://elixir.0x3d.site/
Elixir Online Directory
https://elm.0x3d.site/
Elm Online Directory
https://lua.0x3d.site/
Lua Online Directory
https://c-programming.0x3d.site/
C Programming Online Directory
https://cpp-programming.0x3d.site/
C++ Programming Online Directory
https://r-programming.0x3d.site/
R Programming Online Directory
https://perl.0x3d.site/
Perl Online Directory
https://java.0x3d.site/
Java Online Directory
https://kotlin.0x3d.site/
Kotlin Online Directory
https://php.0x3d.site/
PHP Online Directory
https://react.0x3d.site/
React JS Online Directory
https://angular.0x3d.site/
Angular JS Online Directory