Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
ruanhaishen
redis
Commits
3ddb6ffa
Commit
3ddb6ffa
authored
Aug 06, 2020
by
michael-grunder
Browse files
Remove hiredis so we can add it as a subtree
parent
c17e597d
Changes
53
Expand all
Hide whitespace changes
Inline
Side-by-side
deps/hiredis/dict.h
deleted
100644 → 0
View file @
c17e597d
/* Hash table implementation.
*
* This file implements in memory hash tables with insert/del/replace/find/
* get-random-element operations. Hash tables will auto resize if needed
* tables of power of two in size are used, collisions are handled by
* chaining. See the source code for more information... :)
*
* Copyright (c) 2006-2010, 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.
*/
#ifndef __DICT_H
#define __DICT_H
#define DICT_OK 0
#define DICT_ERR 1
/* Unused arguments generate annoying warnings... */
#define DICT_NOTUSED(V) ((void) V)
typedef
struct
dictEntry
{
void
*
key
;
void
*
val
;
struct
dictEntry
*
next
;
}
dictEntry
;
typedef
struct
dictType
{
unsigned
int
(
*
hashFunction
)(
const
void
*
key
);
void
*
(
*
keyDup
)(
void
*
privdata
,
const
void
*
key
);
void
*
(
*
valDup
)(
void
*
privdata
,
const
void
*
obj
);
int
(
*
keyCompare
)(
void
*
privdata
,
const
void
*
key1
,
const
void
*
key2
);
void
(
*
keyDestructor
)(
void
*
privdata
,
void
*
key
);
void
(
*
valDestructor
)(
void
*
privdata
,
void
*
obj
);
}
dictType
;
typedef
struct
dict
{
dictEntry
**
table
;
dictType
*
type
;
unsigned
long
size
;
unsigned
long
sizemask
;
unsigned
long
used
;
void
*
privdata
;
}
dict
;
typedef
struct
dictIterator
{
dict
*
ht
;
int
index
;
dictEntry
*
entry
,
*
nextEntry
;
}
dictIterator
;
/* This is the initial size of every hash table */
#define DICT_HT_INITIAL_SIZE 4
/* ------------------------------- Macros ------------------------------------*/
#define dictFreeEntryVal(ht, entry) \
if ((ht)->type->valDestructor) \
(ht)->type->valDestructor((ht)->privdata, (entry)->val)
#define dictSetHashVal(ht, entry, _val_) do { \
if ((ht)->type->valDup) \
entry->val = (ht)->type->valDup((ht)->privdata, _val_); \
else \
entry->val = (_val_); \
} while(0)
#define dictFreeEntryKey(ht, entry) \
if ((ht)->type->keyDestructor) \
(ht)->type->keyDestructor((ht)->privdata, (entry)->key)
#define dictSetHashKey(ht, entry, _key_) do { \
if ((ht)->type->keyDup) \
entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \
else \
entry->key = (_key_); \
} while(0)
#define dictCompareHashKeys(ht, key1, key2) \
(((ht)->type->keyCompare) ? \
(ht)->type->keyCompare((ht)->privdata, key1, key2) : \
(key1) == (key2))
#define dictHashKey(ht, key) (ht)->type->hashFunction(key)
#define dictGetEntryKey(he) ((he)->key)
#define dictGetEntryVal(he) ((he)->val)
#define dictSlots(ht) ((ht)->size)
#define dictSize(ht) ((ht)->used)
/* API */
static
unsigned
int
dictGenHashFunction
(
const
unsigned
char
*
buf
,
int
len
);
static
dict
*
dictCreate
(
dictType
*
type
,
void
*
privDataPtr
);
static
int
dictExpand
(
dict
*
ht
,
unsigned
long
size
);
static
int
dictAdd
(
dict
*
ht
,
void
*
key
,
void
*
val
);
static
int
dictReplace
(
dict
*
ht
,
void
*
key
,
void
*
val
);
static
int
dictDelete
(
dict
*
ht
,
const
void
*
key
);
static
void
dictRelease
(
dict
*
ht
);
static
dictEntry
*
dictFind
(
dict
*
ht
,
const
void
*
key
);
static
dictIterator
*
dictGetIterator
(
dict
*
ht
);
static
dictEntry
*
dictNext
(
dictIterator
*
iter
);
static
void
dictReleaseIterator
(
dictIterator
*
iter
);
#endif
/* __DICT_H */
deps/hiredis/examples/CMakeLists.txt
deleted
100644 → 0
View file @
c17e597d
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
)
deps/hiredis/examples/example-ae.c
deleted
100644 → 0
View file @
c17e597d
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <hiredis.h>
#include <async.h>
#include <adapters/ae.h>
/* Put event loop in the global scope, so it can be explicitly stopped */
static
aeEventLoop
*
loop
;
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
);
aeStop
(
loop
);
return
;
}
printf
(
"Connected...
\n
"
);
}
void
disconnectCallback
(
const
redisAsyncContext
*
c
,
int
status
)
{
if
(
status
!=
REDIS_OK
)
{
printf
(
"Error: %s
\n
"
,
c
->
errstr
);
aeStop
(
loop
);
return
;
}
printf
(
"Disconnected...
\n
"
);
aeStop
(
loop
);
}
int
main
(
int
argc
,
char
**
argv
)
{
signal
(
SIGPIPE
,
SIG_IGN
);
redisAsyncContext
*
c
=
redisAsyncConnect
(
"127.0.0.1"
,
6379
);
if
(
c
->
err
)
{
/* Let *c leak for now... */
printf
(
"Error: %s
\n
"
,
c
->
errstr
);
return
1
;
}
loop
=
aeCreateEventLoop
(
64
);
redisAeAttach
(
loop
,
c
);
redisAsyncSetConnectCallback
(
c
,
connectCallback
);
redisAsyncSetDisconnectCallback
(
c
,
disconnectCallback
);
redisAsyncCommand
(
c
,
NULL
,
NULL
,
"SET key %b"
,
argv
[
argc
-
1
],
strlen
(
argv
[
argc
-
1
]));
redisAsyncCommand
(
c
,
getCallback
,
(
char
*
)
"end-1"
,
"GET key"
);
aeMain
(
loop
);
return
0
;
}
deps/hiredis/examples/example-glib.c
deleted
100644 → 0
View file @
c17e597d
#include <stdlib.h>
#include <hiredis.h>
#include <async.h>
#include <adapters/glib.h>
static
GMainLoop
*
mainloop
;
static
void
connect_cb
(
const
redisAsyncContext
*
ac
G_GNUC_UNUSED
,
int
status
)
{
if
(
status
!=
REDIS_OK
)
{
g_printerr
(
"Failed to connect: %s
\n
"
,
ac
->
errstr
);
g_main_loop_quit
(
mainloop
);
}
else
{
g_printerr
(
"Connected...
\n
"
);
}
}
static
void
disconnect_cb
(
const
redisAsyncContext
*
ac
G_GNUC_UNUSED
,
int
status
)
{
if
(
status
!=
REDIS_OK
)
{
g_error
(
"Failed to disconnect: %s"
,
ac
->
errstr
);
}
else
{
g_printerr
(
"Disconnected...
\n
"
);
g_main_loop_quit
(
mainloop
);
}
}
static
void
command_cb
(
redisAsyncContext
*
ac
,
gpointer
r
,
gpointer
user_data
G_GNUC_UNUSED
)
{
redisReply
*
reply
=
r
;
if
(
reply
)
{
g_print
(
"REPLY: %s
\n
"
,
reply
->
str
);
}
redisAsyncDisconnect
(
ac
);
}
gint
main
(
gint
argc
G_GNUC_UNUSED
,
gchar
*
argv
[]
G_GNUC_UNUSED
)
{
redisAsyncContext
*
ac
;
GMainContext
*
context
=
NULL
;
GSource
*
source
;
ac
=
redisAsyncConnect
(
"127.0.0.1"
,
6379
);
if
(
ac
->
err
)
{
g_printerr
(
"%s
\n
"
,
ac
->
errstr
);
exit
(
EXIT_FAILURE
);
}
source
=
redis_source_new
(
ac
);
mainloop
=
g_main_loop_new
(
context
,
FALSE
);
g_source_attach
(
source
,
context
);
redisAsyncSetConnectCallback
(
ac
,
connect_cb
);
redisAsyncSetDisconnectCallback
(
ac
,
disconnect_cb
);
redisAsyncCommand
(
ac
,
command_cb
,
NULL
,
"SET key 1234"
);
redisAsyncCommand
(
ac
,
command_cb
,
NULL
,
"GET key"
);
g_main_loop_run
(
mainloop
);
return
EXIT_SUCCESS
;
}
deps/hiredis/examples/example-ivykis.c
deleted
100644 → 0
View file @
c17e597d
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <hiredis.h>
#include <async.h>
#include <adapters/ivykis.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
);
iv_init
();
redisAsyncContext
*
c
=
redisAsyncConnect
(
"127.0.0.1"
,
6379
);
if
(
c
->
err
)
{
/* Let *c leak for now... */
printf
(
"Error: %s
\n
"
,
c
->
errstr
);
return
1
;
}
redisIvykisAttach
(
c
);
redisAsyncSetConnectCallback
(
c
,
connectCallback
);
redisAsyncSetDisconnectCallback
(
c
,
disconnectCallback
);
redisAsyncCommand
(
c
,
NULL
,
NULL
,
"SET key %b"
,
argv
[
argc
-
1
],
strlen
(
argv
[
argc
-
1
]));
redisAsyncCommand
(
c
,
getCallback
,
(
char
*
)
"end-1"
,
"GET key"
);
iv_main
();
iv_deinit
();
return
0
;
}
deps/hiredis/examples/example-libev.c
deleted
100644 → 0
View file @
c17e597d
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <hiredis.h>
#include <async.h>
#include <adapters/libev.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
);
redisAsyncContext
*
c
=
redisAsyncConnect
(
"127.0.0.1"
,
6379
);
if
(
c
->
err
)
{
/* Let *c leak for now... */
printf
(
"Error: %s
\n
"
,
c
->
errstr
);
return
1
;
}
redisLibevAttach
(
EV_DEFAULT_
c
);
redisAsyncSetConnectCallback
(
c
,
connectCallback
);
redisAsyncSetDisconnectCallback
(
c
,
disconnectCallback
);
redisAsyncCommand
(
c
,
NULL
,
NULL
,
"SET key %b"
,
argv
[
argc
-
1
],
strlen
(
argv
[
argc
-
1
]));
redisAsyncCommand
(
c
,
getCallback
,
(
char
*
)
"end-1"
,
"GET key"
);
ev_loop
(
EV_DEFAULT_
0
);
return
0
;
}
deps/hiredis/examples/example-libevent-ssl.c
deleted
100644 → 0
View file @
c17e597d
#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
;
}
deps/hiredis/examples/example-libevent.c
deleted
100644 → 0
View file @
c17e597d
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <hiredis.h>
#include <async.h>
#include <adapters/libevent.h>
void
getCallback
(
redisAsyncContext
*
c
,
void
*
r
,
void
*
privdata
)
{
redisReply
*
reply
=
r
;
if
(
reply
==
NULL
)
{
if
(
c
->
errstr
)
{
printf
(
"errstr: %s
\n
"
,
c
->
errstr
);
}
return
;
}
printf
(
"argv[%s]: %s
\n
"
,
(
char
*
)
privdata
,
reply
->
str
);
/* 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
();
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
);
if
(
c
->
err
)
{
/* Let *c leak for now... */
printf
(
"Error: %s
\n
"
,
c
->
errstr
);
return
1
;
}
redisLibeventAttach
(
c
,
base
);
redisAsyncSetConnectCallback
(
c
,
connectCallback
);
redisAsyncSetDisconnectCallback
(
c
,
disconnectCallback
);
redisAsyncCommand
(
c
,
NULL
,
NULL
,
"SET key %b"
,
argv
[
argc
-
1
],
strlen
(
argv
[
argc
-
1
]));
redisAsyncCommand
(
c
,
getCallback
,
(
char
*
)
"end-1"
,
"GET key"
);
event_base_dispatch
(
base
);
return
0
;
}
deps/hiredis/examples/example-libuv.c
deleted
100644 → 0
View file @
c17e597d
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <hiredis.h>
#include <async.h>
#include <adapters/libuv.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
);
uv_loop_t
*
loop
=
uv_default_loop
();
redisAsyncContext
*
c
=
redisAsyncConnect
(
"127.0.0.1"
,
6379
);
if
(
c
->
err
)
{
/* Let *c leak for now... */
printf
(
"Error: %s
\n
"
,
c
->
errstr
);
return
1
;
}
redisLibuvAttach
(
c
,
loop
);
redisAsyncSetConnectCallback
(
c
,
connectCallback
);
redisAsyncSetDisconnectCallback
(
c
,
disconnectCallback
);
redisAsyncCommand
(
c
,
NULL
,
NULL
,
"SET key %b"
,
argv
[
argc
-
1
],
strlen
(
argv
[
argc
-
1
]));
redisAsyncCommand
(
c
,
getCallback
,
(
char
*
)
"end-1"
,
"GET key"
);
uv_run
(
loop
,
UV_RUN_DEFAULT
);
return
0
;
}
deps/hiredis/examples/example-macosx.c
deleted
100644 → 0
View file @
c17e597d
//
// Created by Дмитрий Бахвалов on 13.07.15.
// Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.
//
#include <stdio.h>
#include <hiredis.h>
#include <async.h>
#include <adapters/macosx.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
;
}
CFRunLoopStop
(
CFRunLoopGetCurrent
());
printf
(
"Disconnected...
\n
"
);
}
int
main
(
int
argc
,
char
**
argv
)
{
signal
(
SIGPIPE
,
SIG_IGN
);
CFRunLoopRef
loop
=
CFRunLoopGetCurrent
();
if
(
!
loop
)
{
printf
(
"Error: Cannot get current run loop
\n
"
);
return
1
;
}
redisAsyncContext
*
c
=
redisAsyncConnect
(
"127.0.0.1"
,
6379
);
if
(
c
->
err
)
{
/* Let *c leak for now... */
printf
(
"Error: %s
\n
"
,
c
->
errstr
);
return
1
;
}
redisMacOSAttach
(
c
,
loop
);
redisAsyncSetConnectCallback
(
c
,
connectCallback
);
redisAsyncSetDisconnectCallback
(
c
,
disconnectCallback
);
redisAsyncCommand
(
c
,
NULL
,
NULL
,
"SET key %b"
,
argv
[
argc
-
1
],
strlen
(
argv
[
argc
-
1
]));
redisAsyncCommand
(
c
,
getCallback
,
(
char
*
)
"end-1"
,
"GET key"
);
CFRunLoopRun
();
return
0
;
}
deps/hiredis/examples/example-qt.cpp
deleted
100644 → 0
View file @
c17e597d
#include <iostream>
using
namespace
std
;
#include <QCoreApplication>
#include <QTimer>
#include "example-qt.h"
void
getCallback
(
redisAsyncContext
*
,
void
*
r
,
void
*
privdata
)
{
redisReply
*
reply
=
static_cast
<
redisReply
*>
(
r
);
ExampleQt
*
ex
=
static_cast
<
ExampleQt
*>
(
privdata
);
if
(
reply
==
nullptr
||
ex
==
nullptr
)
return
;
cout
<<
"key: "
<<
reply
->
str
<<
endl
;
ex
->
finish
();
}
void
ExampleQt
::
run
()
{
m_ctx
=
redisAsyncConnect
(
"localhost"
,
6379
);
if
(
m_ctx
->
err
)
{
cerr
<<
"Error: "
<<
m_ctx
->
errstr
<<
endl
;
redisAsyncFree
(
m_ctx
);
emit
finished
();
}
m_adapter
.
setContext
(
m_ctx
);
redisAsyncCommand
(
m_ctx
,
NULL
,
NULL
,
"SET key %s"
,
m_value
);
redisAsyncCommand
(
m_ctx
,
getCallback
,
this
,
"GET key"
);
}
int
main
(
int
argc
,
char
**
argv
)
{
QCoreApplication
app
(
argc
,
argv
);
ExampleQt
example
(
argv
[
argc
-
1
]);
QObject
::
connect
(
&
example
,
SIGNAL
(
finished
()),
&
app
,
SLOT
(
quit
()));
QTimer
::
singleShot
(
0
,
&
example
,
SLOT
(
run
()));
return
app
.
exec
();
}
deps/hiredis/examples/example-qt.h
deleted
100644 → 0
View file @
c17e597d
#ifndef __HIREDIS_EXAMPLE_QT_H
#define __HIREDIS_EXAMPLE_QT_H
#include <adapters/qt.h>
class
ExampleQt
:
public
QObject
{
Q_OBJECT
public:
ExampleQt
(
const
char
*
value
,
QObject
*
parent
=
0
)
:
QObject
(
parent
),
m_value
(
value
)
{}
signals:
void
finished
();
public
slots
:
void
run
();
private:
void
finish
()
{
emit
finished
();
}
private:
const
char
*
m_value
;
redisAsyncContext
*
m_ctx
;
RedisQtAdapter
m_adapter
;
friend
void
getCallback
(
redisAsyncContext
*
,
void
*
,
void
*
);
};
#endif
/* !__HIREDIS_EXAMPLE_QT_H */
deps/hiredis/examples/example-ssl.c
deleted
100644 → 0
View file @
c17e597d
#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
;
}
deps/hiredis/examples/example.c
deleted
100644 → 0
View file @
c17e597d
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <hiredis.h>
int
main
(
int
argc
,
char
**
argv
)
{
unsigned
int
j
,
isunix
=
0
;
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
);
}
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
);
}
/* 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
;
}
deps/hiredis/fmacros.h
deleted
100644 → 0
View file @
c17e597d
#ifndef __HIREDIS_FMACRO_H
#define __HIREDIS_FMACRO_H
#define _XOPEN_SOURCE 600
#define _POSIX_C_SOURCE 200112L
#if defined(__APPLE__) && defined(__MACH__)
/* Enable TCP_KEEPALIVE */
#define _DARWIN_C_SOURCE
#endif
#endif
deps/hiredis/hiredis.c
deleted
100644 → 0
View file @
c17e597d
This diff is collapsed.
Click to expand it.
deps/hiredis/hiredis.h
deleted
100644 → 0
View file @
c17e597d
/*
* Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
* Copyright (c) 2010-2014, Pieter Noordhuis <pcnoordhuis at gmail dot com>
* Copyright (c) 2015, Matt Stancliff <matt at genges dot com>,
* Jan-Erik Rediger <janerik at fnordig 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_H
#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 */
#define HIREDIS_MAJOR 0
#define HIREDIS_MINOR 14
#define HIREDIS_PATCH 0
#define HIREDIS_SONAME 0.14
/* Connection type can be blocking or non-blocking and is set in the
* least significant bit of the flags field in redisContext. */
#define REDIS_BLOCK 0x1
/* Connection may be disconnected before being free'd. The second bit
* in the flags field is set when the context is connected. */
#define REDIS_CONNECTED 0x2
/* The async API might try to disconnect cleanly and flush the output
* buffer and read all subsequent replies before disconnecting.
* This flag means no new commands can come in and the connection
* should be terminated once all replies have been read. */
#define REDIS_DISCONNECTING 0x4
/* Flag specific to the async API which means that the context should be clean
* up as soon as possible. */
#define REDIS_FREEING 0x8
/* Flag that is set when an async callback is executed. */
#define REDIS_IN_CALLBACK 0x10
/* Flag that is set when the async context has one or more subscriptions. */
#define REDIS_SUBSCRIBED 0x20
/* Flag that is set when monitor mode is active */
#define REDIS_MONITORING 0x40
/* 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
* SO_REUSEADDR is being used. */
#define REDIS_CONNECT_RETRIES 10
#ifdef __cplusplus
extern
"C"
{
#endif
/* This is the reply object returned by redisCommand() */
typedef
struct
redisReply
{
int
type
;
/* REDIS_REPLY_* */
long
long
integer
;
/* The integer when type is REDIS_REPLY_INTEGER */
double
dval
;
/* The double when type is REDIS_REPLY_DOUBLE */
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
;
redisReader
*
redisReaderCreate
(
void
);
/* Function to free the reply objects hiredis returns by default. */
void
freeReplyObject
(
void
*
reply
);
/* Functions to format a command according to the protocol. */
int
redisvFormatCommand
(
char
**
target
,
const
char
*
format
,
va_list
ap
);
int
redisFormatCommand
(
char
**
target
,
const
char
*
format
,
...);
int
redisFormatCommandArgv
(
char
**
target
,
int
argc
,
const
char
**
argv
,
const
size_t
*
argvlen
);
int
redisFormatSdsCommandArgv
(
sds
*
target
,
int
argc
,
const
char
**
argv
,
const
size_t
*
argvlen
);
void
redisFreeCommand
(
char
*
cmd
);
void
redisFreeSdsCommand
(
sds
cmd
);
enum
redisConnectionType
{
REDIS_CONN_TCP
,
REDIS_CONN_UNIX
,
REDIS_CONN_USERFD
};
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
flags
;
char
*
obuf
;
/* Write buffer */
redisReader
*
reader
;
/* Protocol reader */
enum
redisConnectionType
connection_type
;
struct
timeval
*
timeout
;
struct
{
char
*
host
;
char
*
source_addr
;
int
port
;
}
tcp
;
struct
{
char
*
path
;
}
unix_sock
;
/* 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
);
redisContext
*
redisConnectBindNonBlock
(
const
char
*
ip
,
int
port
,
const
char
*
source_addr
);
redisContext
*
redisConnectBindNonBlockWithReuse
(
const
char
*
ip
,
int
port
,
const
char
*
source_addr
);
redisContext
*
redisConnectUnix
(
const
char
*
path
);
redisContext
*
redisConnectUnixWithTimeout
(
const
char
*
path
,
const
struct
timeval
tv
);
redisContext
*
redisConnectUnixNonBlock
(
const
char
*
path
);
redisContext
*
redisConnectFd
(
redisFD
fd
);
/**
* Reconnect the given context using the saved information.
*
* This re-uses the exact same connect options as in the initial connection.
* host, ip (or path), timeout and bind address are reused,
* flags are used unmodified from the existing context.
*
* Returns REDIS_OK on successful connect or REDIS_ERR otherwise.
*/
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
redisBufferRead
(
redisContext
*
c
);
int
redisBufferWrite
(
redisContext
*
c
,
int
*
done
);
/* In a blocking context, this function first checks if there are unconsumed
* replies to return and returns one if so. Otherwise, it flushes the output
* buffer to the socket and reads until it has a reply. In a non-blocking
* context, it will return unconsumed replies until there are no more. */
int
redisGetReply
(
redisContext
*
c
,
void
**
reply
);
int
redisGetReplyFromReader
(
redisContext
*
c
,
void
**
reply
);
/* Write a formatted command to the output buffer. Use these functions in blocking mode
* to get a pipeline of commands. */
int
redisAppendFormattedCommand
(
redisContext
*
c
,
const
char
*
cmd
,
size_t
len
);
/* Write a command to the output buffer. Use these functions in blocking mode
* to get a pipeline of commands. */
int
redisvAppendCommand
(
redisContext
*
c
,
const
char
*
format
,
va_list
ap
);
int
redisAppendCommand
(
redisContext
*
c
,
const
char
*
format
,
...);
int
redisAppendCommandArgv
(
redisContext
*
c
,
int
argc
,
const
char
**
argv
,
const
size_t
*
argvlen
);
/* Issue a command to Redis. In a blocking context, it is identical to calling
* redisAppendCommand, followed by redisGetReply. The function will return
* NULL if there was an error in performing the request, otherwise it will
* return the reply. In a non-blocking context, it is identical to calling
* only redisAppendCommand and will always return NULL. */
void
*
redisvCommand
(
redisContext
*
c
,
const
char
*
format
,
va_list
ap
);
void
*
redisCommand
(
redisContext
*
c
,
const
char
*
format
,
...);
void
*
redisCommandArgv
(
redisContext
*
c
,
int
argc
,
const
char
**
argv
,
const
size_t
*
argvlen
);
#ifdef __cplusplus
}
#endif
#endif
deps/hiredis/hiredis.pc.in
deleted
100644 → 0
View file @
c17e597d
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
deps/hiredis/hiredis_ssl.h
deleted
100644 → 0
View file @
c17e597d
/*
* 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 */
deps/hiredis/hiredis_ssl.pc.in
deleted
100644 → 0
View file @
c17e597d
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
Prev
1
2
3
Next
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment