deps/hiredis/hiredis.h

   1 /*
   2  * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
   3  * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
   4  *
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are met:
   9  *
  10  *   * Redistributions of source code must retain the above copyright notice,
  11  *     this list of conditions and the following disclaimer.
  12  *   * Redistributions in binary form must reproduce the above copyright
  13  *     notice, this list of conditions and the following disclaimer in the
  14  *     documentation and/or other materials provided with the distribution.
  15  *   * Neither the name of Redis nor the names of its contributors may be used
  16  *     to endorse or promote products derived from this software without
  17  *     specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #ifndef __HIREDIS_H
  33 #define __HIREDIS_H
  34 #include <stdio.h> /* for size_t */
  35 #include <stdarg.h> /* for va_list */
  36 #include <sys/time.h> /* for struct timeval */
  37
  38 #define HIREDIS_MAJOR 0
  39 #define HIREDIS_MINOR 10
  40 #define HIREDIS_PATCH 1
  41
  42 #define REDIS_ERR -1
  43 #define REDIS_OK 0
  44
  45 /* When an error occurs, the err flag in a context is set to hold the type of
  46  * error that occured. REDIS_ERR_IO means there was an I/O error and you
  47  * should use the "errno" variable to find out what is wrong.
  48  * For other values, the "errstr" field will hold a description. */
  49 #define REDIS_ERR_IO 1 /* Error in read or write */
  50 #define REDIS_ERR_EOF 3 /* End of file */
  51 #define REDIS_ERR_PROTOCOL 4 /* Protocol error */
  52 #define REDIS_ERR_OOM 5 /* Out of memory */
  53 #define REDIS_ERR_OTHER 2 /* Everything else... */
  54
  55 /* Connection type can be blocking or non-blocking and is set in the
  56  * least significant bit of the flags field in redisContext. */
  57 #define REDIS_BLOCK 0x1
  58
  59 /* Connection may be disconnected before being free'd. The second bit
  60  * in the flags field is set when the context is connected. */
  61 #define REDIS_CONNECTED 0x2
  62
  63 /* The async API might try to disconnect cleanly and flush the output
  64  * buffer and read all subsequent replies before disconnecting.
  65  * This flag means no new commands can come in and the connection
  66  * should be terminated once all replies have been read. */
  67 #define REDIS_DISCONNECTING 0x4
  68
  69 /* Flag specific to the async API which means that the context should be clean
  70  * up as soon as possible. */
  71 #define REDIS_FREEING 0x8
  72
  73 /* Flag that is set when an async callback is executed. */
  74 #define REDIS_IN_CALLBACK 0x10
  75
  76 /* Flag that is set when the async context has one or more subscriptions. */
  77 #define REDIS_SUBSCRIBED 0x20
  78
  79 /* Flag that is set when monitor mode is active */
  80 #define REDIS_MONITORING 0x40
  81
  82 #define REDIS_REPLY_STRING 1
  83 #define REDIS_REPLY_ARRAY 2
  84 #define REDIS_REPLY_INTEGER 3
  85 #define REDIS_REPLY_NIL 4
  86 #define REDIS_REPLY_STATUS 5
  87 #define REDIS_REPLY_ERROR 6
  88
  89 #define REDIS_READER_MAX_BUF (1024*16)  /* Default max unused reader buffer. */
  90
  91 #ifdef __cplusplus
  92 extern "C" {
  93 #endif
  94
  95 /* This is the reply object returned by redisCommand() */
  96 typedef struct redisReply {
  97     int type; /* REDIS_REPLY_* */
  98     long long integer; /* The integer when type is REDIS_REPLY_INTEGER */
  99     int len; /* Length of string */
 100     char *str; /* Used for both REDIS_REPLY_ERROR and REDIS_REPLY_STRING */
 101     size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */
 102     struct redisReply **element; /* elements vector for REDIS_REPLY_ARRAY */
 103 } redisReply;
 104
 105 typedef struct redisReadTask {
 106     int type;
 107     int elements; /* number of elements in multibulk container */
 108     int idx; /* index in parent (array) object */
 109     void *obj; /* holds user-generated value for a read task */
 110     struct redisReadTask *parent; /* parent task */
 111     void *privdata; /* user-settable arbitrary field */
 112 } redisReadTask;
 113
 114 typedef struct redisReplyObjectFunctions {
 115     void *(*createString)(const redisReadTask*, char*, size_t);
 116     void *(*createArray)(const redisReadTask*, int);
 117     void *(*createInteger)(const redisReadTask*, long long);
 118     void *(*createNil)(const redisReadTask*);
 119     void (*freeObject)(void*);
 120 } redisReplyObjectFunctions;
 121
 122 /* State for the protocol parser */
 123 typedef struct redisReader {
 124     int err; /* Error flags, 0 when there is no error */
 125     char errstr[128]; /* String representation of error when applicable */
 126
 127     char *buf; /* Read buffer */
 128     size_t pos; /* Buffer cursor */
 129     size_t len; /* Buffer length */
 130     size_t maxbuf; /* Max length of unused buffer */
 131
 132     redisReadTask rstack[9];
 133     int ridx; /* Index of current read task */
 134     void *reply; /* Temporary reply pointer */
 135
 136     redisReplyObjectFunctions *fn;
 137     void *privdata;
 138 } redisReader;
 139
 140 /* Public API for the protocol parser. */
 141 redisReader *redisReaderCreate(void);
 142 void redisReaderFree(redisReader *r);
 143 int redisReaderFeed(redisReader *r, const char *buf, size_t len);
 144 int redisReaderGetReply(redisReader *r, void **reply);
 145
 146 /* Backwards compatibility, can be removed on big version bump. */
 147 #define redisReplyReaderCreate redisReaderCreate
 148 #define redisReplyReaderFree redisReaderFree
 149 #define redisReplyReaderFeed redisReaderFeed
 150 #define redisReplyReaderGetReply redisReaderGetReply
 151 #define redisReplyReaderSetPrivdata(_r, _p) (int)(((redisReader*)(_r))->privdata = (_p))
 152 #define redisReplyReaderGetObject(_r) (((redisReader*)(_r))->reply)
 153 #define redisReplyReaderGetError(_r) (((redisReader*)(_r))->errstr)
 154
 155 /* Function to free the reply objects hiredis returns by default. */
 156 void freeReplyObject(void *reply);
 157
 158 /* Functions to format a command according to the protocol. */
 159 int redisvFormatCommand(char **target, const char *format, va_list ap);
 160 int redisFormatCommand(char **target, const char *format, ...);
 161 int redisFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen);
 162
 163 /* Context for a connection to Redis */
 164 typedef struct redisContext {
 165     int err; /* Error flags, 0 when there is no error */
 166     char errstr[128]; /* String representation of error when applicable */
 167     int fd;
 168     int flags;
 169     char *obuf; /* Write buffer */
 170     redisReader *reader; /* Protocol reader */
 171 } redisContext;
 172
 173 redisContext *redisConnect(const char *ip, int port);
 174 redisContext *redisConnectWithTimeout(const char *ip, int port, struct timeval tv);
 175 redisContext *redisConnectNonBlock(const char *ip, int port);
 176 redisContext *redisConnectUnix(const char *path);
 177 redisContext *redisConnectUnixWithTimeout(const char *path, struct timeval tv);
 178 redisContext *redisConnectUnixNonBlock(const char *path);
 179 int redisSetTimeout(redisContext *c, struct timeval tv);
 180 void redisFree(redisContext *c);
 181 int redisBufferRead(redisContext *c);
 182 int redisBufferWrite(redisContext *c, int *done);
 183
 184 /* In a blocking context, this function first checks if there are unconsumed
 185  * replies to return and returns one if so. Otherwise, it flushes the output
 186  * buffer to the socket and reads until it has a reply. In a non-blocking
 187  * context, it will return unconsumed replies until there are no more. */
 188 int redisGetReply(redisContext *c, void **reply);
 189 int redisGetReplyFromReader(redisContext *c, void **reply);
 190
 191 /* Write a command to the output buffer. Use these functions in blocking mode
 192  * to get a pipeline of commands. */
 193 int redisvAppendCommand(redisContext *c, const char *format, va_list ap);
 194 int redisAppendCommand(redisContext *c, const char *format, ...);
 195 int redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
 196
 197 /* Issue a command to Redis. In a blocking context, it is identical to calling
 198  * redisAppendCommand, followed by redisGetReply. The function will return
 199  * NULL if there was an error in performing the request, otherwise it will
 200  * return the reply. In a non-blocking context, it is identical to calling
 201  * only redisAppendCommand and will always return NULL. */
 202 void *redisvCommand(redisContext *c, const char *format, va_list ap);
 203 void *redisCommand(redisContext *c, const char *format, ...);
 204 void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
 205
 206 #ifdef __cplusplus
 207 }
 208 #endif
 209
 210 #endif