1extern crate c2rust_bitfields;
2extern crate libc;
3extern crate core;
4use std::cell::UnsafeCell;
5extern "C" {
6 pub type _IO_wide_data;
7 pub type _IO_codecvt;
8 pub type _IO_marker;
9 pub type redisAsyncContext;
10 pub type sockaddr;
11 static mut stdin: *mut FILE;
12 static mut stdout: *mut FILE;
13 static mut stderr: *mut FILE;
14 fn fclose(__stream: *mut FILE) -> libc::c_int;
15 fn fflush(__stream: *mut FILE) -> libc::c_int;
16 fn fopen(_: *const libc::c_char, _: *const libc::c_char) -> *mut FILE;
17 fn fprintf(_: *mut FILE, _: *const libc::c_char, _: ...) -> libc::c_int;
18 fn printf(_: *const libc::c_char, _: ...) -> libc::c_int;
19 fn sprintf(_: *mut libc::c_char, _: *const libc::c_char, _: ...) -> libc::c_int;
20 fn vfprintf(
21 _: *mut FILE,
22 _: *const libc::c_char,
23 _: core::ffi::VaList,
24 ) -> libc::c_int;
25 fn snprintf(
26 _: *mut libc::c_char,
27 _: libc::c_ulong,
28 _: *const libc::c_char,
29 _: ...
30 ) -> libc::c_int;
31 fn getc(__stream: *mut FILE) -> libc::c_int;
32 fn fgets(
33 __s: *mut libc::c_char,
34 __n: libc::c_int,
35 __stream: *mut FILE,
36 ) -> *mut libc::c_char;
37 fn fputs(__s: *const libc::c_char, __stream: *mut FILE) -> libc::c_int;
38 fn fread(
39 _: *mut libc::c_void,
40 _: libc::c_ulong,
41 _: libc::c_ulong,
42 _: *mut FILE,
43 ) -> libc::c_ulong;
44 fn fwrite(
45 _: *const libc::c_void,
46 _: libc::c_ulong,
47 _: libc::c_ulong,
48 _: *mut FILE,
49 ) -> libc::c_ulong;
50 fn fileno(__stream: *mut FILE) -> libc::c_int;
51 fn memcpy(
52 _: *mut libc::c_void,
53 _: *const libc::c_void,
54 _: libc::c_ulong,
55 ) -> *mut libc::c_void;
56 fn memmove(
57 _: *mut libc::c_void,
58 _: *const libc::c_void,
59 _: libc::c_ulong,
60 ) -> *mut libc::c_void;
61 fn memset(
62 _: *mut libc::c_void,
63 _: libc::c_int,
64 _: libc::c_ulong,
65 ) -> *mut libc::c_void;
66 fn memcmp(
67 _: *const libc::c_void,
68 _: *const libc::c_void,
69 _: libc::c_ulong,
70 ) -> libc::c_int;
71 fn strcpy(_: *mut libc::c_char, _: *const libc::c_char) -> *mut libc::c_char;
72 fn strncpy(
73 _: *mut libc::c_char,
74 _: *const libc::c_char,
75 _: libc::c_ulong,
76 ) -> *mut libc::c_char;
77 fn strcmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int;
78 fn strncmp(
79 _: *const libc::c_char,
80 _: *const libc::c_char,
81 _: libc::c_ulong,
82 ) -> libc::c_int;
83 fn strchr(_: *const libc::c_char, _: libc::c_int) -> *mut libc::c_char;
84 fn strrchr(_: *const libc::c_char, _: libc::c_int) -> *mut libc::c_char;
85 fn strstr(_: *const libc::c_char, _: *const libc::c_char) -> *mut libc::c_char;
86 fn strlen(_: *const libc::c_char) -> libc::c_ulong;
87 fn strerror(_: libc::c_int) -> *mut libc::c_char;
88 fn strcasecmp(__s1: *const libc::c_char, __s2: *const libc::c_char) -> libc::c_int;
89 fn strncasecmp(
90 __s1: *const libc::c_char,
91 __s2: *const libc::c_char,
92 __n: size_t,
93 ) -> libc::c_int;
94 fn strtod(_: *const libc::c_char, _: *mut *mut libc::c_char) -> libc::c_double;
95 fn strtol(
96 _: *const libc::c_char,
97 _: *mut *mut libc::c_char,
98 _: libc::c_int,
99 ) -> libc::c_long;
100 fn strtoll(
101 _: *const libc::c_char,
102 _: *mut *mut libc::c_char,
103 _: libc::c_int,
104 ) -> libc::c_longlong;
105 fn strtoull(
106 _: *const libc::c_char,
107 _: *mut *mut libc::c_char,
108 _: libc::c_int,
109 ) -> libc::c_ulonglong;
110 fn rand() -> libc::c_int;
111 fn srand(__seed: libc::c_uint);
112 fn exit(_: libc::c_int) -> !;
113 fn getenv(__name: *const libc::c_char) -> *mut libc::c_char;
114 fn qsort(
115 __base: *mut libc::c_void,
116 __nmemb: size_t,
117 __size: size_t,
118 __compar: __compar_fn_t,
119 );
120 fn abs(_: libc::c_int) -> libc::c_int;
121 fn llabs(_: libc::c_longlong) -> libc::c_longlong;
122 fn signal(__sig: libc::c_int, __handler: __sighandler_t) -> __sighandler_t;
123 fn gettimeofday(__tv: *mut timeval, __tz: *mut libc::c_void) -> libc::c_int;
124 fn close(__fd: libc::c_int) -> libc::c_int;
125 fn read(__fd: libc::c_int, __buf: *mut libc::c_void, __nbytes: size_t) -> ssize_t;
126 fn write(__fd: libc::c_int, __buf: *const libc::c_void, __n: size_t) -> ssize_t;
127 fn getpid() -> __pid_t;
128 fn isatty(__fd: libc::c_int) -> libc::c_int;
129 fn usleep(__useconds: __useconds_t) -> libc::c_int;
130 fn fsync(__fd: libc::c_int) -> libc::c_int;
131 fn ftruncate(__fd: libc::c_int, __length: __off64_t) -> libc::c_int;
132 fn sleep(__seconds: libc::c_uint) -> libc::c_uint;
133 fn time(__timer: *mut time_t) -> time_t;
134 fn __ctype_b_loc() -> *mut *const libc::c_ushort;
135 fn __errno_location() -> *mut libc::c_int;
136 fn __assert_fail(
137 __assertion: *const libc::c_char,
138 __file: *const libc::c_char,
139 __line: libc::c_uint,
140 __function: *const libc::c_char,
141 ) -> !;
142 fn open(__file: *const libc::c_char, __oflag: libc::c_int, _: ...) -> libc::c_int;
143 fn pow(_: libc::c_double, _: libc::c_double) -> libc::c_double;
144 fn ceil(_: libc::c_double) -> libc::c_double;
145 fn fabs(_: libc::c_double) -> libc::c_double;
146 fn floor(_: libc::c_double) -> libc::c_double;
147 fn lround(_: libc::c_double) -> libc::c_long;
148 fn hi_sdsnewlen(init: *const libc::c_void, initlen: size_t) -> hisds;
149 fn hi_sdsnew(init: *const libc::c_char) -> hisds;
150 fn hi_sdsempty() -> hisds;
151 fn hi_sdsdup(s: hisds) -> hisds;
152 fn hi_sdsfree(s: hisds);
153 fn hi_sdscatlen(s: hisds, t: *const libc::c_void, len: size_t) -> hisds;
154 fn hi_sdscat(s: hisds, t: *const libc::c_char) -> hisds;
155 fn hi_sdscatsds(s: hisds, t: hisds) -> hisds;
156 fn hi_sdscpy(s: hisds, t: *const libc::c_char) -> hisds;
157 fn hi_sdscatprintf(s: hisds, fmt: *const libc::c_char, _: ...) -> hisds;
158 fn hi_sdscatfmt(s: hisds, fmt: *const libc::c_char, _: ...) -> hisds;
159 fn hi_sdsrange(s: hisds, start: ssize_t, end: ssize_t) -> libc::c_int;
160 fn hi_sdscmp(s1: hisds, s2: hisds) -> libc::c_int;
161 fn hi_sdsfreesplitres(tokens: *mut hisds, count: libc::c_int);
162 fn hi_sdstolower(s: hisds);
163 fn hi_sdstoupper(s: hisds);
164 fn hi_sdsfromlonglong(value: libc::c_longlong) -> hisds;
165 fn hi_sdscatrepr(s: hisds, p: *const libc::c_char, len: size_t) -> hisds;
166 fn hi_sdssplitargs(line: *const libc::c_char, argc: *mut libc::c_int) -> *mut hisds;
167 fn hi_sds_malloc(size: size_t) -> *mut libc::c_void;
168 fn hi_sds_realloc(ptr: *mut libc::c_void, size: size_t) -> *mut libc::c_void;
169 fn freeReplyObject(reply: *mut libc::c_void);
170 fn redisConnect(ip: *const libc::c_char, port: libc::c_int) -> *mut redisContext;
171 fn redisConnectUnix(path: *const libc::c_char) -> *mut redisContext;
172 fn redisSetPushCallback(
173 c: *mut redisContext,
174 fn_0: Option::<redisPushFn>,
175 ) -> Option::<redisPushFn>;
176 fn redisFree(c: *mut redisContext);
177 fn redisBufferRead(c: *mut redisContext) -> libc::c_int;
178 fn redisGetReply(c: *mut redisContext, reply: *mut *mut libc::c_void) -> libc::c_int;
179 fn redisAppendCommand(
180 c: *mut redisContext,
181 format: *const libc::c_char,
182 _: ...
183 ) -> libc::c_int;
184 fn redisAppendCommandArgv(
185 c: *mut redisContext,
186 argc: libc::c_int,
187 argv: *mut *const libc::c_char,
188 argvlen: *const size_t,
189 ) -> libc::c_int;
190 fn redisvCommand(
191 c: *mut redisContext,
192 format: *const libc::c_char,
193 ap: core::ffi::VaList,
194 ) -> *mut libc::c_void;
195 fn redisCommand(
196 c: *mut redisContext,
197 format: *const libc::c_char,
198 _: ...
199 ) -> *mut libc::c_void;
200 fn dictCreate(type_0: *mut dictType) -> *mut dict;
201 fn dictAdd(
202 d: *mut dict,
203 key: *mut libc::c_void,
204 val: *mut libc::c_void,
205 ) -> libc::c_int;
206 fn dictReplace(
207 d: *mut dict,
208 key: *mut libc::c_void,
209 val: *mut libc::c_void,
210 ) -> libc::c_int;
211 fn dictRelease(d: *mut dict);
212 fn dictFind(d: *mut dict, key: *const libc::c_void) -> *mut dictEntry;
213 fn init_genrand64(seed: libc::c_ulonglong);
214 fn dictGenHashFunction(key: *const libc::c_void, len: size_t) -> uint64_t;
215 fn dictReleaseIterator(iter: *mut dictIterator);
216 fn dictNext(iter: *mut dictIterator) -> *mut dictEntry;
217 fn dictGetIterator(d: *mut dict) -> *mut dictIterator;
218 fn listCreate() -> *mut list;
219 fn listRelease(list: *mut list);
220 fn listEmpty(list: *mut list);
221 fn listAddNodeTail(list: *mut list, value: *mut libc::c_void) -> *mut list;
222 fn listDelNode(list: *mut list, node: *mut listNode);
223 fn listNext(iter: *mut listIter) -> *mut listNode;
224 fn listRewind(list: *mut list, li: *mut listIter);
225 fn zmalloc(size: size_t) -> *mut libc::c_void;
226 fn zfree(ptr: *mut libc::c_void);
227 fn zcalloc(size: size_t) -> *mut libc::c_void;
228 fn zstrdup(s: *const libc::c_char) -> *mut libc::c_char;
229 fn zrealloc(ptr: *mut libc::c_void, size: size_t) -> *mut libc::c_void;
230 fn linenoiseSetCompletionCallback(_: Option::<linenoiseCompletionCallback>);
231 fn linenoiseSetHintsCallback(_: Option::<linenoiseHintsCallback>);
232 fn linenoiseSetFreeHintsCallback(_: Option::<linenoiseFreeHintsCallback>);
233 fn linenoiseAddCompletion(_: *mut linenoiseCompletions, _: *const libc::c_char);
234 fn linenoise(prompt: *const libc::c_char) -> *mut libc::c_char;
235 fn linenoiseFree(ptr: *mut libc::c_void);
236 fn linenoiseHistoryAdd(line: *const libc::c_char) -> libc::c_int;
237 fn linenoiseHistorySave(filename: *const libc::c_char) -> libc::c_int;
238 fn linenoiseHistoryLoad(filename: *const libc::c_char) -> libc::c_int;
239 fn linenoiseClearScreen();
240 fn linenoiseSetMultiLine(ml: libc::c_int);
241 fn linenoiseMaskModeEnable();
242 fn linenoiseMaskModeDisable();
243 fn anetResolve(
244 err: *mut libc::c_char,
245 host: *mut libc::c_char,
246 ipbuf: *mut libc::c_char,
247 ipbuf_len: size_t,
248 flags: libc::c_int,
249 ) -> libc::c_int;
250 fn anetNonBlock(err: *mut libc::c_char, fd: libc::c_int) -> libc::c_int;
251 fn anetKeepAlive(
252 err: *mut libc::c_char,
253 fd: libc::c_int,
254 interval: libc::c_int,
255 ) -> libc::c_int;
256 fn anetFormatAddr(
257 fmt: *mut libc::c_char,
258 fmt_len: size_t,
259 ip: *mut libc::c_char,
260 port: libc::c_int,
261 ) -> libc::c_int;
262 fn aeWait(
263 fd: libc::c_int,
264 mask: libc::c_int,
265 milliseconds: libc::c_longlong,
266 ) -> libc::c_int;
267 fn cliSecureConnection(
268 c: *mut redisContext,
269 config_0: cliSSLconfig,
270 err: *mut *const libc::c_char,
271 ) -> libc::c_int;
272 fn cliWriteConn(
273 c: *mut redisContext,
274 buf: *const libc::c_char,
275 buf_len: size_t,
276 ) -> ssize_t;
277 fn readArgFromStdin() -> hisds;
278 fn getSdsArrayFromArgv(
279 argc: libc::c_int,
280 argv: *mut *mut libc::c_char,
281 quoted: libc::c_int,
282 ) -> *mut hisds;
283 fn unquoteCString(str: *mut libc::c_char) -> hisds;
284 fn parseRedisUri(
285 uri: *const libc::c_char,
286 tool_name: *const libc::c_char,
287 connInfo: *mut cliConnInfo,
288 tls_flag: *mut libc::c_int,
289 );
290 fn escapeJsonString(s: hisds, p: *const libc::c_char, len: size_t) -> hisds;
291 fn redisGitSHA1() -> *mut libc::c_char;
292 fn redisGitDirty() -> *mut libc::c_char;
293 fn crc16(buf: *const libc::c_char, len: libc::c_int) -> uint16_t;
294}
295pub type __builtin_va_list = __va_list;
296#[derive(Copy, Clone)]
297#[repr(C)]
298pub struct __va_list {
299 pub __stack: *mut libc::c_void,
300 pub __gr_top: *mut libc::c_void,
301 pub __vr_top: *mut libc::c_void,
302 pub __gr_offs: libc::c_int,
303 pub __vr_offs: libc::c_int,
304}
305pub type size_t = libc::c_ulong;
306pub type va_list = __builtin_va_list;
307pub type __gnuc_va_list = __builtin_va_list;
308pub type __uint8_t = libc::c_uchar;
309pub type __int16_t = libc::c_short;
310pub type __uint16_t = libc::c_ushort;
311pub type __uint32_t = libc::c_uint;
312pub type __int64_t = libc::c_long;
313pub type __uint64_t = libc::c_ulong;
314pub type __off_t = libc::c_long;
315pub type __off64_t = libc::c_long;
316pub type __pid_t = libc::c_int;
317pub type __time_t = libc::c_long;
318pub type __useconds_t = libc::c_uint;
319pub type __suseconds_t = libc::c_long;
320pub type __ssize_t = libc::c_long;
321pub type __sig_atomic_t = libc::c_int;
322#[derive(Copy, Clone)]
323#[repr(C)]
324pub struct _IO_FILE {
325 pub _flags: libc::c_int,
326 pub _IO_read_ptr: *mut libc::c_char,
327 pub _IO_read_end: *mut libc::c_char,
328 pub _IO_read_base: *mut libc::c_char,
329 pub _IO_write_base: *mut libc::c_char,
330 pub _IO_write_ptr: *mut libc::c_char,
331 pub _IO_write_end: *mut libc::c_char,
332 pub _IO_buf_base: *mut libc::c_char,
333 pub _IO_buf_end: *mut libc::c_char,
334 pub _IO_save_base: *mut libc::c_char,
335 pub _IO_backup_base: *mut libc::c_char,
336 pub _IO_save_end: *mut libc::c_char,
337 pub _markers: *mut _IO_marker,
338 pub _chain: *mut _IO_FILE,
339 pub _fileno: libc::c_int,
340 pub _flags2: libc::c_int,
341 pub _old_offset: __off_t,
342 pub _cur_column: libc::c_ushort,
343 pub _vtable_offset: libc::c_schar,
344 pub _shortbuf: [libc::c_char; 1],
345 pub _lock: *mut libc::c_void,
346 pub _offset: __off64_t,
347 pub _codecvt: *mut _IO_codecvt,
348 pub _wide_data: *mut _IO_wide_data,
349 pub _freeres_list: *mut _IO_FILE,
350 pub _freeres_buf: *mut libc::c_void,
351 pub __pad5: size_t,
352 pub _mode: libc::c_int,
353 pub _unused2: [libc::c_char; 20],
354}
355pub type _IO_lock_t = ();
356pub type FILE = _IO_FILE;
357pub type ssize_t = __ssize_t;
358pub type time_t = __time_t;
359pub type int16_t = __int16_t;
360pub type int64_t = __int64_t;
361#[derive(Copy, Clone)]
362#[repr(C)]
363pub struct timeval {
364 pub tv_sec: __time_t,
365 pub tv_usec: __suseconds_t,
366}
367pub type __compar_fn_t = Option::<
368 unsafe extern "C" fn(*const libc::c_void, *const libc::c_void) -> libc::c_int,
369>;
370pub type sig_atomic_t = __sig_atomic_t;
371pub type __sighandler_t = Option::<unsafe extern "C" fn(libc::c_int) -> ()>;
372pub type C2RustUnnamed = libc::c_uint;
373pub const _ISalnum: C2RustUnnamed = 8;
374pub const _ISpunct: C2RustUnnamed = 4;
375pub const _IScntrl: C2RustUnnamed = 2;
376pub const _ISblank: C2RustUnnamed = 1;
377pub const _ISgraph: C2RustUnnamed = 32768;
378pub const _ISprint: C2RustUnnamed = 16384;
379pub const _ISspace: C2RustUnnamed = 8192;
380pub const _ISxdigit: C2RustUnnamed = 4096;
381pub const _ISdigit: C2RustUnnamed = 2048;
382pub const _ISalpha: C2RustUnnamed = 1024;
383pub const _ISlower: C2RustUnnamed = 512;
384pub const _ISupper: C2RustUnnamed = 256;
385#[derive(Copy, Clone)]
386#[repr(C)]
387pub struct redisReadTask {
388 pub type_0: libc::c_int,
389 pub elements: libc::c_longlong,
390 pub idx: libc::c_int,
391 pub obj: *mut libc::c_void,
392 pub parent: *mut redisReadTask,
393 pub privdata: *mut libc::c_void,
394}
395#[derive(Copy, Clone)]
396#[repr(C)]
397pub struct redisReplyObjectFunctions {
398 pub createString: Option::<
399 unsafe extern "C" fn(
400 *const redisReadTask,
401 *mut libc::c_char,
402 size_t,
403 ) -> *mut libc::c_void,
404 >,
405 pub createArray: Option::<
406 unsafe extern "C" fn(*const redisReadTask, size_t) -> *mut libc::c_void,
407 >,
408 pub createInteger: Option::<
409 unsafe extern "C" fn(*const redisReadTask, libc::c_longlong) -> *mut libc::c_void,
410 >,
411 pub createDouble: Option::<
412 unsafe extern "C" fn(
413 *const redisReadTask,
414 libc::c_double,
415 *mut libc::c_char,
416 size_t,
417 ) -> *mut libc::c_void,
418 >,
419 pub createNil: Option::<
420 unsafe extern "C" fn(*const redisReadTask) -> *mut libc::c_void,
421 >,
422 pub createBool: Option::<
423 unsafe extern "C" fn(*const redisReadTask, libc::c_int) -> *mut libc::c_void,
424 >,
425 pub freeObject: Option::<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
426}
427#[derive(Copy, Clone)]
428#[repr(C)]
429pub struct redisReader {
430 pub err: libc::c_int,
431 pub errstr: [libc::c_char; 128],
432 pub buf: *mut libc::c_char,
433 pub pos: size_t,
434 pub len: size_t,
435 pub maxbuf: size_t,
436 pub maxelements: libc::c_longlong,
437 pub task: *mut *mut redisReadTask,
438 pub tasks: libc::c_int,
439 pub ridx: libc::c_int,
440 pub reply: *mut libc::c_void,
441 pub fn_0: *mut redisReplyObjectFunctions,
442 pub privdata: *mut libc::c_void,
443}
444pub type uint8_t = __uint8_t;
445pub type uint16_t = __uint16_t;
446pub type uint32_t = __uint32_t;
447pub type uint64_t = __uint64_t;
448pub type hisds = *mut libc::c_char;
449#[derive(Copy, Clone)]
450#[repr(C, packed)]
451pub struct hisdshdr8 {
452 pub len: uint8_t,
453 pub alloc: uint8_t,
454 pub flags: libc::c_uchar,
455 pub buf: [libc::c_char; 0],
456}
457#[derive(Copy, Clone)]
458#[repr(C, packed)]
459pub struct hisdshdr16 {
460 pub len: uint16_t,
461 pub alloc: uint16_t,
462 pub flags: libc::c_uchar,
463 pub buf: [libc::c_char; 0],
464}
465#[derive(Copy, Clone)]
466#[repr(C, packed)]
467pub struct hisdshdr32 {
468 pub len: uint32_t,
469 pub alloc: uint32_t,
470 pub flags: libc::c_uchar,
471 pub buf: [libc::c_char; 0],
472}
473#[derive(Copy, Clone)]
474#[repr(C, packed)]
475pub struct hisdshdr64 {
476 pub len: uint64_t,
477 pub alloc: uint64_t,
478 pub flags: libc::c_uchar,
479 pub buf: [libc::c_char; 0],
480}
481#[derive(Copy, Clone)]
482#[repr(C)]
483pub struct redisContext {
484 pub funcs: *const redisContextFuncs,
485 pub err: libc::c_int,
486 pub errstr: [libc::c_char; 128],
487 pub fd: redisFD,
488 pub flags: libc::c_int,
489 pub obuf: *mut libc::c_char,
490 pub reader: *mut redisReader,
491 pub connection_type: redisConnectionType,
492 pub connect_timeout: *mut timeval,
493 pub command_timeout: *mut timeval,
494 pub tcp: C2RustUnnamed_1,
495 pub unix_sock: C2RustUnnamed_0,
496 pub saddr: *mut sockaddr,
497 pub addrlen: size_t,
498 pub privdata: *mut libc::c_void,
499 pub free_privdata: Option::<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
500 pub privctx: *mut libc::c_void,
501 pub push_cb: Option::<redisPushFn>,
502}
503pub type redisPushFn = unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_void) -> ();
504#[derive(Copy, Clone)]
505#[repr(C)]
506pub struct C2RustUnnamed_0 {
507 pub path: *mut libc::c_char,
508}
509#[derive(Copy, Clone)]
510#[repr(C)]
511pub struct C2RustUnnamed_1 {
512 pub host: *mut libc::c_char,
513 pub source_addr: *mut libc::c_char,
514 pub port: libc::c_int,
515}
516pub type redisConnectionType = libc::c_uint;
517pub const REDIS_CONN_USERFD: redisConnectionType = 2;
518pub const REDIS_CONN_UNIX: redisConnectionType = 1;
519pub const REDIS_CONN_TCP: redisConnectionType = 0;
520pub type redisFD = libc::c_int;
521#[derive(Copy, Clone)]
522#[repr(C)]
523pub struct redisContextFuncs {
524 pub free_privctx: Option::<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
525 pub async_read: Option::<unsafe extern "C" fn(*mut redisAsyncContext) -> ()>,
526 pub async_write: Option::<unsafe extern "C" fn(*mut redisAsyncContext) -> ()>,
527 pub read: Option::<
528 unsafe extern "C" fn(*mut redisContext, *mut libc::c_char, size_t) -> ssize_t,
529 >,
530 pub write: Option::<unsafe extern "C" fn(*mut redisContext) -> ssize_t>,
531}
532#[derive(Copy, Clone)]
533#[repr(C)]
534pub struct redisReply {
535 pub type_0: libc::c_int,
536 pub integer: libc::c_longlong,
537 pub dval: libc::c_double,
538 pub len: size_t,
539 pub str_0: *mut libc::c_char,
540 pub vtype: [libc::c_char; 4],
541 pub elements: size_t,
542 pub element: *mut *mut redisReply,
543}
544#[derive(Copy, Clone)]
545#[repr(C)]
546pub struct dictEntry {
547 pub key: *mut libc::c_void,
548 pub v: C2RustUnnamed_2,
549 pub next: *mut dictEntry,
550 pub metadata: [*mut libc::c_void; 0],
551}
552#[derive(Copy, Clone)]
553#[repr(C)]
554pub union C2RustUnnamed_2 {
555 pub val: *mut libc::c_void,
556 pub u64_0: uint64_t,
557 pub s64: int64_t,
558 pub d: libc::c_double,
559}
560#[derive(Copy, Clone)]
561#[repr(C)]
562pub struct dict {
563 pub type_0: *mut dictType,
564 pub ht_table: [*mut *mut dictEntry; 2],
565 pub ht_used: [libc::c_ulong; 2],
566 pub rehashidx: libc::c_long,
567 pub pauserehash: int16_t,
568 pub ht_size_exp: [libc::c_schar; 2],
569}
570#[derive(Copy, Clone)]
571#[repr(C)]
572pub struct dictType {
573 pub hashFunction: Option::<unsafe extern "C" fn(*const libc::c_void) -> uint64_t>,
574 pub keyDup: Option::<
575 unsafe extern "C" fn(*mut dict, *const libc::c_void) -> *mut libc::c_void,
576 >,
577 pub valDup: Option::<
578 unsafe extern "C" fn(*mut dict, *const libc::c_void) -> *mut libc::c_void,
579 >,
580 pub keyCompare: Option::<
581 unsafe extern "C" fn(
582 *mut dict,
583 *const libc::c_void,
584 *const libc::c_void,
585 ) -> libc::c_int,
586 >,
587 pub keyDestructor: Option::<
588 unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
589 >,
590 pub valDestructor: Option::<
591 unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
592 >,
593 pub expandAllowed: Option::<
594 unsafe extern "C" fn(size_t, libc::c_double) -> libc::c_int,
595 >,
596 pub dictEntryMetadataBytes: Option::<unsafe extern "C" fn(*mut dict) -> size_t>,
597}
598#[derive(Copy, Clone)]
599#[repr(C)]
600pub struct dictIterator {
601 pub d: *mut dict,
602 pub index: libc::c_long,
603 pub table: libc::c_int,
604 pub safe: libc::c_int,
605 pub entry: *mut dictEntry,
606 pub nextEntry: *mut dictEntry,
607 pub fingerprint: libc::c_ulonglong,
608}
609#[derive(Copy, Clone)]
610#[repr(C)]
611pub struct listNode {
612 pub prev: *mut listNode,
613 pub next: *mut listNode,
614 pub value: *mut libc::c_void,
615}
616#[derive(Copy, Clone)]
617#[repr(C)]
618pub struct listIter {
619 pub next: *mut listNode,
620 pub direction: libc::c_int,
621}
622#[derive(Copy, Clone)]
623#[repr(C)]
624pub struct list {
625 pub head: *mut listNode,
626 pub tail: *mut listNode,
627 pub dup: Option::<unsafe extern "C" fn(*mut libc::c_void) -> *mut libc::c_void>,
628 pub free: Option::<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
629 pub match_0: Option::<
630 unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_void) -> libc::c_int,
631 >,
632 pub len: libc::c_ulong,
633}
634#[derive(Copy, Clone)]
635#[repr(C)]
636pub struct linenoiseCompletions {
637 pub len: size_t,
638 pub cvec: *mut *mut libc::c_char,
639}
640pub type linenoiseCompletionCallback = unsafe extern "C" fn(
641 *const libc::c_char,
642 *mut linenoiseCompletions,
643) -> ();
644pub type linenoiseHintsCallback = unsafe extern "C" fn(
645 *const libc::c_char,
646 *mut libc::c_int,
647 *mut libc::c_int,
648) -> *mut libc::c_char;
649pub type linenoiseFreeHintsCallback = unsafe extern "C" fn(*mut libc::c_void) -> ();
650#[derive(Copy, Clone)]
651#[repr(C)]
652pub struct commandHelp {
653 pub name: *mut libc::c_char,
654 pub params: *mut libc::c_char,
655 pub summary: *mut libc::c_char,
656 pub group: libc::c_int,
657 pub since: *mut libc::c_char,
658}
659#[derive(Copy, Clone)]
660#[repr(C)]
661pub struct cliSSLconfig {
662 pub sni: *mut libc::c_char,
663 pub cacert: *mut libc::c_char,
664 pub cacertdir: *mut libc::c_char,
665 pub skip_cert_verify: libc::c_int,
666 pub cert: *mut libc::c_char,
667 pub key: *mut libc::c_char,
668 pub ciphers: *mut libc::c_char,
669 pub ciphersuites: *mut libc::c_char,
670}
671#[derive(Copy, Clone)]
672#[repr(C)]
673pub struct cliConnInfo {
674 pub hostip: *mut libc::c_char,
675 pub hostport: libc::c_int,
676 pub input_dbnum: libc::c_int,
677 pub auth: *mut libc::c_char,
678 pub user: *mut libc::c_char,
679}
680#[derive(Copy, Clone)]
681#[repr(C)]
682pub struct commandDocs {
683 pub name: *mut libc::c_char,
684 pub params: *mut libc::c_char,
685 pub summary: *mut libc::c_char,
686 pub group: *mut libc::c_char,
687 pub since: *mut libc::c_char,
688}
689#[derive(Copy, Clone)]
690#[repr(C)]
691pub struct clusterManagerCommand {
692 pub name: *mut libc::c_char,
693 pub argc: libc::c_int,
694 pub argv: *mut *mut libc::c_char,
695 pub stdin_arg: hisds,
696 pub flags: libc::c_int,
697 pub replicas: libc::c_int,
698 pub from: *mut libc::c_char,
699 pub to: *mut libc::c_char,
700 pub weight: *mut *mut libc::c_char,
701 pub weight_argc: libc::c_int,
702 pub master_id: *mut libc::c_char,
703 pub slots: libc::c_int,
704 pub timeout: libc::c_int,
705 pub pipeline: libc::c_int,
706 pub threshold: libc::c_float,
707 pub backup_dir: *mut libc::c_char,
708 pub from_user: *mut libc::c_char,
709 pub from_pass: *mut libc::c_char,
710 pub from_askpass: libc::c_int,
711}
712#[derive(Copy, Clone)]
713#[repr(C)]
714pub struct config {
715 pub conn_info: cliConnInfo,
716 pub hostsocket: *mut libc::c_char,
717 pub tls: libc::c_int,
718 pub sslconfig: cliSSLconfig,
719 pub repeat: libc::c_long,
720 pub interval: libc::c_long,
721 pub dbnum: libc::c_int,
722 pub interactive: libc::c_int,
723 pub shutdown: libc::c_int,
724 pub monitor_mode: libc::c_int,
725 pub pubsub_mode: libc::c_int,
726 pub blocking_state_aborted: libc::c_int,
727 pub latency_mode: libc::c_int,
728 pub latency_dist_mode: libc::c_int,
729 pub latency_history: libc::c_int,
730 pub lru_test_mode: libc::c_int,
731 pub lru_test_sample_size: libc::c_longlong,
732 pub cluster_mode: libc::c_int,
733 pub cluster_reissue_command: libc::c_int,
734 pub cluster_send_asking: libc::c_int,
735 pub slave_mode: libc::c_int,
736 pub pipe_mode: libc::c_int,
737 pub pipe_timeout: libc::c_int,
738 pub getrdb_mode: libc::c_int,
739 pub get_functions_rdb_mode: libc::c_int,
740 pub stat_mode: libc::c_int,
741 pub scan_mode: libc::c_int,
742 pub intrinsic_latency_mode: libc::c_int,
743 pub intrinsic_latency_duration: libc::c_int,
744 pub pattern: hisds,
745 pub rdb_filename: *mut libc::c_char,
746 pub bigkeys: libc::c_int,
747 pub memkeys: libc::c_int,
748 pub memkeys_samples: libc::c_uint,
749 pub hotkeys: libc::c_int,
750 pub stdin_lastarg: libc::c_int,
751 pub stdin_tag_arg: libc::c_int,
752 pub stdin_tag_name: *mut libc::c_char,
753 pub askpass: libc::c_int,
754 pub quoted_input: libc::c_int,
755 pub output: libc::c_int,
756 pub push_output: libc::c_int,
757 pub mb_delim: hisds,
758 pub cmd_delim: hisds,
759 pub prompt: [libc::c_char; 128],
760 pub eval: *mut libc::c_char,
761 pub eval_ldb: libc::c_int,
762 pub eval_ldb_sync: libc::c_int,
763 pub eval_ldb_end: libc::c_int,
764 pub enable_ldb_on_eval: libc::c_int,
765 pub last_cmd_type: libc::c_int,
766 pub verbose: libc::c_int,
767 pub set_errcode: libc::c_int,
768 pub cluster_manager_command: clusterManagerCommand,
769 pub no_auth_warning: libc::c_int,
770 pub resp2: libc::c_int,
771 pub resp3: libc::c_int,
772 pub in_multi: libc::c_int,
773 pub pre_multi_dbnum: libc::c_int,
774}
775#[derive(Copy, Clone)]
776#[repr(C)]
777pub struct pref {
778 pub hints: libc::c_int,
779}
780#[derive(Copy, Clone)]
781#[repr(C)]
782pub struct helpEntry {
783 pub type_0: libc::c_int,
784 pub argc: libc::c_int,
785 pub argv: *mut hisds,
786 pub full: hisds,
787 pub org: commandDocs,
788}
789#[derive(Copy, Clone)]
790#[repr(C)]
791pub struct clusterManager {
792 pub nodes: *mut list,
793 pub errors: *mut list,
794 pub unreachable_masters: libc::c_int,
795}
796#[derive(Copy, Clone)]
797#[repr(C)]
798pub struct clusterManagerNode {
799 pub context: *mut redisContext,
800 pub name: hisds,
801 pub ip: *mut libc::c_char,
802 pub port: libc::c_int,
803 pub bus_port: libc::c_int,
804 pub current_epoch: uint64_t,
805 pub ping_sent: time_t,
806 pub ping_recv: time_t,
807 pub flags: libc::c_int,
808 pub flags_str: *mut list,
809 pub replicate: hisds,
810 pub dirty: libc::c_int,
811 pub slots: [uint8_t; 16384],
812 pub slots_count: libc::c_int,
813 pub replicas_count: libc::c_int,
814 pub friends: *mut list,
815 pub migrating: *mut hisds,
816 pub importing: *mut hisds,
817 pub migrating_count: libc::c_int,
818 pub importing_count: libc::c_int,
819 pub weight: libc::c_float,
820 pub balance: libc::c_int,
821}
822#[derive(Copy, Clone)]
823#[repr(C)]
824pub struct clusterManagerNodeArray {
825 pub nodes: *mut *mut clusterManagerNode,
826 pub alloc: *mut *mut clusterManagerNode,
827 pub len: libc::c_int,
828 pub count: libc::c_int,
829}
830#[derive(Copy, Clone)]
831#[repr(C)]
832pub struct clusterManagerReshardTableItem {
833 pub source: *mut clusterManagerNode,
834 pub slot: libc::c_int,
835}
836#[derive(Copy, Clone)]
837#[repr(C)]
838pub struct clusterManagerLink {
839 pub node_name: hisds,
840 pub node_addr: hisds,
841 pub connected: libc::c_int,
842 pub handshaking: libc::c_int,
843}
844pub type clusterManagerCommandProc = unsafe extern "C" fn(
845 libc::c_int,
846 *mut *mut libc::c_char,
847) -> libc::c_int;
848pub type clusterManagerOnReplyError = Option::<
849 unsafe extern "C" fn(
850 *mut redisReply,
851 *mut clusterManagerNode,
852 libc::c_int,
853 ) -> libc::c_int,
854>;
855#[derive(Copy, Clone)]
856#[repr(C)]
857pub struct clusterManagerOptionDef {
858 pub name: *mut libc::c_char,
859 pub desc: *mut libc::c_char,
860}
861#[derive(Copy, Clone)]
862#[repr(C)]
863pub struct clusterManagerCommandDef {
864 pub name: *mut libc::c_char,
865 pub proc_0: Option::<clusterManagerCommandProc>,
866 pub arity: libc::c_int,
867 pub args: *mut libc::c_char,
868 pub options: *mut libc::c_char,
869}
870#[derive(Copy, Clone)]
871#[repr(C)]
872pub struct distsamples {
873 pub max: libc::c_longlong,
874 pub count: libc::c_longlong,
875 pub character: libc::c_int,
876}
877#[derive(Copy, Clone)]
878#[repr(C)]
879pub struct typeinfo {
880 pub name: *mut libc::c_char,
881 pub sizecmd: *mut libc::c_char,
882 pub sizeunit: *mut libc::c_char,
883 pub biggest: libc::c_ulonglong,
884 pub count: libc::c_ulonglong,
885 pub totalsize: libc::c_ulonglong,
886 pub biggest_key: hisds,
887}
888#[inline]
889unsafe extern "C" fn vprintf(
890 mut __fmt: *const libc::c_char,
891 mut __arg: core::ffi::VaList,
892) -> libc::c_int {
893 return vfprintf(stdout, __fmt, __arg.as_va_list());
894}
895#[inline]
896unsafe extern "C" fn getchar() -> libc::c_int {
897 return getc(stdin);
898}
899#[inline]
900unsafe extern "C" fn atof(mut __nptr: *const libc::c_char) -> libc::c_double {
901 return strtod(__nptr, 0 as *mut libc::c_void as *mut *mut libc::c_char);
902}
903#[inline]
904unsafe extern "C" fn atoi(mut __nptr: *const libc::c_char) -> libc::c_int {
905 return strtol(
906 __nptr,
907 0 as *mut libc::c_void as *mut *mut libc::c_char,
908 10 as libc::c_int,
909 ) as libc::c_int;
910}
911#[inline]
912unsafe extern "C" fn atoll(mut __nptr: *const libc::c_char) -> libc::c_longlong {
913 return strtoll(
914 __nptr,
915 0 as *mut libc::c_void as *mut *mut libc::c_char,
916 10 as libc::c_int,
917 );
918}
919#[inline]
920unsafe extern "C" fn hi_sdslen(s: hisds) -> size_t {
921 let mut flags: libc::c_uchar = *s.offset(-(1 as libc::c_int) as isize)
922 as libc::c_uchar;
923 match flags as libc::c_int & 7 as libc::c_int {
924 0 => return (flags as libc::c_int >> 3 as libc::c_int) as size_t,
925 1 => {
926 return (*(s
927 .offset(-(core::mem::size_of::<hisdshdr8>() as libc::c_ulong as isize))
928 as *mut hisdshdr8))
929 .len as size_t;
930 }
931 2 => {
932 return (*(s
933 .offset(
934 -(core::mem::size_of::<hisdshdr16>() as libc::c_ulong as isize),
935 ) as *mut hisdshdr16))
936 .len as size_t;
937 }
938 3 => {
939 return (*(s
940 .offset(
941 -(core::mem::size_of::<hisdshdr32>() as libc::c_ulong as isize),
942 ) as *mut hisdshdr32))
943 .len as size_t;
944 }
945 4 => {
946 return (*(s
947 .offset(
948 -(core::mem::size_of::<hisdshdr64>() as libc::c_ulong as isize),
949 ) as *mut hisdshdr64))
950 .len;
951 }
952 _ => {}
953 }
954 return 0 as libc::c_int as size_t;
955}
956static mut commandGroups: [*mut libc::c_char; 16] = [
957 b"generic\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
958 b"string\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
959 b"list\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
960 b"set\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
961 b"sorted-set\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
962 b"hash\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
963 b"pubsub\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
964 b"transactions\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
965 b"connection\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
966 b"server\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
967 b"scripting\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
968 b"hyperloglog\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
969 b"cluster\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
970 b"geo\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
971 b"stream\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
972 b"bitmap\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
973];
974#[no_mangle]
975pub static mut commandHelp: [commandHelp; 366] = [
976 {
977 let mut init = commandHelp {
978 name: b"ACL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
979 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
980 summary: b"A container for Access List Control commands \0" as *const u8
981 as *const libc::c_char as *mut libc::c_char,
982 group: 9 as libc::c_int,
983 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
984 };
985 init
986 },
987 {
988 let mut init = commandHelp {
989 name: b"ACL CAT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
990 params: b"[categoryname]\0" as *const u8 as *const libc::c_char
991 as *mut libc::c_char,
992 summary: b"List the ACL categories or the commands inside a category\0"
993 as *const u8 as *const libc::c_char as *mut libc::c_char,
994 group: 9 as libc::c_int,
995 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
996 };
997 init
998 },
999 {
1000 let mut init = commandHelp {
1001 name: b"ACL DELUSER\0" as *const u8 as *const libc::c_char
1002 as *mut libc::c_char,
1003 params: b"username [username ...]\0" as *const u8 as *const libc::c_char
1004 as *mut libc::c_char,
1005 summary: b"Remove the specified ACL users and the associated rules\0"
1006 as *const u8 as *const libc::c_char as *mut libc::c_char,
1007 group: 9 as libc::c_int,
1008 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1009 };
1010 init
1011 },
1012 {
1013 let mut init = commandHelp {
1014 name: b"ACL DRYRUN\0" as *const u8 as *const libc::c_char
1015 as *mut libc::c_char,
1016 params: b"username command [arg [arg ...]]\0" as *const u8
1017 as *const libc::c_char as *mut libc::c_char,
1018 summary: b"Returns whether the user can execute the given command without executing the command.\0"
1019 as *const u8 as *const libc::c_char as *mut libc::c_char,
1020 group: 9 as libc::c_int,
1021 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1022 };
1023 init
1024 },
1025 {
1026 let mut init = commandHelp {
1027 name: b"ACL GENPASS\0" as *const u8 as *const libc::c_char
1028 as *mut libc::c_char,
1029 params: b"[bits]\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1030 summary: b"Generate a pseudorandom secure password to use for ACL users\0"
1031 as *const u8 as *const libc::c_char as *mut libc::c_char,
1032 group: 9 as libc::c_int,
1033 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1034 };
1035 init
1036 },
1037 {
1038 let mut init = commandHelp {
1039 name: b"ACL GETUSER\0" as *const u8 as *const libc::c_char
1040 as *mut libc::c_char,
1041 params: b"username\0" as *const u8 as *const libc::c_char
1042 as *mut libc::c_char,
1043 summary: b"Get the rules for a specific ACL user\0" as *const u8
1044 as *const libc::c_char as *mut libc::c_char,
1045 group: 9 as libc::c_int,
1046 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1047 };
1048 init
1049 },
1050 {
1051 let mut init = commandHelp {
1052 name: b"ACL HELP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1053 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1054 summary: b"Show helpful text about the different subcommands\0" as *const u8
1055 as *const libc::c_char as *mut libc::c_char,
1056 group: 9 as libc::c_int,
1057 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1058 };
1059 init
1060 },
1061 {
1062 let mut init = commandHelp {
1063 name: b"ACL LIST\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1064 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1065 summary: b"List the current ACL rules in ACL config file format\0"
1066 as *const u8 as *const libc::c_char as *mut libc::c_char,
1067 group: 9 as libc::c_int,
1068 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1069 };
1070 init
1071 },
1072 {
1073 let mut init = commandHelp {
1074 name: b"ACL LOAD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1075 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1076 summary: b"Reload the ACLs from the configured ACL file\0" as *const u8
1077 as *const libc::c_char as *mut libc::c_char,
1078 group: 9 as libc::c_int,
1079 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1080 };
1081 init
1082 },
1083 {
1084 let mut init = commandHelp {
1085 name: b"ACL LOG\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1086 params: b"[count|RESET]\0" as *const u8 as *const libc::c_char
1087 as *mut libc::c_char,
1088 summary: b"List latest events denied because of ACLs in place\0" as *const u8
1089 as *const libc::c_char as *mut libc::c_char,
1090 group: 9 as libc::c_int,
1091 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1092 };
1093 init
1094 },
1095 {
1096 let mut init = commandHelp {
1097 name: b"ACL SAVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1098 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1099 summary: b"Save the current ACL rules in the configured ACL file\0"
1100 as *const u8 as *const libc::c_char as *mut libc::c_char,
1101 group: 9 as libc::c_int,
1102 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1103 };
1104 init
1105 },
1106 {
1107 let mut init = commandHelp {
1108 name: b"ACL SETUSER\0" as *const u8 as *const libc::c_char
1109 as *mut libc::c_char,
1110 params: b"username [rule [rule ...]]\0" as *const u8 as *const libc::c_char
1111 as *mut libc::c_char,
1112 summary: b"Modify or create the rules for a specific ACL user\0" as *const u8
1113 as *const libc::c_char as *mut libc::c_char,
1114 group: 9 as libc::c_int,
1115 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1116 };
1117 init
1118 },
1119 {
1120 let mut init = commandHelp {
1121 name: b"ACL USERS\0" as *const u8 as *const libc::c_char
1122 as *mut libc::c_char,
1123 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1124 summary: b"List the username of all the configured ACL rules\0" as *const u8
1125 as *const libc::c_char as *mut libc::c_char,
1126 group: 9 as libc::c_int,
1127 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1128 };
1129 init
1130 },
1131 {
1132 let mut init = commandHelp {
1133 name: b"ACL WHOAMI\0" as *const u8 as *const libc::c_char
1134 as *mut libc::c_char,
1135 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1136 summary: b"Return the name of the user associated to the current connection\0"
1137 as *const u8 as *const libc::c_char as *mut libc::c_char,
1138 group: 9 as libc::c_int,
1139 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1140 };
1141 init
1142 },
1143 {
1144 let mut init = commandHelp {
1145 name: b"APPEND\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1146 params: b"key value\0" as *const u8 as *const libc::c_char
1147 as *mut libc::c_char,
1148 summary: b"Append a value to a key\0" as *const u8 as *const libc::c_char
1149 as *mut libc::c_char,
1150 group: 1 as libc::c_int,
1151 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1152 };
1153 init
1154 },
1155 {
1156 let mut init = commandHelp {
1157 name: b"ASKING\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1158 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1159 summary: b"Sent by cluster clients after an -ASK redirect\0" as *const u8
1160 as *const libc::c_char as *mut libc::c_char,
1161 group: 12 as libc::c_int,
1162 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1163 };
1164 init
1165 },
1166 {
1167 let mut init = commandHelp {
1168 name: b"AUTH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1169 params: b"[username] password\0" as *const u8 as *const libc::c_char
1170 as *mut libc::c_char,
1171 summary: b"Authenticate to the server\0" as *const u8 as *const libc::c_char
1172 as *mut libc::c_char,
1173 group: 8 as libc::c_int,
1174 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1175 };
1176 init
1177 },
1178 {
1179 let mut init = commandHelp {
1180 name: b"BGREWRITEAOF\0" as *const u8 as *const libc::c_char
1181 as *mut libc::c_char,
1182 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1183 summary: b"Asynchronously rewrite the append-only file\0" as *const u8
1184 as *const libc::c_char as *mut libc::c_char,
1185 group: 9 as libc::c_int,
1186 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1187 };
1188 init
1189 },
1190 {
1191 let mut init = commandHelp {
1192 name: b"BGSAVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1193 params: b"[SCHEDULE]\0" as *const u8 as *const libc::c_char
1194 as *mut libc::c_char,
1195 summary: b"Asynchronously save the dataset to disk\0" as *const u8
1196 as *const libc::c_char as *mut libc::c_char,
1197 group: 9 as libc::c_int,
1198 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1199 };
1200 init
1201 },
1202 {
1203 let mut init = commandHelp {
1204 name: b"BITCOUNT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1205 params: b"key [start end [BYTE|BIT]]\0" as *const u8 as *const libc::c_char
1206 as *mut libc::c_char,
1207 summary: b"Count set bits in a string\0" as *const u8 as *const libc::c_char
1208 as *mut libc::c_char,
1209 group: 15 as libc::c_int,
1210 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1211 };
1212 init
1213 },
1214 {
1215 let mut init = commandHelp {
1216 name: b"BITFIELD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1217 params: b"key GET encoding offset|[OVERFLOW WRAP|SAT|FAIL] SET encoding offset value|INCRBY encoding offset increment [GET encoding offset|[OVERFLOW WRAP|SAT|FAIL] SET encoding offset value|INCRBY encoding offset increment ...]\0"
1218 as *const u8 as *const libc::c_char as *mut libc::c_char,
1219 summary: b"Perform arbitrary bitfield integer operations on strings\0"
1220 as *const u8 as *const libc::c_char as *mut libc::c_char,
1221 group: 15 as libc::c_int,
1222 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1223 };
1224 init
1225 },
1226 {
1227 let mut init = commandHelp {
1228 name: b"BITFIELD_RO\0" as *const u8 as *const libc::c_char
1229 as *mut libc::c_char,
1230 params: b"key GET encoding offset [GET encoding offset ...]\0" as *const u8
1231 as *const libc::c_char as *mut libc::c_char,
1232 summary: b"Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD\0"
1233 as *const u8 as *const libc::c_char as *mut libc::c_char,
1234 group: 15 as libc::c_int,
1235 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1236 };
1237 init
1238 },
1239 {
1240 let mut init = commandHelp {
1241 name: b"BITOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1242 params: b"operation destkey key [key ...]\0" as *const u8
1243 as *const libc::c_char as *mut libc::c_char,
1244 summary: b"Perform bitwise operations between strings\0" as *const u8
1245 as *const libc::c_char as *mut libc::c_char,
1246 group: 15 as libc::c_int,
1247 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1248 };
1249 init
1250 },
1251 {
1252 let mut init = commandHelp {
1253 name: b"BITPOS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1254 params: b"key bit [start [end [BYTE|BIT]]]\0" as *const u8
1255 as *const libc::c_char as *mut libc::c_char,
1256 summary: b"Find first bit set or clear in a string\0" as *const u8
1257 as *const libc::c_char as *mut libc::c_char,
1258 group: 15 as libc::c_int,
1259 since: b"2.8.7\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1260 };
1261 init
1262 },
1263 {
1264 let mut init = commandHelp {
1265 name: b"BLMOVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1266 params: b"source destination LEFT|RIGHT LEFT|RIGHT timeout\0" as *const u8
1267 as *const libc::c_char as *mut libc::c_char,
1268 summary: b"Pop an element from a list, push it to another list and return it; or block until one is available\0"
1269 as *const u8 as *const libc::c_char as *mut libc::c_char,
1270 group: 2 as libc::c_int,
1271 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1272 };
1273 init
1274 },
1275 {
1276 let mut init = commandHelp {
1277 name: b"BLMPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1278 params: b"timeout numkeys key [key ...] LEFT|RIGHT [COUNT count]\0"
1279 as *const u8 as *const libc::c_char as *mut libc::c_char,
1280 summary: b"Pop elements from a list, or block until one is available\0"
1281 as *const u8 as *const libc::c_char as *mut libc::c_char,
1282 group: 2 as libc::c_int,
1283 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1284 };
1285 init
1286 },
1287 {
1288 let mut init = commandHelp {
1289 name: b"BLPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1290 params: b"key [key ...] timeout\0" as *const u8 as *const libc::c_char
1291 as *mut libc::c_char,
1292 summary: b"Remove and get the first element in a list, or block until one is available\0"
1293 as *const u8 as *const libc::c_char as *mut libc::c_char,
1294 group: 2 as libc::c_int,
1295 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1296 };
1297 init
1298 },
1299 {
1300 let mut init = commandHelp {
1301 name: b"BRPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1302 params: b"key [key ...] timeout\0" as *const u8 as *const libc::c_char
1303 as *mut libc::c_char,
1304 summary: b"Remove and get the last element in a list, or block until one is available\0"
1305 as *const u8 as *const libc::c_char as *mut libc::c_char,
1306 group: 2 as libc::c_int,
1307 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1308 };
1309 init
1310 },
1311 {
1312 let mut init = commandHelp {
1313 name: b"BRPOPLPUSH\0" as *const u8 as *const libc::c_char
1314 as *mut libc::c_char,
1315 params: b"source destination timeout\0" as *const u8 as *const libc::c_char
1316 as *mut libc::c_char,
1317 summary: b"Pop an element from a list, push it to another list and return it; or block until one is available\0"
1318 as *const u8 as *const libc::c_char as *mut libc::c_char,
1319 group: 2 as libc::c_int,
1320 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1321 };
1322 init
1323 },
1324 {
1325 let mut init = commandHelp {
1326 name: b"BZMPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1327 params: b"timeout numkeys key [key ...] MIN|MAX [COUNT count]\0" as *const u8
1328 as *const libc::c_char as *mut libc::c_char,
1329 summary: b"Remove and return members with scores in a sorted set or block until one is available\0"
1330 as *const u8 as *const libc::c_char as *mut libc::c_char,
1331 group: 4 as libc::c_int,
1332 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1333 };
1334 init
1335 },
1336 {
1337 let mut init = commandHelp {
1338 name: b"BZPOPMAX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1339 params: b"key [key ...] timeout\0" as *const u8 as *const libc::c_char
1340 as *mut libc::c_char,
1341 summary: b"Remove and return the member with the highest score from one or more sorted sets, or block until one is available\0"
1342 as *const u8 as *const libc::c_char as *mut libc::c_char,
1343 group: 4 as libc::c_int,
1344 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1345 };
1346 init
1347 },
1348 {
1349 let mut init = commandHelp {
1350 name: b"BZPOPMIN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1351 params: b"key [key ...] timeout\0" as *const u8 as *const libc::c_char
1352 as *mut libc::c_char,
1353 summary: b"Remove and return the member with the lowest score from one or more sorted sets, or block until one is available\0"
1354 as *const u8 as *const libc::c_char as *mut libc::c_char,
1355 group: 4 as libc::c_int,
1356 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1357 };
1358 init
1359 },
1360 {
1361 let mut init = commandHelp {
1362 name: b"CLIENT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1363 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1364 summary: b"A container for client connection commands\0" as *const u8
1365 as *const libc::c_char as *mut libc::c_char,
1366 group: 8 as libc::c_int,
1367 since: b"2.4.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1368 };
1369 init
1370 },
1371 {
1372 let mut init = commandHelp {
1373 name: b"CLIENT CACHING\0" as *const u8 as *const libc::c_char
1374 as *mut libc::c_char,
1375 params: b"YES|NO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1376 summary: b"Instruct the server about tracking or not keys in the next request\0"
1377 as *const u8 as *const libc::c_char as *mut libc::c_char,
1378 group: 8 as libc::c_int,
1379 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1380 };
1381 init
1382 },
1383 {
1384 let mut init = commandHelp {
1385 name: b"CLIENT GETNAME\0" as *const u8 as *const libc::c_char
1386 as *mut libc::c_char,
1387 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1388 summary: b"Get the current connection name\0" as *const u8
1389 as *const libc::c_char as *mut libc::c_char,
1390 group: 8 as libc::c_int,
1391 since: b"2.6.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1392 };
1393 init
1394 },
1395 {
1396 let mut init = commandHelp {
1397 name: b"CLIENT GETREDIR\0" as *const u8 as *const libc::c_char
1398 as *mut libc::c_char,
1399 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1400 summary: b"Get tracking notifications redirection client ID if any\0"
1401 as *const u8 as *const libc::c_char as *mut libc::c_char,
1402 group: 8 as libc::c_int,
1403 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1404 };
1405 init
1406 },
1407 {
1408 let mut init = commandHelp {
1409 name: b"CLIENT HELP\0" as *const u8 as *const libc::c_char
1410 as *mut libc::c_char,
1411 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1412 summary: b"Show helpful text about the different subcommands\0" as *const u8
1413 as *const libc::c_char as *mut libc::c_char,
1414 group: 8 as libc::c_int,
1415 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1416 };
1417 init
1418 },
1419 {
1420 let mut init = commandHelp {
1421 name: b"CLIENT ID\0" as *const u8 as *const libc::c_char
1422 as *mut libc::c_char,
1423 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1424 summary: b"Returns the client ID for the current connection\0" as *const u8
1425 as *const libc::c_char as *mut libc::c_char,
1426 group: 8 as libc::c_int,
1427 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1428 };
1429 init
1430 },
1431 {
1432 let mut init = commandHelp {
1433 name: b"CLIENT INFO\0" as *const u8 as *const libc::c_char
1434 as *mut libc::c_char,
1435 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1436 summary: b"Returns information about the current client connection.\0"
1437 as *const u8 as *const libc::c_char as *mut libc::c_char,
1438 group: 8 as libc::c_int,
1439 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1440 };
1441 init
1442 },
1443 {
1444 let mut init = commandHelp {
1445 name: b"CLIENT KILL\0" as *const u8 as *const libc::c_char
1446 as *mut libc::c_char,
1447 params: b"ip:port|[ID client-id]|[TYPE NORMAL|MASTER|SLAVE|REPLICA|PUBSUB]|[USER username]|[ADDR ip:port]|[LADDR ip:port]|[SKIPME yes/no] [[ID client-id]|[TYPE NORMAL|MASTER|SLAVE|REPLICA|PUBSUB]|[USER username]|[ADDR ip:port]|[LADDR ip:port]|[SKIPME yes/no] ...]\0"
1448 as *const u8 as *const libc::c_char as *mut libc::c_char,
1449 summary: b"Kill the connection of a client\0" as *const u8
1450 as *const libc::c_char as *mut libc::c_char,
1451 group: 8 as libc::c_int,
1452 since: b"2.4.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1453 };
1454 init
1455 },
1456 {
1457 let mut init = commandHelp {
1458 name: b"CLIENT LIST\0" as *const u8 as *const libc::c_char
1459 as *mut libc::c_char,
1460 params: b"[TYPE NORMAL|MASTER|REPLICA|PUBSUB] [ID client-id [client-id ...]]\0"
1461 as *const u8 as *const libc::c_char as *mut libc::c_char,
1462 summary: b"Get the list of client connections\0" as *const u8
1463 as *const libc::c_char as *mut libc::c_char,
1464 group: 8 as libc::c_int,
1465 since: b"2.4.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1466 };
1467 init
1468 },
1469 {
1470 let mut init = commandHelp {
1471 name: b"CLIENT NO-EVICT\0" as *const u8 as *const libc::c_char
1472 as *mut libc::c_char,
1473 params: b"ON|OFF\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1474 summary: b"Set client eviction mode for the current connection\0"
1475 as *const u8 as *const libc::c_char as *mut libc::c_char,
1476 group: 8 as libc::c_int,
1477 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1478 };
1479 init
1480 },
1481 {
1482 let mut init = commandHelp {
1483 name: b"CLIENT PAUSE\0" as *const u8 as *const libc::c_char
1484 as *mut libc::c_char,
1485 params: b"timeout [WRITE|ALL]\0" as *const u8 as *const libc::c_char
1486 as *mut libc::c_char,
1487 summary: b"Stop processing commands from clients for some time\0"
1488 as *const u8 as *const libc::c_char as *mut libc::c_char,
1489 group: 8 as libc::c_int,
1490 since: b"2.9.50\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1491 };
1492 init
1493 },
1494 {
1495 let mut init = commandHelp {
1496 name: b"CLIENT REPLY\0" as *const u8 as *const libc::c_char
1497 as *mut libc::c_char,
1498 params: b"ON|OFF|SKIP\0" as *const u8 as *const libc::c_char
1499 as *mut libc::c_char,
1500 summary: b"Instruct the server whether to reply to commands\0" as *const u8
1501 as *const libc::c_char as *mut libc::c_char,
1502 group: 8 as libc::c_int,
1503 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1504 };
1505 init
1506 },
1507 {
1508 let mut init = commandHelp {
1509 name: b"CLIENT SETNAME\0" as *const u8 as *const libc::c_char
1510 as *mut libc::c_char,
1511 params: b"connection-name\0" as *const u8 as *const libc::c_char
1512 as *mut libc::c_char,
1513 summary: b"Set the current connection name\0" as *const u8
1514 as *const libc::c_char as *mut libc::c_char,
1515 group: 8 as libc::c_int,
1516 since: b"2.6.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1517 };
1518 init
1519 },
1520 {
1521 let mut init = commandHelp {
1522 name: b"CLIENT TRACKING\0" as *const u8 as *const libc::c_char
1523 as *mut libc::c_char,
1524 params: b"ON|OFF [REDIRECT client-id] [PREFIX prefix [PREFIX prefix ...]] [BCAST] [OPTIN] [OPTOUT] [NOLOOP]\0"
1525 as *const u8 as *const libc::c_char as *mut libc::c_char,
1526 summary: b"Enable or disable server assisted client side caching support\0"
1527 as *const u8 as *const libc::c_char as *mut libc::c_char,
1528 group: 8 as libc::c_int,
1529 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1530 };
1531 init
1532 },
1533 {
1534 let mut init = commandHelp {
1535 name: b"CLIENT TRACKINGINFO\0" as *const u8 as *const libc::c_char
1536 as *mut libc::c_char,
1537 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1538 summary: b"Return information about server assisted client side caching for the current connection\0"
1539 as *const u8 as *const libc::c_char as *mut libc::c_char,
1540 group: 8 as libc::c_int,
1541 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1542 };
1543 init
1544 },
1545 {
1546 let mut init = commandHelp {
1547 name: b"CLIENT UNBLOCK\0" as *const u8 as *const libc::c_char
1548 as *mut libc::c_char,
1549 params: b"client-id [TIMEOUT|ERROR]\0" as *const u8 as *const libc::c_char
1550 as *mut libc::c_char,
1551 summary: b"Unblock a client blocked in a blocking command from a different connection\0"
1552 as *const u8 as *const libc::c_char as *mut libc::c_char,
1553 group: 8 as libc::c_int,
1554 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1555 };
1556 init
1557 },
1558 {
1559 let mut init = commandHelp {
1560 name: b"CLIENT UNPAUSE\0" as *const u8 as *const libc::c_char
1561 as *mut libc::c_char,
1562 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1563 summary: b"Resume processing of clients that were paused\0" as *const u8
1564 as *const libc::c_char as *mut libc::c_char,
1565 group: 8 as libc::c_int,
1566 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1567 };
1568 init
1569 },
1570 {
1571 let mut init = commandHelp {
1572 name: b"CLUSTER\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1573 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1574 summary: b"A container for cluster commands\0" as *const u8
1575 as *const libc::c_char as *mut libc::c_char,
1576 group: 12 as libc::c_int,
1577 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1578 };
1579 init
1580 },
1581 {
1582 let mut init = commandHelp {
1583 name: b"CLUSTER ADDSLOTS\0" as *const u8 as *const libc::c_char
1584 as *mut libc::c_char,
1585 params: b"slot [slot ...]\0" as *const u8 as *const libc::c_char
1586 as *mut libc::c_char,
1587 summary: b"Assign new hash slots to receiving node\0" as *const u8
1588 as *const libc::c_char as *mut libc::c_char,
1589 group: 12 as libc::c_int,
1590 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1591 };
1592 init
1593 },
1594 {
1595 let mut init = commandHelp {
1596 name: b"CLUSTER ADDSLOTSRANGE\0" as *const u8 as *const libc::c_char
1597 as *mut libc::c_char,
1598 params: b"start-slot end-slot [start-slot end-slot ...]\0" as *const u8
1599 as *const libc::c_char as *mut libc::c_char,
1600 summary: b"Assign new hash slots to receiving node\0" as *const u8
1601 as *const libc::c_char as *mut libc::c_char,
1602 group: 12 as libc::c_int,
1603 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1604 };
1605 init
1606 },
1607 {
1608 let mut init = commandHelp {
1609 name: b"CLUSTER BUMPEPOCH\0" as *const u8 as *const libc::c_char
1610 as *mut libc::c_char,
1611 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1612 summary: b"Advance the cluster config epoch\0" as *const u8
1613 as *const libc::c_char as *mut libc::c_char,
1614 group: 12 as libc::c_int,
1615 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1616 };
1617 init
1618 },
1619 {
1620 let mut init = commandHelp {
1621 name: b"CLUSTER COUNT-FAILURE-REPORTS\0" as *const u8 as *const libc::c_char
1622 as *mut libc::c_char,
1623 params: b"node-id\0" as *const u8 as *const libc::c_char
1624 as *mut libc::c_char,
1625 summary: b"Return the number of failure reports active for a given node\0"
1626 as *const u8 as *const libc::c_char as *mut libc::c_char,
1627 group: 12 as libc::c_int,
1628 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1629 };
1630 init
1631 },
1632 {
1633 let mut init = commandHelp {
1634 name: b"CLUSTER COUNTKEYSINSLOT\0" as *const u8 as *const libc::c_char
1635 as *mut libc::c_char,
1636 params: b"slot\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1637 summary: b"Return the number of local keys in the specified hash slot\0"
1638 as *const u8 as *const libc::c_char as *mut libc::c_char,
1639 group: 12 as libc::c_int,
1640 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1641 };
1642 init
1643 },
1644 {
1645 let mut init = commandHelp {
1646 name: b"CLUSTER DELSLOTS\0" as *const u8 as *const libc::c_char
1647 as *mut libc::c_char,
1648 params: b"slot [slot ...]\0" as *const u8 as *const libc::c_char
1649 as *mut libc::c_char,
1650 summary: b"Set hash slots as unbound in receiving node\0" as *const u8
1651 as *const libc::c_char as *mut libc::c_char,
1652 group: 12 as libc::c_int,
1653 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1654 };
1655 init
1656 },
1657 {
1658 let mut init = commandHelp {
1659 name: b"CLUSTER DELSLOTSRANGE\0" as *const u8 as *const libc::c_char
1660 as *mut libc::c_char,
1661 params: b"start-slot end-slot [start-slot end-slot ...]\0" as *const u8
1662 as *const libc::c_char as *mut libc::c_char,
1663 summary: b"Set hash slots as unbound in receiving node\0" as *const u8
1664 as *const libc::c_char as *mut libc::c_char,
1665 group: 12 as libc::c_int,
1666 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1667 };
1668 init
1669 },
1670 {
1671 let mut init = commandHelp {
1672 name: b"CLUSTER FAILOVER\0" as *const u8 as *const libc::c_char
1673 as *mut libc::c_char,
1674 params: b"[FORCE|TAKEOVER]\0" as *const u8 as *const libc::c_char
1675 as *mut libc::c_char,
1676 summary: b"Forces a replica to perform a manual failover of its master.\0"
1677 as *const u8 as *const libc::c_char as *mut libc::c_char,
1678 group: 12 as libc::c_int,
1679 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1680 };
1681 init
1682 },
1683 {
1684 let mut init = commandHelp {
1685 name: b"CLUSTER FLUSHSLOTS\0" as *const u8 as *const libc::c_char
1686 as *mut libc::c_char,
1687 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1688 summary: b"Delete a node's own slots information\0" as *const u8
1689 as *const libc::c_char as *mut libc::c_char,
1690 group: 12 as libc::c_int,
1691 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1692 };
1693 init
1694 },
1695 {
1696 let mut init = commandHelp {
1697 name: b"CLUSTER FORGET\0" as *const u8 as *const libc::c_char
1698 as *mut libc::c_char,
1699 params: b"node-id\0" as *const u8 as *const libc::c_char
1700 as *mut libc::c_char,
1701 summary: b"Remove a node from the nodes table\0" as *const u8
1702 as *const libc::c_char as *mut libc::c_char,
1703 group: 12 as libc::c_int,
1704 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1705 };
1706 init
1707 },
1708 {
1709 let mut init = commandHelp {
1710 name: b"CLUSTER GETKEYSINSLOT\0" as *const u8 as *const libc::c_char
1711 as *mut libc::c_char,
1712 params: b"slot count\0" as *const u8 as *const libc::c_char
1713 as *mut libc::c_char,
1714 summary: b"Return local key names in the specified hash slot\0" as *const u8
1715 as *const libc::c_char as *mut libc::c_char,
1716 group: 12 as libc::c_int,
1717 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1718 };
1719 init
1720 },
1721 {
1722 let mut init = commandHelp {
1723 name: b"CLUSTER HELP\0" as *const u8 as *const libc::c_char
1724 as *mut libc::c_char,
1725 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1726 summary: b"Show helpful text about the different subcommands\0" as *const u8
1727 as *const libc::c_char as *mut libc::c_char,
1728 group: 12 as libc::c_int,
1729 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1730 };
1731 init
1732 },
1733 {
1734 let mut init = commandHelp {
1735 name: b"CLUSTER INFO\0" as *const u8 as *const libc::c_char
1736 as *mut libc::c_char,
1737 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1738 summary: b"Provides info about Redis Cluster node state\0" as *const u8
1739 as *const libc::c_char as *mut libc::c_char,
1740 group: 12 as libc::c_int,
1741 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1742 };
1743 init
1744 },
1745 {
1746 let mut init = commandHelp {
1747 name: b"CLUSTER KEYSLOT\0" as *const u8 as *const libc::c_char
1748 as *mut libc::c_char,
1749 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1750 summary: b"Returns the hash slot of the specified key\0" as *const u8
1751 as *const libc::c_char as *mut libc::c_char,
1752 group: 12 as libc::c_int,
1753 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1754 };
1755 init
1756 },
1757 {
1758 let mut init = commandHelp {
1759 name: b"CLUSTER LINKS\0" as *const u8 as *const libc::c_char
1760 as *mut libc::c_char,
1761 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1762 summary: b"Returns a list of all TCP links to and from peer nodes in cluster\0"
1763 as *const u8 as *const libc::c_char as *mut libc::c_char,
1764 group: 12 as libc::c_int,
1765 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1766 };
1767 init
1768 },
1769 {
1770 let mut init = commandHelp {
1771 name: b"CLUSTER MEET\0" as *const u8 as *const libc::c_char
1772 as *mut libc::c_char,
1773 params: b"ip port [cluster_bus_port]\0" as *const u8 as *const libc::c_char
1774 as *mut libc::c_char,
1775 summary: b"Force a node cluster to handshake with another node\0"
1776 as *const u8 as *const libc::c_char as *mut libc::c_char,
1777 group: 12 as libc::c_int,
1778 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1779 };
1780 init
1781 },
1782 {
1783 let mut init = commandHelp {
1784 name: b"CLUSTER MYID\0" as *const u8 as *const libc::c_char
1785 as *mut libc::c_char,
1786 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1787 summary: b"Return the node id\0" as *const u8 as *const libc::c_char
1788 as *mut libc::c_char,
1789 group: 12 as libc::c_int,
1790 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1791 };
1792 init
1793 },
1794 {
1795 let mut init = commandHelp {
1796 name: b"CLUSTER NODES\0" as *const u8 as *const libc::c_char
1797 as *mut libc::c_char,
1798 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1799 summary: b"Get Cluster config for the node\0" as *const u8
1800 as *const libc::c_char as *mut libc::c_char,
1801 group: 12 as libc::c_int,
1802 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1803 };
1804 init
1805 },
1806 {
1807 let mut init = commandHelp {
1808 name: b"CLUSTER REPLICAS\0" as *const u8 as *const libc::c_char
1809 as *mut libc::c_char,
1810 params: b"node-id\0" as *const u8 as *const libc::c_char
1811 as *mut libc::c_char,
1812 summary: b"List replica nodes of the specified master node\0" as *const u8
1813 as *const libc::c_char as *mut libc::c_char,
1814 group: 12 as libc::c_int,
1815 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1816 };
1817 init
1818 },
1819 {
1820 let mut init = commandHelp {
1821 name: b"CLUSTER REPLICATE\0" as *const u8 as *const libc::c_char
1822 as *mut libc::c_char,
1823 params: b"node-id\0" as *const u8 as *const libc::c_char
1824 as *mut libc::c_char,
1825 summary: b"Reconfigure a node as a replica of the specified master node\0"
1826 as *const u8 as *const libc::c_char as *mut libc::c_char,
1827 group: 12 as libc::c_int,
1828 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1829 };
1830 init
1831 },
1832 {
1833 let mut init = commandHelp {
1834 name: b"CLUSTER RESET\0" as *const u8 as *const libc::c_char
1835 as *mut libc::c_char,
1836 params: b"[HARD|SOFT]\0" as *const u8 as *const libc::c_char
1837 as *mut libc::c_char,
1838 summary: b"Reset a Redis Cluster node\0" as *const u8 as *const libc::c_char
1839 as *mut libc::c_char,
1840 group: 12 as libc::c_int,
1841 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1842 };
1843 init
1844 },
1845 {
1846 let mut init = commandHelp {
1847 name: b"CLUSTER SAVECONFIG\0" as *const u8 as *const libc::c_char
1848 as *mut libc::c_char,
1849 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1850 summary: b"Forces the node to save cluster state on disk\0" as *const u8
1851 as *const libc::c_char as *mut libc::c_char,
1852 group: 12 as libc::c_int,
1853 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1854 };
1855 init
1856 },
1857 {
1858 let mut init = commandHelp {
1859 name: b"CLUSTER SET-CONFIG-EPOCH\0" as *const u8 as *const libc::c_char
1860 as *mut libc::c_char,
1861 params: b"config-epoch\0" as *const u8 as *const libc::c_char
1862 as *mut libc::c_char,
1863 summary: b"Set the configuration epoch in a new node\0" as *const u8
1864 as *const libc::c_char as *mut libc::c_char,
1865 group: 12 as libc::c_int,
1866 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1867 };
1868 init
1869 },
1870 {
1871 let mut init = commandHelp {
1872 name: b"CLUSTER SETSLOT\0" as *const u8 as *const libc::c_char
1873 as *mut libc::c_char,
1874 params: b"slot IMPORTING node-id|MIGRATING node-id|NODE node-id|STABLE\0"
1875 as *const u8 as *const libc::c_char as *mut libc::c_char,
1876 summary: b"Bind a hash slot to a specific node\0" as *const u8
1877 as *const libc::c_char as *mut libc::c_char,
1878 group: 12 as libc::c_int,
1879 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1880 };
1881 init
1882 },
1883 {
1884 let mut init = commandHelp {
1885 name: b"CLUSTER SHARDS\0" as *const u8 as *const libc::c_char
1886 as *mut libc::c_char,
1887 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1888 summary: b"Get array of cluster slots to node mappings\0" as *const u8
1889 as *const libc::c_char as *mut libc::c_char,
1890 group: 12 as libc::c_int,
1891 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1892 };
1893 init
1894 },
1895 {
1896 let mut init = commandHelp {
1897 name: b"CLUSTER SLAVES\0" as *const u8 as *const libc::c_char
1898 as *mut libc::c_char,
1899 params: b"node-id\0" as *const u8 as *const libc::c_char
1900 as *mut libc::c_char,
1901 summary: b"List replica nodes of the specified master node\0" as *const u8
1902 as *const libc::c_char as *mut libc::c_char,
1903 group: 12 as libc::c_int,
1904 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1905 };
1906 init
1907 },
1908 {
1909 let mut init = commandHelp {
1910 name: b"CLUSTER SLOTS\0" as *const u8 as *const libc::c_char
1911 as *mut libc::c_char,
1912 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1913 summary: b"Get array of Cluster slot to node mappings\0" as *const u8
1914 as *const libc::c_char as *mut libc::c_char,
1915 group: 12 as libc::c_int,
1916 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1917 };
1918 init
1919 },
1920 {
1921 let mut init = commandHelp {
1922 name: b"COMMAND\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1923 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1924 summary: b"Get array of Redis command details\0" as *const u8
1925 as *const libc::c_char as *mut libc::c_char,
1926 group: 9 as libc::c_int,
1927 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1928 };
1929 init
1930 },
1931 {
1932 let mut init = commandHelp {
1933 name: b"COMMAND COUNT\0" as *const u8 as *const libc::c_char
1934 as *mut libc::c_char,
1935 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1936 summary: b"Get total number of Redis commands\0" as *const u8
1937 as *const libc::c_char as *mut libc::c_char,
1938 group: 9 as libc::c_int,
1939 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1940 };
1941 init
1942 },
1943 {
1944 let mut init = commandHelp {
1945 name: b"COMMAND DOCS\0" as *const u8 as *const libc::c_char
1946 as *mut libc::c_char,
1947 params: b"[command-name [command-name ...]]\0" as *const u8
1948 as *const libc::c_char as *mut libc::c_char,
1949 summary: b"Get array of specific Redis command documentation\0" as *const u8
1950 as *const libc::c_char as *mut libc::c_char,
1951 group: 9 as libc::c_int,
1952 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1953 };
1954 init
1955 },
1956 {
1957 let mut init = commandHelp {
1958 name: b"COMMAND GETKEYS\0" as *const u8 as *const libc::c_char
1959 as *mut libc::c_char,
1960 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1961 summary: b"Extract keys given a full Redis command\0" as *const u8
1962 as *const libc::c_char as *mut libc::c_char,
1963 group: 9 as libc::c_int,
1964 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1965 };
1966 init
1967 },
1968 {
1969 let mut init = commandHelp {
1970 name: b"COMMAND GETKEYSANDFLAGS\0" as *const u8 as *const libc::c_char
1971 as *mut libc::c_char,
1972 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1973 summary: b"Extract keys and access flags given a full Redis command\0"
1974 as *const u8 as *const libc::c_char as *mut libc::c_char,
1975 group: 9 as libc::c_int,
1976 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1977 };
1978 init
1979 },
1980 {
1981 let mut init = commandHelp {
1982 name: b"COMMAND HELP\0" as *const u8 as *const libc::c_char
1983 as *mut libc::c_char,
1984 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1985 summary: b"Show helpful text about the different subcommands\0" as *const u8
1986 as *const libc::c_char as *mut libc::c_char,
1987 group: 9 as libc::c_int,
1988 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
1989 };
1990 init
1991 },
1992 {
1993 let mut init = commandHelp {
1994 name: b"COMMAND INFO\0" as *const u8 as *const libc::c_char
1995 as *mut libc::c_char,
1996 params: b"[command-name [command-name ...]]\0" as *const u8
1997 as *const libc::c_char as *mut libc::c_char,
1998 summary: b"Get array of specific Redis command details, or all when no argument is given.\0"
1999 as *const u8 as *const libc::c_char as *mut libc::c_char,
2000 group: 9 as libc::c_int,
2001 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2002 };
2003 init
2004 },
2005 {
2006 let mut init = commandHelp {
2007 name: b"COMMAND LIST\0" as *const u8 as *const libc::c_char
2008 as *mut libc::c_char,
2009 params: b"[FILTERBY MODULE module-name|ACLCAT category|PATTERN pattern]\0"
2010 as *const u8 as *const libc::c_char as *mut libc::c_char,
2011 summary: b"Get an array of Redis command names\0" as *const u8
2012 as *const libc::c_char as *mut libc::c_char,
2013 group: 9 as libc::c_int,
2014 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2015 };
2016 init
2017 },
2018 {
2019 let mut init = commandHelp {
2020 name: b"CONFIG\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2021 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2022 summary: b"A container for server configuration commands\0" as *const u8
2023 as *const libc::c_char as *mut libc::c_char,
2024 group: 9 as libc::c_int,
2025 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2026 };
2027 init
2028 },
2029 {
2030 let mut init = commandHelp {
2031 name: b"CONFIG GET\0" as *const u8 as *const libc::c_char
2032 as *mut libc::c_char,
2033 params: b"parameter [parameter ...]\0" as *const u8 as *const libc::c_char
2034 as *mut libc::c_char,
2035 summary: b"Get the values of configuration parameters\0" as *const u8
2036 as *const libc::c_char as *mut libc::c_char,
2037 group: 9 as libc::c_int,
2038 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2039 };
2040 init
2041 },
2042 {
2043 let mut init = commandHelp {
2044 name: b"CONFIG HELP\0" as *const u8 as *const libc::c_char
2045 as *mut libc::c_char,
2046 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2047 summary: b"Show helpful text about the different subcommands\0" as *const u8
2048 as *const libc::c_char as *mut libc::c_char,
2049 group: 9 as libc::c_int,
2050 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2051 };
2052 init
2053 },
2054 {
2055 let mut init = commandHelp {
2056 name: b"CONFIG RESETSTAT\0" as *const u8 as *const libc::c_char
2057 as *mut libc::c_char,
2058 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2059 summary: b"Reset the stats returned by INFO\0" as *const u8
2060 as *const libc::c_char as *mut libc::c_char,
2061 group: 9 as libc::c_int,
2062 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2063 };
2064 init
2065 },
2066 {
2067 let mut init = commandHelp {
2068 name: b"CONFIG REWRITE\0" as *const u8 as *const libc::c_char
2069 as *mut libc::c_char,
2070 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2071 summary: b"Rewrite the configuration file with the in memory configuration\0"
2072 as *const u8 as *const libc::c_char as *mut libc::c_char,
2073 group: 9 as libc::c_int,
2074 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2075 };
2076 init
2077 },
2078 {
2079 let mut init = commandHelp {
2080 name: b"CONFIG SET\0" as *const u8 as *const libc::c_char
2081 as *mut libc::c_char,
2082 params: b"parameter value [parameter value ...]\0" as *const u8
2083 as *const libc::c_char as *mut libc::c_char,
2084 summary: b"Set configuration parameters to the given values\0" as *const u8
2085 as *const libc::c_char as *mut libc::c_char,
2086 group: 9 as libc::c_int,
2087 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2088 };
2089 init
2090 },
2091 {
2092 let mut init = commandHelp {
2093 name: b"COPY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2094 params: b"source destination [DB destination-db] [REPLACE]\0" as *const u8
2095 as *const libc::c_char as *mut libc::c_char,
2096 summary: b"Copy a key\0" as *const u8 as *const libc::c_char
2097 as *mut libc::c_char,
2098 group: 0 as libc::c_int,
2099 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2100 };
2101 init
2102 },
2103 {
2104 let mut init = commandHelp {
2105 name: b"DBSIZE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2106 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2107 summary: b"Return the number of keys in the selected database\0" as *const u8
2108 as *const libc::c_char as *mut libc::c_char,
2109 group: 9 as libc::c_int,
2110 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2111 };
2112 init
2113 },
2114 {
2115 let mut init = commandHelp {
2116 name: b"DEBUG\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2117 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2118 summary: b"A container for debugging commands\0" as *const u8
2119 as *const libc::c_char as *mut libc::c_char,
2120 group: 9 as libc::c_int,
2121 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2122 };
2123 init
2124 },
2125 {
2126 let mut init = commandHelp {
2127 name: b"DECR\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2128 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2129 summary: b"Decrement the integer value of a key by one\0" as *const u8
2130 as *const libc::c_char as *mut libc::c_char,
2131 group: 1 as libc::c_int,
2132 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2133 };
2134 init
2135 },
2136 {
2137 let mut init = commandHelp {
2138 name: b"DECRBY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2139 params: b"key decrement\0" as *const u8 as *const libc::c_char
2140 as *mut libc::c_char,
2141 summary: b"Decrement the integer value of a key by the given number\0"
2142 as *const u8 as *const libc::c_char as *mut libc::c_char,
2143 group: 1 as libc::c_int,
2144 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2145 };
2146 init
2147 },
2148 {
2149 let mut init = commandHelp {
2150 name: b"DEL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2151 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
2152 as *mut libc::c_char,
2153 summary: b"Delete a key\0" as *const u8 as *const libc::c_char
2154 as *mut libc::c_char,
2155 group: 0 as libc::c_int,
2156 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2157 };
2158 init
2159 },
2160 {
2161 let mut init = commandHelp {
2162 name: b"DISCARD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2163 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2164 summary: b"Discard all commands issued after MULTI\0" as *const u8
2165 as *const libc::c_char as *mut libc::c_char,
2166 group: 7 as libc::c_int,
2167 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2168 };
2169 init
2170 },
2171 {
2172 let mut init = commandHelp {
2173 name: b"DUMP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2174 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2175 summary: b"Return a serialized version of the value stored at the specified key.\0"
2176 as *const u8 as *const libc::c_char as *mut libc::c_char,
2177 group: 0 as libc::c_int,
2178 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2179 };
2180 init
2181 },
2182 {
2183 let mut init = commandHelp {
2184 name: b"ECHO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2185 params: b"message\0" as *const u8 as *const libc::c_char
2186 as *mut libc::c_char,
2187 summary: b"Echo the given string\0" as *const u8 as *const libc::c_char
2188 as *mut libc::c_char,
2189 group: 8 as libc::c_int,
2190 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2191 };
2192 init
2193 },
2194 {
2195 let mut init = commandHelp {
2196 name: b"EVAL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2197 params: b"script numkeys [key [key ...]] [arg [arg ...]]\0" as *const u8
2198 as *const libc::c_char as *mut libc::c_char,
2199 summary: b"Execute a Lua script server side\0" as *const u8
2200 as *const libc::c_char as *mut libc::c_char,
2201 group: 10 as libc::c_int,
2202 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2203 };
2204 init
2205 },
2206 {
2207 let mut init = commandHelp {
2208 name: b"EVALSHA\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2209 params: b"sha1 numkeys [key [key ...]] [arg [arg ...]]\0" as *const u8
2210 as *const libc::c_char as *mut libc::c_char,
2211 summary: b"Execute a Lua script server side\0" as *const u8
2212 as *const libc::c_char as *mut libc::c_char,
2213 group: 10 as libc::c_int,
2214 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2215 };
2216 init
2217 },
2218 {
2219 let mut init = commandHelp {
2220 name: b"EVALSHA_RO\0" as *const u8 as *const libc::c_char
2221 as *mut libc::c_char,
2222 params: b"sha1 numkeys [key [key ...]] [arg [arg ...]]\0" as *const u8
2223 as *const libc::c_char as *mut libc::c_char,
2224 summary: b"Execute a read-only Lua script server side\0" as *const u8
2225 as *const libc::c_char as *mut libc::c_char,
2226 group: 10 as libc::c_int,
2227 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2228 };
2229 init
2230 },
2231 {
2232 let mut init = commandHelp {
2233 name: b"EVAL_RO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2234 params: b"script numkeys [key [key ...]] [arg [arg ...]]\0" as *const u8
2235 as *const libc::c_char as *mut libc::c_char,
2236 summary: b"Execute a read-only Lua script server side\0" as *const u8
2237 as *const libc::c_char as *mut libc::c_char,
2238 group: 10 as libc::c_int,
2239 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2240 };
2241 init
2242 },
2243 {
2244 let mut init = commandHelp {
2245 name: b"EXEC\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2246 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2247 summary: b"Execute all commands issued after MULTI\0" as *const u8
2248 as *const libc::c_char as *mut libc::c_char,
2249 group: 7 as libc::c_int,
2250 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2251 };
2252 init
2253 },
2254 {
2255 let mut init = commandHelp {
2256 name: b"EXISTS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2257 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
2258 as *mut libc::c_char,
2259 summary: b"Determine if a key exists\0" as *const u8 as *const libc::c_char
2260 as *mut libc::c_char,
2261 group: 0 as libc::c_int,
2262 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2263 };
2264 init
2265 },
2266 {
2267 let mut init = commandHelp {
2268 name: b"EXPIRE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2269 params: b"key seconds [NX|XX|GT|LT]\0" as *const u8 as *const libc::c_char
2270 as *mut libc::c_char,
2271 summary: b"Set a key's time to live in seconds\0" as *const u8
2272 as *const libc::c_char as *mut libc::c_char,
2273 group: 0 as libc::c_int,
2274 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2275 };
2276 init
2277 },
2278 {
2279 let mut init = commandHelp {
2280 name: b"EXPIREAT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2281 params: b"key unix-time-seconds [NX|XX|GT|LT]\0" as *const u8
2282 as *const libc::c_char as *mut libc::c_char,
2283 summary: b"Set the expiration for a key as a UNIX timestamp\0" as *const u8
2284 as *const libc::c_char as *mut libc::c_char,
2285 group: 0 as libc::c_int,
2286 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2287 };
2288 init
2289 },
2290 {
2291 let mut init = commandHelp {
2292 name: b"EXPIRETIME\0" as *const u8 as *const libc::c_char
2293 as *mut libc::c_char,
2294 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2295 summary: b"Get the expiration Unix timestamp for a key\0" as *const u8
2296 as *const libc::c_char as *mut libc::c_char,
2297 group: 0 as libc::c_int,
2298 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2299 };
2300 init
2301 },
2302 {
2303 let mut init = commandHelp {
2304 name: b"FAILOVER\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2305 params: b"[TO host port [FORCE]] [ABORT] [TIMEOUT milliseconds]\0"
2306 as *const u8 as *const libc::c_char as *mut libc::c_char,
2307 summary: b"Start a coordinated failover between this server and one of its replicas.\0"
2308 as *const u8 as *const libc::c_char as *mut libc::c_char,
2309 group: 9 as libc::c_int,
2310 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2311 };
2312 init
2313 },
2314 {
2315 let mut init = commandHelp {
2316 name: b"FCALL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2317 params: b"function numkeys [key [key ...]] [arg [arg ...]]\0" as *const u8
2318 as *const libc::c_char as *mut libc::c_char,
2319 summary: b"Invoke a function\0" as *const u8 as *const libc::c_char
2320 as *mut libc::c_char,
2321 group: 10 as libc::c_int,
2322 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2323 };
2324 init
2325 },
2326 {
2327 let mut init = commandHelp {
2328 name: b"FCALL_RO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2329 params: b"function numkeys [key [key ...]] [arg [arg ...]]\0" as *const u8
2330 as *const libc::c_char as *mut libc::c_char,
2331 summary: b"Invoke a read-only function\0" as *const u8 as *const libc::c_char
2332 as *mut libc::c_char,
2333 group: 10 as libc::c_int,
2334 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2335 };
2336 init
2337 },
2338 {
2339 let mut init = commandHelp {
2340 name: b"FLUSHALL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2341 params: b"[ASYNC|SYNC]\0" as *const u8 as *const libc::c_char
2342 as *mut libc::c_char,
2343 summary: b"Remove all keys from all databases\0" as *const u8
2344 as *const libc::c_char as *mut libc::c_char,
2345 group: 9 as libc::c_int,
2346 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2347 };
2348 init
2349 },
2350 {
2351 let mut init = commandHelp {
2352 name: b"FLUSHDB\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2353 params: b"[ASYNC|SYNC]\0" as *const u8 as *const libc::c_char
2354 as *mut libc::c_char,
2355 summary: b"Remove all keys from the current database\0" as *const u8
2356 as *const libc::c_char as *mut libc::c_char,
2357 group: 9 as libc::c_int,
2358 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2359 };
2360 init
2361 },
2362 {
2363 let mut init = commandHelp {
2364 name: b"FUNCTION\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2365 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2366 summary: b"A container for function commands\0" as *const u8
2367 as *const libc::c_char as *mut libc::c_char,
2368 group: 10 as libc::c_int,
2369 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2370 };
2371 init
2372 },
2373 {
2374 let mut init = commandHelp {
2375 name: b"FUNCTION DELETE\0" as *const u8 as *const libc::c_char
2376 as *mut libc::c_char,
2377 params: b"library-name\0" as *const u8 as *const libc::c_char
2378 as *mut libc::c_char,
2379 summary: b"Delete a function by name\0" as *const u8 as *const libc::c_char
2380 as *mut libc::c_char,
2381 group: 10 as libc::c_int,
2382 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2383 };
2384 init
2385 },
2386 {
2387 let mut init = commandHelp {
2388 name: b"FUNCTION DUMP\0" as *const u8 as *const libc::c_char
2389 as *mut libc::c_char,
2390 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2391 summary: b"Dump all functions into a serialized binary payload\0"
2392 as *const u8 as *const libc::c_char as *mut libc::c_char,
2393 group: 10 as libc::c_int,
2394 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2395 };
2396 init
2397 },
2398 {
2399 let mut init = commandHelp {
2400 name: b"FUNCTION FLUSH\0" as *const u8 as *const libc::c_char
2401 as *mut libc::c_char,
2402 params: b"[ASYNC|SYNC]\0" as *const u8 as *const libc::c_char
2403 as *mut libc::c_char,
2404 summary: b"Deleting all functions\0" as *const u8 as *const libc::c_char
2405 as *mut libc::c_char,
2406 group: 10 as libc::c_int,
2407 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2408 };
2409 init
2410 },
2411 {
2412 let mut init = commandHelp {
2413 name: b"FUNCTION HELP\0" as *const u8 as *const libc::c_char
2414 as *mut libc::c_char,
2415 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2416 summary: b"Show helpful text about the different subcommands\0" as *const u8
2417 as *const libc::c_char as *mut libc::c_char,
2418 group: 10 as libc::c_int,
2419 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2420 };
2421 init
2422 },
2423 {
2424 let mut init = commandHelp {
2425 name: b"FUNCTION KILL\0" as *const u8 as *const libc::c_char
2426 as *mut libc::c_char,
2427 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2428 summary: b"Kill the function currently in execution.\0" as *const u8
2429 as *const libc::c_char as *mut libc::c_char,
2430 group: 10 as libc::c_int,
2431 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2432 };
2433 init
2434 },
2435 {
2436 let mut init = commandHelp {
2437 name: b"FUNCTION LIST\0" as *const u8 as *const libc::c_char
2438 as *mut libc::c_char,
2439 params: b"[LIBRARYNAME library-name-pattern] [WITHCODE]\0" as *const u8
2440 as *const libc::c_char as *mut libc::c_char,
2441 summary: b"List information about all the functions\0" as *const u8
2442 as *const libc::c_char as *mut libc::c_char,
2443 group: 10 as libc::c_int,
2444 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2445 };
2446 init
2447 },
2448 {
2449 let mut init = commandHelp {
2450 name: b"FUNCTION LOAD\0" as *const u8 as *const libc::c_char
2451 as *mut libc::c_char,
2452 params: b"[REPLACE] function-code\0" as *const u8 as *const libc::c_char
2453 as *mut libc::c_char,
2454 summary: b"Create a function with the given arguments (name, code, description)\0"
2455 as *const u8 as *const libc::c_char as *mut libc::c_char,
2456 group: 10 as libc::c_int,
2457 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2458 };
2459 init
2460 },
2461 {
2462 let mut init = commandHelp {
2463 name: b"FUNCTION RESTORE\0" as *const u8 as *const libc::c_char
2464 as *mut libc::c_char,
2465 params: b"serialized-value [FLUSH|APPEND|REPLACE]\0" as *const u8
2466 as *const libc::c_char as *mut libc::c_char,
2467 summary: b"Restore all the functions on the given payload\0" as *const u8
2468 as *const libc::c_char as *mut libc::c_char,
2469 group: 10 as libc::c_int,
2470 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2471 };
2472 init
2473 },
2474 {
2475 let mut init = commandHelp {
2476 name: b"FUNCTION STATS\0" as *const u8 as *const libc::c_char
2477 as *mut libc::c_char,
2478 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2479 summary: b"Return information about the function currently running (name, description, duration)\0"
2480 as *const u8 as *const libc::c_char as *mut libc::c_char,
2481 group: 10 as libc::c_int,
2482 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2483 };
2484 init
2485 },
2486 {
2487 let mut init = commandHelp {
2488 name: b"GEOADD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2489 params: b"key [NX|XX] [CH] longitude latitude member [longitude latitude member ...]\0"
2490 as *const u8 as *const libc::c_char as *mut libc::c_char,
2491 summary: b"Add one or more geospatial items in the geospatial index represented using a sorted set\0"
2492 as *const u8 as *const libc::c_char as *mut libc::c_char,
2493 group: 13 as libc::c_int,
2494 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2495 };
2496 init
2497 },
2498 {
2499 let mut init = commandHelp {
2500 name: b"GEODIST\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2501 params: b"key member1 member2 [M|KM|FT|MI]\0" as *const u8
2502 as *const libc::c_char as *mut libc::c_char,
2503 summary: b"Returns the distance between two members of a geospatial index\0"
2504 as *const u8 as *const libc::c_char as *mut libc::c_char,
2505 group: 13 as libc::c_int,
2506 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2507 };
2508 init
2509 },
2510 {
2511 let mut init = commandHelp {
2512 name: b"GEOHASH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2513 params: b"key member [member ...]\0" as *const u8 as *const libc::c_char
2514 as *mut libc::c_char,
2515 summary: b"Returns members of a geospatial index as standard geohash strings\0"
2516 as *const u8 as *const libc::c_char as *mut libc::c_char,
2517 group: 13 as libc::c_int,
2518 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2519 };
2520 init
2521 },
2522 {
2523 let mut init = commandHelp {
2524 name: b"GEOPOS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2525 params: b"key member [member ...]\0" as *const u8 as *const libc::c_char
2526 as *mut libc::c_char,
2527 summary: b"Returns longitude and latitude of members of a geospatial index\0"
2528 as *const u8 as *const libc::c_char as *mut libc::c_char,
2529 group: 13 as libc::c_int,
2530 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2531 };
2532 init
2533 },
2534 {
2535 let mut init = commandHelp {
2536 name: b"GEORADIUS\0" as *const u8 as *const libc::c_char
2537 as *mut libc::c_char,
2538 params: b"key longitude latitude radius M|KM|FT|MI [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count [ANY]] [ASC|DESC] [STORE key] [STOREDIST key]\0"
2539 as *const u8 as *const libc::c_char as *mut libc::c_char,
2540 summary: b"Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point\0"
2541 as *const u8 as *const libc::c_char as *mut libc::c_char,
2542 group: 13 as libc::c_int,
2543 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2544 };
2545 init
2546 },
2547 {
2548 let mut init = commandHelp {
2549 name: b"GEORADIUSBYMEMBER\0" as *const u8 as *const libc::c_char
2550 as *mut libc::c_char,
2551 params: b"key member radius M|KM|FT|MI [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count [ANY]] [ASC|DESC] [STORE key] [STOREDIST key]\0"
2552 as *const u8 as *const libc::c_char as *mut libc::c_char,
2553 summary: b"Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member\0"
2554 as *const u8 as *const libc::c_char as *mut libc::c_char,
2555 group: 13 as libc::c_int,
2556 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2557 };
2558 init
2559 },
2560 {
2561 let mut init = commandHelp {
2562 name: b"GEORADIUSBYMEMBER_RO\0" as *const u8 as *const libc::c_char
2563 as *mut libc::c_char,
2564 params: b"key member radius M|KM|FT|MI [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count [ANY]] [ASC|DESC]\0"
2565 as *const u8 as *const libc::c_char as *mut libc::c_char,
2566 summary: b"A read-only variant for GEORADIUSBYMEMBER\0" as *const u8
2567 as *const libc::c_char as *mut libc::c_char,
2568 group: 13 as libc::c_int,
2569 since: b"3.2.10\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2570 };
2571 init
2572 },
2573 {
2574 let mut init = commandHelp {
2575 name: b"GEORADIUS_RO\0" as *const u8 as *const libc::c_char
2576 as *mut libc::c_char,
2577 params: b"key longitude latitude radius M|KM|FT|MI [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count [ANY]] [ASC|DESC]\0"
2578 as *const u8 as *const libc::c_char as *mut libc::c_char,
2579 summary: b"A read-only variant for GEORADIUS\0" as *const u8
2580 as *const libc::c_char as *mut libc::c_char,
2581 group: 13 as libc::c_int,
2582 since: b"3.2.10\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2583 };
2584 init
2585 },
2586 {
2587 let mut init = commandHelp {
2588 name: b"GEOSEARCH\0" as *const u8 as *const libc::c_char
2589 as *mut libc::c_char,
2590 params: b"key FROMMEMBER member|FROMLONLAT longitude latitude BYRADIUS radius M|KM|FT|MI|BYBOX width height M|KM|FT|MI [ASC|DESC] [COUNT count [ANY]] [WITHCOORD] [WITHDIST] [WITHHASH]\0"
2591 as *const u8 as *const libc::c_char as *mut libc::c_char,
2592 summary: b"Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.\0"
2593 as *const u8 as *const libc::c_char as *mut libc::c_char,
2594 group: 13 as libc::c_int,
2595 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2596 };
2597 init
2598 },
2599 {
2600 let mut init = commandHelp {
2601 name: b"GEOSEARCHSTORE\0" as *const u8 as *const libc::c_char
2602 as *mut libc::c_char,
2603 params: b"destination source FROMMEMBER member|FROMLONLAT longitude latitude BYRADIUS radius M|KM|FT|MI|BYBOX width height M|KM|FT|MI [ASC|DESC] [COUNT count [ANY]] [STOREDIST]\0"
2604 as *const u8 as *const libc::c_char as *mut libc::c_char,
2605 summary: b"Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.\0"
2606 as *const u8 as *const libc::c_char as *mut libc::c_char,
2607 group: 13 as libc::c_int,
2608 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2609 };
2610 init
2611 },
2612 {
2613 let mut init = commandHelp {
2614 name: b"GET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2615 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2616 summary: b"Get the value of a key\0" as *const u8 as *const libc::c_char
2617 as *mut libc::c_char,
2618 group: 1 as libc::c_int,
2619 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2620 };
2621 init
2622 },
2623 {
2624 let mut init = commandHelp {
2625 name: b"GETBIT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2626 params: b"key offset\0" as *const u8 as *const libc::c_char
2627 as *mut libc::c_char,
2628 summary: b"Returns the bit value at offset in the string value stored at key\0"
2629 as *const u8 as *const libc::c_char as *mut libc::c_char,
2630 group: 15 as libc::c_int,
2631 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2632 };
2633 init
2634 },
2635 {
2636 let mut init = commandHelp {
2637 name: b"GETDEL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2638 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2639 summary: b"Get the value of a key and delete the key\0" as *const u8
2640 as *const libc::c_char as *mut libc::c_char,
2641 group: 1 as libc::c_int,
2642 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2643 };
2644 init
2645 },
2646 {
2647 let mut init = commandHelp {
2648 name: b"GETEX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2649 params: b"key [EX seconds|PX milliseconds|EXAT unix-time-seconds|PXAT unix-time-milliseconds|PERSIST]\0"
2650 as *const u8 as *const libc::c_char as *mut libc::c_char,
2651 summary: b"Get the value of a key and optionally set its expiration\0"
2652 as *const u8 as *const libc::c_char as *mut libc::c_char,
2653 group: 1 as libc::c_int,
2654 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2655 };
2656 init
2657 },
2658 {
2659 let mut init = commandHelp {
2660 name: b"GETRANGE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2661 params: b"key start end\0" as *const u8 as *const libc::c_char
2662 as *mut libc::c_char,
2663 summary: b"Get a substring of the string stored at a key\0" as *const u8
2664 as *const libc::c_char as *mut libc::c_char,
2665 group: 1 as libc::c_int,
2666 since: b"2.4.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2667 };
2668 init
2669 },
2670 {
2671 let mut init = commandHelp {
2672 name: b"GETSET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2673 params: b"key value\0" as *const u8 as *const libc::c_char
2674 as *mut libc::c_char,
2675 summary: b"Set the string value of a key and return its old value\0"
2676 as *const u8 as *const libc::c_char as *mut libc::c_char,
2677 group: 1 as libc::c_int,
2678 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2679 };
2680 init
2681 },
2682 {
2683 let mut init = commandHelp {
2684 name: b"HDEL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2685 params: b"key field [field ...]\0" as *const u8 as *const libc::c_char
2686 as *mut libc::c_char,
2687 summary: b"Delete one or more hash fields\0" as *const u8
2688 as *const libc::c_char as *mut libc::c_char,
2689 group: 5 as libc::c_int,
2690 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2691 };
2692 init
2693 },
2694 {
2695 let mut init = commandHelp {
2696 name: b"HELLO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2697 params: b"[protover [AUTH username password] [SETNAME clientname]]\0"
2698 as *const u8 as *const libc::c_char as *mut libc::c_char,
2699 summary: b"Handshake with Redis\0" as *const u8 as *const libc::c_char
2700 as *mut libc::c_char,
2701 group: 8 as libc::c_int,
2702 since: b"6.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2703 };
2704 init
2705 },
2706 {
2707 let mut init = commandHelp {
2708 name: b"HEXISTS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2709 params: b"key field\0" as *const u8 as *const libc::c_char
2710 as *mut libc::c_char,
2711 summary: b"Determine if a hash field exists\0" as *const u8
2712 as *const libc::c_char as *mut libc::c_char,
2713 group: 5 as libc::c_int,
2714 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2715 };
2716 init
2717 },
2718 {
2719 let mut init = commandHelp {
2720 name: b"HGET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2721 params: b"key field\0" as *const u8 as *const libc::c_char
2722 as *mut libc::c_char,
2723 summary: b"Get the value of a hash field\0" as *const u8
2724 as *const libc::c_char as *mut libc::c_char,
2725 group: 5 as libc::c_int,
2726 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2727 };
2728 init
2729 },
2730 {
2731 let mut init = commandHelp {
2732 name: b"HGETALL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2733 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2734 summary: b"Get all the fields and values in a hash\0" as *const u8
2735 as *const libc::c_char as *mut libc::c_char,
2736 group: 5 as libc::c_int,
2737 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2738 };
2739 init
2740 },
2741 {
2742 let mut init = commandHelp {
2743 name: b"HINCRBY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2744 params: b"key field increment\0" as *const u8 as *const libc::c_char
2745 as *mut libc::c_char,
2746 summary: b"Increment the integer value of a hash field by the given number\0"
2747 as *const u8 as *const libc::c_char as *mut libc::c_char,
2748 group: 5 as libc::c_int,
2749 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2750 };
2751 init
2752 },
2753 {
2754 let mut init = commandHelp {
2755 name: b"HINCRBYFLOAT\0" as *const u8 as *const libc::c_char
2756 as *mut libc::c_char,
2757 params: b"key field increment\0" as *const u8 as *const libc::c_char
2758 as *mut libc::c_char,
2759 summary: b"Increment the float value of a hash field by the given amount\0"
2760 as *const u8 as *const libc::c_char as *mut libc::c_char,
2761 group: 5 as libc::c_int,
2762 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2763 };
2764 init
2765 },
2766 {
2767 let mut init = commandHelp {
2768 name: b"HKEYS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2769 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2770 summary: b"Get all the fields in a hash\0" as *const u8
2771 as *const libc::c_char as *mut libc::c_char,
2772 group: 5 as libc::c_int,
2773 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2774 };
2775 init
2776 },
2777 {
2778 let mut init = commandHelp {
2779 name: b"HLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2780 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2781 summary: b"Get the number of fields in a hash\0" as *const u8
2782 as *const libc::c_char as *mut libc::c_char,
2783 group: 5 as libc::c_int,
2784 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2785 };
2786 init
2787 },
2788 {
2789 let mut init = commandHelp {
2790 name: b"HMGET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2791 params: b"key field [field ...]\0" as *const u8 as *const libc::c_char
2792 as *mut libc::c_char,
2793 summary: b"Get the values of all the given hash fields\0" as *const u8
2794 as *const libc::c_char as *mut libc::c_char,
2795 group: 5 as libc::c_int,
2796 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2797 };
2798 init
2799 },
2800 {
2801 let mut init = commandHelp {
2802 name: b"HMSET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2803 params: b"key field value [field value ...]\0" as *const u8
2804 as *const libc::c_char as *mut libc::c_char,
2805 summary: b"Set multiple hash fields to multiple values\0" as *const u8
2806 as *const libc::c_char as *mut libc::c_char,
2807 group: 5 as libc::c_int,
2808 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2809 };
2810 init
2811 },
2812 {
2813 let mut init = commandHelp {
2814 name: b"HRANDFIELD\0" as *const u8 as *const libc::c_char
2815 as *mut libc::c_char,
2816 params: b"key [count [WITHVALUES]]\0" as *const u8 as *const libc::c_char
2817 as *mut libc::c_char,
2818 summary: b"Get one or multiple random fields from a hash\0" as *const u8
2819 as *const libc::c_char as *mut libc::c_char,
2820 group: 5 as libc::c_int,
2821 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2822 };
2823 init
2824 },
2825 {
2826 let mut init = commandHelp {
2827 name: b"HSCAN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2828 params: b"key cursor [MATCH pattern] [COUNT count]\0" as *const u8
2829 as *const libc::c_char as *mut libc::c_char,
2830 summary: b"Incrementally iterate hash fields and associated values\0"
2831 as *const u8 as *const libc::c_char as *mut libc::c_char,
2832 group: 5 as libc::c_int,
2833 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2834 };
2835 init
2836 },
2837 {
2838 let mut init = commandHelp {
2839 name: b"HSET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2840 params: b"key field value [field value ...]\0" as *const u8
2841 as *const libc::c_char as *mut libc::c_char,
2842 summary: b"Set the string value of a hash field\0" as *const u8
2843 as *const libc::c_char as *mut libc::c_char,
2844 group: 5 as libc::c_int,
2845 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2846 };
2847 init
2848 },
2849 {
2850 let mut init = commandHelp {
2851 name: b"HSETNX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2852 params: b"key field value\0" as *const u8 as *const libc::c_char
2853 as *mut libc::c_char,
2854 summary: b"Set the value of a hash field, only if the field does not exist\0"
2855 as *const u8 as *const libc::c_char as *mut libc::c_char,
2856 group: 5 as libc::c_int,
2857 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2858 };
2859 init
2860 },
2861 {
2862 let mut init = commandHelp {
2863 name: b"HSTRLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2864 params: b"key field\0" as *const u8 as *const libc::c_char
2865 as *mut libc::c_char,
2866 summary: b"Get the length of the value of a hash field\0" as *const u8
2867 as *const libc::c_char as *mut libc::c_char,
2868 group: 5 as libc::c_int,
2869 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2870 };
2871 init
2872 },
2873 {
2874 let mut init = commandHelp {
2875 name: b"HVALS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2876 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2877 summary: b"Get all the values in a hash\0" as *const u8
2878 as *const libc::c_char as *mut libc::c_char,
2879 group: 5 as libc::c_int,
2880 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2881 };
2882 init
2883 },
2884 {
2885 let mut init = commandHelp {
2886 name: b"INCR\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2887 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2888 summary: b"Increment the integer value of a key by one\0" as *const u8
2889 as *const libc::c_char as *mut libc::c_char,
2890 group: 1 as libc::c_int,
2891 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2892 };
2893 init
2894 },
2895 {
2896 let mut init = commandHelp {
2897 name: b"INCRBY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2898 params: b"key increment\0" as *const u8 as *const libc::c_char
2899 as *mut libc::c_char,
2900 summary: b"Increment the integer value of a key by the given amount\0"
2901 as *const u8 as *const libc::c_char as *mut libc::c_char,
2902 group: 1 as libc::c_int,
2903 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2904 };
2905 init
2906 },
2907 {
2908 let mut init = commandHelp {
2909 name: b"INCRBYFLOAT\0" as *const u8 as *const libc::c_char
2910 as *mut libc::c_char,
2911 params: b"key increment\0" as *const u8 as *const libc::c_char
2912 as *mut libc::c_char,
2913 summary: b"Increment the float value of a key by the given amount\0"
2914 as *const u8 as *const libc::c_char as *mut libc::c_char,
2915 group: 1 as libc::c_int,
2916 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2917 };
2918 init
2919 },
2920 {
2921 let mut init = commandHelp {
2922 name: b"INFO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2923 params: b"[section [section ...]]\0" as *const u8 as *const libc::c_char
2924 as *mut libc::c_char,
2925 summary: b"Get information and statistics about the server\0" as *const u8
2926 as *const libc::c_char as *mut libc::c_char,
2927 group: 9 as libc::c_int,
2928 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2929 };
2930 init
2931 },
2932 {
2933 let mut init = commandHelp {
2934 name: b"KEYS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2935 params: b"pattern\0" as *const u8 as *const libc::c_char
2936 as *mut libc::c_char,
2937 summary: b"Find all keys matching the given pattern\0" as *const u8
2938 as *const libc::c_char as *mut libc::c_char,
2939 group: 0 as libc::c_int,
2940 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2941 };
2942 init
2943 },
2944 {
2945 let mut init = commandHelp {
2946 name: b"LASTSAVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2947 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2948 summary: b"Get the UNIX time stamp of the last successful save to disk\0"
2949 as *const u8 as *const libc::c_char as *mut libc::c_char,
2950 group: 9 as libc::c_int,
2951 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2952 };
2953 init
2954 },
2955 {
2956 let mut init = commandHelp {
2957 name: b"LATENCY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2958 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2959 summary: b"A container for latency diagnostics commands\0" as *const u8
2960 as *const libc::c_char as *mut libc::c_char,
2961 group: 9 as libc::c_int,
2962 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2963 };
2964 init
2965 },
2966 {
2967 let mut init = commandHelp {
2968 name: b"LATENCY DOCTOR\0" as *const u8 as *const libc::c_char
2969 as *mut libc::c_char,
2970 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2971 summary: b"Return a human readable latency analysis report.\0" as *const u8
2972 as *const libc::c_char as *mut libc::c_char,
2973 group: 9 as libc::c_int,
2974 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2975 };
2976 init
2977 },
2978 {
2979 let mut init = commandHelp {
2980 name: b"LATENCY GRAPH\0" as *const u8 as *const libc::c_char
2981 as *mut libc::c_char,
2982 params: b"event\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2983 summary: b"Return a latency graph for the event.\0" as *const u8
2984 as *const libc::c_char as *mut libc::c_char,
2985 group: 9 as libc::c_int,
2986 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2987 };
2988 init
2989 },
2990 {
2991 let mut init = commandHelp {
2992 name: b"LATENCY HELP\0" as *const u8 as *const libc::c_char
2993 as *mut libc::c_char,
2994 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2995 summary: b"Show helpful text about the different subcommands.\0" as *const u8
2996 as *const libc::c_char as *mut libc::c_char,
2997 group: 9 as libc::c_int,
2998 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
2999 };
3000 init
3001 },
3002 {
3003 let mut init = commandHelp {
3004 name: b"LATENCY HISTOGRAM\0" as *const u8 as *const libc::c_char
3005 as *mut libc::c_char,
3006 params: b"[command [command ...]]\0" as *const u8 as *const libc::c_char
3007 as *mut libc::c_char,
3008 summary: b"Return the cumulative distribution of latencies of a subset of commands or all.\0"
3009 as *const u8 as *const libc::c_char as *mut libc::c_char,
3010 group: 9 as libc::c_int,
3011 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3012 };
3013 init
3014 },
3015 {
3016 let mut init = commandHelp {
3017 name: b"LATENCY HISTORY\0" as *const u8 as *const libc::c_char
3018 as *mut libc::c_char,
3019 params: b"event\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3020 summary: b"Return timestamp-latency samples for the event.\0" as *const u8
3021 as *const libc::c_char as *mut libc::c_char,
3022 group: 9 as libc::c_int,
3023 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3024 };
3025 init
3026 },
3027 {
3028 let mut init = commandHelp {
3029 name: b"LATENCY LATEST\0" as *const u8 as *const libc::c_char
3030 as *mut libc::c_char,
3031 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3032 summary: b"Return the latest latency samples for all events.\0" as *const u8
3033 as *const libc::c_char as *mut libc::c_char,
3034 group: 9 as libc::c_int,
3035 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3036 };
3037 init
3038 },
3039 {
3040 let mut init = commandHelp {
3041 name: b"LATENCY RESET\0" as *const u8 as *const libc::c_char
3042 as *mut libc::c_char,
3043 params: b"[event [event ...]]\0" as *const u8 as *const libc::c_char
3044 as *mut libc::c_char,
3045 summary: b"Reset latency data for one or more events.\0" as *const u8
3046 as *const libc::c_char as *mut libc::c_char,
3047 group: 9 as libc::c_int,
3048 since: b"2.8.13\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3049 };
3050 init
3051 },
3052 {
3053 let mut init = commandHelp {
3054 name: b"LCS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3055 params: b"key1 key2 [LEN] [IDX] [MINMATCHLEN len] [WITHMATCHLEN]\0"
3056 as *const u8 as *const libc::c_char as *mut libc::c_char,
3057 summary: b"Find longest common substring\0" as *const u8
3058 as *const libc::c_char as *mut libc::c_char,
3059 group: 1 as libc::c_int,
3060 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3061 };
3062 init
3063 },
3064 {
3065 let mut init = commandHelp {
3066 name: b"LINDEX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3067 params: b"key index\0" as *const u8 as *const libc::c_char
3068 as *mut libc::c_char,
3069 summary: b"Get an element from a list by its index\0" as *const u8
3070 as *const libc::c_char as *mut libc::c_char,
3071 group: 2 as libc::c_int,
3072 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3073 };
3074 init
3075 },
3076 {
3077 let mut init = commandHelp {
3078 name: b"LINSERT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3079 params: b"key BEFORE|AFTER pivot element\0" as *const u8
3080 as *const libc::c_char as *mut libc::c_char,
3081 summary: b"Insert an element before or after another element in a list\0"
3082 as *const u8 as *const libc::c_char as *mut libc::c_char,
3083 group: 2 as libc::c_int,
3084 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3085 };
3086 init
3087 },
3088 {
3089 let mut init = commandHelp {
3090 name: b"LLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3091 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3092 summary: b"Get the length of a list\0" as *const u8 as *const libc::c_char
3093 as *mut libc::c_char,
3094 group: 2 as libc::c_int,
3095 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3096 };
3097 init
3098 },
3099 {
3100 let mut init = commandHelp {
3101 name: b"LMOVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3102 params: b"source destination LEFT|RIGHT LEFT|RIGHT\0" as *const u8
3103 as *const libc::c_char as *mut libc::c_char,
3104 summary: b"Pop an element from a list, push it to another list and return it\0"
3105 as *const u8 as *const libc::c_char as *mut libc::c_char,
3106 group: 2 as libc::c_int,
3107 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3108 };
3109 init
3110 },
3111 {
3112 let mut init = commandHelp {
3113 name: b"LMPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3114 params: b"numkeys key [key ...] LEFT|RIGHT [COUNT count]\0" as *const u8
3115 as *const libc::c_char as *mut libc::c_char,
3116 summary: b"Pop elements from a list\0" as *const u8 as *const libc::c_char
3117 as *mut libc::c_char,
3118 group: 2 as libc::c_int,
3119 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3120 };
3121 init
3122 },
3123 {
3124 let mut init = commandHelp {
3125 name: b"LOLWUT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3126 params: b"[VERSION version]\0" as *const u8 as *const libc::c_char
3127 as *mut libc::c_char,
3128 summary: b"Display some computer art and the Redis version\0" as *const u8
3129 as *const libc::c_char as *mut libc::c_char,
3130 group: 9 as libc::c_int,
3131 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3132 };
3133 init
3134 },
3135 {
3136 let mut init = commandHelp {
3137 name: b"LPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3138 params: b"key [count]\0" as *const u8 as *const libc::c_char
3139 as *mut libc::c_char,
3140 summary: b"Remove and get the first elements in a list\0" as *const u8
3141 as *const libc::c_char as *mut libc::c_char,
3142 group: 2 as libc::c_int,
3143 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3144 };
3145 init
3146 },
3147 {
3148 let mut init = commandHelp {
3149 name: b"LPOS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3150 params: b"key element [RANK rank] [COUNT num-matches] [MAXLEN len]\0"
3151 as *const u8 as *const libc::c_char as *mut libc::c_char,
3152 summary: b"Return the index of matching elements on a list\0" as *const u8
3153 as *const libc::c_char as *mut libc::c_char,
3154 group: 2 as libc::c_int,
3155 since: b"6.0.6\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3156 };
3157 init
3158 },
3159 {
3160 let mut init = commandHelp {
3161 name: b"LPUSH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3162 params: b"key element [element ...]\0" as *const u8 as *const libc::c_char
3163 as *mut libc::c_char,
3164 summary: b"Prepend one or multiple elements to a list\0" as *const u8
3165 as *const libc::c_char as *mut libc::c_char,
3166 group: 2 as libc::c_int,
3167 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3168 };
3169 init
3170 },
3171 {
3172 let mut init = commandHelp {
3173 name: b"LPUSHX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3174 params: b"key element [element ...]\0" as *const u8 as *const libc::c_char
3175 as *mut libc::c_char,
3176 summary: b"Prepend an element to a list, only if the list exists\0"
3177 as *const u8 as *const libc::c_char as *mut libc::c_char,
3178 group: 2 as libc::c_int,
3179 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3180 };
3181 init
3182 },
3183 {
3184 let mut init = commandHelp {
3185 name: b"LRANGE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3186 params: b"key start stop\0" as *const u8 as *const libc::c_char
3187 as *mut libc::c_char,
3188 summary: b"Get a range of elements from a list\0" as *const u8
3189 as *const libc::c_char as *mut libc::c_char,
3190 group: 2 as libc::c_int,
3191 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3192 };
3193 init
3194 },
3195 {
3196 let mut init = commandHelp {
3197 name: b"LREM\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3198 params: b"key count element\0" as *const u8 as *const libc::c_char
3199 as *mut libc::c_char,
3200 summary: b"Remove elements from a list\0" as *const u8 as *const libc::c_char
3201 as *mut libc::c_char,
3202 group: 2 as libc::c_int,
3203 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3204 };
3205 init
3206 },
3207 {
3208 let mut init = commandHelp {
3209 name: b"LSET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3210 params: b"key index element\0" as *const u8 as *const libc::c_char
3211 as *mut libc::c_char,
3212 summary: b"Set the value of an element in a list by its index\0" as *const u8
3213 as *const libc::c_char as *mut libc::c_char,
3214 group: 2 as libc::c_int,
3215 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3216 };
3217 init
3218 },
3219 {
3220 let mut init = commandHelp {
3221 name: b"LTRIM\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3222 params: b"key start stop\0" as *const u8 as *const libc::c_char
3223 as *mut libc::c_char,
3224 summary: b"Trim a list to the specified range\0" as *const u8
3225 as *const libc::c_char as *mut libc::c_char,
3226 group: 2 as libc::c_int,
3227 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3228 };
3229 init
3230 },
3231 {
3232 let mut init = commandHelp {
3233 name: b"MEMORY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3234 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3235 summary: b"A container for memory diagnostics commands\0" as *const u8
3236 as *const libc::c_char as *mut libc::c_char,
3237 group: 9 as libc::c_int,
3238 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3239 };
3240 init
3241 },
3242 {
3243 let mut init = commandHelp {
3244 name: b"MEMORY DOCTOR\0" as *const u8 as *const libc::c_char
3245 as *mut libc::c_char,
3246 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3247 summary: b"Outputs memory problems report\0" as *const u8
3248 as *const libc::c_char as *mut libc::c_char,
3249 group: 9 as libc::c_int,
3250 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3251 };
3252 init
3253 },
3254 {
3255 let mut init = commandHelp {
3256 name: b"MEMORY HELP\0" as *const u8 as *const libc::c_char
3257 as *mut libc::c_char,
3258 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3259 summary: b"Show helpful text about the different subcommands\0" as *const u8
3260 as *const libc::c_char as *mut libc::c_char,
3261 group: 9 as libc::c_int,
3262 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3263 };
3264 init
3265 },
3266 {
3267 let mut init = commandHelp {
3268 name: b"MEMORY MALLOC-STATS\0" as *const u8 as *const libc::c_char
3269 as *mut libc::c_char,
3270 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3271 summary: b"Show allocator internal stats\0" as *const u8
3272 as *const libc::c_char as *mut libc::c_char,
3273 group: 9 as libc::c_int,
3274 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3275 };
3276 init
3277 },
3278 {
3279 let mut init = commandHelp {
3280 name: b"MEMORY PURGE\0" as *const u8 as *const libc::c_char
3281 as *mut libc::c_char,
3282 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3283 summary: b"Ask the allocator to release memory\0" as *const u8
3284 as *const libc::c_char as *mut libc::c_char,
3285 group: 9 as libc::c_int,
3286 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3287 };
3288 init
3289 },
3290 {
3291 let mut init = commandHelp {
3292 name: b"MEMORY STATS\0" as *const u8 as *const libc::c_char
3293 as *mut libc::c_char,
3294 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3295 summary: b"Show memory usage details\0" as *const u8 as *const libc::c_char
3296 as *mut libc::c_char,
3297 group: 9 as libc::c_int,
3298 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3299 };
3300 init
3301 },
3302 {
3303 let mut init = commandHelp {
3304 name: b"MEMORY USAGE\0" as *const u8 as *const libc::c_char
3305 as *mut libc::c_char,
3306 params: b"key [SAMPLES count]\0" as *const u8 as *const libc::c_char
3307 as *mut libc::c_char,
3308 summary: b"Estimate the memory usage of a key\0" as *const u8
3309 as *const libc::c_char as *mut libc::c_char,
3310 group: 9 as libc::c_int,
3311 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3312 };
3313 init
3314 },
3315 {
3316 let mut init = commandHelp {
3317 name: b"MGET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3318 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
3319 as *mut libc::c_char,
3320 summary: b"Get the values of all the given keys\0" as *const u8
3321 as *const libc::c_char as *mut libc::c_char,
3322 group: 1 as libc::c_int,
3323 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3324 };
3325 init
3326 },
3327 {
3328 let mut init = commandHelp {
3329 name: b"MIGRATE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3330 params: b"host port key| destination-db timeout [COPY] [REPLACE] [[AUTH password]|[AUTH2 username password]] [KEYS key [key ...]]\0"
3331 as *const u8 as *const libc::c_char as *mut libc::c_char,
3332 summary: b"Atomically transfer a key from a Redis instance to another one.\0"
3333 as *const u8 as *const libc::c_char as *mut libc::c_char,
3334 group: 0 as libc::c_int,
3335 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3336 };
3337 init
3338 },
3339 {
3340 let mut init = commandHelp {
3341 name: b"MODULE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3342 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3343 summary: b"A container for module commands\0" as *const u8
3344 as *const libc::c_char as *mut libc::c_char,
3345 group: 9 as libc::c_int,
3346 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3347 };
3348 init
3349 },
3350 {
3351 let mut init = commandHelp {
3352 name: b"MODULE HELP\0" as *const u8 as *const libc::c_char
3353 as *mut libc::c_char,
3354 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3355 summary: b"Show helpful text about the different subcommands\0" as *const u8
3356 as *const libc::c_char as *mut libc::c_char,
3357 group: 9 as libc::c_int,
3358 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3359 };
3360 init
3361 },
3362 {
3363 let mut init = commandHelp {
3364 name: b"MODULE LIST\0" as *const u8 as *const libc::c_char
3365 as *mut libc::c_char,
3366 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3367 summary: b"List all modules loaded by the server\0" as *const u8
3368 as *const libc::c_char as *mut libc::c_char,
3369 group: 9 as libc::c_int,
3370 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3371 };
3372 init
3373 },
3374 {
3375 let mut init = commandHelp {
3376 name: b"MODULE LOAD\0" as *const u8 as *const libc::c_char
3377 as *mut libc::c_char,
3378 params: b"path [arg [arg ...]]\0" as *const u8 as *const libc::c_char
3379 as *mut libc::c_char,
3380 summary: b"Load a module\0" as *const u8 as *const libc::c_char
3381 as *mut libc::c_char,
3382 group: 9 as libc::c_int,
3383 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3384 };
3385 init
3386 },
3387 {
3388 let mut init = commandHelp {
3389 name: b"MODULE LOADEX\0" as *const u8 as *const libc::c_char
3390 as *mut libc::c_char,
3391 params: b"path [CONFIG name value [CONFIG name value ...]] [ARGS arg [arg ...]]\0"
3392 as *const u8 as *const libc::c_char as *mut libc::c_char,
3393 summary: b"Load a module with extended parameters\0" as *const u8
3394 as *const libc::c_char as *mut libc::c_char,
3395 group: 9 as libc::c_int,
3396 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3397 };
3398 init
3399 },
3400 {
3401 let mut init = commandHelp {
3402 name: b"MODULE UNLOAD\0" as *const u8 as *const libc::c_char
3403 as *mut libc::c_char,
3404 params: b"name\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3405 summary: b"Unload a module\0" as *const u8 as *const libc::c_char
3406 as *mut libc::c_char,
3407 group: 9 as libc::c_int,
3408 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3409 };
3410 init
3411 },
3412 {
3413 let mut init = commandHelp {
3414 name: b"MONITOR\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3415 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3416 summary: b"Listen for all requests received by the server in real time\0"
3417 as *const u8 as *const libc::c_char as *mut libc::c_char,
3418 group: 9 as libc::c_int,
3419 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3420 };
3421 init
3422 },
3423 {
3424 let mut init = commandHelp {
3425 name: b"MOVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3426 params: b"key db\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3427 summary: b"Move a key to another database\0" as *const u8
3428 as *const libc::c_char as *mut libc::c_char,
3429 group: 0 as libc::c_int,
3430 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3431 };
3432 init
3433 },
3434 {
3435 let mut init = commandHelp {
3436 name: b"MSET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3437 params: b"key value [key value ...]\0" as *const u8 as *const libc::c_char
3438 as *mut libc::c_char,
3439 summary: b"Set multiple keys to multiple values\0" as *const u8
3440 as *const libc::c_char as *mut libc::c_char,
3441 group: 1 as libc::c_int,
3442 since: b"1.0.1\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3443 };
3444 init
3445 },
3446 {
3447 let mut init = commandHelp {
3448 name: b"MSETNX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3449 params: b"key value [key value ...]\0" as *const u8 as *const libc::c_char
3450 as *mut libc::c_char,
3451 summary: b"Set multiple keys to multiple values, only if none of the keys exist\0"
3452 as *const u8 as *const libc::c_char as *mut libc::c_char,
3453 group: 1 as libc::c_int,
3454 since: b"1.0.1\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3455 };
3456 init
3457 },
3458 {
3459 let mut init = commandHelp {
3460 name: b"MULTI\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3461 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3462 summary: b"Mark the start of a transaction block\0" as *const u8
3463 as *const libc::c_char as *mut libc::c_char,
3464 group: 7 as libc::c_int,
3465 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3466 };
3467 init
3468 },
3469 {
3470 let mut init = commandHelp {
3471 name: b"OBJECT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3472 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3473 summary: b"A container for object introspection commands\0" as *const u8
3474 as *const libc::c_char as *mut libc::c_char,
3475 group: 0 as libc::c_int,
3476 since: b"2.2.3\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3477 };
3478 init
3479 },
3480 {
3481 let mut init = commandHelp {
3482 name: b"OBJECT ENCODING\0" as *const u8 as *const libc::c_char
3483 as *mut libc::c_char,
3484 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3485 summary: b"Inspect the internal encoding of a Redis object\0" as *const u8
3486 as *const libc::c_char as *mut libc::c_char,
3487 group: 0 as libc::c_int,
3488 since: b"2.2.3\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3489 };
3490 init
3491 },
3492 {
3493 let mut init = commandHelp {
3494 name: b"OBJECT FREQ\0" as *const u8 as *const libc::c_char
3495 as *mut libc::c_char,
3496 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3497 summary: b"Get the logarithmic access frequency counter of a Redis object\0"
3498 as *const u8 as *const libc::c_char as *mut libc::c_char,
3499 group: 0 as libc::c_int,
3500 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3501 };
3502 init
3503 },
3504 {
3505 let mut init = commandHelp {
3506 name: b"OBJECT HELP\0" as *const u8 as *const libc::c_char
3507 as *mut libc::c_char,
3508 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3509 summary: b"Show helpful text about the different subcommands\0" as *const u8
3510 as *const libc::c_char as *mut libc::c_char,
3511 group: 0 as libc::c_int,
3512 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3513 };
3514 init
3515 },
3516 {
3517 let mut init = commandHelp {
3518 name: b"OBJECT IDLETIME\0" as *const u8 as *const libc::c_char
3519 as *mut libc::c_char,
3520 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3521 summary: b"Get the time since a Redis object was last accessed\0"
3522 as *const u8 as *const libc::c_char as *mut libc::c_char,
3523 group: 0 as libc::c_int,
3524 since: b"2.2.3\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3525 };
3526 init
3527 },
3528 {
3529 let mut init = commandHelp {
3530 name: b"OBJECT REFCOUNT\0" as *const u8 as *const libc::c_char
3531 as *mut libc::c_char,
3532 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3533 summary: b"Get the number of references to the value of the key\0"
3534 as *const u8 as *const libc::c_char as *mut libc::c_char,
3535 group: 0 as libc::c_int,
3536 since: b"2.2.3\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3537 };
3538 init
3539 },
3540 {
3541 let mut init = commandHelp {
3542 name: b"PERSIST\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3543 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3544 summary: b"Remove the expiration from a key\0" as *const u8
3545 as *const libc::c_char as *mut libc::c_char,
3546 group: 0 as libc::c_int,
3547 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3548 };
3549 init
3550 },
3551 {
3552 let mut init = commandHelp {
3553 name: b"PEXPIRE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3554 params: b"key milliseconds [NX|XX|GT|LT]\0" as *const u8
3555 as *const libc::c_char as *mut libc::c_char,
3556 summary: b"Set a key's time to live in milliseconds\0" as *const u8
3557 as *const libc::c_char as *mut libc::c_char,
3558 group: 0 as libc::c_int,
3559 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3560 };
3561 init
3562 },
3563 {
3564 let mut init = commandHelp {
3565 name: b"PEXPIREAT\0" as *const u8 as *const libc::c_char
3566 as *mut libc::c_char,
3567 params: b"key unix-time-milliseconds [NX|XX|GT|LT]\0" as *const u8
3568 as *const libc::c_char as *mut libc::c_char,
3569 summary: b"Set the expiration for a key as a UNIX timestamp specified in milliseconds\0"
3570 as *const u8 as *const libc::c_char as *mut libc::c_char,
3571 group: 0 as libc::c_int,
3572 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3573 };
3574 init
3575 },
3576 {
3577 let mut init = commandHelp {
3578 name: b"PEXPIRETIME\0" as *const u8 as *const libc::c_char
3579 as *mut libc::c_char,
3580 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3581 summary: b"Get the expiration Unix timestamp for a key in milliseconds\0"
3582 as *const u8 as *const libc::c_char as *mut libc::c_char,
3583 group: 0 as libc::c_int,
3584 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3585 };
3586 init
3587 },
3588 {
3589 let mut init = commandHelp {
3590 name: b"PFADD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3591 params: b"key [element [element ...]]\0" as *const u8 as *const libc::c_char
3592 as *mut libc::c_char,
3593 summary: b"Adds the specified elements to the specified HyperLogLog.\0"
3594 as *const u8 as *const libc::c_char as *mut libc::c_char,
3595 group: 11 as libc::c_int,
3596 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3597 };
3598 init
3599 },
3600 {
3601 let mut init = commandHelp {
3602 name: b"PFCOUNT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3603 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
3604 as *mut libc::c_char,
3605 summary: b"Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).\0"
3606 as *const u8 as *const libc::c_char as *mut libc::c_char,
3607 group: 11 as libc::c_int,
3608 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3609 };
3610 init
3611 },
3612 {
3613 let mut init = commandHelp {
3614 name: b"PFDEBUG\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3615 params: b"subcommand key\0" as *const u8 as *const libc::c_char
3616 as *mut libc::c_char,
3617 summary: b"Internal commands for debugging HyperLogLog values\0" as *const u8
3618 as *const libc::c_char as *mut libc::c_char,
3619 group: 11 as libc::c_int,
3620 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3621 };
3622 init
3623 },
3624 {
3625 let mut init = commandHelp {
3626 name: b"PFMERGE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3627 params: b"destkey sourcekey [sourcekey ...]\0" as *const u8
3628 as *const libc::c_char as *mut libc::c_char,
3629 summary: b"Merge N different HyperLogLogs into a single one.\0" as *const u8
3630 as *const libc::c_char as *mut libc::c_char,
3631 group: 11 as libc::c_int,
3632 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3633 };
3634 init
3635 },
3636 {
3637 let mut init = commandHelp {
3638 name: b"PFSELFTEST\0" as *const u8 as *const libc::c_char
3639 as *mut libc::c_char,
3640 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3641 summary: b"An internal command for testing HyperLogLog values\0" as *const u8
3642 as *const libc::c_char as *mut libc::c_char,
3643 group: 11 as libc::c_int,
3644 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3645 };
3646 init
3647 },
3648 {
3649 let mut init = commandHelp {
3650 name: b"PING\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3651 params: b"[message]\0" as *const u8 as *const libc::c_char
3652 as *mut libc::c_char,
3653 summary: b"Ping the server\0" as *const u8 as *const libc::c_char
3654 as *mut libc::c_char,
3655 group: 8 as libc::c_int,
3656 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3657 };
3658 init
3659 },
3660 {
3661 let mut init = commandHelp {
3662 name: b"PSETEX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3663 params: b"key milliseconds value\0" as *const u8 as *const libc::c_char
3664 as *mut libc::c_char,
3665 summary: b"Set the value and expiration in milliseconds of a key\0"
3666 as *const u8 as *const libc::c_char as *mut libc::c_char,
3667 group: 1 as libc::c_int,
3668 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3669 };
3670 init
3671 },
3672 {
3673 let mut init = commandHelp {
3674 name: b"PSUBSCRIBE\0" as *const u8 as *const libc::c_char
3675 as *mut libc::c_char,
3676 params: b"pattern [pattern ...]\0" as *const u8 as *const libc::c_char
3677 as *mut libc::c_char,
3678 summary: b"Listen for messages published to channels matching the given patterns\0"
3679 as *const u8 as *const libc::c_char as *mut libc::c_char,
3680 group: 6 as libc::c_int,
3681 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3682 };
3683 init
3684 },
3685 {
3686 let mut init = commandHelp {
3687 name: b"PSYNC\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3688 params: b"replicationid offset\0" as *const u8 as *const libc::c_char
3689 as *mut libc::c_char,
3690 summary: b"Internal command used for replication\0" as *const u8
3691 as *const libc::c_char as *mut libc::c_char,
3692 group: 9 as libc::c_int,
3693 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3694 };
3695 init
3696 },
3697 {
3698 let mut init = commandHelp {
3699 name: b"PTTL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3700 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3701 summary: b"Get the time to live for a key in milliseconds\0" as *const u8
3702 as *const libc::c_char as *mut libc::c_char,
3703 group: 0 as libc::c_int,
3704 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3705 };
3706 init
3707 },
3708 {
3709 let mut init = commandHelp {
3710 name: b"PUBLISH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3711 params: b"channel message\0" as *const u8 as *const libc::c_char
3712 as *mut libc::c_char,
3713 summary: b"Post a message to a channel\0" as *const u8 as *const libc::c_char
3714 as *mut libc::c_char,
3715 group: 6 as libc::c_int,
3716 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3717 };
3718 init
3719 },
3720 {
3721 let mut init = commandHelp {
3722 name: b"PUBSUB\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3723 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3724 summary: b"A container for Pub/Sub commands\0" as *const u8
3725 as *const libc::c_char as *mut libc::c_char,
3726 group: 6 as libc::c_int,
3727 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3728 };
3729 init
3730 },
3731 {
3732 let mut init = commandHelp {
3733 name: b"PUBSUB CHANNELS\0" as *const u8 as *const libc::c_char
3734 as *mut libc::c_char,
3735 params: b"[pattern]\0" as *const u8 as *const libc::c_char
3736 as *mut libc::c_char,
3737 summary: b"List active channels\0" as *const u8 as *const libc::c_char
3738 as *mut libc::c_char,
3739 group: 6 as libc::c_int,
3740 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3741 };
3742 init
3743 },
3744 {
3745 let mut init = commandHelp {
3746 name: b"PUBSUB HELP\0" as *const u8 as *const libc::c_char
3747 as *mut libc::c_char,
3748 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3749 summary: b"Show helpful text about the different subcommands\0" as *const u8
3750 as *const libc::c_char as *mut libc::c_char,
3751 group: 6 as libc::c_int,
3752 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3753 };
3754 init
3755 },
3756 {
3757 let mut init = commandHelp {
3758 name: b"PUBSUB NUMPAT\0" as *const u8 as *const libc::c_char
3759 as *mut libc::c_char,
3760 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3761 summary: b"Get the count of unique patterns pattern subscriptions\0"
3762 as *const u8 as *const libc::c_char as *mut libc::c_char,
3763 group: 6 as libc::c_int,
3764 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3765 };
3766 init
3767 },
3768 {
3769 let mut init = commandHelp {
3770 name: b"PUBSUB NUMSUB\0" as *const u8 as *const libc::c_char
3771 as *mut libc::c_char,
3772 params: b"[channel [channel ...]]\0" as *const u8 as *const libc::c_char
3773 as *mut libc::c_char,
3774 summary: b"Get the count of subscribers for channels\0" as *const u8
3775 as *const libc::c_char as *mut libc::c_char,
3776 group: 6 as libc::c_int,
3777 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3778 };
3779 init
3780 },
3781 {
3782 let mut init = commandHelp {
3783 name: b"PUBSUB SHARDCHANNELS\0" as *const u8 as *const libc::c_char
3784 as *mut libc::c_char,
3785 params: b"[pattern]\0" as *const u8 as *const libc::c_char
3786 as *mut libc::c_char,
3787 summary: b"List active shard channels\0" as *const u8 as *const libc::c_char
3788 as *mut libc::c_char,
3789 group: 6 as libc::c_int,
3790 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3791 };
3792 init
3793 },
3794 {
3795 let mut init = commandHelp {
3796 name: b"PUBSUB SHARDNUMSUB\0" as *const u8 as *const libc::c_char
3797 as *mut libc::c_char,
3798 params: b"[shardchannel [shardchannel ...]]\0" as *const u8
3799 as *const libc::c_char as *mut libc::c_char,
3800 summary: b"Get the count of subscribers for shard channels\0" as *const u8
3801 as *const libc::c_char as *mut libc::c_char,
3802 group: 6 as libc::c_int,
3803 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3804 };
3805 init
3806 },
3807 {
3808 let mut init = commandHelp {
3809 name: b"PUNSUBSCRIBE\0" as *const u8 as *const libc::c_char
3810 as *mut libc::c_char,
3811 params: b"[pattern [pattern ...]]\0" as *const u8 as *const libc::c_char
3812 as *mut libc::c_char,
3813 summary: b"Stop listening for messages posted to channels matching the given patterns\0"
3814 as *const u8 as *const libc::c_char as *mut libc::c_char,
3815 group: 6 as libc::c_int,
3816 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3817 };
3818 init
3819 },
3820 {
3821 let mut init = commandHelp {
3822 name: b"QUIT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3823 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3824 summary: b"Close the connection\0" as *const u8 as *const libc::c_char
3825 as *mut libc::c_char,
3826 group: 8 as libc::c_int,
3827 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3828 };
3829 init
3830 },
3831 {
3832 let mut init = commandHelp {
3833 name: b"RANDOMKEY\0" as *const u8 as *const libc::c_char
3834 as *mut libc::c_char,
3835 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3836 summary: b"Return a random key from the keyspace\0" as *const u8
3837 as *const libc::c_char as *mut libc::c_char,
3838 group: 0 as libc::c_int,
3839 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3840 };
3841 init
3842 },
3843 {
3844 let mut init = commandHelp {
3845 name: b"READONLY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3846 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3847 summary: b"Enables read queries for a connection to a cluster replica node\0"
3848 as *const u8 as *const libc::c_char as *mut libc::c_char,
3849 group: 12 as libc::c_int,
3850 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3851 };
3852 init
3853 },
3854 {
3855 let mut init = commandHelp {
3856 name: b"READWRITE\0" as *const u8 as *const libc::c_char
3857 as *mut libc::c_char,
3858 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3859 summary: b"Disables read queries for a connection to a cluster replica node\0"
3860 as *const u8 as *const libc::c_char as *mut libc::c_char,
3861 group: 12 as libc::c_int,
3862 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3863 };
3864 init
3865 },
3866 {
3867 let mut init = commandHelp {
3868 name: b"RENAME\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3869 params: b"key newkey\0" as *const u8 as *const libc::c_char
3870 as *mut libc::c_char,
3871 summary: b"Rename a key\0" as *const u8 as *const libc::c_char
3872 as *mut libc::c_char,
3873 group: 0 as libc::c_int,
3874 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3875 };
3876 init
3877 },
3878 {
3879 let mut init = commandHelp {
3880 name: b"RENAMENX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3881 params: b"key newkey\0" as *const u8 as *const libc::c_char
3882 as *mut libc::c_char,
3883 summary: b"Rename a key, only if the new key does not exist\0" as *const u8
3884 as *const libc::c_char as *mut libc::c_char,
3885 group: 0 as libc::c_int,
3886 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3887 };
3888 init
3889 },
3890 {
3891 let mut init = commandHelp {
3892 name: b"REPLCONF\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3893 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3894 summary: b"An internal command for configuring the replication stream\0"
3895 as *const u8 as *const libc::c_char as *mut libc::c_char,
3896 group: 9 as libc::c_int,
3897 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3898 };
3899 init
3900 },
3901 {
3902 let mut init = commandHelp {
3903 name: b"REPLICAOF\0" as *const u8 as *const libc::c_char
3904 as *mut libc::c_char,
3905 params: b"host port\0" as *const u8 as *const libc::c_char
3906 as *mut libc::c_char,
3907 summary: b"Make the server a replica of another instance, or promote it as master.\0"
3908 as *const u8 as *const libc::c_char as *mut libc::c_char,
3909 group: 9 as libc::c_int,
3910 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3911 };
3912 init
3913 },
3914 {
3915 let mut init = commandHelp {
3916 name: b"RESET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3917 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3918 summary: b"Reset the connection\0" as *const u8 as *const libc::c_char
3919 as *mut libc::c_char,
3920 group: 8 as libc::c_int,
3921 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3922 };
3923 init
3924 },
3925 {
3926 let mut init = commandHelp {
3927 name: b"RESTORE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3928 params: b"key ttl serialized-value [REPLACE] [ABSTTL] [IDLETIME seconds] [FREQ frequency]\0"
3929 as *const u8 as *const libc::c_char as *mut libc::c_char,
3930 summary: b"Create a key using the provided serialized value, previously obtained using DUMP.\0"
3931 as *const u8 as *const libc::c_char as *mut libc::c_char,
3932 group: 0 as libc::c_int,
3933 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3934 };
3935 init
3936 },
3937 {
3938 let mut init = commandHelp {
3939 name: b"RESTORE-ASKING\0" as *const u8 as *const libc::c_char
3940 as *mut libc::c_char,
3941 params: b"key ttl serialized-value [REPLACE] [ABSTTL] [IDLETIME seconds] [FREQ frequency]\0"
3942 as *const u8 as *const libc::c_char as *mut libc::c_char,
3943 summary: b"An internal command for migrating keys in a cluster\0"
3944 as *const u8 as *const libc::c_char as *mut libc::c_char,
3945 group: 9 as libc::c_int,
3946 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3947 };
3948 init
3949 },
3950 {
3951 let mut init = commandHelp {
3952 name: b"ROLE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3953 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3954 summary: b"Return the role of the instance in the context of replication\0"
3955 as *const u8 as *const libc::c_char as *mut libc::c_char,
3956 group: 9 as libc::c_int,
3957 since: b"2.8.12\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3958 };
3959 init
3960 },
3961 {
3962 let mut init = commandHelp {
3963 name: b"RPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3964 params: b"key [count]\0" as *const u8 as *const libc::c_char
3965 as *mut libc::c_char,
3966 summary: b"Remove and get the last elements in a list\0" as *const u8
3967 as *const libc::c_char as *mut libc::c_char,
3968 group: 2 as libc::c_int,
3969 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3970 };
3971 init
3972 },
3973 {
3974 let mut init = commandHelp {
3975 name: b"RPOPLPUSH\0" as *const u8 as *const libc::c_char
3976 as *mut libc::c_char,
3977 params: b"source destination\0" as *const u8 as *const libc::c_char
3978 as *mut libc::c_char,
3979 summary: b"Remove the last element in a list, prepend it to another list and return it\0"
3980 as *const u8 as *const libc::c_char as *mut libc::c_char,
3981 group: 2 as libc::c_int,
3982 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3983 };
3984 init
3985 },
3986 {
3987 let mut init = commandHelp {
3988 name: b"RPUSH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3989 params: b"key element [element ...]\0" as *const u8 as *const libc::c_char
3990 as *mut libc::c_char,
3991 summary: b"Append one or multiple elements to a list\0" as *const u8
3992 as *const libc::c_char as *mut libc::c_char,
3993 group: 2 as libc::c_int,
3994 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
3995 };
3996 init
3997 },
3998 {
3999 let mut init = commandHelp {
4000 name: b"RPUSHX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4001 params: b"key element [element ...]\0" as *const u8 as *const libc::c_char
4002 as *mut libc::c_char,
4003 summary: b"Append an element to a list, only if the list exists\0"
4004 as *const u8 as *const libc::c_char as *mut libc::c_char,
4005 group: 2 as libc::c_int,
4006 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4007 };
4008 init
4009 },
4010 {
4011 let mut init = commandHelp {
4012 name: b"SADD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4013 params: b"key member [member ...]\0" as *const u8 as *const libc::c_char
4014 as *mut libc::c_char,
4015 summary: b"Add one or more members to a set\0" as *const u8
4016 as *const libc::c_char as *mut libc::c_char,
4017 group: 3 as libc::c_int,
4018 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4019 };
4020 init
4021 },
4022 {
4023 let mut init = commandHelp {
4024 name: b"SAVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4025 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4026 summary: b"Synchronously save the dataset to disk\0" as *const u8
4027 as *const libc::c_char as *mut libc::c_char,
4028 group: 9 as libc::c_int,
4029 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4030 };
4031 init
4032 },
4033 {
4034 let mut init = commandHelp {
4035 name: b"SCAN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4036 params: b"cursor [MATCH pattern] [COUNT count] [TYPE type]\0" as *const u8
4037 as *const libc::c_char as *mut libc::c_char,
4038 summary: b"Incrementally iterate the keys space\0" as *const u8
4039 as *const libc::c_char as *mut libc::c_char,
4040 group: 0 as libc::c_int,
4041 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4042 };
4043 init
4044 },
4045 {
4046 let mut init = commandHelp {
4047 name: b"SCARD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4048 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4049 summary: b"Get the number of members in a set\0" as *const u8
4050 as *const libc::c_char as *mut libc::c_char,
4051 group: 3 as libc::c_int,
4052 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4053 };
4054 init
4055 },
4056 {
4057 let mut init = commandHelp {
4058 name: b"SCRIPT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4059 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4060 summary: b"A container for Lua scripts management commands\0" as *const u8
4061 as *const libc::c_char as *mut libc::c_char,
4062 group: 10 as libc::c_int,
4063 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4064 };
4065 init
4066 },
4067 {
4068 let mut init = commandHelp {
4069 name: b"SCRIPT DEBUG\0" as *const u8 as *const libc::c_char
4070 as *mut libc::c_char,
4071 params: b"YES|SYNC|NO\0" as *const u8 as *const libc::c_char
4072 as *mut libc::c_char,
4073 summary: b"Set the debug mode for executed scripts.\0" as *const u8
4074 as *const libc::c_char as *mut libc::c_char,
4075 group: 10 as libc::c_int,
4076 since: b"3.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4077 };
4078 init
4079 },
4080 {
4081 let mut init = commandHelp {
4082 name: b"SCRIPT EXISTS\0" as *const u8 as *const libc::c_char
4083 as *mut libc::c_char,
4084 params: b"sha1 [sha1 ...]\0" as *const u8 as *const libc::c_char
4085 as *mut libc::c_char,
4086 summary: b"Check existence of scripts in the script cache.\0" as *const u8
4087 as *const libc::c_char as *mut libc::c_char,
4088 group: 10 as libc::c_int,
4089 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4090 };
4091 init
4092 },
4093 {
4094 let mut init = commandHelp {
4095 name: b"SCRIPT FLUSH\0" as *const u8 as *const libc::c_char
4096 as *mut libc::c_char,
4097 params: b"[ASYNC|SYNC]\0" as *const u8 as *const libc::c_char
4098 as *mut libc::c_char,
4099 summary: b"Remove all the scripts from the script cache.\0" as *const u8
4100 as *const libc::c_char as *mut libc::c_char,
4101 group: 10 as libc::c_int,
4102 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4103 };
4104 init
4105 },
4106 {
4107 let mut init = commandHelp {
4108 name: b"SCRIPT HELP\0" as *const u8 as *const libc::c_char
4109 as *mut libc::c_char,
4110 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4111 summary: b"Show helpful text about the different subcommands\0" as *const u8
4112 as *const libc::c_char as *mut libc::c_char,
4113 group: 10 as libc::c_int,
4114 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4115 };
4116 init
4117 },
4118 {
4119 let mut init = commandHelp {
4120 name: b"SCRIPT KILL\0" as *const u8 as *const libc::c_char
4121 as *mut libc::c_char,
4122 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4123 summary: b"Kill the script currently in execution.\0" as *const u8
4124 as *const libc::c_char as *mut libc::c_char,
4125 group: 10 as libc::c_int,
4126 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4127 };
4128 init
4129 },
4130 {
4131 let mut init = commandHelp {
4132 name: b"SCRIPT LOAD\0" as *const u8 as *const libc::c_char
4133 as *mut libc::c_char,
4134 params: b"script\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4135 summary: b"Load the specified Lua script into the script cache.\0"
4136 as *const u8 as *const libc::c_char as *mut libc::c_char,
4137 group: 10 as libc::c_int,
4138 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4139 };
4140 init
4141 },
4142 {
4143 let mut init = commandHelp {
4144 name: b"SDIFF\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4145 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
4146 as *mut libc::c_char,
4147 summary: b"Subtract multiple sets\0" as *const u8 as *const libc::c_char
4148 as *mut libc::c_char,
4149 group: 3 as libc::c_int,
4150 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4151 };
4152 init
4153 },
4154 {
4155 let mut init = commandHelp {
4156 name: b"SDIFFSTORE\0" as *const u8 as *const libc::c_char
4157 as *mut libc::c_char,
4158 params: b"destination key [key ...]\0" as *const u8 as *const libc::c_char
4159 as *mut libc::c_char,
4160 summary: b"Subtract multiple sets and store the resulting set in a key\0"
4161 as *const u8 as *const libc::c_char as *mut libc::c_char,
4162 group: 3 as libc::c_int,
4163 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4164 };
4165 init
4166 },
4167 {
4168 let mut init = commandHelp {
4169 name: b"SELECT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4170 params: b"index\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4171 summary: b"Change the selected database for the current connection\0"
4172 as *const u8 as *const libc::c_char as *mut libc::c_char,
4173 group: 8 as libc::c_int,
4174 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4175 };
4176 init
4177 },
4178 {
4179 let mut init = commandHelp {
4180 name: b"SET\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4181 params: b"key value [NX|XX] [GET] [EX seconds|PX milliseconds|EXAT unix-time-seconds|PXAT unix-time-milliseconds|KEEPTTL]\0"
4182 as *const u8 as *const libc::c_char as *mut libc::c_char,
4183 summary: b"Set the string value of a key\0" as *const u8
4184 as *const libc::c_char as *mut libc::c_char,
4185 group: 1 as libc::c_int,
4186 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4187 };
4188 init
4189 },
4190 {
4191 let mut init = commandHelp {
4192 name: b"SETBIT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4193 params: b"key offset value\0" as *const u8 as *const libc::c_char
4194 as *mut libc::c_char,
4195 summary: b"Sets or clears the bit at offset in the string value stored at key\0"
4196 as *const u8 as *const libc::c_char as *mut libc::c_char,
4197 group: 15 as libc::c_int,
4198 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4199 };
4200 init
4201 },
4202 {
4203 let mut init = commandHelp {
4204 name: b"SETEX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4205 params: b"key seconds value\0" as *const u8 as *const libc::c_char
4206 as *mut libc::c_char,
4207 summary: b"Set the value and expiration of a key\0" as *const u8
4208 as *const libc::c_char as *mut libc::c_char,
4209 group: 1 as libc::c_int,
4210 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4211 };
4212 init
4213 },
4214 {
4215 let mut init = commandHelp {
4216 name: b"SETNX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4217 params: b"key value\0" as *const u8 as *const libc::c_char
4218 as *mut libc::c_char,
4219 summary: b"Set the value of a key, only if the key does not exist\0"
4220 as *const u8 as *const libc::c_char as *mut libc::c_char,
4221 group: 1 as libc::c_int,
4222 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4223 };
4224 init
4225 },
4226 {
4227 let mut init = commandHelp {
4228 name: b"SETRANGE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4229 params: b"key offset value\0" as *const u8 as *const libc::c_char
4230 as *mut libc::c_char,
4231 summary: b"Overwrite part of a string at key starting at the specified offset\0"
4232 as *const u8 as *const libc::c_char as *mut libc::c_char,
4233 group: 1 as libc::c_int,
4234 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4235 };
4236 init
4237 },
4238 {
4239 let mut init = commandHelp {
4240 name: b"SHUTDOWN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4241 params: b"[NOSAVE|SAVE] [NOW] [FORCE] [ABORT]\0" as *const u8
4242 as *const libc::c_char as *mut libc::c_char,
4243 summary: b"Synchronously save the dataset to disk and then shut down the server\0"
4244 as *const u8 as *const libc::c_char as *mut libc::c_char,
4245 group: 9 as libc::c_int,
4246 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4247 };
4248 init
4249 },
4250 {
4251 let mut init = commandHelp {
4252 name: b"SINTER\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4253 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
4254 as *mut libc::c_char,
4255 summary: b"Intersect multiple sets\0" as *const u8 as *const libc::c_char
4256 as *mut libc::c_char,
4257 group: 3 as libc::c_int,
4258 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4259 };
4260 init
4261 },
4262 {
4263 let mut init = commandHelp {
4264 name: b"SINTERCARD\0" as *const u8 as *const libc::c_char
4265 as *mut libc::c_char,
4266 params: b"numkeys key [key ...] [LIMIT limit]\0" as *const u8
4267 as *const libc::c_char as *mut libc::c_char,
4268 summary: b"Intersect multiple sets and return the cardinality of the result\0"
4269 as *const u8 as *const libc::c_char as *mut libc::c_char,
4270 group: 3 as libc::c_int,
4271 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4272 };
4273 init
4274 },
4275 {
4276 let mut init = commandHelp {
4277 name: b"SINTERSTORE\0" as *const u8 as *const libc::c_char
4278 as *mut libc::c_char,
4279 params: b"destination key [key ...]\0" as *const u8 as *const libc::c_char
4280 as *mut libc::c_char,
4281 summary: b"Intersect multiple sets and store the resulting set in a key\0"
4282 as *const u8 as *const libc::c_char as *mut libc::c_char,
4283 group: 3 as libc::c_int,
4284 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4285 };
4286 init
4287 },
4288 {
4289 let mut init = commandHelp {
4290 name: b"SISMEMBER\0" as *const u8 as *const libc::c_char
4291 as *mut libc::c_char,
4292 params: b"key member\0" as *const u8 as *const libc::c_char
4293 as *mut libc::c_char,
4294 summary: b"Determine if a given value is a member of a set\0" as *const u8
4295 as *const libc::c_char as *mut libc::c_char,
4296 group: 3 as libc::c_int,
4297 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4298 };
4299 init
4300 },
4301 {
4302 let mut init = commandHelp {
4303 name: b"SLAVEOF\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4304 params: b"host port\0" as *const u8 as *const libc::c_char
4305 as *mut libc::c_char,
4306 summary: b"Make the server a replica of another instance, or promote it as master.\0"
4307 as *const u8 as *const libc::c_char as *mut libc::c_char,
4308 group: 9 as libc::c_int,
4309 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4310 };
4311 init
4312 },
4313 {
4314 let mut init = commandHelp {
4315 name: b"SLOWLOG\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4316 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4317 summary: b"A container for slow log commands\0" as *const u8
4318 as *const libc::c_char as *mut libc::c_char,
4319 group: 9 as libc::c_int,
4320 since: b"2.2.12\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4321 };
4322 init
4323 },
4324 {
4325 let mut init = commandHelp {
4326 name: b"SLOWLOG GET\0" as *const u8 as *const libc::c_char
4327 as *mut libc::c_char,
4328 params: b"[count]\0" as *const u8 as *const libc::c_char
4329 as *mut libc::c_char,
4330 summary: b"Get the slow log's entries\0" as *const u8 as *const libc::c_char
4331 as *mut libc::c_char,
4332 group: 9 as libc::c_int,
4333 since: b"2.2.12\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4334 };
4335 init
4336 },
4337 {
4338 let mut init = commandHelp {
4339 name: b"SLOWLOG HELP\0" as *const u8 as *const libc::c_char
4340 as *mut libc::c_char,
4341 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4342 summary: b"Show helpful text about the different subcommands\0" as *const u8
4343 as *const libc::c_char as *mut libc::c_char,
4344 group: 9 as libc::c_int,
4345 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4346 };
4347 init
4348 },
4349 {
4350 let mut init = commandHelp {
4351 name: b"SLOWLOG LEN\0" as *const u8 as *const libc::c_char
4352 as *mut libc::c_char,
4353 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4354 summary: b"Get the slow log's length\0" as *const u8 as *const libc::c_char
4355 as *mut libc::c_char,
4356 group: 9 as libc::c_int,
4357 since: b"2.2.12\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4358 };
4359 init
4360 },
4361 {
4362 let mut init = commandHelp {
4363 name: b"SLOWLOG RESET\0" as *const u8 as *const libc::c_char
4364 as *mut libc::c_char,
4365 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4366 summary: b"Clear all entries from the slow log\0" as *const u8
4367 as *const libc::c_char as *mut libc::c_char,
4368 group: 9 as libc::c_int,
4369 since: b"2.2.12\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4370 };
4371 init
4372 },
4373 {
4374 let mut init = commandHelp {
4375 name: b"SMEMBERS\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4376 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4377 summary: b"Get all the members in a set\0" as *const u8
4378 as *const libc::c_char as *mut libc::c_char,
4379 group: 3 as libc::c_int,
4380 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4381 };
4382 init
4383 },
4384 {
4385 let mut init = commandHelp {
4386 name: b"SMISMEMBER\0" as *const u8 as *const libc::c_char
4387 as *mut libc::c_char,
4388 params: b"key member [member ...]\0" as *const u8 as *const libc::c_char
4389 as *mut libc::c_char,
4390 summary: b"Returns the membership associated with the given elements for a set\0"
4391 as *const u8 as *const libc::c_char as *mut libc::c_char,
4392 group: 3 as libc::c_int,
4393 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4394 };
4395 init
4396 },
4397 {
4398 let mut init = commandHelp {
4399 name: b"SMOVE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4400 params: b"source destination member\0" as *const u8 as *const libc::c_char
4401 as *mut libc::c_char,
4402 summary: b"Move a member from one set to another\0" as *const u8
4403 as *const libc::c_char as *mut libc::c_char,
4404 group: 3 as libc::c_int,
4405 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4406 };
4407 init
4408 },
4409 {
4410 let mut init = commandHelp {
4411 name: b"SORT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4412 params: b"key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination]\0"
4413 as *const u8 as *const libc::c_char as *mut libc::c_char,
4414 summary: b"Sort the elements in a list, set or sorted set\0" as *const u8
4415 as *const libc::c_char as *mut libc::c_char,
4416 group: 0 as libc::c_int,
4417 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4418 };
4419 init
4420 },
4421 {
4422 let mut init = commandHelp {
4423 name: b"SORT_RO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4424 params: b"key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA]\0"
4425 as *const u8 as *const libc::c_char as *mut libc::c_char,
4426 summary: b"Sort the elements in a list, set or sorted set. Read-only variant of SORT.\0"
4427 as *const u8 as *const libc::c_char as *mut libc::c_char,
4428 group: 0 as libc::c_int,
4429 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4430 };
4431 init
4432 },
4433 {
4434 let mut init = commandHelp {
4435 name: b"SPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4436 params: b"key [count]\0" as *const u8 as *const libc::c_char
4437 as *mut libc::c_char,
4438 summary: b"Remove and return one or multiple random members from a set\0"
4439 as *const u8 as *const libc::c_char as *mut libc::c_char,
4440 group: 3 as libc::c_int,
4441 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4442 };
4443 init
4444 },
4445 {
4446 let mut init = commandHelp {
4447 name: b"SPUBLISH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4448 params: b"shardchannel message\0" as *const u8 as *const libc::c_char
4449 as *mut libc::c_char,
4450 summary: b"Post a message to a shard channel\0" as *const u8
4451 as *const libc::c_char as *mut libc::c_char,
4452 group: 6 as libc::c_int,
4453 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4454 };
4455 init
4456 },
4457 {
4458 let mut init = commandHelp {
4459 name: b"SRANDMEMBER\0" as *const u8 as *const libc::c_char
4460 as *mut libc::c_char,
4461 params: b"key [count]\0" as *const u8 as *const libc::c_char
4462 as *mut libc::c_char,
4463 summary: b"Get one or multiple random members from a set\0" as *const u8
4464 as *const libc::c_char as *mut libc::c_char,
4465 group: 3 as libc::c_int,
4466 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4467 };
4468 init
4469 },
4470 {
4471 let mut init = commandHelp {
4472 name: b"SREM\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4473 params: b"key member [member ...]\0" as *const u8 as *const libc::c_char
4474 as *mut libc::c_char,
4475 summary: b"Remove one or more members from a set\0" as *const u8
4476 as *const libc::c_char as *mut libc::c_char,
4477 group: 3 as libc::c_int,
4478 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4479 };
4480 init
4481 },
4482 {
4483 let mut init = commandHelp {
4484 name: b"SSCAN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4485 params: b"key cursor [MATCH pattern] [COUNT count]\0" as *const u8
4486 as *const libc::c_char as *mut libc::c_char,
4487 summary: b"Incrementally iterate Set elements\0" as *const u8
4488 as *const libc::c_char as *mut libc::c_char,
4489 group: 3 as libc::c_int,
4490 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4491 };
4492 init
4493 },
4494 {
4495 let mut init = commandHelp {
4496 name: b"SSUBSCRIBE\0" as *const u8 as *const libc::c_char
4497 as *mut libc::c_char,
4498 params: b"shardchannel [shardchannel ...]\0" as *const u8
4499 as *const libc::c_char as *mut libc::c_char,
4500 summary: b"Listen for messages published to the given shard channels\0"
4501 as *const u8 as *const libc::c_char as *mut libc::c_char,
4502 group: 6 as libc::c_int,
4503 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4504 };
4505 init
4506 },
4507 {
4508 let mut init = commandHelp {
4509 name: b"STRLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4510 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4511 summary: b"Get the length of the value stored in a key\0" as *const u8
4512 as *const libc::c_char as *mut libc::c_char,
4513 group: 1 as libc::c_int,
4514 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4515 };
4516 init
4517 },
4518 {
4519 let mut init = commandHelp {
4520 name: b"SUBSCRIBE\0" as *const u8 as *const libc::c_char
4521 as *mut libc::c_char,
4522 params: b"channel [channel ...]\0" as *const u8 as *const libc::c_char
4523 as *mut libc::c_char,
4524 summary: b"Listen for messages published to the given channels\0"
4525 as *const u8 as *const libc::c_char as *mut libc::c_char,
4526 group: 6 as libc::c_int,
4527 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4528 };
4529 init
4530 },
4531 {
4532 let mut init = commandHelp {
4533 name: b"SUBSTR\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4534 params: b"key start end\0" as *const u8 as *const libc::c_char
4535 as *mut libc::c_char,
4536 summary: b"Get a substring of the string stored at a key\0" as *const u8
4537 as *const libc::c_char as *mut libc::c_char,
4538 group: 1 as libc::c_int,
4539 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4540 };
4541 init
4542 },
4543 {
4544 let mut init = commandHelp {
4545 name: b"SUNION\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4546 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
4547 as *mut libc::c_char,
4548 summary: b"Add multiple sets\0" as *const u8 as *const libc::c_char
4549 as *mut libc::c_char,
4550 group: 3 as libc::c_int,
4551 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4552 };
4553 init
4554 },
4555 {
4556 let mut init = commandHelp {
4557 name: b"SUNIONSTORE\0" as *const u8 as *const libc::c_char
4558 as *mut libc::c_char,
4559 params: b"destination key [key ...]\0" as *const u8 as *const libc::c_char
4560 as *mut libc::c_char,
4561 summary: b"Add multiple sets and store the resulting set in a key\0"
4562 as *const u8 as *const libc::c_char as *mut libc::c_char,
4563 group: 3 as libc::c_int,
4564 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4565 };
4566 init
4567 },
4568 {
4569 let mut init = commandHelp {
4570 name: b"SUNSUBSCRIBE\0" as *const u8 as *const libc::c_char
4571 as *mut libc::c_char,
4572 params: b"[shardchannel [shardchannel ...]]\0" as *const u8
4573 as *const libc::c_char as *mut libc::c_char,
4574 summary: b"Stop listening for messages posted to the given shard channels\0"
4575 as *const u8 as *const libc::c_char as *mut libc::c_char,
4576 group: 6 as libc::c_int,
4577 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4578 };
4579 init
4580 },
4581 {
4582 let mut init = commandHelp {
4583 name: b"SWAPDB\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4584 params: b"index1 index2\0" as *const u8 as *const libc::c_char
4585 as *mut libc::c_char,
4586 summary: b"Swaps two Redis databases\0" as *const u8 as *const libc::c_char
4587 as *mut libc::c_char,
4588 group: 9 as libc::c_int,
4589 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4590 };
4591 init
4592 },
4593 {
4594 let mut init = commandHelp {
4595 name: b"SYNC\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4596 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4597 summary: b"Internal command used for replication\0" as *const u8
4598 as *const libc::c_char as *mut libc::c_char,
4599 group: 9 as libc::c_int,
4600 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4601 };
4602 init
4603 },
4604 {
4605 let mut init = commandHelp {
4606 name: b"TIME\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4607 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4608 summary: b"Return the current server time\0" as *const u8
4609 as *const libc::c_char as *mut libc::c_char,
4610 group: 9 as libc::c_int,
4611 since: b"2.6.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4612 };
4613 init
4614 },
4615 {
4616 let mut init = commandHelp {
4617 name: b"TOUCH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4618 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
4619 as *mut libc::c_char,
4620 summary: b"Alters the last access time of a key(s). Returns the number of existing keys specified.\0"
4621 as *const u8 as *const libc::c_char as *mut libc::c_char,
4622 group: 0 as libc::c_int,
4623 since: b"3.2.1\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4624 };
4625 init
4626 },
4627 {
4628 let mut init = commandHelp {
4629 name: b"TTL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4630 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4631 summary: b"Get the time to live for a key in seconds\0" as *const u8
4632 as *const libc::c_char as *mut libc::c_char,
4633 group: 0 as libc::c_int,
4634 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4635 };
4636 init
4637 },
4638 {
4639 let mut init = commandHelp {
4640 name: b"TYPE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4641 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4642 summary: b"Determine the type stored at key\0" as *const u8
4643 as *const libc::c_char as *mut libc::c_char,
4644 group: 0 as libc::c_int,
4645 since: b"1.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4646 };
4647 init
4648 },
4649 {
4650 let mut init = commandHelp {
4651 name: b"UNLINK\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4652 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
4653 as *mut libc::c_char,
4654 summary: b"Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.\0"
4655 as *const u8 as *const libc::c_char as *mut libc::c_char,
4656 group: 0 as libc::c_int,
4657 since: b"4.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4658 };
4659 init
4660 },
4661 {
4662 let mut init = commandHelp {
4663 name: b"UNSUBSCRIBE\0" as *const u8 as *const libc::c_char
4664 as *mut libc::c_char,
4665 params: b"[channel [channel ...]]\0" as *const u8 as *const libc::c_char
4666 as *mut libc::c_char,
4667 summary: b"Stop listening for messages posted to the given channels\0"
4668 as *const u8 as *const libc::c_char as *mut libc::c_char,
4669 group: 6 as libc::c_int,
4670 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4671 };
4672 init
4673 },
4674 {
4675 let mut init = commandHelp {
4676 name: b"UNWATCH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4677 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4678 summary: b"Forget about all watched keys\0" as *const u8
4679 as *const libc::c_char as *mut libc::c_char,
4680 group: 7 as libc::c_int,
4681 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4682 };
4683 init
4684 },
4685 {
4686 let mut init = commandHelp {
4687 name: b"WAIT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4688 params: b"numreplicas timeout\0" as *const u8 as *const libc::c_char
4689 as *mut libc::c_char,
4690 summary: b"Wait for the synchronous replication of all the write commands sent in the context of the current connection\0"
4691 as *const u8 as *const libc::c_char as *mut libc::c_char,
4692 group: 0 as libc::c_int,
4693 since: b"3.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4694 };
4695 init
4696 },
4697 {
4698 let mut init = commandHelp {
4699 name: b"WATCH\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4700 params: b"key [key ...]\0" as *const u8 as *const libc::c_char
4701 as *mut libc::c_char,
4702 summary: b"Watch the given keys to determine execution of the MULTI/EXEC block\0"
4703 as *const u8 as *const libc::c_char as *mut libc::c_char,
4704 group: 7 as libc::c_int,
4705 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4706 };
4707 init
4708 },
4709 {
4710 let mut init = commandHelp {
4711 name: b"XACK\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4712 params: b"key group id [id ...]\0" as *const u8 as *const libc::c_char
4713 as *mut libc::c_char,
4714 summary: b"Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.\0"
4715 as *const u8 as *const libc::c_char as *mut libc::c_char,
4716 group: 14 as libc::c_int,
4717 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4718 };
4719 init
4720 },
4721 {
4722 let mut init = commandHelp {
4723 name: b"XADD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4724 params: b"key [NOMKSTREAM] [MAXLEN|MINID [=|~] threshold [LIMIT count]] *|id field value [field value ...]\0"
4725 as *const u8 as *const libc::c_char as *mut libc::c_char,
4726 summary: b"Appends a new entry to a stream\0" as *const u8
4727 as *const libc::c_char as *mut libc::c_char,
4728 group: 14 as libc::c_int,
4729 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4730 };
4731 init
4732 },
4733 {
4734 let mut init = commandHelp {
4735 name: b"XAUTOCLAIM\0" as *const u8 as *const libc::c_char
4736 as *mut libc::c_char,
4737 params: b"key group consumer min-idle-time start [COUNT count] [JUSTID]\0"
4738 as *const u8 as *const libc::c_char as *mut libc::c_char,
4739 summary: b"Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.\0"
4740 as *const u8 as *const libc::c_char as *mut libc::c_char,
4741 group: 14 as libc::c_int,
4742 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4743 };
4744 init
4745 },
4746 {
4747 let mut init = commandHelp {
4748 name: b"XCLAIM\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4749 params: b"key group consumer min-idle-time id [id ...] [IDLE ms] [TIME unix-time-milliseconds] [RETRYCOUNT count] [FORCE] [JUSTID] [LASTID id]\0"
4750 as *const u8 as *const libc::c_char as *mut libc::c_char,
4751 summary: b"Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.\0"
4752 as *const u8 as *const libc::c_char as *mut libc::c_char,
4753 group: 14 as libc::c_int,
4754 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4755 };
4756 init
4757 },
4758 {
4759 let mut init = commandHelp {
4760 name: b"XDEL\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4761 params: b"key id [id ...]\0" as *const u8 as *const libc::c_char
4762 as *mut libc::c_char,
4763 summary: b"Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.\0"
4764 as *const u8 as *const libc::c_char as *mut libc::c_char,
4765 group: 14 as libc::c_int,
4766 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4767 };
4768 init
4769 },
4770 {
4771 let mut init = commandHelp {
4772 name: b"XGROUP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4773 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4774 summary: b"A container for consumer groups commands\0" as *const u8
4775 as *const libc::c_char as *mut libc::c_char,
4776 group: 14 as libc::c_int,
4777 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4778 };
4779 init
4780 },
4781 {
4782 let mut init = commandHelp {
4783 name: b"XGROUP CREATE\0" as *const u8 as *const libc::c_char
4784 as *mut libc::c_char,
4785 params: b"key groupname id|$ [MKSTREAM] [ENTRIESREAD entries_read]\0"
4786 as *const u8 as *const libc::c_char as *mut libc::c_char,
4787 summary: b"Create a consumer group.\0" as *const u8 as *const libc::c_char
4788 as *mut libc::c_char,
4789 group: 14 as libc::c_int,
4790 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4791 };
4792 init
4793 },
4794 {
4795 let mut init = commandHelp {
4796 name: b"XGROUP CREATECONSUMER\0" as *const u8 as *const libc::c_char
4797 as *mut libc::c_char,
4798 params: b"key groupname consumername\0" as *const u8 as *const libc::c_char
4799 as *mut libc::c_char,
4800 summary: b"Create a consumer in a consumer group.\0" as *const u8
4801 as *const libc::c_char as *mut libc::c_char,
4802 group: 14 as libc::c_int,
4803 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4804 };
4805 init
4806 },
4807 {
4808 let mut init = commandHelp {
4809 name: b"XGROUP DELCONSUMER\0" as *const u8 as *const libc::c_char
4810 as *mut libc::c_char,
4811 params: b"key groupname consumername\0" as *const u8 as *const libc::c_char
4812 as *mut libc::c_char,
4813 summary: b"Delete a consumer from a consumer group.\0" as *const u8
4814 as *const libc::c_char as *mut libc::c_char,
4815 group: 14 as libc::c_int,
4816 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4817 };
4818 init
4819 },
4820 {
4821 let mut init = commandHelp {
4822 name: b"XGROUP DESTROY\0" as *const u8 as *const libc::c_char
4823 as *mut libc::c_char,
4824 params: b"key groupname\0" as *const u8 as *const libc::c_char
4825 as *mut libc::c_char,
4826 summary: b"Destroy a consumer group.\0" as *const u8 as *const libc::c_char
4827 as *mut libc::c_char,
4828 group: 14 as libc::c_int,
4829 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4830 };
4831 init
4832 },
4833 {
4834 let mut init = commandHelp {
4835 name: b"XGROUP HELP\0" as *const u8 as *const libc::c_char
4836 as *mut libc::c_char,
4837 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4838 summary: b"Show helpful text about the different subcommands\0" as *const u8
4839 as *const libc::c_char as *mut libc::c_char,
4840 group: 14 as libc::c_int,
4841 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4842 };
4843 init
4844 },
4845 {
4846 let mut init = commandHelp {
4847 name: b"XGROUP SETID\0" as *const u8 as *const libc::c_char
4848 as *mut libc::c_char,
4849 params: b"key groupname id|$ [ENTRIESREAD entries_read]\0" as *const u8
4850 as *const libc::c_char as *mut libc::c_char,
4851 summary: b"Set a consumer group to an arbitrary last delivered ID value.\0"
4852 as *const u8 as *const libc::c_char as *mut libc::c_char,
4853 group: 14 as libc::c_int,
4854 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4855 };
4856 init
4857 },
4858 {
4859 let mut init = commandHelp {
4860 name: b"XINFO\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4861 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4862 summary: b"A container for stream introspection commands\0" as *const u8
4863 as *const libc::c_char as *mut libc::c_char,
4864 group: 14 as libc::c_int,
4865 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4866 };
4867 init
4868 },
4869 {
4870 let mut init = commandHelp {
4871 name: b"XINFO CONSUMERS\0" as *const u8 as *const libc::c_char
4872 as *mut libc::c_char,
4873 params: b"key groupname\0" as *const u8 as *const libc::c_char
4874 as *mut libc::c_char,
4875 summary: b"List the consumers in a consumer group\0" as *const u8
4876 as *const libc::c_char as *mut libc::c_char,
4877 group: 14 as libc::c_int,
4878 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4879 };
4880 init
4881 },
4882 {
4883 let mut init = commandHelp {
4884 name: b"XINFO GROUPS\0" as *const u8 as *const libc::c_char
4885 as *mut libc::c_char,
4886 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4887 summary: b"List the consumer groups of a stream\0" as *const u8
4888 as *const libc::c_char as *mut libc::c_char,
4889 group: 14 as libc::c_int,
4890 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4891 };
4892 init
4893 },
4894 {
4895 let mut init = commandHelp {
4896 name: b"XINFO HELP\0" as *const u8 as *const libc::c_char
4897 as *mut libc::c_char,
4898 params: b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4899 summary: b"Show helpful text about the different subcommands\0" as *const u8
4900 as *const libc::c_char as *mut libc::c_char,
4901 group: 14 as libc::c_int,
4902 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4903 };
4904 init
4905 },
4906 {
4907 let mut init = commandHelp {
4908 name: b"XINFO STREAM\0" as *const u8 as *const libc::c_char
4909 as *mut libc::c_char,
4910 params: b"key [FULL [COUNT count]]\0" as *const u8 as *const libc::c_char
4911 as *mut libc::c_char,
4912 summary: b"Get information about a stream\0" as *const u8
4913 as *const libc::c_char as *mut libc::c_char,
4914 group: 14 as libc::c_int,
4915 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4916 };
4917 init
4918 },
4919 {
4920 let mut init = commandHelp {
4921 name: b"XLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4922 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4923 summary: b"Return the number of entries in a stream\0" as *const u8
4924 as *const libc::c_char as *mut libc::c_char,
4925 group: 14 as libc::c_int,
4926 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4927 };
4928 init
4929 },
4930 {
4931 let mut init = commandHelp {
4932 name: b"XPENDING\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4933 params: b"key group [[IDLE min-idle-time] start end count [consumer]]\0"
4934 as *const u8 as *const libc::c_char as *mut libc::c_char,
4935 summary: b"Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.\0"
4936 as *const u8 as *const libc::c_char as *mut libc::c_char,
4937 group: 14 as libc::c_int,
4938 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4939 };
4940 init
4941 },
4942 {
4943 let mut init = commandHelp {
4944 name: b"XRANGE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4945 params: b"key start end [COUNT count]\0" as *const u8 as *const libc::c_char
4946 as *mut libc::c_char,
4947 summary: b"Return a range of elements in a stream, with IDs matching the specified IDs interval\0"
4948 as *const u8 as *const libc::c_char as *mut libc::c_char,
4949 group: 14 as libc::c_int,
4950 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4951 };
4952 init
4953 },
4954 {
4955 let mut init = commandHelp {
4956 name: b"XREAD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4957 params: b"[COUNT count] [BLOCK milliseconds] STREAMS key [key ...] id [id ...]\0"
4958 as *const u8 as *const libc::c_char as *mut libc::c_char,
4959 summary: b"Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.\0"
4960 as *const u8 as *const libc::c_char as *mut libc::c_char,
4961 group: 14 as libc::c_int,
4962 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4963 };
4964 init
4965 },
4966 {
4967 let mut init = commandHelp {
4968 name: b"XREADGROUP\0" as *const u8 as *const libc::c_char
4969 as *mut libc::c_char,
4970 params: b"GROUP group consumer [COUNT count] [BLOCK milliseconds] [NOACK] STREAMS key [key ...] id [id ...]\0"
4971 as *const u8 as *const libc::c_char as *mut libc::c_char,
4972 summary: b"Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.\0"
4973 as *const u8 as *const libc::c_char as *mut libc::c_char,
4974 group: 14 as libc::c_int,
4975 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4976 };
4977 init
4978 },
4979 {
4980 let mut init = commandHelp {
4981 name: b"XREVRANGE\0" as *const u8 as *const libc::c_char
4982 as *mut libc::c_char,
4983 params: b"key end start [COUNT count]\0" as *const u8 as *const libc::c_char
4984 as *mut libc::c_char,
4985 summary: b"Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE\0"
4986 as *const u8 as *const libc::c_char as *mut libc::c_char,
4987 group: 14 as libc::c_int,
4988 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4989 };
4990 init
4991 },
4992 {
4993 let mut init = commandHelp {
4994 name: b"XSETID\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
4995 params: b"key last-id [ENTRIESADDED entries_added] [MAXDELETEDID max_deleted_entry_id]\0"
4996 as *const u8 as *const libc::c_char as *mut libc::c_char,
4997 summary: b"An internal command for replicating stream values\0" as *const u8
4998 as *const libc::c_char as *mut libc::c_char,
4999 group: 14 as libc::c_int,
5000 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5001 };
5002 init
5003 },
5004 {
5005 let mut init = commandHelp {
5006 name: b"XTRIM\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5007 params: b"key MAXLEN|MINID [=|~] threshold [LIMIT count]\0" as *const u8
5008 as *const libc::c_char as *mut libc::c_char,
5009 summary: b"Trims the stream to (approximately if '~' is passed) a certain size\0"
5010 as *const u8 as *const libc::c_char as *mut libc::c_char,
5011 group: 14 as libc::c_int,
5012 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5013 };
5014 init
5015 },
5016 {
5017 let mut init = commandHelp {
5018 name: b"ZADD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5019 params: b"key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]\0"
5020 as *const u8 as *const libc::c_char as *mut libc::c_char,
5021 summary: b"Add one or more members to a sorted set, or update its score if it already exists\0"
5022 as *const u8 as *const libc::c_char as *mut libc::c_char,
5023 group: 4 as libc::c_int,
5024 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5025 };
5026 init
5027 },
5028 {
5029 let mut init = commandHelp {
5030 name: b"ZCARD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5031 params: b"key\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5032 summary: b"Get the number of members in a sorted set\0" as *const u8
5033 as *const libc::c_char as *mut libc::c_char,
5034 group: 4 as libc::c_int,
5035 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5036 };
5037 init
5038 },
5039 {
5040 let mut init = commandHelp {
5041 name: b"ZCOUNT\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5042 params: b"key min max\0" as *const u8 as *const libc::c_char
5043 as *mut libc::c_char,
5044 summary: b"Count the members in a sorted set with scores within the given values\0"
5045 as *const u8 as *const libc::c_char as *mut libc::c_char,
5046 group: 4 as libc::c_int,
5047 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5048 };
5049 init
5050 },
5051 {
5052 let mut init = commandHelp {
5053 name: b"ZDIFF\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5054 params: b"numkeys key [key ...] [WITHSCORES]\0" as *const u8
5055 as *const libc::c_char as *mut libc::c_char,
5056 summary: b"Subtract multiple sorted sets\0" as *const u8
5057 as *const libc::c_char as *mut libc::c_char,
5058 group: 4 as libc::c_int,
5059 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5060 };
5061 init
5062 },
5063 {
5064 let mut init = commandHelp {
5065 name: b"ZDIFFSTORE\0" as *const u8 as *const libc::c_char
5066 as *mut libc::c_char,
5067 params: b"destination numkeys key [key ...]\0" as *const u8
5068 as *const libc::c_char as *mut libc::c_char,
5069 summary: b"Subtract multiple sorted sets and store the resulting sorted set in a new key\0"
5070 as *const u8 as *const libc::c_char as *mut libc::c_char,
5071 group: 4 as libc::c_int,
5072 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5073 };
5074 init
5075 },
5076 {
5077 let mut init = commandHelp {
5078 name: b"ZINCRBY\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5079 params: b"key increment member\0" as *const u8 as *const libc::c_char
5080 as *mut libc::c_char,
5081 summary: b"Increment the score of a member in a sorted set\0" as *const u8
5082 as *const libc::c_char as *mut libc::c_char,
5083 group: 4 as libc::c_int,
5084 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5085 };
5086 init
5087 },
5088 {
5089 let mut init = commandHelp {
5090 name: b"ZINTER\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5091 params: b"numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] [WITHSCORES]\0"
5092 as *const u8 as *const libc::c_char as *mut libc::c_char,
5093 summary: b"Intersect multiple sorted sets\0" as *const u8
5094 as *const libc::c_char as *mut libc::c_char,
5095 group: 4 as libc::c_int,
5096 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5097 };
5098 init
5099 },
5100 {
5101 let mut init = commandHelp {
5102 name: b"ZINTERCARD\0" as *const u8 as *const libc::c_char
5103 as *mut libc::c_char,
5104 params: b"numkeys key [key ...] [LIMIT limit]\0" as *const u8
5105 as *const libc::c_char as *mut libc::c_char,
5106 summary: b"Intersect multiple sorted sets and return the cardinality of the result\0"
5107 as *const u8 as *const libc::c_char as *mut libc::c_char,
5108 group: 4 as libc::c_int,
5109 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5110 };
5111 init
5112 },
5113 {
5114 let mut init = commandHelp {
5115 name: b"ZINTERSTORE\0" as *const u8 as *const libc::c_char
5116 as *mut libc::c_char,
5117 params: b"destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]\0"
5118 as *const u8 as *const libc::c_char as *mut libc::c_char,
5119 summary: b"Intersect multiple sorted sets and store the resulting sorted set in a new key\0"
5120 as *const u8 as *const libc::c_char as *mut libc::c_char,
5121 group: 4 as libc::c_int,
5122 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5123 };
5124 init
5125 },
5126 {
5127 let mut init = commandHelp {
5128 name: b"ZLEXCOUNT\0" as *const u8 as *const libc::c_char
5129 as *mut libc::c_char,
5130 params: b"key min max\0" as *const u8 as *const libc::c_char
5131 as *mut libc::c_char,
5132 summary: b"Count the number of members in a sorted set between a given lexicographical range\0"
5133 as *const u8 as *const libc::c_char as *mut libc::c_char,
5134 group: 4 as libc::c_int,
5135 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5136 };
5137 init
5138 },
5139 {
5140 let mut init = commandHelp {
5141 name: b"ZMPOP\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5142 params: b"numkeys key [key ...] MIN|MAX [COUNT count]\0" as *const u8
5143 as *const libc::c_char as *mut libc::c_char,
5144 summary: b"Remove and return members with scores in a sorted set\0"
5145 as *const u8 as *const libc::c_char as *mut libc::c_char,
5146 group: 4 as libc::c_int,
5147 since: b"7.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5148 };
5149 init
5150 },
5151 {
5152 let mut init = commandHelp {
5153 name: b"ZMSCORE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5154 params: b"key member [member ...]\0" as *const u8 as *const libc::c_char
5155 as *mut libc::c_char,
5156 summary: b"Get the score associated with the given members in a sorted set\0"
5157 as *const u8 as *const libc::c_char as *mut libc::c_char,
5158 group: 4 as libc::c_int,
5159 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5160 };
5161 init
5162 },
5163 {
5164 let mut init = commandHelp {
5165 name: b"ZPOPMAX\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5166 params: b"key [count]\0" as *const u8 as *const libc::c_char
5167 as *mut libc::c_char,
5168 summary: b"Remove and return members with the highest scores in a sorted set\0"
5169 as *const u8 as *const libc::c_char as *mut libc::c_char,
5170 group: 4 as libc::c_int,
5171 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5172 };
5173 init
5174 },
5175 {
5176 let mut init = commandHelp {
5177 name: b"ZPOPMIN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5178 params: b"key [count]\0" as *const u8 as *const libc::c_char
5179 as *mut libc::c_char,
5180 summary: b"Remove and return members with the lowest scores in a sorted set\0"
5181 as *const u8 as *const libc::c_char as *mut libc::c_char,
5182 group: 4 as libc::c_int,
5183 since: b"5.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5184 };
5185 init
5186 },
5187 {
5188 let mut init = commandHelp {
5189 name: b"ZRANDMEMBER\0" as *const u8 as *const libc::c_char
5190 as *mut libc::c_char,
5191 params: b"key [count [WITHSCORES]]\0" as *const u8 as *const libc::c_char
5192 as *mut libc::c_char,
5193 summary: b"Get one or multiple random elements from a sorted set\0"
5194 as *const u8 as *const libc::c_char as *mut libc::c_char,
5195 group: 4 as libc::c_int,
5196 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5197 };
5198 init
5199 },
5200 {
5201 let mut init = commandHelp {
5202 name: b"ZRANGE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5203 params: b"key start stop [BYSCORE|BYLEX] [REV] [LIMIT offset count] [WITHSCORES]\0"
5204 as *const u8 as *const libc::c_char as *mut libc::c_char,
5205 summary: b"Return a range of members in a sorted set\0" as *const u8
5206 as *const libc::c_char as *mut libc::c_char,
5207 group: 4 as libc::c_int,
5208 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5209 };
5210 init
5211 },
5212 {
5213 let mut init = commandHelp {
5214 name: b"ZRANGEBYLEX\0" as *const u8 as *const libc::c_char
5215 as *mut libc::c_char,
5216 params: b"key min max [LIMIT offset count]\0" as *const u8
5217 as *const libc::c_char as *mut libc::c_char,
5218 summary: b"Return a range of members in a sorted set, by lexicographical range\0"
5219 as *const u8 as *const libc::c_char as *mut libc::c_char,
5220 group: 4 as libc::c_int,
5221 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5222 };
5223 init
5224 },
5225 {
5226 let mut init = commandHelp {
5227 name: b"ZRANGEBYSCORE\0" as *const u8 as *const libc::c_char
5228 as *mut libc::c_char,
5229 params: b"key min max [WITHSCORES] [LIMIT offset count]\0" as *const u8
5230 as *const libc::c_char as *mut libc::c_char,
5231 summary: b"Return a range of members in a sorted set, by score\0"
5232 as *const u8 as *const libc::c_char as *mut libc::c_char,
5233 group: 4 as libc::c_int,
5234 since: b"1.0.5\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5235 };
5236 init
5237 },
5238 {
5239 let mut init = commandHelp {
5240 name: b"ZRANGESTORE\0" as *const u8 as *const libc::c_char
5241 as *mut libc::c_char,
5242 params: b"dst src min max [BYSCORE|BYLEX] [REV] [LIMIT offset count]\0"
5243 as *const u8 as *const libc::c_char as *mut libc::c_char,
5244 summary: b"Store a range of members from sorted set into another key\0"
5245 as *const u8 as *const libc::c_char as *mut libc::c_char,
5246 group: 4 as libc::c_int,
5247 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5248 };
5249 init
5250 },
5251 {
5252 let mut init = commandHelp {
5253 name: b"ZRANK\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5254 params: b"key member\0" as *const u8 as *const libc::c_char
5255 as *mut libc::c_char,
5256 summary: b"Determine the index of a member in a sorted set\0" as *const u8
5257 as *const libc::c_char as *mut libc::c_char,
5258 group: 4 as libc::c_int,
5259 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5260 };
5261 init
5262 },
5263 {
5264 let mut init = commandHelp {
5265 name: b"ZREM\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5266 params: b"key member [member ...]\0" as *const u8 as *const libc::c_char
5267 as *mut libc::c_char,
5268 summary: b"Remove one or more members from a sorted set\0" as *const u8
5269 as *const libc::c_char as *mut libc::c_char,
5270 group: 4 as libc::c_int,
5271 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5272 };
5273 init
5274 },
5275 {
5276 let mut init = commandHelp {
5277 name: b"ZREMRANGEBYLEX\0" as *const u8 as *const libc::c_char
5278 as *mut libc::c_char,
5279 params: b"key min max\0" as *const u8 as *const libc::c_char
5280 as *mut libc::c_char,
5281 summary: b"Remove all members in a sorted set between the given lexicographical range\0"
5282 as *const u8 as *const libc::c_char as *mut libc::c_char,
5283 group: 4 as libc::c_int,
5284 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5285 };
5286 init
5287 },
5288 {
5289 let mut init = commandHelp {
5290 name: b"ZREMRANGEBYRANK\0" as *const u8 as *const libc::c_char
5291 as *mut libc::c_char,
5292 params: b"key start stop\0" as *const u8 as *const libc::c_char
5293 as *mut libc::c_char,
5294 summary: b"Remove all members in a sorted set within the given indexes\0"
5295 as *const u8 as *const libc::c_char as *mut libc::c_char,
5296 group: 4 as libc::c_int,
5297 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5298 };
5299 init
5300 },
5301 {
5302 let mut init = commandHelp {
5303 name: b"ZREMRANGEBYSCORE\0" as *const u8 as *const libc::c_char
5304 as *mut libc::c_char,
5305 params: b"key min max\0" as *const u8 as *const libc::c_char
5306 as *mut libc::c_char,
5307 summary: b"Remove all members in a sorted set within the given scores\0"
5308 as *const u8 as *const libc::c_char as *mut libc::c_char,
5309 group: 4 as libc::c_int,
5310 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5311 };
5312 init
5313 },
5314 {
5315 let mut init = commandHelp {
5316 name: b"ZREVRANGE\0" as *const u8 as *const libc::c_char
5317 as *mut libc::c_char,
5318 params: b"key start stop [WITHSCORES]\0" as *const u8 as *const libc::c_char
5319 as *mut libc::c_char,
5320 summary: b"Return a range of members in a sorted set, by index, with scores ordered from high to low\0"
5321 as *const u8 as *const libc::c_char as *mut libc::c_char,
5322 group: 4 as libc::c_int,
5323 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5324 };
5325 init
5326 },
5327 {
5328 let mut init = commandHelp {
5329 name: b"ZREVRANGEBYLEX\0" as *const u8 as *const libc::c_char
5330 as *mut libc::c_char,
5331 params: b"key max min [LIMIT offset count]\0" as *const u8
5332 as *const libc::c_char as *mut libc::c_char,
5333 summary: b"Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.\0"
5334 as *const u8 as *const libc::c_char as *mut libc::c_char,
5335 group: 4 as libc::c_int,
5336 since: b"2.8.9\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5337 };
5338 init
5339 },
5340 {
5341 let mut init = commandHelp {
5342 name: b"ZREVRANGEBYSCORE\0" as *const u8 as *const libc::c_char
5343 as *mut libc::c_char,
5344 params: b"key max min [WITHSCORES] [LIMIT offset count]\0" as *const u8
5345 as *const libc::c_char as *mut libc::c_char,
5346 summary: b"Return a range of members in a sorted set, by score, with scores ordered from high to low\0"
5347 as *const u8 as *const libc::c_char as *mut libc::c_char,
5348 group: 4 as libc::c_int,
5349 since: b"2.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5350 };
5351 init
5352 },
5353 {
5354 let mut init = commandHelp {
5355 name: b"ZREVRANK\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5356 params: b"key member\0" as *const u8 as *const libc::c_char
5357 as *mut libc::c_char,
5358 summary: b"Determine the index of a member in a sorted set, with scores ordered from high to low\0"
5359 as *const u8 as *const libc::c_char as *mut libc::c_char,
5360 group: 4 as libc::c_int,
5361 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5362 };
5363 init
5364 },
5365 {
5366 let mut init = commandHelp {
5367 name: b"ZSCAN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5368 params: b"key cursor [MATCH pattern] [COUNT count]\0" as *const u8
5369 as *const libc::c_char as *mut libc::c_char,
5370 summary: b"Incrementally iterate sorted sets elements and associated scores\0"
5371 as *const u8 as *const libc::c_char as *mut libc::c_char,
5372 group: 4 as libc::c_int,
5373 since: b"2.8.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5374 };
5375 init
5376 },
5377 {
5378 let mut init = commandHelp {
5379 name: b"ZSCORE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5380 params: b"key member\0" as *const u8 as *const libc::c_char
5381 as *mut libc::c_char,
5382 summary: b"Get the score associated with the given member in a sorted set\0"
5383 as *const u8 as *const libc::c_char as *mut libc::c_char,
5384 group: 4 as libc::c_int,
5385 since: b"1.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5386 };
5387 init
5388 },
5389 {
5390 let mut init = commandHelp {
5391 name: b"ZUNION\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5392 params: b"numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] [WITHSCORES]\0"
5393 as *const u8 as *const libc::c_char as *mut libc::c_char,
5394 summary: b"Add multiple sorted sets\0" as *const u8 as *const libc::c_char
5395 as *mut libc::c_char,
5396 group: 4 as libc::c_int,
5397 since: b"6.2.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5398 };
5399 init
5400 },
5401 {
5402 let mut init = commandHelp {
5403 name: b"ZUNIONSTORE\0" as *const u8 as *const libc::c_char
5404 as *mut libc::c_char,
5405 params: b"destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]\0"
5406 as *const u8 as *const libc::c_char as *mut libc::c_char,
5407 summary: b"Add multiple sorted sets and store the resulting sorted set in a new key\0"
5408 as *const u8 as *const libc::c_char as *mut libc::c_char,
5409 group: 4 as libc::c_int,
5410 since: b"2.0.0\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
5411 };
5412 init
5413 },
5414];
5415#[no_mangle]
5416pub static mut spectrum_palette_color_size: libc::c_int = 19 as libc::c_int;
5417#[no_mangle]
5418pub static mut spectrum_palette_color: [libc::c_int; 19] = [
5419 0 as libc::c_int,
5420 233 as libc::c_int,
5421 234 as libc::c_int,
5422 235 as libc::c_int,
5423 237 as libc::c_int,
5424 239 as libc::c_int,
5425 241 as libc::c_int,
5426 243 as libc::c_int,
5427 245 as libc::c_int,
5428 247 as libc::c_int,
5429 144 as libc::c_int,
5430 143 as libc::c_int,
5431 142 as libc::c_int,
5432 184 as libc::c_int,
5433 226 as libc::c_int,
5434 214 as libc::c_int,
5435 208 as libc::c_int,
5436 202 as libc::c_int,
5437 196 as libc::c_int,
5438];
5439#[no_mangle]
5440pub static mut spectrum_palette_mono_size: libc::c_int = 13 as libc::c_int;
5441#[no_mangle]
5442pub static mut spectrum_palette_mono: [libc::c_int; 13] = [
5443 0 as libc::c_int,
5444 233 as libc::c_int,
5445 234 as libc::c_int,
5446 235 as libc::c_int,
5447 237 as libc::c_int,
5448 239 as libc::c_int,
5449 241 as libc::c_int,
5450 243 as libc::c_int,
5451 245 as libc::c_int,
5452 247 as libc::c_int,
5453 249 as libc::c_int,
5454 251 as libc::c_int,
5455 253 as libc::c_int,
5456];
5457#[no_mangle]
5458pub static mut spectrum_palette: *mut libc::c_int = 0 as *const libc::c_int
5459 as *mut libc::c_int;
5460#[no_mangle]
5461pub static mut spectrum_palette_size: libc::c_int = 0;
5462static mut context: *mut redisContext = 0 as *const redisContext as *mut redisContext;
5463pub static mut config: config = config {
5464 conn_info: cliConnInfo {
5465 hostip: 0 as *const libc::c_char as *mut libc::c_char,
5466 hostport: 0,
5467 input_dbnum: 0,
5468 auth: 0 as *const libc::c_char as *mut libc::c_char,
5469 user: 0 as *const libc::c_char as *mut libc::c_char,
5470 },
5471 hostsocket: 0 as *const libc::c_char as *mut libc::c_char,
5472 tls: 0,
5473 sslconfig: cliSSLconfig {
5474 sni: 0 as *mut libc::c_char,
5475 cacert: 0 as *mut libc::c_char,
5476 cacertdir: 0 as *mut libc::c_char,
5477 skip_cert_verify: 0,
5478 cert: 0 as *mut libc::c_char,
5479 key: 0 as *mut libc::c_char,
5480 ciphers: 0 as *mut libc::c_char,
5481 ciphersuites: 0 as *mut libc::c_char,
5482 },
5483 repeat: 0,
5484 interval: 0,
5485 dbnum: 0,
5486 interactive: 0,
5487 shutdown: 0,
5488 monitor_mode: 0,
5489 pubsub_mode: 0,
5490 blocking_state_aborted: 0,
5491 latency_mode: 0,
5492 latency_dist_mode: 0,
5493 latency_history: 0,
5494 lru_test_mode: 0,
5495 lru_test_sample_size: 0,
5496 cluster_mode: 0,
5497 cluster_reissue_command: 0,
5498 cluster_send_asking: 0,
5499 slave_mode: 0,
5500 pipe_mode: 0,
5501 pipe_timeout: 0,
5502 getrdb_mode: 0,
5503 get_functions_rdb_mode: 0,
5504 stat_mode: 0,
5505 scan_mode: 0,
5506 intrinsic_latency_mode: 0,
5507 intrinsic_latency_duration: 0,
5508 pattern: 0 as *const libc::c_char as *mut libc::c_char,
5509 rdb_filename: 0 as *const libc::c_char as *mut libc::c_char,
5510 bigkeys: 0,
5511 memkeys: 0,
5512 memkeys_samples: 0,
5513 hotkeys: 0,
5514 stdin_lastarg: 0,
5515 stdin_tag_arg: 0,
5516 stdin_tag_name: 0 as *const libc::c_char as *mut libc::c_char,
5517 askpass: 0,
5518 quoted_input: 0,
5519 output: 0,
5520 push_output: 0,
5521 mb_delim: 0 as *const libc::c_char as *mut libc::c_char,
5522 cmd_delim: 0 as *const libc::c_char as *mut libc::c_char,
5523 prompt: [0; 128],
5524 eval: 0 as *const libc::c_char as *mut libc::c_char,
5525 eval_ldb: 0,
5526 eval_ldb_sync: 0,
5527 eval_ldb_end: 0,
5528 enable_ldb_on_eval: 0,
5529 last_cmd_type: 0,
5530 verbose: 0,
5531 set_errcode: 0,
5532 cluster_manager_command: clusterManagerCommand {
5533 name: 0 as *const libc::c_char as *mut libc::c_char,
5534 argc: 0,
5535 argv: 0 as *const *mut libc::c_char as *mut *mut libc::c_char,
5536 stdin_arg: 0 as *const libc::c_char as *mut libc::c_char,
5537 flags: 0,
5538 replicas: 0,
5539 from: 0 as *const libc::c_char as *mut libc::c_char,
5540 to: 0 as *const libc::c_char as *mut libc::c_char,
5541 weight: 0 as *const *mut libc::c_char as *mut *mut libc::c_char,
5542 weight_argc: 0,
5543 master_id: 0 as *const libc::c_char as *mut libc::c_char,
5544 slots: 0,
5545 timeout: 0,
5546 pipeline: 0,
5547 threshold: 0.,
5548 backup_dir: 0 as *const libc::c_char as *mut libc::c_char,
5549 from_user: 0 as *const libc::c_char as *mut libc::c_char,
5550 from_pass: 0 as *const libc::c_char as *mut libc::c_char,
5551 from_askpass: 0,
5552 },
5553 no_auth_warning: 0,
5554 resp2: 0,
5555 resp3: 0,
5556 in_multi: 0,
5557 pre_multi_dbnum: 0,
5558};
5559static mut pref: pref = pref { hints: 0 };
5560static mut force_cancel_loop: sig_atomic_t = 0 as libc::c_int;
5561unsafe extern "C" fn ustime() -> libc::c_longlong {
5562 let mut tv: timeval = timeval { tv_sec: 0, tv_usec: 0 };
5563 let mut ust: libc::c_longlong = 0;
5564 gettimeofday(&mut tv, 0 as *mut libc::c_void);
5565 ust = tv.tv_sec as libc::c_longlong * 1000000 as libc::c_int as libc::c_longlong;
5566 ust += tv.tv_usec as libc::c_longlong;
5567 return ust;
5568}
5569unsafe extern "C" fn mstime() -> libc::c_longlong {
5570 return ustime() / 1000 as libc::c_int as libc::c_longlong;
5571}
5572unsafe extern "C" fn cliRefreshPrompt() {
5573 if config.eval_ldb != 0 {
5574 return;
5575 }
5576 let mut prompt: hisds = hi_sdsempty();
5577 if !(config.hostsocket).is_null() {
5578 prompt = hi_sdscatfmt(
5579 prompt,
5580 b"redis %s\0" as *const u8 as *const libc::c_char,
5581 config.hostsocket,
5582 );
5583 } else {
5584 let mut addr: [libc::c_char; 256] = [0; 256];
5585 anetFormatAddr(
5586 addr.as_mut_ptr(),
5587 core::mem::size_of::<[libc::c_char; 256]>() as libc::c_ulong,
5588 config.conn_info.hostip,
5589 config.conn_info.hostport,
5590 );
5591 prompt = hi_sdscatlen(
5592 prompt,
5593 addr.as_mut_ptr() as *const libc::c_void,
5594 strlen(addr.as_mut_ptr()),
5595 );
5596 }
5597 if config.dbnum != 0 as libc::c_int {
5598 prompt = hi_sdscatfmt(
5599 prompt,
5600 b"[%i]\0" as *const u8 as *const libc::c_char,
5601 config.dbnum,
5602 );
5603 }
5604 if config.in_multi != 0 {
5605 prompt = hi_sdscatlen(
5606 prompt,
5607 b"(TX)\0" as *const u8 as *const libc::c_char as *const libc::c_void,
5608 4 as libc::c_int as size_t,
5609 );
5610 }
5611 prompt = hi_sdscatlen(
5612 prompt,
5613 b"> \0" as *const u8 as *const libc::c_char as *const libc::c_void,
5614 2 as libc::c_int as size_t,
5615 );
5616 snprintf(
5617 (config.prompt).as_mut_ptr(),
5618 core::mem::size_of::<[libc::c_char; 128]>() as libc::c_ulong,
5619 b"%s\0" as *const u8 as *const libc::c_char,
5620 prompt,
5621 );
5622 hi_sdsfree(prompt);
5623}
5624unsafe extern "C" fn getDotfilePath(
5625 mut envoverride: *mut libc::c_char,
5626 mut dotfilename: *mut libc::c_char,
5627) -> hisds {
5628 let mut path: *mut libc::c_char = 0 as *mut libc::c_char;
5629 let mut dotPath: hisds = 0 as hisds;
5630 path = getenv(envoverride);
5631 if !path.is_null() && *path as libc::c_int != '\0' as i32 {
5632 if strcmp(b"/dev/null\0" as *const u8 as *const libc::c_char, path) == 0 {
5633 return 0 as hisds;
5634 }
5635 dotPath = hi_sdsnew(path);
5636 } else {
5637 let mut home: *mut libc::c_char = getenv(
5638 b"HOME\0" as *const u8 as *const libc::c_char,
5639 );
5640 if !home.is_null() && *home as libc::c_int != '\0' as i32 {
5641 dotPath = hi_sdscatprintf(
5642 hi_sdsempty(),
5643 b"%s/%s\0" as *const u8 as *const libc::c_char,
5644 home,
5645 dotfilename,
5646 );
5647 }
5648 }
5649 return dotPath;
5650}
5651unsafe extern "C" fn dictSdsHash(mut key: *const libc::c_void) -> uint64_t {
5652 return dictGenHashFunction(
5653 key as *mut libc::c_uchar as *const libc::c_void,
5654 hi_sdslen(key as *mut libc::c_char),
5655 );
5656}
5657unsafe extern "C" fn dictSdsKeyCompare(
5658 mut d: *mut dict,
5659 mut key1: *const libc::c_void,
5660 mut key2: *const libc::c_void,
5661) -> libc::c_int {
5662 let mut l1: libc::c_int = 0;
5663 let mut l2: libc::c_int = 0;
5664 l1 = hi_sdslen(key1 as hisds) as libc::c_int;
5665 l2 = hi_sdslen(key2 as hisds) as libc::c_int;
5666 if l1 != l2 {
5667 return 0 as libc::c_int;
5668 }
5669 return (memcmp(key1, key2, l1 as libc::c_ulong) == 0 as libc::c_int) as libc::c_int;
5670}
5671unsafe extern "C" fn dictSdsDestructor(mut d: *mut dict, mut val: *mut libc::c_void) {
5672 hi_sdsfree(val as hisds);
5673}
5674unsafe extern "C" fn dictListDestructor(mut d: *mut dict, mut val: *mut libc::c_void) {
5675 listRelease(val as *mut list);
5676}
5677static mut helpEntries: *mut helpEntry = 0 as *const helpEntry as *mut helpEntry;
5678static mut helpEntriesLen: libc::c_int = 0 as libc::c_int;
5679unsafe extern "C" fn cliVersion() -> hisds {
5680 let mut version: hisds = 0 as *mut libc::c_char;
5681 version = hi_sdscatprintf(
5682 hi_sdsempty(),
5683 b"%s\0" as *const u8 as *const libc::c_char,
5684 b"7.0.8\0" as *const u8 as *const libc::c_char,
5685 );
5686 if strtoll(redisGitSHA1(), 0 as *mut *mut libc::c_char, 16 as libc::c_int) != 0 {
5687 version = hi_sdscatprintf(
5688 version,
5689 b" (git:%s\0" as *const u8 as *const libc::c_char,
5690 redisGitSHA1(),
5691 );
5692 if strtoll(redisGitDirty(), 0 as *mut *mut libc::c_char, 10 as libc::c_int) != 0
5693 {
5694 version = hi_sdscatprintf(
5695 version,
5696 b"-dirty\0" as *const u8 as *const libc::c_char,
5697 );
5698 }
5699 version = hi_sdscat(version, b")\0" as *const u8 as *const libc::c_char);
5700 }
5701 return version;
5702}
5703unsafe extern "C" fn cliOldInitHelp() {
5704 let mut commandslen: libc::c_int = (core::mem::size_of::<[commandHelp; 366]>()
5705 as libc::c_ulong)
5706 .wrapping_div(core::mem::size_of::<commandHelp>() as libc::c_ulong)
5707 as libc::c_int;
5708 let mut groupslen: libc::c_int = (core::mem::size_of::<[*mut libc::c_char; 16]>()
5709 as libc::c_ulong)
5710 .wrapping_div(core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong)
5711 as libc::c_int;
5712 let mut i: libc::c_int = 0;
5713 let mut len: libc::c_int = 0;
5714 let mut pos: libc::c_int = 0 as libc::c_int;
5715 let mut tmp: helpEntry = helpEntry {
5716 type_0: 0,
5717 argc: 0,
5718 argv: 0 as *mut hisds,
5719 full: 0 as *mut libc::c_char,
5720 org: commandDocs {
5721 name: 0 as *mut libc::c_char,
5722 params: 0 as *mut libc::c_char,
5723 summary: 0 as *mut libc::c_char,
5724 group: 0 as *mut libc::c_char,
5725 since: 0 as *mut libc::c_char,
5726 },
5727 };
5728 len = commandslen + groupslen;
5729 helpEntriesLen = len;
5730 helpEntries = zmalloc(
5731 (core::mem::size_of::<helpEntry>() as libc::c_ulong)
5732 .wrapping_mul(len as libc::c_ulong),
5733 ) as *mut helpEntry;
5734 i = 0 as libc::c_int;
5735 while i < groupslen {
5736 tmp.argc = 1 as libc::c_int;
5737 tmp
5738 .argv = zmalloc(core::mem::size_of::<hisds>() as libc::c_ulong)
5739 as *mut hisds;
5740 let ref mut fresh0 = *(tmp.argv).offset(0 as libc::c_int as isize);
5741 *fresh0 = hi_sdscatprintf(
5742 hi_sdsempty(),
5743 b"@%s\0" as *const u8 as *const libc::c_char,
5744 commandGroups[i as usize],
5745 );
5746 tmp.full = *(tmp.argv).offset(0 as libc::c_int as isize);
5747 tmp.type_0 = 2 as libc::c_int;
5748 tmp.org.name = 0 as *mut libc::c_char;
5749 tmp.org.params = 0 as *mut libc::c_char;
5750 tmp.org.summary = 0 as *mut libc::c_char;
5751 tmp.org.since = 0 as *mut libc::c_char;
5752 tmp.org.group = 0 as *mut libc::c_char;
5753 let fresh1 = pos;
5754 pos = pos + 1;
5755 *helpEntries.offset(fresh1 as isize) = tmp;
5756 i += 1;
5757 }
5758 i = 0 as libc::c_int;
5759 while i < commandslen {
5760 tmp.argv = hi_sdssplitargs(commandHelp[i as usize].name, &mut tmp.argc);
5761 tmp.full = hi_sdsnew(commandHelp[i as usize].name);
5762 tmp.type_0 = 1 as libc::c_int;
5763 tmp.org.name = commandHelp[i as usize].name;
5764 tmp.org.params = commandHelp[i as usize].params;
5765 tmp.org.summary = commandHelp[i as usize].summary;
5766 tmp.org.since = commandHelp[i as usize].since;
5767 tmp.org.group = commandGroups[commandHelp[i as usize].group as usize];
5768 let fresh2 = pos;
5769 pos = pos + 1;
5770 *helpEntries.offset(fresh2 as isize) = tmp;
5771 i += 1;
5772 }
5773}
5774unsafe extern "C" fn cliOldIntegrateHelp() {
5775 if cliConnect((1 as libc::c_int) << 1 as libc::c_int) == -(1 as libc::c_int) {
5776 return;
5777 }
5778 let mut reply: *mut redisReply = redisCommand(
5779 context,
5780 b"COMMAND\0" as *const u8 as *const libc::c_char,
5781 ) as *mut redisReply;
5782 if reply.is_null() || (*reply).type_0 != 2 as libc::c_int {
5783 return;
5784 }
5785 let mut j: size_t = 0 as libc::c_int as size_t;
5786 while j < (*reply).elements {
5787 let mut entry: *mut redisReply = *((*reply).element).offset(j as isize);
5788 if (*entry).type_0 != 2 as libc::c_int
5789 || (*entry).elements < 4 as libc::c_int as libc::c_ulong
5790 || (**((*entry).element).offset(0 as libc::c_int as isize)).type_0
5791 != 1 as libc::c_int
5792 || (**((*entry).element).offset(1 as libc::c_int as isize)).type_0
5793 != 3 as libc::c_int
5794 || (**((*entry).element).offset(3 as libc::c_int as isize)).type_0
5795 != 3 as libc::c_int
5796 {
5797 return;
5798 }
5799 let mut cmdname: *mut libc::c_char = (**((*entry).element)
5800 .offset(0 as libc::c_int as isize))
5801 .str_0;
5802 let mut i: libc::c_int = 0;
5803 i = 0 as libc::c_int;
5804 while i < helpEntriesLen {
5805 let mut he: *mut helpEntry = helpEntries.offset(i as isize);
5806 if strcasecmp(
5807 *((*he).argv).offset(0 as libc::c_int as isize) as *const libc::c_char,
5808 cmdname,
5809 ) == 0
5810 {
5811 break;
5812 }
5813 i += 1;
5814 }
5815 if !(i != helpEntriesLen) {
5816 helpEntriesLen += 1;
5817 helpEntries = zrealloc(
5818 helpEntries as *mut libc::c_void,
5819 (core::mem::size_of::<helpEntry>() as libc::c_ulong)
5820 .wrapping_mul(helpEntriesLen as libc::c_ulong),
5821 ) as *mut helpEntry;
5822 let mut new: *mut helpEntry = helpEntries
5823 .offset((helpEntriesLen - 1 as libc::c_int) as isize);
5824 (*new).argc = 1 as libc::c_int;
5825 (*new)
5826 .argv = zmalloc(core::mem::size_of::<hisds>() as libc::c_ulong)
5827 as *mut hisds;
5828 let ref mut fresh3 = *((*new).argv).offset(0 as libc::c_int as isize);
5829 *fresh3 = hi_sdsnew(cmdname);
5830 (*new).full = *((*new).argv).offset(0 as libc::c_int as isize);
5831 (*new).type_0 = 1 as libc::c_int;
5832 hi_sdstoupper(*((*new).argv).offset(0 as libc::c_int as isize));
5833 (*new).org.name = *((*new).argv).offset(0 as libc::c_int as isize);
5834 (*new).org.params = hi_sdsempty();
5835 let mut args: libc::c_int = llabs(
5836 (**((*entry).element).offset(1 as libc::c_int as isize)).integer,
5837 ) as libc::c_int;
5838 args -= 1;
5839 if (**((*entry).element).offset(3 as libc::c_int as isize)).integer
5840 == 1 as libc::c_int as libc::c_longlong
5841 {
5842 (*new)
5843 .org
5844 .params = hi_sdscat(
5845 (*new).org.params,
5846 b"key \0" as *const u8 as *const libc::c_char,
5847 );
5848 args -= 1;
5849 }
5850 loop {
5851 let fresh4 = args;
5852 args = args - 1;
5853 if !(fresh4 > 0 as libc::c_int) {
5854 break;
5855 }
5856 (*new)
5857 .org
5858 .params = hi_sdscat(
5859 (*new).org.params,
5860 b"arg \0" as *const u8 as *const libc::c_char,
5861 );
5862 }
5863 if (**((*entry).element).offset(1 as libc::c_int as isize)).integer
5864 < 0 as libc::c_int as libc::c_longlong
5865 {
5866 (*new)
5867 .org
5868 .params = hi_sdscat(
5869 (*new).org.params,
5870 b"...options...\0" as *const u8 as *const libc::c_char,
5871 );
5872 }
5873 (*new)
5874 .org
5875 .summary = b"Help not available\0" as *const u8 as *const libc::c_char
5876 as *mut libc::c_char;
5877 (*new)
5878 .org
5879 .since = b"Not known\0" as *const u8 as *const libc::c_char
5880 as *mut libc::c_char;
5881 (*new).org.group = commandGroups[0 as libc::c_int as usize];
5882 }
5883 j = j.wrapping_add(1);
5884 }
5885 freeReplyObject(reply as *mut libc::c_void);
5886}
5887unsafe extern "C" fn sdscat_orempty(
5888 mut params: hisds,
5889 mut value: *mut libc::c_char,
5890) -> hisds {
5891 if *value.offset(0 as libc::c_int as isize) as libc::c_int == '\0' as i32 {
5892 return hi_sdscat(params, b"\"\"\0" as *const u8 as *const libc::c_char);
5893 }
5894 return hi_sdscat(params, value);
5895}
5896unsafe extern "C" fn cliConcatArguments(
5897 mut params: hisds,
5898 mut arguments: *mut redisReply,
5899 mut separator: *mut libc::c_char,
5900) -> hisds {
5901 let mut j: size_t = 0 as libc::c_int as size_t;
5902 while j < (*arguments).elements {
5903 params = cliAddArgument(params, *((*arguments).element).offset(j as isize));
5904 if j != ((*arguments).elements).wrapping_sub(1 as libc::c_int as libc::c_ulong) {
5905 params = hi_sdscat(params, separator);
5906 }
5907 j = j.wrapping_add(1);
5908 }
5909 return params;
5910}
5911unsafe extern "C" fn cliAddArgument(
5912 mut params: hisds,
5913 mut argMap: *mut redisReply,
5914) -> hisds {
5915 let mut name: *mut libc::c_char = 0 as *mut libc::c_char;
5916 let mut type_0: *mut libc::c_char = 0 as *mut libc::c_char;
5917 let mut optional: libc::c_int = 0 as libc::c_int;
5918 let mut multiple: libc::c_int = 0 as libc::c_int;
5919 let mut multipleToken: libc::c_int = 0 as libc::c_int;
5920 let mut arguments: *mut redisReply = 0 as *mut redisReply;
5921 let mut tokenPart: hisds = hi_sdsempty();
5922 let mut repeatPart: hisds = hi_sdsempty();
5923 if (*argMap).type_0 != 9 as libc::c_int && (*argMap).type_0 != 2 as libc::c_int {
5924 return params;
5925 }
5926 let mut i: size_t = 0 as libc::c_int as size_t;
5927 while i < (*argMap).elements {
5928 if (**((*argMap).element).offset(i as isize)).type_0 == 1 as libc::c_int
5929 {} else {
5930 __assert_fail(
5931 b"argMap->element[i]->type == REDIS_REPLY_STRING\0" as *const u8
5932 as *const libc::c_char,
5933 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
5934 567 as libc::c_int as libc::c_uint,
5935 (*core::mem::transmute::<
5936 &[u8; 42],
5937 &[libc::c_char; 42],
5938 >(b"hisds cliAddArgument(hisds, redisReply *)\0"))
5939 .as_ptr(),
5940 );
5941 };
5942 let mut key: *mut libc::c_char = (**((*argMap).element).offset(i as isize))
5943 .str_0;
5944 if strcmp(key, b"name\0" as *const u8 as *const libc::c_char) == 0 {
5945 if (**((*argMap).element)
5946 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
5947 .type_0 == 1 as libc::c_int
5948 {} else {
5949 __assert_fail(
5950 b"argMap->element[i + 1]->type == REDIS_REPLY_STRING\0" as *const u8
5951 as *const libc::c_char,
5952 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
5953 570 as libc::c_int as libc::c_uint,
5954 (*core::mem::transmute::<
5955 &[u8; 42],
5956 &[libc::c_char; 42],
5957 >(b"hisds cliAddArgument(hisds, redisReply *)\0"))
5958 .as_ptr(),
5959 );
5960 };
5961 name = (**((*argMap).element)
5962 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
5963 .str_0;
5964 } else if strcmp(key, b"token\0" as *const u8 as *const libc::c_char) == 0 {
5965 if (**((*argMap).element)
5966 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
5967 .type_0 == 1 as libc::c_int
5968 {} else {
5969 __assert_fail(
5970 b"argMap->element[i + 1]->type == REDIS_REPLY_STRING\0" as *const u8
5971 as *const libc::c_char,
5972 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
5973 573 as libc::c_int as libc::c_uint,
5974 (*core::mem::transmute::<
5975 &[u8; 42],
5976 &[libc::c_char; 42],
5977 >(b"hisds cliAddArgument(hisds, redisReply *)\0"))
5978 .as_ptr(),
5979 );
5980 };
5981 let mut token: *mut libc::c_char = (**((*argMap).element)
5982 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
5983 .str_0;
5984 tokenPart = sdscat_orempty(tokenPart, token);
5985 } else if strcmp(key, b"type\0" as *const u8 as *const libc::c_char) == 0 {
5986 if (**((*argMap).element)
5987 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
5988 .type_0 == 1 as libc::c_int
5989 {} else {
5990 __assert_fail(
5991 b"argMap->element[i + 1]->type == REDIS_REPLY_STRING\0" as *const u8
5992 as *const libc::c_char,
5993 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
5994 577 as libc::c_int as libc::c_uint,
5995 (*core::mem::transmute::<
5996 &[u8; 42],
5997 &[libc::c_char; 42],
5998 >(b"hisds cliAddArgument(hisds, redisReply *)\0"))
5999 .as_ptr(),
6000 );
6001 };
6002 type_0 = (**((*argMap).element)
6003 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
6004 .str_0;
6005 } else if strcmp(key, b"arguments\0" as *const u8 as *const libc::c_char) == 0 {
6006 arguments = *((*argMap).element)
6007 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6008 } else if strcmp(key, b"flags\0" as *const u8 as *const libc::c_char) == 0 {
6009 let mut flags: *mut redisReply = *((*argMap).element)
6010 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6011 if (*flags).type_0 == 10 as libc::c_int
6012 || (*flags).type_0 == 2 as libc::c_int
6013 {} else {
6014 __assert_fail(
6015 b"flags->type == REDIS_REPLY_SET || flags->type == REDIS_REPLY_ARRAY\0"
6016 as *const u8 as *const libc::c_char,
6017 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6018 583 as libc::c_int as libc::c_uint,
6019 (*core::mem::transmute::<
6020 &[u8; 42],
6021 &[libc::c_char; 42],
6022 >(b"hisds cliAddArgument(hisds, redisReply *)\0"))
6023 .as_ptr(),
6024 );
6025 };
6026 let mut j: size_t = 0 as libc::c_int as size_t;
6027 while j < (*flags).elements {
6028 if (**((*flags).element).offset(j as isize)).type_0 == 5 as libc::c_int
6029 {} else {
6030 __assert_fail(
6031 b"flags->element[j]->type == REDIS_REPLY_STATUS\0" as *const u8
6032 as *const libc::c_char,
6033 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6034 585 as libc::c_int as libc::c_uint,
6035 (*core::mem::transmute::<
6036 &[u8; 42],
6037 &[libc::c_char; 42],
6038 >(b"hisds cliAddArgument(hisds, redisReply *)\0"))
6039 .as_ptr(),
6040 );
6041 };
6042 let mut flag: *mut libc::c_char = (**((*flags).element)
6043 .offset(j as isize))
6044 .str_0;
6045 if strcmp(flag, b"optional\0" as *const u8 as *const libc::c_char) == 0 {
6046 optional = 1 as libc::c_int;
6047 } else if strcmp(flag, b"multiple\0" as *const u8 as *const libc::c_char)
6048 == 0
6049 {
6050 multiple = 1 as libc::c_int;
6051 } else if strcmp(
6052 flag,
6053 b"multiple_token\0" as *const u8 as *const libc::c_char,
6054 ) == 0
6055 {
6056 multipleToken = 1 as libc::c_int;
6057 }
6058 j = j.wrapping_add(1);
6059 }
6060 }
6061 i = (i as libc::c_ulong).wrapping_add(2 as libc::c_int as libc::c_ulong)
6062 as size_t as size_t;
6063 }
6064 if strcmp(type_0, b"key\0" as *const u8 as *const libc::c_char) == 0
6065 || strcmp(type_0, b"string\0" as *const u8 as *const libc::c_char) == 0
6066 || strcmp(type_0, b"integer\0" as *const u8 as *const libc::c_char) == 0
6067 || strcmp(type_0, b"double\0" as *const u8 as *const libc::c_char) == 0
6068 || strcmp(type_0, b"pattern\0" as *const u8 as *const libc::c_char) == 0
6069 || strcmp(type_0, b"unix-time\0" as *const u8 as *const libc::c_char) == 0
6070 || strcmp(type_0, b"token\0" as *const u8 as *const libc::c_char) == 0
6071 {
6072 repeatPart = sdscat_orempty(repeatPart, name);
6073 } else if strcmp(type_0, b"oneof\0" as *const u8 as *const libc::c_char) == 0 {
6074 repeatPart = cliConcatArguments(
6075 repeatPart,
6076 arguments,
6077 b"|\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
6078 );
6079 } else if strcmp(type_0, b"block\0" as *const u8 as *const libc::c_char) == 0 {
6080 repeatPart = cliConcatArguments(
6081 repeatPart,
6082 arguments,
6083 b" \0" as *const u8 as *const libc::c_char as *mut libc::c_char,
6084 );
6085 } else if strcmp(type_0, b"pure-token\0" as *const u8 as *const libc::c_char)
6086 != 0 as libc::c_int
6087 {
6088 fprintf(
6089 stderr,
6090 b"Unknown type '%s' set for argument '%s'\n\0" as *const u8
6091 as *const libc::c_char,
6092 type_0,
6093 name,
6094 );
6095 }
6096 if *tokenPart.offset(0 as libc::c_int as isize) as libc::c_int != '\0' as i32
6097 && strcmp(type_0, b"pure-token\0" as *const u8 as *const libc::c_char)
6098 != 0 as libc::c_int
6099 {
6100 tokenPart = hi_sdscat(tokenPart, b" \0" as *const u8 as *const libc::c_char);
6101 }
6102 if optional != 0 {
6103 params = hi_sdscat(params, b"[\0" as *const u8 as *const libc::c_char);
6104 }
6105 params = hi_sdscat(params, tokenPart as *const libc::c_char);
6106 params = hi_sdscat(params, repeatPart as *const libc::c_char);
6107 if multiple != 0 {
6108 params = hi_sdscat(params, b" [\0" as *const u8 as *const libc::c_char);
6109 if multipleToken != 0 {
6110 params = hi_sdscat(params, tokenPart as *const libc::c_char);
6111 }
6112 params = hi_sdscat(params, repeatPart as *const libc::c_char);
6113 params = hi_sdscat(params, b" ...]\0" as *const u8 as *const libc::c_char);
6114 }
6115 if optional != 0 {
6116 params = hi_sdscat(params, b"]\0" as *const u8 as *const libc::c_char);
6117 }
6118 hi_sdsfree(tokenPart);
6119 hi_sdsfree(repeatPart);
6120 return params;
6121}
6122unsafe extern "C" fn cliFillInCommandHelpEntry(
6123 mut help: *mut helpEntry,
6124 mut cmdname: *mut libc::c_char,
6125 mut subcommandname: *mut libc::c_char,
6126) {
6127 (*help)
6128 .argc = if !subcommandname.is_null() {
6129 2 as libc::c_int
6130 } else {
6131 1 as libc::c_int
6132 };
6133 (*help)
6134 .argv = zmalloc(
6135 (core::mem::size_of::<hisds>() as libc::c_ulong)
6136 .wrapping_mul((*help).argc as libc::c_ulong),
6137 ) as *mut hisds;
6138 let ref mut fresh5 = *((*help).argv).offset(0 as libc::c_int as isize);
6139 *fresh5 = hi_sdsnew(cmdname);
6140 hi_sdstoupper(*((*help).argv).offset(0 as libc::c_int as isize));
6141 if !subcommandname.is_null() {
6142 let ref mut fresh6 = *((*help).argv).offset(1 as libc::c_int as isize);
6143 *fresh6 = hi_sdsnew(
6144 (strchr(subcommandname, '|' as i32)).offset(1 as libc::c_int as isize),
6145 );
6146 hi_sdstoupper(*((*help).argv).offset(1 as libc::c_int as isize));
6147 }
6148 let mut fullname: hisds = hi_sdsnew(
6149 *((*help).argv).offset(0 as libc::c_int as isize) as *const libc::c_char,
6150 );
6151 if !subcommandname.is_null() {
6152 fullname = hi_sdscat(fullname, b" \0" as *const u8 as *const libc::c_char);
6153 fullname = hi_sdscat(
6154 fullname,
6155 *((*help).argv).offset(1 as libc::c_int as isize) as *const libc::c_char,
6156 );
6157 }
6158 (*help).full = fullname;
6159 (*help).type_0 = 1 as libc::c_int;
6160 (*help).org.name = (*help).full;
6161 (*help).org.params = hi_sdsempty();
6162 (*help).org.since = 0 as *mut libc::c_char;
6163}
6164unsafe extern "C" fn cliInitCommandHelpEntry(
6165 mut cmdname: *mut libc::c_char,
6166 mut subcommandname: *mut libc::c_char,
6167 mut next: *mut helpEntry,
6168 mut specs: *mut redisReply,
6169 mut groups: *mut dict,
6170) -> *mut helpEntry {
6171 let fresh7 = next;
6172 next = next.offset(1);
6173 let mut help: *mut helpEntry = fresh7;
6174 cliFillInCommandHelpEntry(help, cmdname, subcommandname);
6175 if (*specs).type_0 == 9 as libc::c_int || (*specs).type_0 == 2 as libc::c_int
6176 {} else {
6177 __assert_fail(
6178 b"specs->type == REDIS_REPLY_MAP || specs->type == REDIS_REPLY_ARRAY\0"
6179 as *const u8 as *const libc::c_char,
6180 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6181 677 as libc::c_int as libc::c_uint,
6182 (*core::mem::transmute::<
6183 &[u8; 86],
6184 &[libc::c_char; 86],
6185 >(
6186 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6187 ))
6188 .as_ptr(),
6189 );
6190 };
6191 let mut j: size_t = 0 as libc::c_int as size_t;
6192 while j < (*specs).elements {
6193 if (**((*specs).element).offset(j as isize)).type_0 == 1 as libc::c_int {} else {
6194 __assert_fail(
6195 b"specs->element[j]->type == REDIS_REPLY_STRING\0" as *const u8
6196 as *const libc::c_char,
6197 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6198 679 as libc::c_int as libc::c_uint,
6199 (*core::mem::transmute::<
6200 &[u8; 86],
6201 &[libc::c_char; 86],
6202 >(
6203 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6204 ))
6205 .as_ptr(),
6206 );
6207 };
6208 let mut key: *mut libc::c_char = (**((*specs).element).offset(j as isize)).str_0;
6209 if strcmp(key, b"summary\0" as *const u8 as *const libc::c_char) == 0 {
6210 let mut reply: *mut redisReply = *((*specs).element)
6211 .offset(j.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6212 if (*reply).type_0 == 1 as libc::c_int {} else {
6213 __assert_fail(
6214 b"reply->type == REDIS_REPLY_STRING\0" as *const u8
6215 as *const libc::c_char,
6216 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6217 683 as libc::c_int as libc::c_uint,
6218 (*core::mem::transmute::<
6219 &[u8; 86],
6220 &[libc::c_char; 86],
6221 >(
6222 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6223 ))
6224 .as_ptr(),
6225 );
6226 };
6227 (*help).org.summary = hi_sdsnew((*reply).str_0);
6228 } else if strcmp(key, b"since\0" as *const u8 as *const libc::c_char) == 0 {
6229 let mut reply_0: *mut redisReply = *((*specs).element)
6230 .offset(j.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6231 if (*reply_0).type_0 == 1 as libc::c_int {} else {
6232 __assert_fail(
6233 b"reply->type == REDIS_REPLY_STRING\0" as *const u8
6234 as *const libc::c_char,
6235 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6236 687 as libc::c_int as libc::c_uint,
6237 (*core::mem::transmute::<
6238 &[u8; 86],
6239 &[libc::c_char; 86],
6240 >(
6241 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6242 ))
6243 .as_ptr(),
6244 );
6245 };
6246 (*help).org.since = hi_sdsnew((*reply_0).str_0);
6247 } else if strcmp(key, b"group\0" as *const u8 as *const libc::c_char) == 0 {
6248 let mut reply_1: *mut redisReply = *((*specs).element)
6249 .offset(j.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6250 if (*reply_1).type_0 == 1 as libc::c_int {} else {
6251 __assert_fail(
6252 b"reply->type == REDIS_REPLY_STRING\0" as *const u8
6253 as *const libc::c_char,
6254 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6255 691 as libc::c_int as libc::c_uint,
6256 (*core::mem::transmute::<
6257 &[u8; 86],
6258 &[libc::c_char; 86],
6259 >(
6260 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6261 ))
6262 .as_ptr(),
6263 );
6264 };
6265 (*help).org.group = hi_sdsnew((*reply_1).str_0);
6266 let mut group: hisds = hi_sdsdup((*help).org.group);
6267 if dictAdd(groups, group as *mut libc::c_void, 0 as *mut libc::c_void)
6268 != 0 as libc::c_int
6269 {
6270 hi_sdsfree(group);
6271 }
6272 } else if strcmp(key, b"arguments\0" as *const u8 as *const libc::c_char) == 0 {
6273 let mut args: *mut redisReply = *((*specs).element)
6274 .offset(j.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6275 if (*args).type_0 == 2 as libc::c_int {} else {
6276 __assert_fail(
6277 b"args->type == REDIS_REPLY_ARRAY\0" as *const u8
6278 as *const libc::c_char,
6279 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6280 699 as libc::c_int as libc::c_uint,
6281 (*core::mem::transmute::<
6282 &[u8; 86],
6283 &[libc::c_char; 86],
6284 >(
6285 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6286 ))
6287 .as_ptr(),
6288 );
6289 };
6290 (*help)
6291 .org
6292 .params = cliConcatArguments(
6293 (*help).org.params,
6294 args,
6295 b" \0" as *const u8 as *const libc::c_char as *mut libc::c_char,
6296 );
6297 } else if strcmp(key, b"subcommands\0" as *const u8 as *const libc::c_char) == 0
6298 {
6299 let mut subcommands: *mut redisReply = *((*specs).element)
6300 .offset(j.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6301 if (*subcommands).type_0 == 9 as libc::c_int
6302 || (*subcommands).type_0 == 2 as libc::c_int
6303 {} else {
6304 __assert_fail(
6305 b"subcommands->type == REDIS_REPLY_MAP || subcommands->type == REDIS_REPLY_ARRAY\0"
6306 as *const u8 as *const libc::c_char,
6307 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6308 703 as libc::c_int as libc::c_uint,
6309 (*core::mem::transmute::<
6310 &[u8; 86],
6311 &[libc::c_char; 86],
6312 >(
6313 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6314 ))
6315 .as_ptr(),
6316 );
6317 };
6318 let mut i: size_t = 0 as libc::c_int as size_t;
6319 while i < (*subcommands).elements {
6320 if (**((*subcommands).element).offset(i as isize)).type_0
6321 == 1 as libc::c_int
6322 {} else {
6323 __assert_fail(
6324 b"subcommands->element[i]->type == REDIS_REPLY_STRING\0"
6325 as *const u8 as *const libc::c_char,
6326 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6327 705 as libc::c_int as libc::c_uint,
6328 (*core::mem::transmute::<
6329 &[u8; 86],
6330 &[libc::c_char; 86],
6331 >(
6332 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6333 ))
6334 .as_ptr(),
6335 );
6336 };
6337 let mut subcommandname_0: *mut libc::c_char = (**((*subcommands).element)
6338 .offset(i as isize))
6339 .str_0;
6340 let mut subcommand: *mut redisReply = *((*subcommands).element)
6341 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6342 if (*subcommand).type_0 == 9 as libc::c_int
6343 || (*subcommand).type_0 == 2 as libc::c_int
6344 {} else {
6345 __assert_fail(
6346 b"subcommand->type == REDIS_REPLY_MAP || subcommand->type == REDIS_REPLY_ARRAY\0"
6347 as *const u8 as *const libc::c_char,
6348 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6349 708 as libc::c_int as libc::c_uint,
6350 (*core::mem::transmute::<
6351 &[u8; 86],
6352 &[libc::c_char; 86],
6353 >(
6354 b"helpEntry *cliInitCommandHelpEntry(char *, char *, helpEntry *, redisReply *, dict *)\0",
6355 ))
6356 .as_ptr(),
6357 );
6358 };
6359 next = cliInitCommandHelpEntry(
6360 cmdname,
6361 subcommandname_0,
6362 next,
6363 subcommand,
6364 groups,
6365 );
6366 i = (i as libc::c_ulong).wrapping_add(2 as libc::c_int as libc::c_ulong)
6367 as size_t as size_t;
6368 }
6369 }
6370 j = (j as libc::c_ulong).wrapping_add(2 as libc::c_int as libc::c_ulong)
6371 as size_t as size_t;
6372 }
6373 return next;
6374}
6375unsafe extern "C" fn cliCountCommands(mut commandTable: *mut redisReply) -> size_t {
6376 let mut numCommands: size_t = ((*commandTable).elements)
6377 .wrapping_div(2 as libc::c_int as libc::c_ulong);
6378 let mut i: size_t = 0 as libc::c_int as size_t;
6379 while i < (*commandTable).elements {
6380 if (**((*commandTable).element).offset(i as isize)).type_0 == 1 as libc::c_int
6381 {} else {
6382 __assert_fail(
6383 b"commandTable->element[i]->type == REDIS_REPLY_STRING\0" as *const u8
6384 as *const libc::c_char,
6385 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6386 722 as libc::c_int as libc::c_uint,
6387 (*core::mem::transmute::<
6388 &[u8; 38],
6389 &[libc::c_char; 38],
6390 >(b"size_t cliCountCommands(redisReply *)\0"))
6391 .as_ptr(),
6392 );
6393 };
6394 if (**((*commandTable).element)
6395 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
6396 .type_0 == 9 as libc::c_int
6397 || (**((*commandTable).element)
6398 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
6399 .type_0 == 2 as libc::c_int
6400 {} else {
6401 __assert_fail(
6402 b"commandTable->element[i + 1]->type == REDIS_REPLY_MAP || commandTable->element[i + 1]->type == REDIS_REPLY_ARRAY\0"
6403 as *const u8 as *const libc::c_char,
6404 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6405 724 as libc::c_int as libc::c_uint,
6406 (*core::mem::transmute::<
6407 &[u8; 38],
6408 &[libc::c_char; 38],
6409 >(b"size_t cliCountCommands(redisReply *)\0"))
6410 .as_ptr(),
6411 );
6412 };
6413 let mut map: *mut redisReply = *((*commandTable).element)
6414 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6415 let mut j: size_t = 0 as libc::c_int as size_t;
6416 while j < (*map).elements {
6417 if (**((*map).element).offset(j as isize)).type_0 == 1 as libc::c_int
6418 {} else {
6419 __assert_fail(
6420 b"map->element[j]->type == REDIS_REPLY_STRING\0" as *const u8
6421 as *const libc::c_char,
6422 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6423 727 as libc::c_int as libc::c_uint,
6424 (*core::mem::transmute::<
6425 &[u8; 38],
6426 &[libc::c_char; 38],
6427 >(b"size_t cliCountCommands(redisReply *)\0"))
6428 .as_ptr(),
6429 );
6430 };
6431 let mut key: *mut libc::c_char = (**((*map).element).offset(j as isize))
6432 .str_0;
6433 if strcmp(key, b"subcommands\0" as *const u8 as *const libc::c_char) == 0 {
6434 let mut subcommands: *mut redisReply = *((*map).element)
6435 .offset(j.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6436 if (*subcommands).type_0 == 9 as libc::c_int
6437 || (*subcommands).type_0 == 2 as libc::c_int
6438 {} else {
6439 __assert_fail(
6440 b"subcommands->type == REDIS_REPLY_MAP || subcommands->type == REDIS_REPLY_ARRAY\0"
6441 as *const u8 as *const libc::c_char,
6442 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6443 731 as libc::c_int as libc::c_uint,
6444 (*core::mem::transmute::<
6445 &[u8; 38],
6446 &[libc::c_char; 38],
6447 >(b"size_t cliCountCommands(redisReply *)\0"))
6448 .as_ptr(),
6449 );
6450 };
6451 numCommands = (numCommands as libc::c_ulong)
6452 .wrapping_add(
6453 ((*subcommands).elements)
6454 .wrapping_div(2 as libc::c_int as libc::c_ulong),
6455 ) as size_t as size_t;
6456 }
6457 j = (j as libc::c_ulong).wrapping_add(2 as libc::c_int as libc::c_ulong)
6458 as size_t as size_t;
6459 }
6460 i = (i as libc::c_ulong).wrapping_add(2 as libc::c_int as libc::c_ulong)
6461 as size_t as size_t;
6462 }
6463 return numCommands;
6464}
6465#[no_mangle]
6466pub unsafe extern "C" fn helpEntryCompare(
6467 mut entry1: *const libc::c_void,
6468 mut entry2: *const libc::c_void,
6469) -> libc::c_int {
6470 let mut i1: *mut helpEntry = entry1 as *mut helpEntry;
6471 let mut i2: *mut helpEntry = entry2 as *mut helpEntry;
6472 return strcmp((*i1).full as *const libc::c_char, (*i2).full as *const libc::c_char);
6473}
6474#[no_mangle]
6475pub unsafe extern "C" fn cliInitGroupHelpEntries(mut groups: *mut dict) {
6476 let mut iter: *mut dictIterator = dictGetIterator(groups);
6477 let mut entry: *mut dictEntry = 0 as *mut dictEntry;
6478 let mut tmp: helpEntry = helpEntry {
6479 type_0: 0,
6480 argc: 0,
6481 argv: 0 as *mut hisds,
6482 full: 0 as *mut libc::c_char,
6483 org: commandDocs {
6484 name: 0 as *mut libc::c_char,
6485 params: 0 as *mut libc::c_char,
6486 summary: 0 as *mut libc::c_char,
6487 group: 0 as *mut libc::c_char,
6488 since: 0 as *mut libc::c_char,
6489 },
6490 };
6491 let mut numGroups: libc::c_int = ((*groups).ht_used[0 as libc::c_int as usize])
6492 .wrapping_add((*groups).ht_used[1 as libc::c_int as usize]) as libc::c_int;
6493 let mut pos: libc::c_int = helpEntriesLen;
6494 helpEntriesLen += numGroups;
6495 helpEntries = zrealloc(
6496 helpEntries as *mut libc::c_void,
6497 (core::mem::size_of::<helpEntry>() as libc::c_ulong)
6498 .wrapping_mul(helpEntriesLen as libc::c_ulong),
6499 ) as *mut helpEntry;
6500 entry = dictNext(iter);
6501 while !entry.is_null() {
6502 tmp.argc = 1 as libc::c_int;
6503 tmp
6504 .argv = zmalloc(core::mem::size_of::<hisds>() as libc::c_ulong)
6505 as *mut hisds;
6506 let ref mut fresh8 = *(tmp.argv).offset(0 as libc::c_int as isize);
6507 *fresh8 = hi_sdscatprintf(
6508 hi_sdsempty(),
6509 b"@%s\0" as *const u8 as *const libc::c_char,
6510 (*entry).key as *mut libc::c_char,
6511 );
6512 tmp.full = *(tmp.argv).offset(0 as libc::c_int as isize);
6513 tmp.type_0 = 2 as libc::c_int;
6514 tmp.org.name = 0 as *mut libc::c_char;
6515 tmp.org.params = 0 as *mut libc::c_char;
6516 tmp.org.summary = 0 as *mut libc::c_char;
6517 tmp.org.since = 0 as *mut libc::c_char;
6518 tmp.org.group = 0 as *mut libc::c_char;
6519 let fresh9 = pos;
6520 pos = pos + 1;
6521 *helpEntries.offset(fresh9 as isize) = tmp;
6522 entry = dictNext(iter);
6523 }
6524 dictReleaseIterator(iter);
6525}
6526#[no_mangle]
6527pub unsafe extern "C" fn cliInitCommandHelpEntries(
6528 mut commandTable: *mut redisReply,
6529 mut groups: *mut dict,
6530) {
6531 let mut next: *mut helpEntry = helpEntries;
6532 let mut i: size_t = 0 as libc::c_int as size_t;
6533 while i < (*commandTable).elements {
6534 if (**((*commandTable).element).offset(i as isize)).type_0 == 1 as libc::c_int
6535 {} else {
6536 __assert_fail(
6537 b"commandTable->element[i]->type == REDIS_REPLY_STRING\0" as *const u8
6538 as *const libc::c_char,
6539 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6540 780 as libc::c_int as libc::c_uint,
6541 (*core::mem::transmute::<
6542 &[u8; 53],
6543 &[libc::c_char; 53],
6544 >(b"void cliInitCommandHelpEntries(redisReply *, dict *)\0"))
6545 .as_ptr(),
6546 );
6547 };
6548 let mut cmdname: *mut libc::c_char = (**((*commandTable).element)
6549 .offset(i as isize))
6550 .str_0;
6551 if (**((*commandTable).element)
6552 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
6553 .type_0 == 9 as libc::c_int
6554 || (**((*commandTable).element)
6555 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize))
6556 .type_0 == 2 as libc::c_int
6557 {} else {
6558 __assert_fail(
6559 b"commandTable->element[i + 1]->type == REDIS_REPLY_MAP || commandTable->element[i + 1]->type == REDIS_REPLY_ARRAY\0"
6560 as *const u8 as *const libc::c_char,
6561 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6562 784 as libc::c_int as libc::c_uint,
6563 (*core::mem::transmute::<
6564 &[u8; 53],
6565 &[libc::c_char; 53],
6566 >(b"void cliInitCommandHelpEntries(redisReply *, dict *)\0"))
6567 .as_ptr(),
6568 );
6569 };
6570 let mut cmdspecs: *mut redisReply = *((*commandTable).element)
6571 .offset(i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
6572 next = cliInitCommandHelpEntry(
6573 cmdname,
6574 0 as *mut libc::c_char,
6575 next,
6576 cmdspecs,
6577 groups,
6578 );
6579 i = (i as libc::c_ulong).wrapping_add(2 as libc::c_int as libc::c_ulong)
6580 as size_t as size_t;
6581 }
6582}
6583unsafe extern "C" fn cliInitHelp() {
6584 let mut groupsdt: dictType = {
6585 let mut init = dictType {
6586 hashFunction: Some(
6587 dictSdsHash as unsafe extern "C" fn(*const libc::c_void) -> uint64_t,
6588 ),
6589 keyDup: None,
6590 valDup: None,
6591 keyCompare: Some(
6592 dictSdsKeyCompare
6593 as unsafe extern "C" fn(
6594 *mut dict,
6595 *const libc::c_void,
6596 *const libc::c_void,
6597 ) -> libc::c_int,
6598 ),
6599 keyDestructor: Some(
6600 dictSdsDestructor
6601 as unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
6602 ),
6603 valDestructor: None,
6604 expandAllowed: None,
6605 dictEntryMetadataBytes: None,
6606 };
6607 init
6608 };
6609 let mut commandTable: *mut redisReply = 0 as *mut redisReply;
6610 let mut groups: *mut dict = 0 as *mut dict;
6611 if cliConnect((1 as libc::c_int) << 1 as libc::c_int) == -(1 as libc::c_int) {
6612 cliOldInitHelp();
6613 return;
6614 }
6615 commandTable = redisCommand(
6616 context,
6617 b"COMMAND DOCS\0" as *const u8 as *const libc::c_char,
6618 ) as *mut redisReply;
6619 if commandTable.is_null() || (*commandTable).type_0 == 6 as libc::c_int {
6620 freeReplyObject(commandTable as *mut libc::c_void);
6621 cliOldInitHelp();
6622 cliOldIntegrateHelp();
6623 return;
6624 }
6625 if (*commandTable).type_0 != 9 as libc::c_int
6626 && (*commandTable).type_0 != 2 as libc::c_int
6627 {
6628 return;
6629 }
6630 helpEntriesLen = cliCountCommands(commandTable) as libc::c_int;
6631 helpEntries = zmalloc(
6632 (core::mem::size_of::<helpEntry>() as libc::c_ulong)
6633 .wrapping_mul(helpEntriesLen as libc::c_ulong),
6634 ) as *mut helpEntry;
6635 groups = dictCreate(&mut groupsdt);
6636 cliInitCommandHelpEntries(commandTable, groups);
6637 cliInitGroupHelpEntries(groups);
6638 qsort(
6639 helpEntries as *mut libc::c_void,
6640 helpEntriesLen as size_t,
6641 core::mem::size_of::<helpEntry>() as libc::c_ulong,
6642 Some(
6643 helpEntryCompare
6644 as unsafe extern "C" fn(
6645 *const libc::c_void,
6646 *const libc::c_void,
6647 ) -> libc::c_int,
6648 ),
6649 );
6650 freeReplyObject(commandTable as *mut libc::c_void);
6651 dictRelease(groups);
6652}
6653unsafe extern "C" fn cliOutputCommandHelp(
6654 mut help: *mut commandDocs,
6655 mut group: libc::c_int,
6656) {
6657 printf(
6658 b"\r\n \x1B[1m%s\x1B[0m \x1B[90m%s\x1B[0m\r\n\0" as *const u8
6659 as *const libc::c_char,
6660 (*help).name,
6661 (*help).params,
6662 );
6663 printf(
6664 b" \x1B[33msummary:\x1B[0m %s\r\n\0" as *const u8 as *const libc::c_char,
6665 (*help).summary,
6666 );
6667 if !((*help).since).is_null() {
6668 printf(
6669 b" \x1B[33msince:\x1B[0m %s\r\n\0" as *const u8 as *const libc::c_char,
6670 (*help).since,
6671 );
6672 }
6673 if group != 0 {
6674 printf(
6675 b" \x1B[33mgroup:\x1B[0m %s\r\n\0" as *const u8 as *const libc::c_char,
6676 (*help).group,
6677 );
6678 }
6679}
6680unsafe extern "C" fn cliOutputGenericHelp() {
6681 let mut version: hisds = cliVersion();
6682 printf(
6683 b"redis-cli %s\nTo get help about Redis commands type:\n \"help @<group>\" to get a list of commands in <group>\n \"help <command>\" for help on <command>\n \"help <tab>\" to get a list of possible help topics\n \"quit\" to exit\n\nTo set redis-cli preferences:\n \":set hints\" enable online hints\n \":set nohints\" disable online hints\nSet your preferences in ~/.redisclirc\n\0"
6684 as *const u8 as *const libc::c_char,
6685 version,
6686 );
6687 hi_sdsfree(version);
6688}
6689unsafe extern "C" fn cliOutputHelp(
6690 mut argc: libc::c_int,
6691 mut argv: *mut *mut libc::c_char,
6692) {
6693 let mut i: libc::c_int = 0;
6694 let mut j: libc::c_int = 0;
6695 let mut group: *mut libc::c_char = 0 as *mut libc::c_char;
6696 let mut entry: *mut helpEntry = 0 as *mut helpEntry;
6697 let mut help: *mut commandDocs = 0 as *mut commandDocs;
6698 if argc == 0 as libc::c_int {
6699 cliOutputGenericHelp();
6700 return;
6701 } else {
6702 if argc > 0 as libc::c_int
6703 && *(*argv.offset(0 as libc::c_int as isize))
6704 .offset(0 as libc::c_int as isize) as libc::c_int == '@' as i32
6705 {
6706 group = (*argv.offset(0 as libc::c_int as isize))
6707 .offset(1 as libc::c_int as isize);
6708 }
6709 }
6710 if helpEntries.is_null() {
6711 cliInitHelp();
6712 }
6713 if argc > 0 as libc::c_int {} else {
6714 __assert_fail(
6715 b"argc > 0\0" as *const u8 as *const libc::c_char,
6716 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
6717 888 as libc::c_int as libc::c_uint,
6718 (*core::mem::transmute::<
6719 &[u8; 33],
6720 &[libc::c_char; 33],
6721 >(b"void cliOutputHelp(int, char **)\0"))
6722 .as_ptr(),
6723 );
6724 };
6725 i = 0 as libc::c_int;
6726 while i < helpEntriesLen {
6727 entry = &mut *helpEntries.offset(i as isize) as *mut helpEntry;
6728 if !((*entry).type_0 != 1 as libc::c_int) {
6729 help = &mut (*entry).org;
6730 if group.is_null() {
6731 if argc <= (*entry).argc {
6732 j = 0 as libc::c_int;
6733 while j < argc {
6734 if strcasecmp(
6735 *argv.offset(j as isize),
6736 *((*entry).argv).offset(j as isize) as *const libc::c_char,
6737 ) != 0 as libc::c_int
6738 {
6739 break;
6740 }
6741 j += 1;
6742 }
6743 if j == argc {
6744 cliOutputCommandHelp(help, 1 as libc::c_int);
6745 }
6746 }
6747 } else if strcasecmp(group, (*help).group) == 0 as libc::c_int {
6748 cliOutputCommandHelp(help, 0 as libc::c_int);
6749 }
6750 }
6751 i += 1;
6752 }
6753 printf(b"\r\n\0" as *const u8 as *const libc::c_char);
6754}
6755unsafe extern "C" fn completionCallback(
6756 mut buf: *const libc::c_char,
6757 mut lc: *mut linenoiseCompletions,
6758) {
6759 let mut startpos: size_t = 0 as libc::c_int as size_t;
6760 let mut mask: libc::c_int = 0;
6761 let mut i: libc::c_int = 0;
6762 let mut matchlen: size_t = 0;
6763 let mut tmp: hisds = 0 as *mut libc::c_char;
6764 if strncasecmp(
6765 buf,
6766 b"help \0" as *const u8 as *const libc::c_char,
6767 5 as libc::c_int as size_t,
6768 ) == 0 as libc::c_int
6769 {
6770 startpos = 5 as libc::c_int as size_t;
6771 while *(*__ctype_b_loc())
6772 .offset(*buf.offset(startpos as isize) as libc::c_int as isize)
6773 as libc::c_int & _ISspace as libc::c_int as libc::c_ushort as libc::c_int
6774 != 0
6775 {
6776 startpos = startpos.wrapping_add(1);
6777 }
6778 mask = 1 as libc::c_int | 2 as libc::c_int;
6779 } else {
6780 mask = 1 as libc::c_int;
6781 }
6782 i = 0 as libc::c_int;
6783 while i < helpEntriesLen {
6784 if !((*helpEntries.offset(i as isize)).type_0 & mask == 0) {
6785 matchlen = strlen(buf.offset(startpos as isize));
6786 if strncasecmp(
6787 buf.offset(startpos as isize),
6788 (*helpEntries.offset(i as isize)).full as *const libc::c_char,
6789 matchlen,
6790 ) == 0 as libc::c_int
6791 {
6792 tmp = hi_sdsnewlen(buf as *const libc::c_void, startpos);
6793 tmp = hi_sdscat(
6794 tmp,
6795 (*helpEntries.offset(i as isize)).full as *const libc::c_char,
6796 );
6797 linenoiseAddCompletion(lc, tmp as *const libc::c_char);
6798 hi_sdsfree(tmp);
6799 }
6800 }
6801 i += 1;
6802 }
6803}
6804unsafe extern "C" fn hintsCallback(
6805 mut buf: *const libc::c_char,
6806 mut color: *mut libc::c_int,
6807 mut bold: *mut libc::c_int,
6808) -> *mut libc::c_char {
6809 if pref.hints == 0 {
6810 return 0 as *mut libc::c_char;
6811 }
6812 let mut i: libc::c_int = 0;
6813 let mut rawargc: libc::c_int = 0;
6814 let mut argc: libc::c_int = 0;
6815 let mut buflen: libc::c_int = strlen(buf) as libc::c_int;
6816 let mut matchlen: libc::c_int = 0 as libc::c_int;
6817 let mut rawargv: *mut hisds = 0 as *mut hisds;
6818 let mut argv: *mut hisds = hi_sdssplitargs(buf, &mut argc);
6819 let mut endspace: libc::c_int = (buflen != 0
6820 && *(*__ctype_b_loc())
6821 .offset(
6822 *buf.offset((buflen - 1 as libc::c_int) as isize) as libc::c_int as isize,
6823 ) as libc::c_int & _ISspace as libc::c_int as libc::c_ushort as libc::c_int
6824 != 0) as libc::c_int;
6825 let mut entry: *mut helpEntry = 0 as *mut helpEntry;
6826 if argc == 0 as libc::c_int {
6827 hi_sdsfreesplitres(argv, argc);
6828 return 0 as *mut libc::c_char;
6829 }
6830 i = 0 as libc::c_int;
6831 while i < helpEntriesLen {
6832 if !((*helpEntries.offset(i as isize)).type_0 & 1 as libc::c_int == 0) {
6833 rawargv = hi_sdssplitargs(
6834 (*helpEntries.offset(i as isize)).full as *const libc::c_char,
6835 &mut rawargc,
6836 );
6837 if rawargc <= argc {
6838 let mut j: libc::c_int = 0;
6839 j = 0 as libc::c_int;
6840 while j < rawargc {
6841 if strcasecmp(
6842 *rawargv.offset(j as isize) as *const libc::c_char,
6843 *argv.offset(j as isize) as *const libc::c_char,
6844 ) != 0
6845 {
6846 break;
6847 }
6848 j += 1;
6849 }
6850 if j == rawargc && rawargc > matchlen {
6851 matchlen = rawargc;
6852 entry = &mut *helpEntries.offset(i as isize) as *mut helpEntry;
6853 }
6854 }
6855 hi_sdsfreesplitres(rawargv, rawargc);
6856 }
6857 i += 1;
6858 }
6859 hi_sdsfreesplitres(argv, argc);
6860 if !entry.is_null() {
6861 *color = 90 as libc::c_int;
6862 *bold = 0 as libc::c_int;
6863 let mut hint: hisds = hi_sdsnew((*entry).org.params);
6864 let mut toremove: libc::c_int = argc - matchlen;
6865 while toremove > 0 as libc::c_int && hi_sdslen(hint) != 0 {
6866 if *hint.offset(0 as libc::c_int as isize) as libc::c_int == '[' as i32 {
6867 break;
6868 }
6869 if *hint.offset(0 as libc::c_int as isize) as libc::c_int == ' ' as i32 {
6870 toremove -= 1;
6871 }
6872 hi_sdsrange(
6873 hint,
6874 1 as libc::c_int as ssize_t,
6875 -(1 as libc::c_int) as ssize_t,
6876 );
6877 }
6878 if endspace == 0 {
6879 let mut newhint: hisds = hi_sdsnewlen(
6880 b" \0" as *const u8 as *const libc::c_char as *const libc::c_void,
6881 1 as libc::c_int as size_t,
6882 );
6883 newhint = hi_sdscatsds(newhint, hint);
6884 hi_sdsfree(hint);
6885 hint = newhint;
6886 }
6887 return hint;
6888 }
6889 return 0 as *mut libc::c_char;
6890}
6891unsafe extern "C" fn freeHintsCallback(mut ptr: *mut libc::c_void) {
6892 hi_sdsfree(ptr as hisds);
6893}
6894unsafe extern "C" fn cliAuth(
6895 mut ctx: *mut redisContext,
6896 mut user: *mut libc::c_char,
6897 mut auth: *mut libc::c_char,
6898) -> libc::c_int {
6899 let mut reply: *mut redisReply = 0 as *mut redisReply;
6900 if auth.is_null() {
6901 return 0 as libc::c_int;
6902 }
6903 if user.is_null() {
6904 reply = redisCommand(ctx, b"AUTH %s\0" as *const u8 as *const libc::c_char, auth)
6905 as *mut redisReply;
6906 } else {
6907 reply = redisCommand(
6908 ctx,
6909 b"AUTH %s %s\0" as *const u8 as *const libc::c_char,
6910 user,
6911 auth,
6912 ) as *mut redisReply;
6913 }
6914 if reply.is_null() {
6915 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
6916 return -(1 as libc::c_int);
6917 }
6918 let mut result: libc::c_int = 0 as libc::c_int;
6919 if (*reply).type_0 == 6 as libc::c_int {
6920 result = -(1 as libc::c_int);
6921 fprintf(
6922 stderr,
6923 b"AUTH failed: %s\n\0" as *const u8 as *const libc::c_char,
6924 (*reply).str_0,
6925 );
6926 }
6927 freeReplyObject(reply as *mut libc::c_void);
6928 return result;
6929}
6930unsafe extern "C" fn cliSelect() -> libc::c_int {
6931 let mut reply: *mut redisReply = 0 as *mut redisReply;
6932 if config.conn_info.input_dbnum == config.dbnum {
6933 return 0 as libc::c_int;
6934 }
6935 reply = redisCommand(
6936 context,
6937 b"SELECT %d\0" as *const u8 as *const libc::c_char,
6938 config.conn_info.input_dbnum,
6939 ) as *mut redisReply;
6940 if reply.is_null() {
6941 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
6942 return -(1 as libc::c_int);
6943 }
6944 let mut result: libc::c_int = 0 as libc::c_int;
6945 if (*reply).type_0 == 6 as libc::c_int {
6946 result = -(1 as libc::c_int);
6947 fprintf(
6948 stderr,
6949 b"SELECT %d failed: %s\n\0" as *const u8 as *const libc::c_char,
6950 config.conn_info.input_dbnum,
6951 (*reply).str_0,
6952 );
6953 } else {
6954 config.dbnum = config.conn_info.input_dbnum;
6955 cliRefreshPrompt();
6956 }
6957 freeReplyObject(reply as *mut libc::c_void);
6958 return result;
6959}
6960unsafe extern "C" fn cliSwitchProto() -> libc::c_int {
6961 let mut reply: *mut redisReply = 0 as *mut redisReply;
6962 if config.resp3 == 0 || config.resp2 != 0 {
6963 return 0 as libc::c_int;
6964 }
6965 reply = redisCommand(context, b"HELLO 3\0" as *const u8 as *const libc::c_char)
6966 as *mut redisReply;
6967 if reply.is_null() {
6968 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
6969 return -(1 as libc::c_int);
6970 }
6971 let mut result: libc::c_int = 0 as libc::c_int;
6972 if (*reply).type_0 == 6 as libc::c_int {
6973 fprintf(
6974 stderr,
6975 b"HELLO 3 failed: %s\n\0" as *const u8 as *const libc::c_char,
6976 (*reply).str_0,
6977 );
6978 if config.resp3 == 1 as libc::c_int {
6979 result = -(1 as libc::c_int);
6980 } else if config.resp3 == 2 as libc::c_int {
6981 result = 0 as libc::c_int;
6982 }
6983 }
6984 freeReplyObject(reply as *mut libc::c_void);
6985 return result;
6986}
6987unsafe extern "C" fn cliConnect(mut flags: libc::c_int) -> libc::c_int {
6988 if context.is_null() || flags & (1 as libc::c_int) << 0 as libc::c_int != 0 {
6989 if !context.is_null() {
6990 redisFree(context);
6991 config.dbnum = 0 as libc::c_int;
6992 config.in_multi = 0 as libc::c_int;
6993 cliRefreshPrompt();
6994 }
6995 if (config.hostsocket).is_null()
6996 || config.cluster_mode != 0 && config.cluster_reissue_command != 0
6997 {
6998 context = redisConnect(config.conn_info.hostip, config.conn_info.hostport);
6999 } else {
7000 context = redisConnectUnix(config.hostsocket);
7001 }
7002 if (*context).err == 0 && config.tls != 0 {
7003 let mut err: *const libc::c_char = 0 as *const libc::c_char;
7004 if cliSecureConnection(context, config.sslconfig, &mut err)
7005 == -(1 as libc::c_int) && !err.is_null()
7006 {
7007 fprintf(
7008 stderr,
7009 b"Could not negotiate a TLS connection: %s\n\0" as *const u8
7010 as *const libc::c_char,
7011 err,
7012 );
7013 redisFree(context);
7014 context = 0 as *mut redisContext;
7015 return -(1 as libc::c_int);
7016 }
7017 }
7018 if (*context).err != 0 {
7019 if flags & (1 as libc::c_int) << 1 as libc::c_int == 0 {
7020 fprintf(
7021 stderr,
7022 b"Could not connect to Redis at \0" as *const u8
7023 as *const libc::c_char,
7024 );
7025 if (config.hostsocket).is_null()
7026 || config.cluster_mode != 0 && config.cluster_reissue_command != 0
7027 {
7028 fprintf(
7029 stderr,
7030 b"%s:%d: %s\n\0" as *const u8 as *const libc::c_char,
7031 config.conn_info.hostip,
7032 config.conn_info.hostport,
7033 ((*context).errstr).as_mut_ptr(),
7034 );
7035 } else {
7036 fprintf(
7037 stderr,
7038 b"%s: %s\n\0" as *const u8 as *const libc::c_char,
7039 config.hostsocket,
7040 ((*context).errstr).as_mut_ptr(),
7041 );
7042 }
7043 }
7044 redisFree(context);
7045 context = 0 as *mut redisContext;
7046 return -(1 as libc::c_int);
7047 }
7048 anetKeepAlive(0 as *mut libc::c_char, (*context).fd, 15 as libc::c_int);
7049 if cliAuth(context, config.conn_info.user, config.conn_info.auth)
7050 != 0 as libc::c_int
7051 {
7052 return -(1 as libc::c_int);
7053 }
7054 if cliSelect() != 0 as libc::c_int {
7055 return -(1 as libc::c_int);
7056 }
7057 if cliSwitchProto() != 0 as libc::c_int {
7058 return -(1 as libc::c_int);
7059 }
7060 }
7061 if config.push_output != 0 {
7062 redisSetPushCallback(
7063 context,
7064 Some(
7065 cliPushHandler
7066 as unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_void) -> (),
7067 ),
7068 );
7069 }
7070 return 0 as libc::c_int;
7071}
7072unsafe extern "C" fn cliSendAsking() -> libc::c_int {
7073 let mut reply: *mut redisReply = 0 as *mut redisReply;
7074 config.cluster_send_asking = 0 as libc::c_int;
7075 if context.is_null() {
7076 return -(1 as libc::c_int);
7077 }
7078 reply = redisCommand(context, b"ASKING\0" as *const u8 as *const libc::c_char)
7079 as *mut redisReply;
7080 if reply.is_null() {
7081 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
7082 return -(1 as libc::c_int);
7083 }
7084 let mut result: libc::c_int = 0 as libc::c_int;
7085 if (*reply).type_0 == 6 as libc::c_int {
7086 result = -(1 as libc::c_int);
7087 fprintf(
7088 stderr,
7089 b"ASKING failed: %s\n\0" as *const u8 as *const libc::c_char,
7090 (*reply).str_0,
7091 );
7092 }
7093 freeReplyObject(reply as *mut libc::c_void);
7094 return result;
7095}
7096unsafe extern "C" fn cliPrintContextError() {
7097 if context.is_null() {
7098 return;
7099 }
7100 fprintf(
7101 stderr,
7102 b"Error: %s\n\0" as *const u8 as *const libc::c_char,
7103 ((*context).errstr).as_mut_ptr(),
7104 );
7105}
7106unsafe extern "C" fn isInvalidateReply(mut reply: *mut redisReply) -> libc::c_int {
7107 return ((*reply).type_0 == 12 as libc::c_int
7108 && (*reply).elements == 2 as libc::c_int as libc::c_ulong
7109 && (**((*reply).element).offset(0 as libc::c_int as isize)).type_0
7110 == 1 as libc::c_int
7111 && strncmp(
7112 (**((*reply).element).offset(0 as libc::c_int as isize)).str_0,
7113 b"invalidate\0" as *const u8 as *const libc::c_char,
7114 10 as libc::c_int as libc::c_ulong,
7115 ) == 0
7116 && (**((*reply).element).offset(1 as libc::c_int as isize)).type_0
7117 == 2 as libc::c_int) as libc::c_int;
7118}
7119unsafe extern "C" fn cliFormatInvalidateTTY(mut r: *mut redisReply) -> hisds {
7120 let mut out: hisds = hi_sdsnew(
7121 b"-> invalidate: \0" as *const u8 as *const libc::c_char,
7122 );
7123 let mut i: size_t = 0 as libc::c_int as size_t;
7124 while i < (**((*r).element).offset(1 as libc::c_int as isize)).elements {
7125 let mut key: *mut redisReply = *((**((*r).element)
7126 .offset(1 as libc::c_int as isize))
7127 .element)
7128 .offset(i as isize);
7129 if (*key).type_0 == 1 as libc::c_int {} else {
7130 __assert_fail(
7131 b"key->type == REDIS_REPLY_STRING\0" as *const u8 as *const libc::c_char,
7132 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
7133 1198 as libc::c_int as libc::c_uint,
7134 (*core::mem::transmute::<
7135 &[u8; 43],
7136 &[libc::c_char; 43],
7137 >(b"hisds cliFormatInvalidateTTY(redisReply *)\0"))
7138 .as_ptr(),
7139 );
7140 };
7141 out = hi_sdscatfmt(
7142 out,
7143 b"'%s'\0" as *const u8 as *const libc::c_char,
7144 (*key).str_0,
7145 (*key).len,
7146 );
7147 if i
7148 < ((**((*r).element).offset(1 as libc::c_int as isize)).elements)
7149 .wrapping_sub(1 as libc::c_int as libc::c_ulong)
7150 {
7151 out = hi_sdscatlen(
7152 out,
7153 b", \0" as *const u8 as *const libc::c_char as *const libc::c_void,
7154 2 as libc::c_int as size_t,
7155 );
7156 }
7157 i = i.wrapping_add(1);
7158 }
7159 return hi_sdscatlen(
7160 out,
7161 b"\n\0" as *const u8 as *const libc::c_char as *const libc::c_void,
7162 1 as libc::c_int as size_t,
7163 );
7164}
7165unsafe extern "C" fn cliIsMultilineValueTTY(mut r: *mut redisReply) -> libc::c_int {
7166 match (*r).type_0 {
7167 2 | 10 | 12 => {
7168 if (*r).elements == 0 as libc::c_int as libc::c_ulong {
7169 return 0 as libc::c_int;
7170 }
7171 if (*r).elements > 1 as libc::c_int as libc::c_ulong {
7172 return 1 as libc::c_int;
7173 }
7174 return cliIsMultilineValueTTY(
7175 *((*r).element).offset(0 as libc::c_int as isize),
7176 );
7177 }
7178 9 => {
7179 if (*r).elements == 0 as libc::c_int as libc::c_ulong {
7180 return 0 as libc::c_int;
7181 }
7182 if (*r).elements > 2 as libc::c_int as libc::c_ulong {
7183 return 1 as libc::c_int;
7184 }
7185 return cliIsMultilineValueTTY(
7186 *((*r).element).offset(1 as libc::c_int as isize),
7187 );
7188 }
7189 _ => return 0 as libc::c_int,
7190 };
7191}
7192unsafe extern "C" fn cliFormatReplyTTY(
7193 mut r: *mut redisReply,
7194 mut prefix: *mut libc::c_char,
7195) -> hisds {
7196 let mut out: hisds = hi_sdsempty();
7197 match (*r).type_0 {
7198 6 => {
7199 out = hi_sdscatprintf(
7200 out,
7201 b"(error) %s\n\0" as *const u8 as *const libc::c_char,
7202 (*r).str_0,
7203 );
7204 }
7205 5 => {
7206 out = hi_sdscat(out, (*r).str_0);
7207 out = hi_sdscat(out, b"\n\0" as *const u8 as *const libc::c_char);
7208 }
7209 3 => {
7210 out = hi_sdscatprintf(
7211 out,
7212 b"(integer) %lld\n\0" as *const u8 as *const libc::c_char,
7213 (*r).integer,
7214 );
7215 }
7216 7 => {
7217 out = hi_sdscatprintf(
7218 out,
7219 b"(double) %s\n\0" as *const u8 as *const libc::c_char,
7220 (*r).str_0,
7221 );
7222 }
7223 1 | 14 => {
7224 if (*r).type_0 == 1 as libc::c_int {
7225 out = hi_sdscatrepr(out, (*r).str_0, (*r).len);
7226 out = hi_sdscat(out, b"\n\0" as *const u8 as *const libc::c_char);
7227 } else {
7228 out = hi_sdscatlen(out, (*r).str_0 as *const libc::c_void, (*r).len);
7229 out = hi_sdscat(out, b"\n\0" as *const u8 as *const libc::c_char);
7230 }
7231 }
7232 4 => {
7233 out = hi_sdscat(out, b"(nil)\n\0" as *const u8 as *const libc::c_char);
7234 }
7235 8 => {
7236 out = hi_sdscat(
7237 out,
7238 if (*r).integer != 0 {
7239 b"(true)\n\0" as *const u8 as *const libc::c_char
7240 } else {
7241 b"(false)\n\0" as *const u8 as *const libc::c_char
7242 },
7243 );
7244 }
7245 2 | 9 | 10 | 12 => {
7246 if (*r).elements == 0 as libc::c_int as libc::c_ulong {
7247 if (*r).type_0 == 2 as libc::c_int {
7248 out = hi_sdscat(
7249 out,
7250 b"(empty array)\n\0" as *const u8 as *const libc::c_char,
7251 );
7252 } else if (*r).type_0 == 9 as libc::c_int {
7253 out = hi_sdscat(
7254 out,
7255 b"(empty hash)\n\0" as *const u8 as *const libc::c_char,
7256 );
7257 } else if (*r).type_0 == 10 as libc::c_int {
7258 out = hi_sdscat(
7259 out,
7260 b"(empty set)\n\0" as *const u8 as *const libc::c_char,
7261 );
7262 } else if (*r).type_0 == 12 as libc::c_int {
7263 out = hi_sdscat(
7264 out,
7265 b"(empty push)\n\0" as *const u8 as *const libc::c_char,
7266 );
7267 } else {
7268 out = hi_sdscat(
7269 out,
7270 b"(empty aggregate type)\n\0" as *const u8 as *const libc::c_char,
7271 );
7272 }
7273 } else {
7274 let mut i: libc::c_uint = 0;
7275 let mut idxlen: libc::c_uint = 0 as libc::c_int as libc::c_uint;
7276 let mut _prefixlen: [libc::c_char; 16] = [0; 16];
7277 let mut _prefixfmt: [libc::c_char; 16] = [0; 16];
7278 let mut _prefix: hisds = 0 as *mut libc::c_char;
7279 let mut tmp: hisds = 0 as *mut libc::c_char;
7280 i = (*r).elements as libc::c_uint;
7281 if (*r).type_0 == 9 as libc::c_int {
7282 i = i.wrapping_div(2 as libc::c_int as libc::c_uint);
7283 }
7284 loop {
7285 idxlen = idxlen.wrapping_add(1);
7286 i = i.wrapping_div(10 as libc::c_int as libc::c_uint);
7287 if !(i != 0) {
7288 break;
7289 }
7290 }
7291 memset(
7292 _prefixlen.as_mut_ptr() as *mut libc::c_void,
7293 ' ' as i32,
7294 idxlen.wrapping_add(2 as libc::c_int as libc::c_uint)
7295 as libc::c_ulong,
7296 );
7297 _prefixlen[idxlen.wrapping_add(2 as libc::c_int as libc::c_uint)
7298 as usize] = '\0' as i32 as libc::c_char;
7299 _prefix = hi_sdscat(hi_sdsnew(prefix), _prefixlen.as_mut_ptr());
7300 let mut numsep: libc::c_char = 0;
7301 if (*r).type_0 == 10 as libc::c_int {
7302 numsep = '~' as i32 as libc::c_char;
7303 } else if (*r).type_0 == 9 as libc::c_int {
7304 numsep = '#' as i32 as libc::c_char;
7305 } else {
7306 numsep = ')' as i32 as libc::c_char;
7307 }
7308 snprintf(
7309 _prefixfmt.as_mut_ptr(),
7310 core::mem::size_of::<[libc::c_char; 16]>() as libc::c_ulong,
7311 b"%%s%%%ud%c \0" as *const u8 as *const libc::c_char,
7312 idxlen,
7313 numsep as libc::c_int,
7314 );
7315 i = 0 as libc::c_int as libc::c_uint;
7316 while (i as libc::c_ulong) < (*r).elements {
7317 let mut human_idx: libc::c_uint = if (*r).type_0 == 9 as libc::c_int
7318 {
7319 i.wrapping_div(2 as libc::c_int as libc::c_uint)
7320 } else {
7321 i
7322 };
7323 human_idx = human_idx.wrapping_add(1);
7324 out = hi_sdscatprintf(
7325 out,
7326 _prefixfmt.as_mut_ptr(),
7327 if i == 0 as libc::c_int as libc::c_uint {
7328 b"\0" as *const u8 as *const libc::c_char
7329 } else {
7330 prefix as *const libc::c_char
7331 },
7332 human_idx,
7333 );
7334 tmp = cliFormatReplyTTY(*((*r).element).offset(i as isize), _prefix);
7335 out = hi_sdscatlen(out, tmp as *const libc::c_void, hi_sdslen(tmp));
7336 hi_sdsfree(tmp);
7337 if (*r).type_0 == 9 as libc::c_int {
7338 i = i.wrapping_add(1);
7339 hi_sdsrange(
7340 out,
7341 0 as libc::c_int as ssize_t,
7342 -(2 as libc::c_int) as ssize_t,
7343 );
7344 out = hi_sdscat(
7345 out,
7346 b" => \0" as *const u8 as *const libc::c_char,
7347 );
7348 if cliIsMultilineValueTTY(*((*r).element).offset(i as isize))
7349 != 0
7350 {
7351 out = hi_sdscat(
7352 out,
7353 b"\n\0" as *const u8 as *const libc::c_char,
7354 );
7355 out = hi_sdscat(out, _prefix as *const libc::c_char);
7356 }
7357 tmp = cliFormatReplyTTY(
7358 *((*r).element).offset(i as isize),
7359 _prefix,
7360 );
7361 out = hi_sdscatlen(
7362 out,
7363 tmp as *const libc::c_void,
7364 hi_sdslen(tmp),
7365 );
7366 hi_sdsfree(tmp);
7367 }
7368 i = i.wrapping_add(1);
7369 }
7370 hi_sdsfree(_prefix);
7371 }
7372 }
7373 _ => {
7374 fprintf(
7375 stderr,
7376 b"Unknown reply type: %d\n\0" as *const u8 as *const libc::c_char,
7377 (*r).type_0,
7378 );
7379 exit(1 as libc::c_int);
7380 }
7381 }
7382 return out;
7383}
7384#[no_mangle]
7385pub unsafe extern "C" fn isColorTerm() -> libc::c_int {
7386 let mut t: *mut libc::c_char = getenv(b"TERM\0" as *const u8 as *const libc::c_char);
7387 return (!t.is_null()
7388 && !(strstr(t, b"xterm\0" as *const u8 as *const libc::c_char)).is_null())
7389 as libc::c_int;
7390}
7391#[no_mangle]
7392pub unsafe extern "C" fn sdscatcolor(
7393 mut o: hisds,
7394 mut s: *mut libc::c_char,
7395 mut len: size_t,
7396 mut color: *mut libc::c_char,
7397) -> hisds {
7398 if isColorTerm() == 0 {
7399 return hi_sdscatlen(o, s as *const libc::c_void, len);
7400 }
7401 let mut bold: libc::c_int = (strstr(
7402 color,
7403 b"bold\0" as *const u8 as *const libc::c_char,
7404 ) != 0 as *mut libc::c_void as *mut libc::c_char) as libc::c_int;
7405 let mut ccode: libc::c_int = 37 as libc::c_int;
7406 if !(strstr(color, b"red\0" as *const u8 as *const libc::c_char)).is_null() {
7407 ccode = 31 as libc::c_int;
7408 } else if !(strstr(color, b"green\0" as *const u8 as *const libc::c_char)).is_null()
7409 {
7410 ccode = 32 as libc::c_int;
7411 } else if !(strstr(color, b"yellow\0" as *const u8 as *const libc::c_char)).is_null()
7412 {
7413 ccode = 33 as libc::c_int;
7414 } else if !(strstr(color, b"blue\0" as *const u8 as *const libc::c_char)).is_null() {
7415 ccode = 34 as libc::c_int;
7416 } else if !(strstr(color, b"magenta\0" as *const u8 as *const libc::c_char))
7417 .is_null()
7418 {
7419 ccode = 35 as libc::c_int;
7420 } else if !(strstr(color, b"cyan\0" as *const u8 as *const libc::c_char)).is_null() {
7421 ccode = 36 as libc::c_int;
7422 } else if !(strstr(color, b"white\0" as *const u8 as *const libc::c_char)).is_null()
7423 {
7424 ccode = 37 as libc::c_int;
7425 }
7426 o = hi_sdscatfmt(
7427 o,
7428 b"\x1B[%i;%i;49m\0" as *const u8 as *const libc::c_char,
7429 bold,
7430 ccode,
7431 );
7432 o = hi_sdscatlen(o, s as *const libc::c_void, len);
7433 o = hi_sdscat(o, b"\x1B[0m\0" as *const u8 as *const libc::c_char);
7434 return o;
7435}
7436#[no_mangle]
7437pub unsafe extern "C" fn sdsCatColorizedLdbReply(
7438 mut o: hisds,
7439 mut s: *mut libc::c_char,
7440 mut len: size_t,
7441) -> hisds {
7442 let mut color: *mut libc::c_char = b"white\0" as *const u8 as *const libc::c_char
7443 as *mut libc::c_char;
7444 if !(strstr(s, b"<debug>\0" as *const u8 as *const libc::c_char)).is_null() {
7445 color = b"bold\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7446 }
7447 if !(strstr(s, b"<redis>\0" as *const u8 as *const libc::c_char)).is_null() {
7448 color = b"green\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7449 }
7450 if !(strstr(s, b"<reply>\0" as *const u8 as *const libc::c_char)).is_null() {
7451 color = b"cyan\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7452 }
7453 if !(strstr(s, b"<error>\0" as *const u8 as *const libc::c_char)).is_null() {
7454 color = b"red\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7455 }
7456 if !(strstr(s, b"<hint>\0" as *const u8 as *const libc::c_char)).is_null() {
7457 color = b"bold\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7458 }
7459 if !(strstr(s, b"<value>\0" as *const u8 as *const libc::c_char)).is_null()
7460 || !(strstr(s, b"<retval>\0" as *const u8 as *const libc::c_char)).is_null()
7461 {
7462 color = b"magenta\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7463 }
7464 if len > 4 as libc::c_int as libc::c_ulong
7465 && *(*__ctype_b_loc())
7466 .offset(*s.offset(3 as libc::c_int as isize) as libc::c_int as isize)
7467 as libc::c_int & _ISdigit as libc::c_int as libc::c_ushort as libc::c_int
7468 != 0
7469 {
7470 if *s.offset(1 as libc::c_int as isize) as libc::c_int == '>' as i32 {
7471 color = b"yellow\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7472 } else if *s.offset(2 as libc::c_int as isize) as libc::c_int == '#' as i32 {
7473 color = b"bold\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
7474 }
7475 }
7476 return sdscatcolor(o, s, len, color);
7477}
7478unsafe extern "C" fn cliFormatReplyRaw(mut r: *mut redisReply) -> hisds {
7479 let mut out: hisds = hi_sdsempty();
7480 let mut tmp: hisds = 0 as *mut libc::c_char;
7481 let mut i: size_t = 0;
7482 match (*r).type_0 {
7483 4 => {}
7484 6 => {
7485 out = hi_sdscatlen(out, (*r).str_0 as *const libc::c_void, (*r).len);
7486 out = hi_sdscatlen(
7487 out,
7488 b"\n\0" as *const u8 as *const libc::c_char as *const libc::c_void,
7489 1 as libc::c_int as size_t,
7490 );
7491 }
7492 5 | 1 | 14 => {
7493 if (*r).type_0 == 5 as libc::c_int && config.eval_ldb != 0 {
7494 if strstr(
7495 (*r).str_0,
7496 b"<endsession>\0" as *const u8 as *const libc::c_char,
7497 ) == (*r).str_0
7498 {
7499 config.enable_ldb_on_eval = 0 as libc::c_int;
7500 config.eval_ldb = 0 as libc::c_int;
7501 config.eval_ldb_end = 1 as libc::c_int;
7502 config.output = 0 as libc::c_int;
7503 cliRefreshPrompt();
7504 } else {
7505 out = sdsCatColorizedLdbReply(out, (*r).str_0, (*r).len);
7506 }
7507 } else {
7508 out = hi_sdscatlen(out, (*r).str_0 as *const libc::c_void, (*r).len);
7509 }
7510 }
7511 8 => {
7512 out = hi_sdscat(
7513 out,
7514 if (*r).integer != 0 {
7515 b"(true)\0" as *const u8 as *const libc::c_char
7516 } else {
7517 b"(false)\0" as *const u8 as *const libc::c_char
7518 },
7519 );
7520 }
7521 3 => {
7522 out = hi_sdscatprintf(
7523 out,
7524 b"%lld\0" as *const u8 as *const libc::c_char,
7525 (*r).integer,
7526 );
7527 }
7528 7 => {
7529 out = hi_sdscatprintf(
7530 out,
7531 b"%s\0" as *const u8 as *const libc::c_char,
7532 (*r).str_0,
7533 );
7534 }
7535 10 | 2 | 12 => {
7536 i = 0 as libc::c_int as size_t;
7537 while i < (*r).elements {
7538 if i > 0 as libc::c_int as libc::c_ulong {
7539 out = hi_sdscat(out, config.mb_delim as *const libc::c_char);
7540 }
7541 tmp = cliFormatReplyRaw(*((*r).element).offset(i as isize));
7542 out = hi_sdscatlen(out, tmp as *const libc::c_void, hi_sdslen(tmp));
7543 hi_sdsfree(tmp);
7544 i = i.wrapping_add(1);
7545 }
7546 }
7547 9 => {
7548 i = 0 as libc::c_int as size_t;
7549 while i < (*r).elements {
7550 if i > 0 as libc::c_int as libc::c_ulong {
7551 out = hi_sdscat(out, config.mb_delim as *const libc::c_char);
7552 }
7553 tmp = cliFormatReplyRaw(*((*r).element).offset(i as isize));
7554 out = hi_sdscatlen(out, tmp as *const libc::c_void, hi_sdslen(tmp));
7555 hi_sdsfree(tmp);
7556 out = hi_sdscatlen(
7557 out,
7558 b" \0" as *const u8 as *const libc::c_char as *const libc::c_void,
7559 1 as libc::c_int as size_t,
7560 );
7561 tmp = cliFormatReplyRaw(
7562 *((*r).element)
7563 .offset(
7564 i.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize,
7565 ),
7566 );
7567 out = hi_sdscatlen(out, tmp as *const libc::c_void, hi_sdslen(tmp));
7568 hi_sdsfree(tmp);
7569 i = (i as libc::c_ulong).wrapping_add(2 as libc::c_int as libc::c_ulong)
7570 as size_t as size_t;
7571 }
7572 }
7573 _ => {
7574 fprintf(
7575 stderr,
7576 b"Unknown reply type: %d\n\0" as *const u8 as *const libc::c_char,
7577 (*r).type_0,
7578 );
7579 exit(1 as libc::c_int);
7580 }
7581 }
7582 return out;
7583}
7584unsafe extern "C" fn cliFormatReplyCSV(mut r: *mut redisReply) -> hisds {
7585 let mut i: libc::c_uint = 0;
7586 let mut out: hisds = hi_sdsempty();
7587 match (*r).type_0 {
7588 6 => {
7589 out = hi_sdscat(out, b"ERROR,\0" as *const u8 as *const libc::c_char);
7590 out = hi_sdscatrepr(out, (*r).str_0, strlen((*r).str_0));
7591 }
7592 5 => {
7593 out = hi_sdscatrepr(out, (*r).str_0, (*r).len);
7594 }
7595 3 => {
7596 out = hi_sdscatprintf(
7597 out,
7598 b"%lld\0" as *const u8 as *const libc::c_char,
7599 (*r).integer,
7600 );
7601 }
7602 7 => {
7603 out = hi_sdscatprintf(
7604 out,
7605 b"%s\0" as *const u8 as *const libc::c_char,
7606 (*r).str_0,
7607 );
7608 }
7609 1 | 14 => {
7610 out = hi_sdscatrepr(out, (*r).str_0, (*r).len);
7611 }
7612 4 => {
7613 out = hi_sdscat(out, b"NULL\0" as *const u8 as *const libc::c_char);
7614 }
7615 8 => {
7616 out = hi_sdscat(
7617 out,
7618 if (*r).integer != 0 {
7619 b"true\0" as *const u8 as *const libc::c_char
7620 } else {
7621 b"false\0" as *const u8 as *const libc::c_char
7622 },
7623 );
7624 }
7625 2 | 10 | 12 | 9 => {
7626 i = 0 as libc::c_int as libc::c_uint;
7627 while (i as libc::c_ulong) < (*r).elements {
7628 let mut tmp: hisds = cliFormatReplyCSV(
7629 *((*r).element).offset(i as isize),
7630 );
7631 out = hi_sdscatlen(out, tmp as *const libc::c_void, hi_sdslen(tmp));
7632 if i as libc::c_ulong
7633 != ((*r).elements).wrapping_sub(1 as libc::c_int as libc::c_ulong)
7634 {
7635 out = hi_sdscat(out, b",\0" as *const u8 as *const libc::c_char);
7636 }
7637 hi_sdsfree(tmp);
7638 i = i.wrapping_add(1);
7639 }
7640 }
7641 _ => {
7642 fprintf(
7643 stderr,
7644 b"Unknown reply type: %d\n\0" as *const u8 as *const libc::c_char,
7645 (*r).type_0,
7646 );
7647 exit(1 as libc::c_int);
7648 }
7649 }
7650 return out;
7651}
7652unsafe extern "C" fn jsonStringOutput(
7653 mut out: hisds,
7654 mut p: *const libc::c_char,
7655 mut len: libc::c_int,
7656 mut mode: libc::c_int,
7657) -> hisds {
7658 if mode == 3 as libc::c_int {
7659 return escapeJsonString(out, p, len as size_t)
7660 } else {
7661 if mode == 4 as libc::c_int {
7662 let mut tmp: hisds = hi_sdscatrepr(hi_sdsempty(), p, len as size_t);
7663 let mut tmplen: libc::c_int = hi_sdslen(tmp) as libc::c_int;
7664 let mut n: *mut libc::c_char = tmp;
7665 loop {
7666 let fresh10 = tmplen;
7667 tmplen = tmplen - 1;
7668 if !(fresh10 != 0) {
7669 break;
7670 }
7671 if *n as libc::c_int == '\\' as i32 {
7672 out = hi_sdscatlen(
7673 out,
7674 b"\\\\\0" as *const u8 as *const libc::c_char
7675 as *const libc::c_void,
7676 2 as libc::c_int as size_t,
7677 );
7678 } else {
7679 out = hi_sdscatlen(
7680 out,
7681 n as *const libc::c_void,
7682 1 as libc::c_int as size_t,
7683 );
7684 }
7685 n = n.offset(1);
7686 }
7687 hi_sdsfree(tmp);
7688 return out;
7689 } else {
7690 if 0 as libc::c_int != 0 {} else {
7691 __assert_fail(
7692 b"0\0" as *const u8 as *const libc::c_char,
7693 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
7694 1524 as libc::c_int as libc::c_uint,
7695 (*core::mem::transmute::<
7696 &[u8; 54],
7697 &[libc::c_char; 54],
7698 >(b"hisds jsonStringOutput(hisds, const char *, int, int)\0"))
7699 .as_ptr(),
7700 );
7701 };
7702 }
7703 }
7704 panic!("Reached end of non-void function without returning");
7705}
7706unsafe extern "C" fn cliFormatReplyJson(
7707 mut out: hisds,
7708 mut r: *mut redisReply,
7709 mut mode: libc::c_int,
7710) -> hisds {
7711 let mut i: libc::c_uint = 0;
7712 match (*r).type_0 {
7713 6 => {
7714 out = hi_sdscat(out, b"error:\0" as *const u8 as *const libc::c_char);
7715 out = jsonStringOutput(
7716 out,
7717 (*r).str_0,
7718 strlen((*r).str_0) as libc::c_int,
7719 mode,
7720 );
7721 }
7722 5 => {
7723 out = jsonStringOutput(out, (*r).str_0, (*r).len as libc::c_int, mode);
7724 }
7725 3 => {
7726 out = hi_sdscatprintf(
7727 out,
7728 b"%lld\0" as *const u8 as *const libc::c_char,
7729 (*r).integer,
7730 );
7731 }
7732 7 => {
7733 out = hi_sdscatprintf(
7734 out,
7735 b"%s\0" as *const u8 as *const libc::c_char,
7736 (*r).str_0,
7737 );
7738 }
7739 1 | 14 => {
7740 out = jsonStringOutput(out, (*r).str_0, (*r).len as libc::c_int, mode);
7741 }
7742 4 => {
7743 out = hi_sdscat(out, b"null\0" as *const u8 as *const libc::c_char);
7744 }
7745 8 => {
7746 out = hi_sdscat(
7747 out,
7748 if (*r).integer != 0 {
7749 b"true\0" as *const u8 as *const libc::c_char
7750 } else {
7751 b"false\0" as *const u8 as *const libc::c_char
7752 },
7753 );
7754 }
7755 2 | 10 | 12 => {
7756 out = hi_sdscat(out, b"[\0" as *const u8 as *const libc::c_char);
7757 i = 0 as libc::c_int as libc::c_uint;
7758 while (i as libc::c_ulong) < (*r).elements {
7759 out = cliFormatReplyJson(out, *((*r).element).offset(i as isize), mode);
7760 if i as libc::c_ulong
7761 != ((*r).elements).wrapping_sub(1 as libc::c_int as libc::c_ulong)
7762 {
7763 out = hi_sdscat(out, b",\0" as *const u8 as *const libc::c_char);
7764 }
7765 i = i.wrapping_add(1);
7766 }
7767 out = hi_sdscat(out, b"]\0" as *const u8 as *const libc::c_char);
7768 }
7769 9 => {
7770 out = hi_sdscat(out, b"{\0" as *const u8 as *const libc::c_char);
7771 i = 0 as libc::c_int as libc::c_uint;
7772 while (i as libc::c_ulong) < (*r).elements {
7773 let mut key: *mut redisReply = *((*r).element).offset(i as isize);
7774 if (*key).type_0 == 6 as libc::c_int || (*key).type_0 == 5 as libc::c_int
7775 || (*key).type_0 == 1 as libc::c_int
7776 || (*key).type_0 == 14 as libc::c_int
7777 {
7778 out = cliFormatReplyJson(out, key, mode);
7779 } else {
7780 let mut keystr: hisds = cliFormatReplyJson(hi_sdsempty(), key, mode);
7781 if *keystr.offset(0 as libc::c_int as isize) as libc::c_int
7782 == '"' as i32
7783 {
7784 out = hi_sdscatsds(out, keystr);
7785 } else {
7786 out = hi_sdscatfmt(
7787 out,
7788 b"\"%S\"\0" as *const u8 as *const libc::c_char,
7789 keystr,
7790 );
7791 }
7792 hi_sdsfree(keystr);
7793 }
7794 out = hi_sdscat(out, b":\0" as *const u8 as *const libc::c_char);
7795 out = cliFormatReplyJson(
7796 out,
7797 *((*r).element)
7798 .offset(
7799 i.wrapping_add(1 as libc::c_int as libc::c_uint) as isize,
7800 ),
7801 mode,
7802 );
7803 if i as libc::c_ulong
7804 != ((*r).elements).wrapping_sub(2 as libc::c_int as libc::c_ulong)
7805 {
7806 out = hi_sdscat(out, b",\0" as *const u8 as *const libc::c_char);
7807 }
7808 i = i.wrapping_add(2 as libc::c_int as libc::c_uint);
7809 }
7810 out = hi_sdscat(out, b"}\0" as *const u8 as *const libc::c_char);
7811 }
7812 _ => {
7813 fprintf(
7814 stderr,
7815 b"Unknown reply type: %d\n\0" as *const u8 as *const libc::c_char,
7816 (*r).type_0,
7817 );
7818 exit(1 as libc::c_int);
7819 }
7820 }
7821 return out;
7822}
7823unsafe extern "C" fn cliFormatReply(
7824 mut reply: *mut redisReply,
7825 mut mode: libc::c_int,
7826 mut verbatim: libc::c_int,
7827) -> hisds {
7828 let mut out: hisds = 0 as *mut libc::c_char;
7829 if verbatim != 0 {
7830 out = cliFormatReplyRaw(reply);
7831 } else if mode == 0 as libc::c_int {
7832 out = cliFormatReplyTTY(
7833 reply,
7834 b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
7835 );
7836 } else if mode == 1 as libc::c_int {
7837 out = cliFormatReplyRaw(reply);
7838 out = hi_sdscatsds(out, config.cmd_delim);
7839 } else if mode == 2 as libc::c_int {
7840 out = cliFormatReplyCSV(reply);
7841 out = hi_sdscatlen(
7842 out,
7843 b"\n\0" as *const u8 as *const libc::c_char as *const libc::c_void,
7844 1 as libc::c_int as size_t,
7845 );
7846 } else if mode == 3 as libc::c_int || mode == 4 as libc::c_int {
7847 out = cliFormatReplyJson(hi_sdsempty(), reply, mode);
7848 out = hi_sdscatlen(
7849 out,
7850 b"\n\0" as *const u8 as *const libc::c_char as *const libc::c_void,
7851 1 as libc::c_int as size_t,
7852 );
7853 } else {
7854 fprintf(
7855 stderr,
7856 b"Error: Unknown output encoding %d\n\0" as *const u8
7857 as *const libc::c_char,
7858 mode,
7859 );
7860 exit(1 as libc::c_int);
7861 }
7862 return out;
7863}
7864unsafe extern "C" fn cliPushHandler(
7865 mut privdata: *mut libc::c_void,
7866 mut reply: *mut libc::c_void,
7867) {
7868 let mut out: hisds = 0 as *mut libc::c_char;
7869 if config.output == 0 as libc::c_int
7870 && isInvalidateReply(reply as *mut redisReply) != 0
7871 {
7872 out = cliFormatInvalidateTTY(reply as *mut redisReply);
7873 } else {
7874 out = cliFormatReply(reply as *mut redisReply, config.output, 0 as libc::c_int);
7875 }
7876 fwrite(
7877 out as *const libc::c_void,
7878 hi_sdslen(out),
7879 1 as libc::c_int as libc::c_ulong,
7880 stdout,
7881 );
7882 freeReplyObject(reply);
7883 hi_sdsfree(out);
7884}
7885unsafe extern "C" fn cliReadReply(mut output_raw_strings: libc::c_int) -> libc::c_int {
7886 let mut _reply: *mut libc::c_void = 0 as *mut libc::c_void;
7887 let mut reply: *mut redisReply = 0 as *mut redisReply;
7888 let mut out: hisds = 0 as hisds;
7889 let mut output: libc::c_int = 1 as libc::c_int;
7890 if redisGetReply(context, &mut _reply) != 0 as libc::c_int {
7891 if config.blocking_state_aborted != 0 {
7892 config.blocking_state_aborted = 0 as libc::c_int;
7893 config.monitor_mode = 0 as libc::c_int;
7894 config.pubsub_mode = 0 as libc::c_int;
7895 return cliConnect((1 as libc::c_int) << 0 as libc::c_int);
7896 }
7897 if config.shutdown != 0 {
7898 redisFree(context);
7899 context = 0 as *mut redisContext;
7900 return 0 as libc::c_int;
7901 }
7902 if config.interactive != 0 {
7903 if (*context).err == 1 as libc::c_int
7904 && (*__errno_location() == 104 as libc::c_int
7905 || *__errno_location() == 32 as libc::c_int)
7906 {
7907 return -(1 as libc::c_int);
7908 }
7909 if (*context).err == 3 as libc::c_int {
7910 return -(1 as libc::c_int);
7911 }
7912 }
7913 cliPrintContextError();
7914 exit(1 as libc::c_int);
7915 }
7916 reply = _reply as *mut redisReply;
7917 config.last_cmd_type = (*reply).type_0;
7918 if config.cluster_mode != 0 && (*reply).type_0 == 6 as libc::c_int
7919 && (strncmp(
7920 (*reply).str_0,
7921 b"MOVED \0" as *const u8 as *const libc::c_char,
7922 6 as libc::c_int as libc::c_ulong,
7923 ) == 0
7924 || strncmp(
7925 (*reply).str_0,
7926 b"ASK \0" as *const u8 as *const libc::c_char,
7927 4 as libc::c_int as libc::c_ulong,
7928 ) == 0)
7929 {
7930 let mut p: *mut libc::c_char = (*reply).str_0;
7931 let mut s: *mut libc::c_char = 0 as *mut libc::c_char;
7932 let mut slot: libc::c_int = 0;
7933 output = 0 as libc::c_int;
7934 s = strchr(p, ' ' as i32);
7935 p = strchr(s.offset(1 as libc::c_int as isize), ' ' as i32);
7936 *p = '\0' as i32 as libc::c_char;
7937 slot = atoi(s.offset(1 as libc::c_int as isize));
7938 s = strrchr(p.offset(1 as libc::c_int as isize), ':' as i32);
7939 *s = '\0' as i32 as libc::c_char;
7940 hi_sdsfree(config.conn_info.hostip);
7941 config.conn_info.hostip = hi_sdsnew(p.offset(1 as libc::c_int as isize));
7942 config.conn_info.hostport = atoi(s.offset(1 as libc::c_int as isize));
7943 if config.interactive != 0 {
7944 printf(
7945 b"-> Redirected to slot [%d] located at %s:%d\n\0" as *const u8
7946 as *const libc::c_char,
7947 slot,
7948 config.conn_info.hostip,
7949 config.conn_info.hostport,
7950 );
7951 }
7952 config.cluster_reissue_command = 1 as libc::c_int;
7953 if strncmp(
7954 (*reply).str_0,
7955 b"ASK \0" as *const u8 as *const libc::c_char,
7956 4 as libc::c_int as libc::c_ulong,
7957 ) == 0
7958 {
7959 config.cluster_send_asking = 1 as libc::c_int;
7960 }
7961 cliRefreshPrompt();
7962 } else if config.interactive == 0 && config.set_errcode != 0
7963 && (*reply).type_0 == 6 as libc::c_int
7964 {
7965 fprintf(stderr, b"%s\n\0" as *const u8 as *const libc::c_char, (*reply).str_0);
7966 exit(1 as libc::c_int);
7967 }
7968 if output != 0 {
7969 out = cliFormatReply(reply, config.output, output_raw_strings);
7970 fwrite(
7971 out as *const libc::c_void,
7972 hi_sdslen(out),
7973 1 as libc::c_int as libc::c_ulong,
7974 stdout,
7975 );
7976 fflush(stdout);
7977 hi_sdsfree(out);
7978 }
7979 freeReplyObject(reply as *mut libc::c_void);
7980 return 0 as libc::c_int;
7981}
7982unsafe extern "C" fn cliSendCommand(
7983 mut argc: libc::c_int,
7984 mut argv: *mut *mut libc::c_char,
7985 mut repeat: libc::c_long,
7986) -> libc::c_int {
7987 let mut command: *mut libc::c_char = *argv.offset(0 as libc::c_int as isize);
7988 let mut argvlen: *mut size_t = 0 as *mut size_t;
7989 let mut j: libc::c_int = 0;
7990 let mut output_raw: libc::c_int = 0;
7991 if context.is_null() {
7992 return -(1 as libc::c_int);
7993 }
7994 output_raw = 0 as libc::c_int;
7995 if strcasecmp(command, b"info\0" as *const u8 as *const libc::c_char) == 0
7996 || strcasecmp(command, b"lolwut\0" as *const u8 as *const libc::c_char) == 0
7997 || argc >= 2 as libc::c_int
7998 && strcasecmp(command, b"debug\0" as *const u8 as *const libc::c_char) == 0
7999 && strcasecmp(
8000 *argv.offset(1 as libc::c_int as isize),
8001 b"htstats\0" as *const u8 as *const libc::c_char,
8002 ) == 0
8003 || argc >= 2 as libc::c_int
8004 && strcasecmp(command, b"debug\0" as *const u8 as *const libc::c_char) == 0
8005 && strcasecmp(
8006 *argv.offset(1 as libc::c_int as isize),
8007 b"htstats-key\0" as *const u8 as *const libc::c_char,
8008 ) == 0
8009 || argc >= 2 as libc::c_int
8010 && strcasecmp(command, b"debug\0" as *const u8 as *const libc::c_char) == 0
8011 && strcasecmp(
8012 *argv.offset(1 as libc::c_int as isize),
8013 b"client-eviction\0" as *const u8 as *const libc::c_char,
8014 ) == 0
8015 || argc >= 2 as libc::c_int
8016 && strcasecmp(command, b"memory\0" as *const u8 as *const libc::c_char) == 0
8017 && (strcasecmp(
8018 *argv.offset(1 as libc::c_int as isize),
8019 b"malloc-stats\0" as *const u8 as *const libc::c_char,
8020 ) == 0
8021 || strcasecmp(
8022 *argv.offset(1 as libc::c_int as isize),
8023 b"doctor\0" as *const u8 as *const libc::c_char,
8024 ) == 0)
8025 || argc == 2 as libc::c_int
8026 && strcasecmp(command, b"cluster\0" as *const u8 as *const libc::c_char) == 0
8027 && (strcasecmp(
8028 *argv.offset(1 as libc::c_int as isize),
8029 b"nodes\0" as *const u8 as *const libc::c_char,
8030 ) == 0
8031 || strcasecmp(
8032 *argv.offset(1 as libc::c_int as isize),
8033 b"info\0" as *const u8 as *const libc::c_char,
8034 ) == 0)
8035 || argc >= 2 as libc::c_int
8036 && strcasecmp(command, b"client\0" as *const u8 as *const libc::c_char) == 0
8037 && (strcasecmp(
8038 *argv.offset(1 as libc::c_int as isize),
8039 b"list\0" as *const u8 as *const libc::c_char,
8040 ) == 0
8041 || strcasecmp(
8042 *argv.offset(1 as libc::c_int as isize),
8043 b"info\0" as *const u8 as *const libc::c_char,
8044 ) == 0)
8045 || argc == 3 as libc::c_int
8046 && strcasecmp(command, b"latency\0" as *const u8 as *const libc::c_char) == 0
8047 && strcasecmp(
8048 *argv.offset(1 as libc::c_int as isize),
8049 b"graph\0" as *const u8 as *const libc::c_char,
8050 ) == 0
8051 || argc == 2 as libc::c_int
8052 && strcasecmp(command, b"latency\0" as *const u8 as *const libc::c_char) == 0
8053 && strcasecmp(
8054 *argv.offset(1 as libc::c_int as isize),
8055 b"doctor\0" as *const u8 as *const libc::c_char,
8056 ) == 0
8057 || argc >= 2 as libc::c_int
8058 && strcasecmp(command, b"proxy\0" as *const u8 as *const libc::c_char) == 0
8059 && strcasecmp(
8060 *argv.offset(1 as libc::c_int as isize),
8061 b"info\0" as *const u8 as *const libc::c_char,
8062 ) == 0
8063 {
8064 output_raw = 1 as libc::c_int;
8065 }
8066 if strcasecmp(command, b"shutdown\0" as *const u8 as *const libc::c_char) == 0 {
8067 config.shutdown = 1 as libc::c_int;
8068 }
8069 if strcasecmp(command, b"monitor\0" as *const u8 as *const libc::c_char) == 0 {
8070 config.monitor_mode = 1 as libc::c_int;
8071 }
8072 if strcasecmp(command, b"subscribe\0" as *const u8 as *const libc::c_char) == 0
8073 || strcasecmp(command, b"psubscribe\0" as *const u8 as *const libc::c_char) == 0
8074 || strcasecmp(command, b"ssubscribe\0" as *const u8 as *const libc::c_char) == 0
8075 {
8076 config.pubsub_mode = 1 as libc::c_int;
8077 }
8078 if strcasecmp(command, b"sync\0" as *const u8 as *const libc::c_char) == 0
8079 || strcasecmp(command, b"psync\0" as *const u8 as *const libc::c_char) == 0
8080 {
8081 config.slave_mode = 1 as libc::c_int;
8082 }
8083 if argc == 3 as libc::c_int
8084 && strcasecmp(
8085 *argv.offset(0 as libc::c_int as isize),
8086 b"script\0" as *const u8 as *const libc::c_char,
8087 ) == 0
8088 && strcasecmp(
8089 *argv.offset(1 as libc::c_int as isize),
8090 b"debug\0" as *const u8 as *const libc::c_char,
8091 ) == 0
8092 {
8093 if strcasecmp(
8094 *argv.offset(2 as libc::c_int as isize),
8095 b"yes\0" as *const u8 as *const libc::c_char,
8096 ) == 0
8097 || strcasecmp(
8098 *argv.offset(2 as libc::c_int as isize),
8099 b"sync\0" as *const u8 as *const libc::c_char,
8100 ) == 0
8101 {
8102 config.enable_ldb_on_eval = 1 as libc::c_int;
8103 } else {
8104 config.enable_ldb_on_eval = 0 as libc::c_int;
8105 }
8106 }
8107 if strcasecmp(command, b"eval\0" as *const u8 as *const libc::c_char) == 0
8108 && config.enable_ldb_on_eval != 0
8109 {
8110 config.eval_ldb = 1 as libc::c_int;
8111 config.output = 1 as libc::c_int;
8112 }
8113 argvlen = zmalloc(
8114 (argc as libc::c_ulong)
8115 .wrapping_mul(core::mem::size_of::<size_t>() as libc::c_ulong),
8116 ) as *mut size_t;
8117 j = 0 as libc::c_int;
8118 while j < argc {
8119 *argvlen.offset(j as isize) = hi_sdslen(*argv.offset(j as isize));
8120 j += 1;
8121 }
8122 while repeat < 0 as libc::c_int as libc::c_long
8123 || {
8124 let fresh11 = repeat;
8125 repeat = repeat - 1;
8126 fresh11 > 0 as libc::c_int as libc::c_long
8127 }
8128 {
8129 redisAppendCommandArgv(context, argc, argv as *mut *const libc::c_char, argvlen);
8130 if config.monitor_mode != 0 {
8131 loop {
8132 if cliReadReply(output_raw) != 0 as libc::c_int {
8133 cliPrintContextError();
8134 exit(1 as libc::c_int);
8135 }
8136 fflush(stdout);
8137 if config.last_cmd_type == 6 as libc::c_int {
8138 config.monitor_mode = 0 as libc::c_int;
8139 }
8140 if !(config.monitor_mode != 0) {
8141 break;
8142 }
8143 }
8144 zfree(argvlen as *mut libc::c_void);
8145 return 0 as libc::c_int;
8146 }
8147 if config.pubsub_mode != 0 {
8148 if config.output != 1 as libc::c_int {
8149 printf(
8150 b"Reading messages... (press Ctrl-C to quit)\n\0" as *const u8
8151 as *const libc::c_char,
8152 );
8153 }
8154 redisSetPushCallback(context, None);
8155 while config.pubsub_mode != 0 {
8156 if cliReadReply(output_raw) != 0 as libc::c_int {
8157 cliPrintContextError();
8158 exit(1 as libc::c_int);
8159 }
8160 fflush(stdout);
8161 if config.pubsub_mode == 0 || config.last_cmd_type == 6 as libc::c_int {
8162 if config.push_output != 0 {
8163 redisSetPushCallback(
8164 context,
8165 Some(
8166 cliPushHandler
8167 as unsafe extern "C" fn(
8168 *mut libc::c_void,
8169 *mut libc::c_void,
8170 ) -> (),
8171 ),
8172 );
8173 }
8174 config.pubsub_mode = 0 as libc::c_int;
8175 }
8176 }
8177 } else {
8178 if config.slave_mode != 0 {
8179 printf(
8180 b"Entering replica output mode... (press Ctrl-C to quit)\n\0"
8181 as *const u8 as *const libc::c_char,
8182 );
8183 slaveMode();
8184 config.slave_mode = 0 as libc::c_int;
8185 zfree(argvlen as *mut libc::c_void);
8186 return -(1 as libc::c_int);
8187 }
8188 if cliReadReply(output_raw) != 0 as libc::c_int {
8189 zfree(argvlen as *mut libc::c_void);
8190 return -(1 as libc::c_int);
8191 } else {
8192 if strcasecmp(command, b"select\0" as *const u8 as *const libc::c_char)
8193 == 0 && argc == 2 as libc::c_int
8194 && config.last_cmd_type != 6 as libc::c_int
8195 {
8196 config.dbnum = atoi(*argv.offset(1 as libc::c_int as isize));
8197 config.conn_info.input_dbnum = config.dbnum;
8198 cliRefreshPrompt();
8199 } else if strcasecmp(
8200 command,
8201 b"auth\0" as *const u8 as *const libc::c_char,
8202 ) == 0 && (argc == 2 as libc::c_int || argc == 3 as libc::c_int)
8203 {
8204 cliSelect();
8205 } else if strcasecmp(
8206 command,
8207 b"multi\0" as *const u8 as *const libc::c_char,
8208 ) == 0 && argc == 1 as libc::c_int
8209 && config.last_cmd_type != 6 as libc::c_int
8210 {
8211 config.in_multi = 1 as libc::c_int;
8212 config.pre_multi_dbnum = config.dbnum;
8213 cliRefreshPrompt();
8214 } else if strcasecmp(
8215 command,
8216 b"exec\0" as *const u8 as *const libc::c_char,
8217 ) == 0 && argc == 1 as libc::c_int && config.in_multi != 0
8218 {
8219 config.in_multi = 0 as libc::c_int;
8220 if config.last_cmd_type == 6 as libc::c_int
8221 || config.last_cmd_type == 4 as libc::c_int
8222 {
8223 config.dbnum = config.pre_multi_dbnum;
8224 config.conn_info.input_dbnum = config.dbnum;
8225 }
8226 cliRefreshPrompt();
8227 } else if strcasecmp(
8228 command,
8229 b"discard\0" as *const u8 as *const libc::c_char,
8230 ) == 0 && argc == 1 as libc::c_int
8231 && config.last_cmd_type != 6 as libc::c_int
8232 {
8233 config.in_multi = 0 as libc::c_int;
8234 config.dbnum = config.pre_multi_dbnum;
8235 config.conn_info.input_dbnum = config.dbnum;
8236 cliRefreshPrompt();
8237 } else if strcasecmp(
8238 command,
8239 b"reset\0" as *const u8 as *const libc::c_char,
8240 ) == 0 && argc == 1 as libc::c_int
8241 && config.last_cmd_type != 6 as libc::c_int
8242 {
8243 config.in_multi = 0 as libc::c_int;
8244 config.dbnum = 0 as libc::c_int;
8245 config.conn_info.input_dbnum = 0 as libc::c_int;
8246 config.resp3 = 0 as libc::c_int;
8247 cliRefreshPrompt();
8248 }
8249 }
8250 if config.cluster_reissue_command != 0 {
8251 break;
8252 }
8253 if config.interval != 0 {
8254 usleep(config.interval as __useconds_t);
8255 }
8256 fflush(stdout);
8257 }
8258 }
8259 zfree(argvlen as *mut libc::c_void);
8260 return 0 as libc::c_int;
8261}
8262unsafe extern "C" fn reconnectingRedisCommand(
8263 mut c: *mut redisContext,
8264 mut fmt: *const libc::c_char,
8265 mut args: ...
8266) -> *mut redisReply {
8267 let mut reply: *mut redisReply = 0 as *mut redisReply;
8268 let mut tries: libc::c_int = 0 as libc::c_int;
8269 let mut ap: core::ffi::VaListImpl;
8270 if (*c).err == 0 {} else {
8271 __assert_fail(
8272 b"!c->err\0" as *const u8 as *const libc::c_char,
8273 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
8274 1905 as libc::c_int as libc::c_uint,
8275 (*core::mem::transmute::<
8276 &[u8; 72],
8277 &[libc::c_char; 72],
8278 >(
8279 b"redisReply *reconnectingRedisCommand(redisContext *, const char *, ...)\0",
8280 ))
8281 .as_ptr(),
8282 );
8283 };
8284 while reply.is_null() {
8285 while (*c).err & (1 as libc::c_int | 3 as libc::c_int) != 0 {
8286 printf(b"\r\x1B[0K\0" as *const u8 as *const libc::c_char);
8287 tries += 1;
8288 printf(b"Reconnecting... %d\r\0" as *const u8 as *const libc::c_char, tries);
8289 fflush(stdout);
8290 redisFree(c);
8291 c = redisConnect(config.conn_info.hostip, config.conn_info.hostport);
8292 if (*c).err == 0 && config.tls != 0 {
8293 let mut err: *const libc::c_char = 0 as *const libc::c_char;
8294 if cliSecureConnection(c, config.sslconfig, &mut err)
8295 == -(1 as libc::c_int) && !err.is_null()
8296 {
8297 fprintf(
8298 stderr,
8299 b"TLS Error: %s\n\0" as *const u8 as *const libc::c_char,
8300 err,
8301 );
8302 exit(1 as libc::c_int);
8303 }
8304 }
8305 usleep(1000000 as libc::c_int as __useconds_t);
8306 }
8307 ap = args.clone();
8308 reply = redisvCommand(c, fmt, ap.as_va_list()) as *mut redisReply;
8309 if (*c).err != 0 && (*c).err & (1 as libc::c_int | 3 as libc::c_int) == 0 {
8310 fprintf(
8311 stderr,
8312 b"Error: %s\n\0" as *const u8 as *const libc::c_char,
8313 ((*c).errstr).as_mut_ptr(),
8314 );
8315 exit(1 as libc::c_int);
8316 } else {
8317 if tries > 0 as libc::c_int {
8318 printf(b"\r\x1B[0K\0" as *const u8 as *const libc::c_char);
8319 }
8320 }
8321 }
8322 context = c;
8323 return reply;
8324}
8325unsafe extern "C" fn parseOptions(
8326 mut argc: libc::c_int,
8327 mut argv: *mut *mut libc::c_char,
8328) -> libc::c_int {
8329 let mut i: libc::c_int = 0;
8330 i = 1 as libc::c_int;
8331 while i < argc {
8332 let mut lastarg: libc::c_int = (i == argc - 1 as libc::c_int) as libc::c_int;
8333 if strcmp(*argv.offset(i as isize), b"-h\0" as *const u8 as *const libc::c_char)
8334 == 0 && lastarg == 0
8335 {
8336 hi_sdsfree(config.conn_info.hostip);
8337 i += 1;
8338 config.conn_info.hostip = hi_sdsnew(*argv.offset(i as isize));
8339 } else if strcmp(
8340 *argv.offset(i as isize),
8341 b"-h\0" as *const u8 as *const libc::c_char,
8342 ) == 0 && lastarg != 0
8343 {
8344 usage(0 as libc::c_int);
8345 } else if strcmp(
8346 *argv.offset(i as isize),
8347 b"--help\0" as *const u8 as *const libc::c_char,
8348 ) == 0
8349 {
8350 usage(0 as libc::c_int);
8351 } else if strcmp(
8352 *argv.offset(i as isize),
8353 b"-x\0" as *const u8 as *const libc::c_char,
8354 ) == 0
8355 {
8356 config.stdin_lastarg = 1 as libc::c_int;
8357 } else if strcmp(
8358 *argv.offset(i as isize),
8359 b"-X\0" as *const u8 as *const libc::c_char,
8360 ) == 0 && lastarg == 0
8361 {
8362 config.stdin_tag_arg = 1 as libc::c_int;
8363 i += 1;
8364 config.stdin_tag_name = *argv.offset(i as isize);
8365 } else if strcmp(
8366 *argv.offset(i as isize),
8367 b"-p\0" as *const u8 as *const libc::c_char,
8368 ) == 0 && lastarg == 0
8369 {
8370 i += 1;
8371 config.conn_info.hostport = atoi(*argv.offset(i as isize));
8372 } else if strcmp(
8373 *argv.offset(i as isize),
8374 b"-s\0" as *const u8 as *const libc::c_char,
8375 ) == 0 && lastarg == 0
8376 {
8377 i += 1;
8378 config.hostsocket = *argv.offset(i as isize);
8379 } else if strcmp(
8380 *argv.offset(i as isize),
8381 b"-r\0" as *const u8 as *const libc::c_char,
8382 ) == 0 && lastarg == 0
8383 {
8384 i += 1;
8385 config
8386 .repeat = strtoll(
8387 *argv.offset(i as isize),
8388 0 as *mut *mut libc::c_char,
8389 10 as libc::c_int,
8390 ) as libc::c_long;
8391 } else if strcmp(
8392 *argv.offset(i as isize),
8393 b"-i\0" as *const u8 as *const libc::c_char,
8394 ) == 0 && lastarg == 0
8395 {
8396 i += 1;
8397 let mut seconds: libc::c_double = atof(*argv.offset(i as isize));
8398 config
8399 .interval = (seconds * 1000000 as libc::c_int as libc::c_double)
8400 as libc::c_long;
8401 } else if strcmp(
8402 *argv.offset(i as isize),
8403 b"-n\0" as *const u8 as *const libc::c_char,
8404 ) == 0 && lastarg == 0
8405 {
8406 i += 1;
8407 config.conn_info.input_dbnum = atoi(*argv.offset(i as isize));
8408 } else if strcmp(
8409 *argv.offset(i as isize),
8410 b"--no-auth-warning\0" as *const u8 as *const libc::c_char,
8411 ) == 0
8412 {
8413 config.no_auth_warning = 1 as libc::c_int;
8414 } else if strcmp(
8415 *argv.offset(i as isize),
8416 b"--askpass\0" as *const u8 as *const libc::c_char,
8417 ) == 0
8418 {
8419 config.askpass = 1 as libc::c_int;
8420 } else if (strcmp(
8421 *argv.offset(i as isize),
8422 b"-a\0" as *const u8 as *const libc::c_char,
8423 ) == 0
8424 || strcmp(
8425 *argv.offset(i as isize),
8426 b"--pass\0" as *const u8 as *const libc::c_char,
8427 ) == 0) && lastarg == 0
8428 {
8429 i += 1;
8430 config.conn_info.auth = hi_sdsnew(*argv.offset(i as isize));
8431 } else if strcmp(
8432 *argv.offset(i as isize),
8433 b"--user\0" as *const u8 as *const libc::c_char,
8434 ) == 0 && lastarg == 0
8435 {
8436 i += 1;
8437 config.conn_info.user = hi_sdsnew(*argv.offset(i as isize));
8438 } else if strcmp(
8439 *argv.offset(i as isize),
8440 b"-u\0" as *const u8 as *const libc::c_char,
8441 ) == 0 && lastarg == 0
8442 {
8443 i += 1;
8444 parseRedisUri(
8445 *argv.offset(i as isize),
8446 b"redis-cli\0" as *const u8 as *const libc::c_char,
8447 &mut config.conn_info,
8448 &mut config.tls,
8449 );
8450 } else if strcmp(
8451 *argv.offset(i as isize),
8452 b"--raw\0" as *const u8 as *const libc::c_char,
8453 ) == 0
8454 {
8455 config.output = 1 as libc::c_int;
8456 } else if strcmp(
8457 *argv.offset(i as isize),
8458 b"--no-raw\0" as *const u8 as *const libc::c_char,
8459 ) == 0
8460 {
8461 config.output = 0 as libc::c_int;
8462 } else if strcmp(
8463 *argv.offset(i as isize),
8464 b"--quoted-input\0" as *const u8 as *const libc::c_char,
8465 ) == 0
8466 {
8467 config.quoted_input = 1 as libc::c_int;
8468 } else if strcmp(
8469 *argv.offset(i as isize),
8470 b"--csv\0" as *const u8 as *const libc::c_char,
8471 ) == 0
8472 {
8473 config.output = 2 as libc::c_int;
8474 } else if strcmp(
8475 *argv.offset(i as isize),
8476 b"--json\0" as *const u8 as *const libc::c_char,
8477 ) == 0
8478 {
8479 if config.resp3 == 0 as libc::c_int {
8480 config.resp3 = 2 as libc::c_int;
8481 }
8482 config.output = 3 as libc::c_int;
8483 } else if strcmp(
8484 *argv.offset(i as isize),
8485 b"--quoted-json\0" as *const u8 as *const libc::c_char,
8486 ) == 0
8487 {
8488 if config.resp3 == 0 as libc::c_int {
8489 config.resp3 = 2 as libc::c_int;
8490 }
8491 config.output = 4 as libc::c_int;
8492 } else if strcmp(
8493 *argv.offset(i as isize),
8494 b"--latency\0" as *const u8 as *const libc::c_char,
8495 ) == 0
8496 {
8497 config.latency_mode = 1 as libc::c_int;
8498 } else if strcmp(
8499 *argv.offset(i as isize),
8500 b"--latency-dist\0" as *const u8 as *const libc::c_char,
8501 ) == 0
8502 {
8503 config.latency_dist_mode = 1 as libc::c_int;
8504 } else if strcmp(
8505 *argv.offset(i as isize),
8506 b"--mono\0" as *const u8 as *const libc::c_char,
8507 ) == 0
8508 {
8509 spectrum_palette = spectrum_palette_mono.as_mut_ptr();
8510 spectrum_palette_size = spectrum_palette_mono_size;
8511 } else if strcmp(
8512 *argv.offset(i as isize),
8513 b"--latency-history\0" as *const u8 as *const libc::c_char,
8514 ) == 0
8515 {
8516 config.latency_mode = 1 as libc::c_int;
8517 config.latency_history = 1 as libc::c_int;
8518 } else if strcmp(
8519 *argv.offset(i as isize),
8520 b"--lru-test\0" as *const u8 as *const libc::c_char,
8521 ) == 0 && lastarg == 0
8522 {
8523 config.lru_test_mode = 1 as libc::c_int;
8524 i += 1;
8525 config
8526 .lru_test_sample_size = strtoll(
8527 *argv.offset(i as isize),
8528 0 as *mut *mut libc::c_char,
8529 10 as libc::c_int,
8530 );
8531 } else if strcmp(
8532 *argv.offset(i as isize),
8533 b"--slave\0" as *const u8 as *const libc::c_char,
8534 ) == 0
8535 {
8536 config.slave_mode = 1 as libc::c_int;
8537 } else if strcmp(
8538 *argv.offset(i as isize),
8539 b"--replica\0" as *const u8 as *const libc::c_char,
8540 ) == 0
8541 {
8542 config.slave_mode = 1 as libc::c_int;
8543 } else if strcmp(
8544 *argv.offset(i as isize),
8545 b"--stat\0" as *const u8 as *const libc::c_char,
8546 ) == 0
8547 {
8548 config.stat_mode = 1 as libc::c_int;
8549 } else if strcmp(
8550 *argv.offset(i as isize),
8551 b"--scan\0" as *const u8 as *const libc::c_char,
8552 ) == 0
8553 {
8554 config.scan_mode = 1 as libc::c_int;
8555 } else if strcmp(
8556 *argv.offset(i as isize),
8557 b"--pattern\0" as *const u8 as *const libc::c_char,
8558 ) == 0 && lastarg == 0
8559 {
8560 hi_sdsfree(config.pattern);
8561 i += 1;
8562 config.pattern = hi_sdsnew(*argv.offset(i as isize));
8563 } else if strcmp(
8564 *argv.offset(i as isize),
8565 b"--quoted-pattern\0" as *const u8 as *const libc::c_char,
8566 ) == 0 && lastarg == 0
8567 {
8568 hi_sdsfree(config.pattern);
8569 i += 1;
8570 config.pattern = unquoteCString(*argv.offset(i as isize));
8571 if (config.pattern).is_null() {
8572 fprintf(
8573 stderr,
8574 b"Invalid quoted string specified for --quoted-pattern.\n\0"
8575 as *const u8 as *const libc::c_char,
8576 );
8577 exit(1 as libc::c_int);
8578 }
8579 } else if strcmp(
8580 *argv.offset(i as isize),
8581 b"--intrinsic-latency\0" as *const u8 as *const libc::c_char,
8582 ) == 0 && lastarg == 0
8583 {
8584 config.intrinsic_latency_mode = 1 as libc::c_int;
8585 i += 1;
8586 config.intrinsic_latency_duration = atoi(*argv.offset(i as isize));
8587 } else if strcmp(
8588 *argv.offset(i as isize),
8589 b"--rdb\0" as *const u8 as *const libc::c_char,
8590 ) == 0 && lastarg == 0
8591 {
8592 config.getrdb_mode = 1 as libc::c_int;
8593 i += 1;
8594 config.rdb_filename = *argv.offset(i as isize);
8595 } else if strcmp(
8596 *argv.offset(i as isize),
8597 b"--functions-rdb\0" as *const u8 as *const libc::c_char,
8598 ) == 0 && lastarg == 0
8599 {
8600 config.get_functions_rdb_mode = 1 as libc::c_int;
8601 i += 1;
8602 config.rdb_filename = *argv.offset(i as isize);
8603 } else if strcmp(
8604 *argv.offset(i as isize),
8605 b"--pipe\0" as *const u8 as *const libc::c_char,
8606 ) == 0
8607 {
8608 config.pipe_mode = 1 as libc::c_int;
8609 } else if strcmp(
8610 *argv.offset(i as isize),
8611 b"--pipe-timeout\0" as *const u8 as *const libc::c_char,
8612 ) == 0 && lastarg == 0
8613 {
8614 i += 1;
8615 config.pipe_timeout = atoi(*argv.offset(i as isize));
8616 } else if strcmp(
8617 *argv.offset(i as isize),
8618 b"--bigkeys\0" as *const u8 as *const libc::c_char,
8619 ) == 0
8620 {
8621 config.bigkeys = 1 as libc::c_int;
8622 } else if strcmp(
8623 *argv.offset(i as isize),
8624 b"--memkeys\0" as *const u8 as *const libc::c_char,
8625 ) == 0
8626 {
8627 config.memkeys = 1 as libc::c_int;
8628 config.memkeys_samples = 0 as libc::c_int as libc::c_uint;
8629 } else if strcmp(
8630 *argv.offset(i as isize),
8631 b"--memkeys-samples\0" as *const u8 as *const libc::c_char,
8632 ) == 0
8633 {
8634 config.memkeys = 1 as libc::c_int;
8635 i += 1;
8636 config.memkeys_samples = atoi(*argv.offset(i as isize)) as libc::c_uint;
8637 } else if strcmp(
8638 *argv.offset(i as isize),
8639 b"--hotkeys\0" as *const u8 as *const libc::c_char,
8640 ) == 0
8641 {
8642 config.hotkeys = 1 as libc::c_int;
8643 } else if strcmp(
8644 *argv.offset(i as isize),
8645 b"--eval\0" as *const u8 as *const libc::c_char,
8646 ) == 0 && lastarg == 0
8647 {
8648 i += 1;
8649 config.eval = *argv.offset(i as isize);
8650 } else if strcmp(
8651 *argv.offset(i as isize),
8652 b"--ldb\0" as *const u8 as *const libc::c_char,
8653 ) == 0
8654 {
8655 config.eval_ldb = 1 as libc::c_int;
8656 config.output = 1 as libc::c_int;
8657 } else if strcmp(
8658 *argv.offset(i as isize),
8659 b"--ldb-sync-mode\0" as *const u8 as *const libc::c_char,
8660 ) == 0
8661 {
8662 config.eval_ldb = 1 as libc::c_int;
8663 config.eval_ldb_sync = 1 as libc::c_int;
8664 config.output = 1 as libc::c_int;
8665 } else if strcmp(
8666 *argv.offset(i as isize),
8667 b"-c\0" as *const u8 as *const libc::c_char,
8668 ) == 0
8669 {
8670 config.cluster_mode = 1 as libc::c_int;
8671 } else if strcmp(
8672 *argv.offset(i as isize),
8673 b"-d\0" as *const u8 as *const libc::c_char,
8674 ) == 0 && lastarg == 0
8675 {
8676 hi_sdsfree(config.mb_delim);
8677 i += 1;
8678 config.mb_delim = hi_sdsnew(*argv.offset(i as isize));
8679 } else if strcmp(
8680 *argv.offset(i as isize),
8681 b"-D\0" as *const u8 as *const libc::c_char,
8682 ) == 0 && lastarg == 0
8683 {
8684 hi_sdsfree(config.cmd_delim);
8685 i += 1;
8686 config.cmd_delim = hi_sdsnew(*argv.offset(i as isize));
8687 } else if strcmp(
8688 *argv.offset(i as isize),
8689 b"-e\0" as *const u8 as *const libc::c_char,
8690 ) == 0
8691 {
8692 config.set_errcode = 1 as libc::c_int;
8693 } else if strcmp(
8694 *argv.offset(i as isize),
8695 b"--verbose\0" as *const u8 as *const libc::c_char,
8696 ) == 0
8697 {
8698 config.verbose = 1 as libc::c_int;
8699 } else if strcmp(
8700 *argv.offset(i as isize),
8701 b"--cluster\0" as *const u8 as *const libc::c_char,
8702 ) == 0 && lastarg == 0
8703 {
8704 if !(config.cluster_manager_command.name).is_null() {
8705 usage(1 as libc::c_int);
8706 }
8707 i += 1;
8708 let mut cmd: *mut libc::c_char = *argv.offset(i as isize);
8709 let mut j: libc::c_int = i;
8710 while j < argc
8711 && *(*argv.offset(j as isize)).offset(0 as libc::c_int as isize)
8712 as libc::c_int != '-' as i32
8713 {
8714 j += 1;
8715 }
8716 if j > i {
8717 j -= 1;
8718 }
8719 let mut err: libc::c_int = createClusterManagerCommand(
8720 cmd,
8721 j - i,
8722 argv.offset(i as isize).offset(1 as libc::c_int as isize),
8723 );
8724 if err != 0 {
8725 exit(err);
8726 }
8727 i = j;
8728 } else if strcmp(
8729 *argv.offset(i as isize),
8730 b"--cluster\0" as *const u8 as *const libc::c_char,
8731 ) == 0 && lastarg != 0
8732 {
8733 usage(1 as libc::c_int);
8734 } else if strcmp(
8735 *argv.offset(i as isize),
8736 b"--cluster-only-masters\0" as *const u8 as *const libc::c_char,
8737 ) == 0
8738 {
8739 config.cluster_manager_command.flags
8740 |= (1 as libc::c_int) << 11 as libc::c_int;
8741 } else if strcmp(
8742 *argv.offset(i as isize),
8743 b"--cluster-only-replicas\0" as *const u8 as *const libc::c_char,
8744 ) == 0
8745 {
8746 config.cluster_manager_command.flags
8747 |= (1 as libc::c_int) << 12 as libc::c_int;
8748 } else if strcmp(
8749 *argv.offset(i as isize),
8750 b"--cluster-replicas\0" as *const u8 as *const libc::c_char,
8751 ) == 0 && lastarg == 0
8752 {
8753 i += 1;
8754 config.cluster_manager_command.replicas = atoi(*argv.offset(i as isize));
8755 } else if strcmp(
8756 *argv.offset(i as isize),
8757 b"--cluster-master-id\0" as *const u8 as *const libc::c_char,
8758 ) == 0 && lastarg == 0
8759 {
8760 i += 1;
8761 config.cluster_manager_command.master_id = *argv.offset(i as isize);
8762 } else if strcmp(
8763 *argv.offset(i as isize),
8764 b"--cluster-from\0" as *const u8 as *const libc::c_char,
8765 ) == 0 && lastarg == 0
8766 {
8767 i += 1;
8768 config.cluster_manager_command.from = *argv.offset(i as isize);
8769 } else if strcmp(
8770 *argv.offset(i as isize),
8771 b"--cluster-to\0" as *const u8 as *const libc::c_char,
8772 ) == 0 && lastarg == 0
8773 {
8774 i += 1;
8775 config.cluster_manager_command.to = *argv.offset(i as isize);
8776 } else if strcmp(
8777 *argv.offset(i as isize),
8778 b"--cluster-from-user\0" as *const u8 as *const libc::c_char,
8779 ) == 0 && lastarg == 0
8780 {
8781 i += 1;
8782 config.cluster_manager_command.from_user = *argv.offset(i as isize);
8783 } else if strcmp(
8784 *argv.offset(i as isize),
8785 b"--cluster-from-pass\0" as *const u8 as *const libc::c_char,
8786 ) == 0 && lastarg == 0
8787 {
8788 i += 1;
8789 config.cluster_manager_command.from_pass = *argv.offset(i as isize);
8790 } else if strcmp(
8791 *argv.offset(i as isize),
8792 b"--cluster-from-askpass\0" as *const u8 as *const libc::c_char,
8793 ) == 0
8794 {
8795 config.cluster_manager_command.from_askpass = 1 as libc::c_int;
8796 } else if strcmp(
8797 *argv.offset(i as isize),
8798 b"--cluster-weight\0" as *const u8 as *const libc::c_char,
8799 ) == 0 && lastarg == 0
8800 {
8801 if !(config.cluster_manager_command.weight).is_null() {
8802 fprintf(
8803 stderr,
8804 b"WARNING: you cannot use --cluster-weight more than once.\nYou can set more weights by adding them as a space-separated list, ie:\n--cluster-weight n1=w n2=w\n\0"
8805 as *const u8 as *const libc::c_char,
8806 );
8807 exit(1 as libc::c_int);
8808 }
8809 let mut widx: libc::c_int = i + 1 as libc::c_int;
8810 let mut weight: *mut *mut libc::c_char = argv.offset(widx as isize);
8811 let mut wargc: libc::c_int = 0 as libc::c_int;
8812 while widx < argc {
8813 if strstr(
8814 *argv.offset(widx as isize),
8815 b"--\0" as *const u8 as *const libc::c_char,
8816 ) == *argv.offset(widx as isize)
8817 {
8818 break;
8819 }
8820 if (strchr(*argv.offset(widx as isize), '=' as i32)).is_null() {
8821 break;
8822 }
8823 wargc += 1;
8824 widx += 1;
8825 }
8826 if wargc > 0 as libc::c_int {
8827 config.cluster_manager_command.weight = weight;
8828 config.cluster_manager_command.weight_argc = wargc;
8829 i += wargc;
8830 }
8831 } else if strcmp(
8832 *argv.offset(i as isize),
8833 b"--cluster-slots\0" as *const u8 as *const libc::c_char,
8834 ) == 0 && lastarg == 0
8835 {
8836 i += 1;
8837 config.cluster_manager_command.slots = atoi(*argv.offset(i as isize));
8838 } else if strcmp(
8839 *argv.offset(i as isize),
8840 b"--cluster-timeout\0" as *const u8 as *const libc::c_char,
8841 ) == 0 && lastarg == 0
8842 {
8843 i += 1;
8844 config.cluster_manager_command.timeout = atoi(*argv.offset(i as isize));
8845 } else if strcmp(
8846 *argv.offset(i as isize),
8847 b"--cluster-pipeline\0" as *const u8 as *const libc::c_char,
8848 ) == 0 && lastarg == 0
8849 {
8850 i += 1;
8851 config.cluster_manager_command.pipeline = atoi(*argv.offset(i as isize));
8852 } else if strcmp(
8853 *argv.offset(i as isize),
8854 b"--cluster-threshold\0" as *const u8 as *const libc::c_char,
8855 ) == 0 && lastarg == 0
8856 {
8857 i += 1;
8858 config
8859 .cluster_manager_command
8860 .threshold = atof(*argv.offset(i as isize)) as libc::c_float;
8861 } else if strcmp(
8862 *argv.offset(i as isize),
8863 b"--cluster-yes\0" as *const u8 as *const libc::c_char,
8864 ) == 0
8865 {
8866 config.cluster_manager_command.flags
8867 |= (1 as libc::c_int) << 2 as libc::c_int;
8868 } else if strcmp(
8869 *argv.offset(i as isize),
8870 b"--cluster-simulate\0" as *const u8 as *const libc::c_char,
8871 ) == 0
8872 {
8873 config.cluster_manager_command.flags
8874 |= (1 as libc::c_int) << 5 as libc::c_int;
8875 } else if strcmp(
8876 *argv.offset(i as isize),
8877 b"--cluster-replace\0" as *const u8 as *const libc::c_char,
8878 ) == 0
8879 {
8880 config.cluster_manager_command.flags
8881 |= (1 as libc::c_int) << 6 as libc::c_int;
8882 } else if strcmp(
8883 *argv.offset(i as isize),
8884 b"--cluster-copy\0" as *const u8 as *const libc::c_char,
8885 ) == 0
8886 {
8887 config.cluster_manager_command.flags
8888 |= (1 as libc::c_int) << 7 as libc::c_int;
8889 } else if strcmp(
8890 *argv.offset(i as isize),
8891 b"--cluster-slave\0" as *const u8 as *const libc::c_char,
8892 ) == 0
8893 {
8894 config.cluster_manager_command.flags
8895 |= (1 as libc::c_int) << 1 as libc::c_int;
8896 } else if strcmp(
8897 *argv.offset(i as isize),
8898 b"--cluster-use-empty-masters\0" as *const u8 as *const libc::c_char,
8899 ) == 0
8900 {
8901 config.cluster_manager_command.flags
8902 |= (1 as libc::c_int) << 4 as libc::c_int;
8903 } else if strcmp(
8904 *argv.offset(i as isize),
8905 b"--cluster-search-multiple-owners\0" as *const u8 as *const libc::c_char,
8906 ) == 0
8907 {
8908 config.cluster_manager_command.flags
8909 |= (1 as libc::c_int) << 9 as libc::c_int;
8910 } else if strcmp(
8911 *argv.offset(i as isize),
8912 b"--cluster-fix-with-unreachable-masters\0" as *const u8
8913 as *const libc::c_char,
8914 ) == 0
8915 {
8916 config.cluster_manager_command.flags
8917 |= (1 as libc::c_int) << 10 as libc::c_int;
8918 } else if strcmp(
8919 *argv.offset(i as isize),
8920 b"-v\0" as *const u8 as *const libc::c_char,
8921 ) == 0
8922 || strcmp(
8923 *argv.offset(i as isize),
8924 b"--version\0" as *const u8 as *const libc::c_char,
8925 ) == 0
8926 {
8927 let mut version: hisds = cliVersion();
8928 printf(b"redis-cli %s\n\0" as *const u8 as *const libc::c_char, version);
8929 hi_sdsfree(version);
8930 exit(0 as libc::c_int);
8931 } else if strcmp(
8932 *argv.offset(i as isize),
8933 b"-2\0" as *const u8 as *const libc::c_char,
8934 ) == 0
8935 {
8936 config.resp2 = 1 as libc::c_int;
8937 } else if strcmp(
8938 *argv.offset(i as isize),
8939 b"-3\0" as *const u8 as *const libc::c_char,
8940 ) == 0
8941 {
8942 config.resp3 = 1 as libc::c_int;
8943 } else if strcmp(
8944 *argv.offset(i as isize),
8945 b"--show-pushes\0" as *const u8 as *const libc::c_char,
8946 ) == 0 && lastarg == 0
8947 {
8948 i += 1;
8949 let mut argval: *mut libc::c_char = *argv.offset(i as isize);
8950 if strncasecmp(
8951 argval,
8952 b"n\0" as *const u8 as *const libc::c_char,
8953 1 as libc::c_int as size_t,
8954 ) == 0
8955 {
8956 config.push_output = 0 as libc::c_int;
8957 } else if strncasecmp(
8958 argval,
8959 b"y\0" as *const u8 as *const libc::c_char,
8960 1 as libc::c_int as size_t,
8961 ) == 0
8962 {
8963 config.push_output = 1 as libc::c_int;
8964 } else {
8965 fprintf(
8966 stderr,
8967 b"Unknown --show-pushes value '%s' (valid: '[y]es', '[n]o')\n\0"
8968 as *const u8 as *const libc::c_char,
8969 argval,
8970 );
8971 }
8972 } else if !(config.cluster_manager_command.name).is_null()
8973 && *(*argv.offset(i as isize)).offset(0 as libc::c_int as isize)
8974 as libc::c_int != '-' as i32
8975 {
8976 if config.cluster_manager_command.argc == 0 as libc::c_int {
8977 let mut j_0: libc::c_int = i + 1 as libc::c_int;
8978 while j_0 < argc
8979 && *(*argv.offset(j_0 as isize)).offset(0 as libc::c_int as isize)
8980 as libc::c_int != '-' as i32
8981 {
8982 j_0 += 1;
8983 }
8984 let mut cmd_argc: libc::c_int = j_0 - i;
8985 config.cluster_manager_command.argc = cmd_argc;
8986 config.cluster_manager_command.argv = argv.offset(i as isize);
8987 if cmd_argc > 1 as libc::c_int {
8988 i = j_0 - 1 as libc::c_int;
8989 }
8990 }
8991 } else {
8992 if !(*(*argv.offset(i as isize)).offset(0 as libc::c_int as isize)
8993 as libc::c_int == '-' as i32)
8994 {
8995 break;
8996 }
8997 fprintf(
8998 stderr,
8999 b"Unrecognized option or bad number of args for: '%s'\n\0" as *const u8
9000 as *const libc::c_char,
9001 *argv.offset(i as isize),
9002 );
9003 exit(1 as libc::c_int);
9004 }
9005 i += 1;
9006 }
9007 if !(config.hostsocket).is_null() && config.cluster_mode != 0 {
9008 fprintf(
9009 stderr,
9010 b"Options -c and -s are mutually exclusive.\n\0" as *const u8
9011 as *const libc::c_char,
9012 );
9013 exit(1 as libc::c_int);
9014 }
9015 if config.resp2 != 0 && config.resp3 == 1 as libc::c_int {
9016 fprintf(
9017 stderr,
9018 b"Options -2 and -3 are mutually exclusive.\n\0" as *const u8
9019 as *const libc::c_char,
9020 );
9021 exit(1 as libc::c_int);
9022 }
9023 if config.eval_ldb != 0 && (config.eval).is_null() {
9024 fprintf(
9025 stderr,
9026 b"Options --ldb and --ldb-sync-mode require --eval.\n\0" as *const u8
9027 as *const libc::c_char,
9028 );
9029 fprintf(
9030 stderr,
9031 b"Try %s --help for more information.\n\0" as *const u8
9032 as *const libc::c_char,
9033 *argv.offset(0 as libc::c_int as isize),
9034 );
9035 exit(1 as libc::c_int);
9036 }
9037 if config.no_auth_warning == 0 && !(config.conn_info.auth).is_null() {
9038 fputs(
9039 b"Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.\n\0"
9040 as *const u8 as *const libc::c_char,
9041 stderr,
9042 );
9043 }
9044 if config.get_functions_rdb_mode != 0 && config.getrdb_mode != 0 {
9045 fprintf(
9046 stderr,
9047 b"Option --functions-rdb and --rdb are mutually exclusive.\n\0" as *const u8
9048 as *const libc::c_char,
9049 );
9050 exit(1 as libc::c_int);
9051 }
9052 if config.stdin_lastarg != 0 && config.stdin_tag_arg != 0 {
9053 fprintf(
9054 stderr,
9055 b"Options -x and -X are mutually exclusive.\n\0" as *const u8
9056 as *const libc::c_char,
9057 );
9058 exit(1 as libc::c_int);
9059 }
9060 return i;
9061}
9062unsafe extern "C" fn parseEnv() {
9063 let mut auth: *mut libc::c_char = getenv(
9064 b"REDISCLI_AUTH\0" as *const u8 as *const libc::c_char,
9065 );
9066 if !auth.is_null() && (config.conn_info.auth).is_null() {
9067 config.conn_info.auth = auth;
9068 }
9069 let mut cluster_yes: *mut libc::c_char = getenv(
9070 b"REDISCLI_CLUSTER_YES\0" as *const u8 as *const libc::c_char,
9071 );
9072 if !cluster_yes.is_null()
9073 && strcmp(cluster_yes, b"1\0" as *const u8 as *const libc::c_char) == 0
9074 {
9075 config.cluster_manager_command.flags |= (1 as libc::c_int) << 2 as libc::c_int;
9076 }
9077}
9078unsafe extern "C" fn usage(mut err: libc::c_int) {
9079 let mut version: hisds = cliVersion();
9080 let mut target: *mut FILE = if err != 0 { stderr } else { stdout };
9081 fprintf(
9082 target,
9083 b"redis-cli %s\n\nUsage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]\n -h <hostname> Server hostname (default: 127.0.0.1).\n -p <port> Server port (default: 6379).\n -s <socket> Server socket (overrides hostname and port).\n -a <password> Password to use when connecting to the server.\n You can also use the REDISCLI_AUTH environment\n variable to pass this password more safely\n (if both are used, this argument takes precedence).\n --user <username> Used to send ACL style 'AUTH username pass'. Needs -a.\n --pass <password> Alias of -a for consistency with the new --user option.\n --askpass Force user to input password with mask from STDIN.\n If this argument is used, '-a' and REDISCLI_AUTH\n environment variable will be ignored.\n -u <uri> Server URI.\n -r <repeat> Execute specified command N times.\n -i <interval> When -r is used, waits <interval> seconds per command.\n It is possible to specify sub-second times like -i 0.1.\n This interval is also used in --scan and --stat per cycle.\n and in --bigkeys, --memkeys, and --hotkeys per 100 cycles.\n -n <db> Database number.\n -2 Start session in RESP2 protocol mode.\n -3 Start session in RESP3 protocol mode.\n -x Read last argument from STDIN (see example below).\n -X Read <tag> argument from STDIN (see example below).\n -d <delimiter> Delimiter between response bulks for raw formatting (default: \\n).\n -D <delimiter> Delimiter between responses for raw formatting (default: \\n).\n -c Enable cluster mode (follow -ASK and -MOVED redirections).\n -e Return exit error code when command execution fails.\n --raw Use raw formatting for replies (default when STDOUT is\n not a tty).\n --no-raw Force formatted output even when STDOUT is not a tty.\n --quoted-input Force input to be handled as quoted strings.\n --csv Output in CSV format.\n --json Output in JSON format (default RESP3, use -2 if you want to use with RESP2).\n --quoted-json Same as --json, but produce ASCII-safe quoted strings, not Unicode.\n --show-pushes <yn> Whether to print RESP3 PUSH messages. Enabled by default when\n STDOUT is a tty but can be overridden with --show-pushes no.\n --stat Print rolling stats about server: mem, clients, ...\n\0"
9084 as *const u8 as *const libc::c_char,
9085 version,
9086 );
9087 fprintf(
9088 target,
9089 b" --latency Enter a special mode continuously sampling latency.\n If you use this mode in an interactive session it runs\n forever displaying real-time stats. Otherwise if --raw or\n --csv is specified, or if you redirect the output to a non\n TTY, it samples the latency for 1 second (you can use\n -i to change the interval), then produces a single output\n and exits.\n --latency-history Like --latency but tracking latency changes over time.\n Default time interval is 15 sec. Change it using -i.\n --latency-dist Shows latency as a spectrum, requires xterm 256 colors.\n Default time interval is 1 sec. Change it using -i.\n --lru-test <keys> Simulate a cache workload with an 80-20 distribution.\n --replica Simulate a replica showing commands received from the master.\n --rdb <filename> Transfer an RDB dump from remote server to local file.\n Use filename of \"-\" to write to stdout.\n --functions-rdb <filename> Like --rdb but only get the functions (not the keys)\n when getting the RDB dump file.\n --pipe Transfer raw Redis protocol from stdin to server.\n --pipe-timeout <n> In --pipe mode, abort with error if after sending all data.\n no reply is received within <n> seconds.\n Default timeout: %d. Use 0 to wait forever.\n\0"
9090 as *const u8 as *const libc::c_char,
9091 30 as libc::c_int,
9092 );
9093 fprintf(
9094 target,
9095 b" --bigkeys Sample Redis keys looking for keys with many elements (complexity).\n --memkeys Sample Redis keys looking for keys consuming a lot of memory.\n --memkeys-samples <n> Sample Redis keys looking for keys consuming a lot of memory.\n And define number of key elements to sample\n --hotkeys Sample Redis keys looking for hot keys.\n only works when maxmemory-policy is *lfu.\n --scan List all keys using the SCAN command.\n --pattern <pat> Keys pattern when using the --scan, --bigkeys or --hotkeys\n options (default: *).\n --quoted-pattern <pat> Same as --pattern, but the specified string can be\n quoted, in order to pass an otherwise non binary-safe string.\n --intrinsic-latency <sec> Run a test to measure intrinsic system latency.\n The test will run for the specified amount of seconds.\n --eval <file> Send an EVAL command using the Lua script at <file>.\n --ldb Used with --eval enable the Redis Lua debugger.\n --ldb-sync-mode Like --ldb but uses the synchronous Lua debugger, in\n this mode the server is blocked and script changes are\n not rolled back from the server memory.\n --cluster <command> [args...] [opts...]\n Cluster Manager command and arguments (see below).\n --verbose Verbose mode.\n --no-auth-warning Don't show warning message when using password on command\n line interface.\n --help Output this help and exit.\n --version Output version and exit.\n\n\0"
9096 as *const u8 as *const libc::c_char,
9097 );
9098 fprintf(
9099 target,
9100 b"Cluster Manager Commands:\n Use --cluster help to list all available cluster manager commands.\n\nExamples:\n cat /etc/passwd | redis-cli -x set mypasswd\n redis-cli -D \"\" --raw dump key > key.dump && redis-cli -X dump_tag restore key2 0 dump_tag replace < key.dump\n redis-cli -r 100 lpush mylist x\n redis-cli -r 100 -i 1 info | grep used_memory_human:\n redis-cli --quoted-input set '\"null-\\x00-separated\"' value\n redis-cli --eval myscript.lua key1 key2 , arg1 arg2 arg3\n redis-cli --scan --pattern '*:12345*'\n\n (Note: when using --eval the comma separates KEYS[] from ARGV[] items)\n\nWhen no command is given, redis-cli starts in interactive mode.\nType \"help\" in interactive mode for information on available commands\nand settings.\n\n\0"
9101 as *const u8 as *const libc::c_char,
9102 );
9103 hi_sdsfree(version);
9104 exit(err);
9105}
9106unsafe extern "C" fn confirmWithYes(
9107 mut msg: *mut libc::c_char,
9108 mut ignore_force: libc::c_int,
9109) -> libc::c_int {
9110 if ignore_force == 0
9111 && config.cluster_manager_command.flags & (1 as libc::c_int) << 2 as libc::c_int
9112 != 0
9113 {
9114 return 1 as libc::c_int;
9115 }
9116 printf(b"%s (type 'yes' to accept): \0" as *const u8 as *const libc::c_char, msg);
9117 fflush(stdout);
9118 let mut buf: [libc::c_char; 4] = [0; 4];
9119 let mut nread: libc::c_int = read(
9120 fileno(stdin),
9121 buf.as_mut_ptr() as *mut libc::c_void,
9122 4 as libc::c_int as size_t,
9123 ) as libc::c_int;
9124 buf[3 as libc::c_int as usize] = '\0' as i32 as libc::c_char;
9125 return (nread != 0 as libc::c_int
9126 && strcmp(b"yes\0" as *const u8 as *const libc::c_char, buf.as_mut_ptr()) == 0)
9127 as libc::c_int;
9128}
9129unsafe extern "C" fn issueCommandRepeat(
9130 mut argc: libc::c_int,
9131 mut argv: *mut *mut libc::c_char,
9132 mut repeat: libc::c_long,
9133) -> libc::c_int {
9134 if config.eval_ldb == 0
9135 && (strcasecmp(
9136 *argv.offset(0 as libc::c_int as isize),
9137 b"help\0" as *const u8 as *const libc::c_char,
9138 ) == 0
9139 || strcasecmp(
9140 *argv.offset(0 as libc::c_int as isize),
9141 b"?\0" as *const u8 as *const libc::c_char,
9142 ) == 0)
9143 {
9144 argc -= 1;
9145 argv = argv.offset(1);
9146 cliOutputHelp(argc, argv);
9147 return 0 as libc::c_int;
9148 }
9149 loop {
9150 if config.cluster_reissue_command != 0 || context.is_null()
9151 || (*context).err == 1 as libc::c_int || (*context).err == 3 as libc::c_int
9152 {
9153 if cliConnect((1 as libc::c_int) << 0 as libc::c_int) != 0 as libc::c_int {
9154 cliPrintContextError();
9155 config.cluster_reissue_command = 0 as libc::c_int;
9156 return -(1 as libc::c_int);
9157 }
9158 }
9159 config.cluster_reissue_command = 0 as libc::c_int;
9160 if config.cluster_send_asking != 0 {
9161 if cliSendAsking() != 0 as libc::c_int {
9162 cliPrintContextError();
9163 return -(1 as libc::c_int);
9164 }
9165 }
9166 if cliSendCommand(argc, argv, repeat) != 0 as libc::c_int {
9167 cliPrintContextError();
9168 redisFree(context);
9169 context = 0 as *mut redisContext;
9170 return -(1 as libc::c_int);
9171 }
9172 if !(config.cluster_mode != 0 && config.cluster_reissue_command != 0) {
9173 break;
9174 }
9175 }
9176 return 0 as libc::c_int;
9177}
9178unsafe extern "C" fn issueCommand(
9179 mut argc: libc::c_int,
9180 mut argv: *mut *mut libc::c_char,
9181) -> libc::c_int {
9182 return issueCommandRepeat(argc, argv, config.repeat);
9183}
9184unsafe extern "C" fn cliSplitArgs(
9185 mut line: *mut libc::c_char,
9186 mut argc: *mut libc::c_int,
9187) -> *mut hisds {
9188 if config.eval_ldb != 0
9189 && (strstr(line, b"eval \0" as *const u8 as *const libc::c_char) == line
9190 || strstr(line, b"e \0" as *const u8 as *const libc::c_char) == line)
9191 {
9192 let mut argv: *mut hisds = hi_sds_malloc(
9193 (core::mem::size_of::<hisds>() as libc::c_ulong)
9194 .wrapping_mul(2 as libc::c_int as libc::c_ulong),
9195 ) as *mut hisds;
9196 *argc = 2 as libc::c_int;
9197 let mut len: libc::c_int = strlen(line) as libc::c_int;
9198 let mut elen: libc::c_int = if *line.offset(1 as libc::c_int as isize)
9199 as libc::c_int == ' ' as i32
9200 {
9201 2 as libc::c_int
9202 } else {
9203 5 as libc::c_int
9204 };
9205 let ref mut fresh12 = *argv.offset(0 as libc::c_int as isize);
9206 *fresh12 = hi_sdsnewlen(
9207 line as *const libc::c_void,
9208 (elen - 1 as libc::c_int) as size_t,
9209 );
9210 let ref mut fresh13 = *argv.offset(1 as libc::c_int as isize);
9211 *fresh13 = hi_sdsnewlen(
9212 line.offset(elen as isize) as *const libc::c_void,
9213 (len - elen) as size_t,
9214 );
9215 return argv;
9216 } else {
9217 return hi_sdssplitargs(line, argc)
9218 };
9219}
9220#[no_mangle]
9221pub unsafe extern "C" fn cliSetPreferences(
9222 mut argv: *mut *mut libc::c_char,
9223 mut argc: libc::c_int,
9224 mut interactive: libc::c_int,
9225) {
9226 if strcasecmp(
9227 *argv.offset(0 as libc::c_int as isize),
9228 b":set\0" as *const u8 as *const libc::c_char,
9229 ) == 0 && argc >= 2 as libc::c_int
9230 {
9231 if strcasecmp(
9232 *argv.offset(1 as libc::c_int as isize),
9233 b"hints\0" as *const u8 as *const libc::c_char,
9234 ) == 0
9235 {
9236 pref.hints = 1 as libc::c_int;
9237 } else if strcasecmp(
9238 *argv.offset(1 as libc::c_int as isize),
9239 b"nohints\0" as *const u8 as *const libc::c_char,
9240 ) == 0
9241 {
9242 pref.hints = 0 as libc::c_int;
9243 } else {
9244 printf(
9245 b"%sunknown redis-cli preference '%s'\n\0" as *const u8
9246 as *const libc::c_char,
9247 if interactive != 0 {
9248 b"\0" as *const u8 as *const libc::c_char
9249 } else {
9250 b".redisclirc: \0" as *const u8 as *const libc::c_char
9251 },
9252 *argv.offset(1 as libc::c_int as isize),
9253 );
9254 }
9255 } else {
9256 printf(
9257 b"%sunknown redis-cli internal command '%s'\n\0" as *const u8
9258 as *const libc::c_char,
9259 if interactive != 0 {
9260 b"\0" as *const u8 as *const libc::c_char
9261 } else {
9262 b".redisclirc: \0" as *const u8 as *const libc::c_char
9263 },
9264 *argv.offset(0 as libc::c_int as isize),
9265 );
9266 };
9267}
9268#[no_mangle]
9269pub unsafe extern "C" fn cliLoadPreferences() {
9270 let mut rcfile: hisds = getDotfilePath(
9271 b"REDISCLI_RCFILE\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
9272 b".redisclirc\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
9273 );
9274 if rcfile.is_null() {
9275 return;
9276 }
9277 let mut fp: *mut FILE = fopen(
9278 rcfile as *const libc::c_char,
9279 b"r\0" as *const u8 as *const libc::c_char,
9280 );
9281 let mut buf: [libc::c_char; 1024] = [0; 1024];
9282 if !fp.is_null() {
9283 while !(fgets(
9284 buf.as_mut_ptr(),
9285 core::mem::size_of::<[libc::c_char; 1024]>() as libc::c_ulong
9286 as libc::c_int,
9287 fp,
9288 ))
9289 .is_null()
9290 {
9291 let mut argv: *mut hisds = 0 as *mut hisds;
9292 let mut argc: libc::c_int = 0;
9293 argv = hi_sdssplitargs(buf.as_mut_ptr(), &mut argc);
9294 if argc > 0 as libc::c_int {
9295 cliSetPreferences(argv, argc, 0 as libc::c_int);
9296 }
9297 hi_sdsfreesplitres(argv, argc);
9298 }
9299 fclose(fp);
9300 }
9301 hi_sdsfree(rcfile);
9302}
9303unsafe extern "C" fn isSensitiveCommand(
9304 mut argc: libc::c_int,
9305 mut argv: *mut *mut libc::c_char,
9306) -> libc::c_int {
9307 if strcasecmp(
9308 *argv.offset(0 as libc::c_int as isize),
9309 b"auth\0" as *const u8 as *const libc::c_char,
9310 ) == 0
9311 {
9312 return 1 as libc::c_int
9313 } else {
9314 if argc > 1 as libc::c_int
9315 && strcasecmp(
9316 *argv.offset(0 as libc::c_int as isize),
9317 b"acl\0" as *const u8 as *const libc::c_char,
9318 ) == 0
9319 && strcasecmp(
9320 *argv.offset(1 as libc::c_int as isize),
9321 b"setuser\0" as *const u8 as *const libc::c_char,
9322 ) == 0
9323 {
9324 return 1 as libc::c_int
9325 } else {
9326 if argc > 2 as libc::c_int
9327 && strcasecmp(
9328 *argv.offset(0 as libc::c_int as isize),
9329 b"config\0" as *const u8 as *const libc::c_char,
9330 ) == 0
9331 && strcasecmp(
9332 *argv.offset(1 as libc::c_int as isize),
9333 b"set\0" as *const u8 as *const libc::c_char,
9334 ) == 0
9335 && (strcasecmp(
9336 *argv.offset(2 as libc::c_int as isize),
9337 b"masterauth\0" as *const u8 as *const libc::c_char,
9338 ) == 0
9339 || strcasecmp(
9340 *argv.offset(2 as libc::c_int as isize),
9341 b"masteruser\0" as *const u8 as *const libc::c_char,
9342 ) == 0
9343 || strcasecmp(
9344 *argv.offset(2 as libc::c_int as isize),
9345 b"requirepass\0" as *const u8 as *const libc::c_char,
9346 ) == 0)
9347 {
9348 return 1 as libc::c_int
9349 } else {
9350 if argc > 4 as libc::c_int
9351 && strcasecmp(
9352 *argv.offset(0 as libc::c_int as isize),
9353 b"hello\0" as *const u8 as *const libc::c_char,
9354 ) == 0
9355 {
9356 let mut j: libc::c_int = 2 as libc::c_int;
9357 while j < argc {
9358 let mut moreargs: libc::c_int = argc - 1 as libc::c_int - j;
9359 if strcasecmp(
9360 *argv.offset(j as isize),
9361 b"AUTH\0" as *const u8 as *const libc::c_char,
9362 ) == 0 && moreargs >= 2 as libc::c_int
9363 {
9364 return 1 as libc::c_int
9365 } else {
9366 if strcasecmp(
9367 *argv.offset(j as isize),
9368 b"SETNAME\0" as *const u8 as *const libc::c_char,
9369 ) == 0 && moreargs != 0
9370 {
9371 j += 1;
9372 } else {
9373 return 0 as libc::c_int
9374 }
9375 }
9376 j += 1;
9377 }
9378 } else if argc > 7 as libc::c_int
9379 && strcasecmp(
9380 *argv.offset(0 as libc::c_int as isize),
9381 b"migrate\0" as *const u8 as *const libc::c_char,
9382 ) == 0
9383 {
9384 let mut j_0: libc::c_int = 6 as libc::c_int;
9385 while j_0 < argc {
9386 let mut moreargs_0: libc::c_int = argc - 1 as libc::c_int - j_0;
9387 if strcasecmp(
9388 *argv.offset(j_0 as isize),
9389 b"auth\0" as *const u8 as *const libc::c_char,
9390 ) == 0 && moreargs_0 != 0
9391 {
9392 return 1 as libc::c_int
9393 } else {
9394 if strcasecmp(
9395 *argv.offset(j_0 as isize),
9396 b"auth2\0" as *const u8 as *const libc::c_char,
9397 ) == 0 && moreargs_0 >= 2 as libc::c_int
9398 {
9399 return 1 as libc::c_int
9400 } else {
9401 if strcasecmp(
9402 *argv.offset(j_0 as isize),
9403 b"keys\0" as *const u8 as *const libc::c_char,
9404 ) == 0 && moreargs_0 != 0
9405 {
9406 return 0 as libc::c_int;
9407 }
9408 }
9409 }
9410 j_0 += 1;
9411 }
9412 }
9413 }
9414 }
9415 }
9416 return 0 as libc::c_int;
9417}
9418unsafe extern "C" fn repl() {
9419 let mut historyfile: hisds = 0 as hisds;
9420 let mut history: libc::c_int = 0 as libc::c_int;
9421 let mut line: *mut libc::c_char = 0 as *mut libc::c_char;
9422 let mut argc: libc::c_int = 0;
9423 let mut argv: *mut hisds = 0 as *mut hisds;
9424 if config.eval_ldb == 0 {
9425 cliInitHelp();
9426 }
9427 config.interactive = 1 as libc::c_int;
9428 linenoiseSetMultiLine(1 as libc::c_int);
9429 linenoiseSetCompletionCallback(
9430 Some(
9431 completionCallback
9432 as unsafe extern "C" fn(
9433 *const libc::c_char,
9434 *mut linenoiseCompletions,
9435 ) -> (),
9436 ),
9437 );
9438 linenoiseSetHintsCallback(
9439 Some(
9440 hintsCallback
9441 as unsafe extern "C" fn(
9442 *const libc::c_char,
9443 *mut libc::c_int,
9444 *mut libc::c_int,
9445 ) -> *mut libc::c_char,
9446 ),
9447 );
9448 linenoiseSetFreeHintsCallback(
9449 Some(freeHintsCallback as unsafe extern "C" fn(*mut libc::c_void) -> ()),
9450 );
9451 if isatty(fileno(stdin)) != 0 {
9452 historyfile = getDotfilePath(
9453 b"REDISCLI_HISTFILE\0" as *const u8 as *const libc::c_char
9454 as *mut libc::c_char,
9455 b".rediscli_history\0" as *const u8 as *const libc::c_char
9456 as *mut libc::c_char,
9457 );
9458 history = 1 as libc::c_int;
9459 if !historyfile.is_null() {
9460 linenoiseHistoryLoad(historyfile as *const libc::c_char);
9461 }
9462 cliLoadPreferences();
9463 }
9464 cliRefreshPrompt();
9465 loop {
9466 line = linenoise(
9467 if !context.is_null() {
9468 (config.prompt).as_mut_ptr() as *const libc::c_char
9469 } else {
9470 b"not connected> \0" as *const u8 as *const libc::c_char
9471 },
9472 );
9473 if line.is_null() {
9474 break;
9475 }
9476 if *line.offset(0 as libc::c_int as isize) as libc::c_int != '\0' as i32 {
9477 let mut repeat: libc::c_long = 1 as libc::c_int as libc::c_long;
9478 let mut skipargs: libc::c_int = 0 as libc::c_int;
9479 let mut endptr: *mut libc::c_char = 0 as *mut libc::c_char;
9480 argv = cliSplitArgs(line, &mut argc);
9481 if argv.is_null() {
9482 printf(b"Invalid argument(s)\n\0" as *const u8 as *const libc::c_char);
9483 fflush(stdout);
9484 if history != 0 {
9485 linenoiseHistoryAdd(line);
9486 }
9487 if !historyfile.is_null() {
9488 linenoiseHistorySave(historyfile as *const libc::c_char);
9489 }
9490 linenoiseFree(line as *mut libc::c_void);
9491 continue;
9492 } else if argc == 0 as libc::c_int {
9493 hi_sdsfreesplitres(argv, argc);
9494 linenoiseFree(line as *mut libc::c_void);
9495 continue;
9496 } else {
9497 *__errno_location() = 0 as libc::c_int;
9498 repeat = strtol(
9499 *argv.offset(0 as libc::c_int as isize) as *const libc::c_char,
9500 &mut endptr,
9501 10 as libc::c_int,
9502 );
9503 if argc > 1 as libc::c_int && *endptr as libc::c_int == '\0' as i32 {
9504 if *__errno_location() == 34 as libc::c_int
9505 || *__errno_location() == 22 as libc::c_int
9506 || repeat <= 0 as libc::c_int as libc::c_long
9507 {
9508 fputs(
9509 b"Invalid redis-cli repeat command option value.\n\0"
9510 as *const u8 as *const libc::c_char,
9511 stdout,
9512 );
9513 hi_sdsfreesplitres(argv, argc);
9514 linenoiseFree(line as *mut libc::c_void);
9515 continue;
9516 } else {
9517 skipargs = 1 as libc::c_int;
9518 }
9519 } else {
9520 repeat = 1 as libc::c_int as libc::c_long;
9521 }
9522 if isSensitiveCommand(argc - skipargs, argv.offset(skipargs as isize))
9523 == 0
9524 {
9525 if history != 0 {
9526 linenoiseHistoryAdd(line);
9527 }
9528 if !historyfile.is_null() {
9529 linenoiseHistorySave(historyfile as *const libc::c_char);
9530 }
9531 }
9532 if strcasecmp(
9533 *argv.offset(0 as libc::c_int as isize) as *const libc::c_char,
9534 b"quit\0" as *const u8 as *const libc::c_char,
9535 ) == 0 as libc::c_int
9536 || strcasecmp(
9537 *argv.offset(0 as libc::c_int as isize) as *const libc::c_char,
9538 b"exit\0" as *const u8 as *const libc::c_char,
9539 ) == 0 as libc::c_int
9540 {
9541 exit(0 as libc::c_int);
9542 } else if *(*argv.offset(0 as libc::c_int as isize))
9543 .offset(0 as libc::c_int as isize) as libc::c_int == ':' as i32
9544 {
9545 cliSetPreferences(argv, argc, 1 as libc::c_int);
9546 hi_sdsfreesplitres(argv, argc);
9547 linenoiseFree(line as *mut libc::c_void);
9548 continue;
9549 } else {
9550 if strcasecmp(
9551 *argv.offset(0 as libc::c_int as isize) as *const libc::c_char,
9552 b"restart\0" as *const u8 as *const libc::c_char,
9553 ) == 0 as libc::c_int
9554 {
9555 if !(config.eval).is_null() {
9556 config.eval_ldb = 1 as libc::c_int;
9557 config.output = 1 as libc::c_int;
9558 hi_sdsfreesplitres(argv, argc);
9559 linenoiseFree(line as *mut libc::c_void);
9560 return;
9561 } else {
9562 printf(
9563 b"Use 'restart' only in Lua debugging mode.\n\0"
9564 as *const u8 as *const libc::c_char,
9565 );
9566 fflush(stdout);
9567 }
9568 } else if argc == 3 as libc::c_int
9569 && strcasecmp(
9570 *argv.offset(0 as libc::c_int as isize)
9571 as *const libc::c_char,
9572 b"connect\0" as *const u8 as *const libc::c_char,
9573 ) == 0
9574 {
9575 hi_sdsfree(config.conn_info.hostip);
9576 config
9577 .conn_info
9578 .hostip = hi_sdsnew(
9579 *argv.offset(1 as libc::c_int as isize)
9580 as *const libc::c_char,
9581 );
9582 config
9583 .conn_info
9584 .hostport = atoi(
9585 *argv.offset(2 as libc::c_int as isize)
9586 as *const libc::c_char,
9587 );
9588 cliRefreshPrompt();
9589 cliConnect((1 as libc::c_int) << 0 as libc::c_int);
9590 } else if argc == 1 as libc::c_int
9591 && strcasecmp(
9592 *argv.offset(0 as libc::c_int as isize)
9593 as *const libc::c_char,
9594 b"clear\0" as *const u8 as *const libc::c_char,
9595 ) == 0
9596 {
9597 linenoiseClearScreen();
9598 } else {
9599 let mut start_time: libc::c_longlong = mstime();
9600 let mut elapsed: libc::c_longlong = 0;
9601 issueCommandRepeat(
9602 argc - skipargs,
9603 argv.offset(skipargs as isize),
9604 repeat,
9605 );
9606 if config.eval_ldb_end != 0 {
9607 config.eval_ldb_end = 0 as libc::c_int;
9608 cliReadReply(0 as libc::c_int);
9609 printf(
9610 b"\n(Lua debugging session ended%s)\n\n\0" as *const u8
9611 as *const libc::c_char,
9612 if config.eval_ldb_sync != 0 {
9613 b"\0" as *const u8 as *const libc::c_char
9614 } else {
9615 b" -- dataset changes rolled back\0" as *const u8
9616 as *const libc::c_char
9617 },
9618 );
9619 cliInitHelp();
9620 }
9621 elapsed = mstime() - start_time;
9622 if elapsed >= 500 as libc::c_int as libc::c_longlong
9623 && config.output == 0 as libc::c_int
9624 {
9625 printf(
9626 b"(%.2fs)\n\0" as *const u8 as *const libc::c_char,
9627 elapsed as libc::c_double
9628 / 1000 as libc::c_int as libc::c_double,
9629 );
9630 }
9631 }
9632 hi_sdsfreesplitres(argv, argc);
9633 }
9634 }
9635 }
9636 linenoiseFree(line as *mut libc::c_void);
9637 }
9638 exit(0 as libc::c_int);
9639}
9640unsafe extern "C" fn noninteractive(
9641 mut argc: libc::c_int,
9642 mut argv: *mut *mut libc::c_char,
9643) -> libc::c_int {
9644 let mut retval: libc::c_int = 0 as libc::c_int;
9645 let mut sds_args: *mut hisds = getSdsArrayFromArgv(argc, argv, config.quoted_input);
9646 if sds_args.is_null() {
9647 printf(b"Invalid quoted string\n\0" as *const u8 as *const libc::c_char);
9648 return 1 as libc::c_int;
9649 }
9650 if config.stdin_lastarg != 0 {
9651 sds_args = hi_sds_realloc(
9652 sds_args as *mut libc::c_void,
9653 ((argc + 1 as libc::c_int) as libc::c_ulong)
9654 .wrapping_mul(core::mem::size_of::<hisds>() as libc::c_ulong),
9655 ) as *mut hisds;
9656 let ref mut fresh14 = *sds_args.offset(argc as isize);
9657 *fresh14 = readArgFromStdin();
9658 argc += 1;
9659 } else if config.stdin_tag_arg != 0 {
9660 let mut i: libc::c_int = 0 as libc::c_int;
9661 let mut tag_match: libc::c_int = 0 as libc::c_int;
9662 while i < argc {
9663 if strcmp(
9664 config.stdin_tag_name,
9665 *sds_args.offset(i as isize) as *const libc::c_char,
9666 ) != 0 as libc::c_int
9667 {
9668 i += 1;
9669 } else {
9670 tag_match = 1 as libc::c_int;
9671 hi_sdsfree(*sds_args.offset(i as isize));
9672 let ref mut fresh15 = *sds_args.offset(i as isize);
9673 *fresh15 = readArgFromStdin();
9674 break;
9675 }
9676 }
9677 if tag_match == 0 {
9678 hi_sdsfreesplitres(sds_args, argc);
9679 fprintf(
9680 stderr,
9681 b"Using -X option but stdin tag not match.\n\0" as *const u8
9682 as *const libc::c_char,
9683 );
9684 return 1 as libc::c_int;
9685 }
9686 }
9687 retval = issueCommand(argc, sds_args);
9688 hi_sdsfreesplitres(sds_args, argc);
9689 return if retval == 0 as libc::c_int { 0 as libc::c_int } else { 1 as libc::c_int };
9690}
9691unsafe extern "C" fn evalMode(
9692 mut argc: libc::c_int,
9693 mut argv: *mut *mut libc::c_char,
9694) -> libc::c_int {
9695 let mut script: hisds = 0 as hisds;
9696 let mut fp: *mut FILE = 0 as *mut FILE;
9697 let mut buf: [libc::c_char; 1024] = [0; 1024];
9698 let mut nread: size_t = 0;
9699 let mut argv2: *mut *mut libc::c_char = 0 as *mut *mut libc::c_char;
9700 let mut j: libc::c_int = 0;
9701 let mut got_comma: libc::c_int = 0;
9702 let mut keys: libc::c_int = 0;
9703 let mut retval: libc::c_int = 0 as libc::c_int;
9704 loop {
9705 if config.eval_ldb != 0 {
9706 printf(
9707 b"Lua debugging session started, please use:\nquit -- End the session.\nrestart -- Restart the script in debug mode again.\nhelp -- Show Lua script debugging commands.\n\n\0"
9708 as *const u8 as *const libc::c_char,
9709 );
9710 }
9711 hi_sdsfree(script);
9712 script = hi_sdsempty();
9713 got_comma = 0 as libc::c_int;
9714 keys = 0 as libc::c_int;
9715 fp = fopen(config.eval, b"r\0" as *const u8 as *const libc::c_char);
9716 if fp.is_null() {
9717 fprintf(
9718 stderr,
9719 b"Can't open file '%s': %s\n\0" as *const u8 as *const libc::c_char,
9720 config.eval,
9721 strerror(*__errno_location()),
9722 );
9723 exit(1 as libc::c_int);
9724 }
9725 loop {
9726 nread = fread(
9727 buf.as_mut_ptr() as *mut libc::c_void,
9728 1 as libc::c_int as libc::c_ulong,
9729 core::mem::size_of::<[libc::c_char; 1024]>() as libc::c_ulong,
9730 fp,
9731 );
9732 if !(nread != 0 as libc::c_int as libc::c_ulong) {
9733 break;
9734 }
9735 script = hi_sdscatlen(
9736 script,
9737 buf.as_mut_ptr() as *const libc::c_void,
9738 nread,
9739 );
9740 }
9741 fclose(fp);
9742 if config.eval_ldb != 0 {
9743 let mut reply: *mut redisReply = redisCommand(
9744 context,
9745 if config.eval_ldb_sync != 0 {
9746 b"SCRIPT DEBUG sync\0" as *const u8 as *const libc::c_char
9747 } else {
9748 b"SCRIPT DEBUG yes\0" as *const u8 as *const libc::c_char
9749 },
9750 ) as *mut redisReply;
9751 if !reply.is_null() {
9752 freeReplyObject(reply as *mut libc::c_void);
9753 }
9754 }
9755 argv2 = zmalloc(
9756 (core::mem::size_of::<hisds>() as libc::c_ulong)
9757 .wrapping_mul((argc + 3 as libc::c_int) as libc::c_ulong),
9758 ) as *mut *mut libc::c_char;
9759 let ref mut fresh16 = *argv2.offset(0 as libc::c_int as isize);
9760 *fresh16 = hi_sdsnew(b"EVAL\0" as *const u8 as *const libc::c_char);
9761 let ref mut fresh17 = *argv2.offset(1 as libc::c_int as isize);
9762 *fresh17 = script;
9763 j = 0 as libc::c_int;
9764 while j < argc {
9765 if got_comma == 0
9766 && *(*argv.offset(j as isize)).offset(0 as libc::c_int as isize)
9767 as libc::c_int == ',' as i32
9768 && *(*argv.offset(j as isize)).offset(1 as libc::c_int as isize)
9769 as libc::c_int == 0 as libc::c_int
9770 {
9771 got_comma = 1 as libc::c_int;
9772 } else {
9773 let ref mut fresh18 = *argv2
9774 .offset((j + 3 as libc::c_int - got_comma) as isize);
9775 *fresh18 = hi_sdsnew(*argv.offset(j as isize));
9776 if got_comma == 0 {
9777 keys += 1;
9778 }
9779 }
9780 j += 1;
9781 }
9782 let ref mut fresh19 = *argv2.offset(2 as libc::c_int as isize);
9783 *fresh19 = hi_sdscatprintf(
9784 hi_sdsempty(),
9785 b"%d\0" as *const u8 as *const libc::c_char,
9786 keys,
9787 );
9788 let mut eval_ldb: libc::c_int = config.eval_ldb;
9789 retval = issueCommand(argc + 3 as libc::c_int - got_comma, argv2);
9790 if !(eval_ldb != 0) {
9791 break;
9792 }
9793 if config.eval_ldb == 0 {
9794 printf(
9795 b"Eval debugging session can't start:\n\0" as *const u8
9796 as *const libc::c_char,
9797 );
9798 cliReadReply(0 as libc::c_int);
9799 break;
9800 } else {
9801 strncpy(
9802 (config.prompt).as_mut_ptr(),
9803 b"lua debugger> \0" as *const u8 as *const libc::c_char,
9804 core::mem::size_of::<[libc::c_char; 128]>() as libc::c_ulong,
9805 );
9806 repl();
9807 cliConnect((1 as libc::c_int) << 0 as libc::c_int);
9808 printf(b"\n\0" as *const u8 as *const libc::c_char);
9809 }
9810 }
9811 return if retval == 0 as libc::c_int { 0 as libc::c_int } else { 1 as libc::c_int };
9812}
9813static mut cluster_manager: clusterManager = clusterManager {
9814 nodes: 0 as *const list as *mut list,
9815 errors: 0 as *const list as *mut list,
9816 unreachable_masters: 0,
9817};
9818#[no_mangle]
9819pub static mut clusterManagerUncoveredSlots: *mut dict = 0 as *const dict as *mut dict;
9820static mut clusterManagerDictType: dictType = unsafe {
9821 {
9822 let mut init = dictType {
9823 hashFunction: Some(
9824 dictSdsHash as unsafe extern "C" fn(*const libc::c_void) -> uint64_t,
9825 ),
9826 keyDup: None,
9827 valDup: None,
9828 keyCompare: Some(
9829 dictSdsKeyCompare
9830 as unsafe extern "C" fn(
9831 *mut dict,
9832 *const libc::c_void,
9833 *const libc::c_void,
9834 ) -> libc::c_int,
9835 ),
9836 keyDestructor: None,
9837 valDestructor: Some(
9838 dictSdsDestructor
9839 as unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
9840 ),
9841 expandAllowed: None,
9842 dictEntryMetadataBytes: None,
9843 };
9844 init
9845 }
9846};
9847static mut clusterManagerLinkDictType: dictType = unsafe {
9848 {
9849 let mut init = dictType {
9850 hashFunction: Some(
9851 dictSdsHash as unsafe extern "C" fn(*const libc::c_void) -> uint64_t,
9852 ),
9853 keyDup: None,
9854 valDup: None,
9855 keyCompare: Some(
9856 dictSdsKeyCompare
9857 as unsafe extern "C" fn(
9858 *mut dict,
9859 *const libc::c_void,
9860 *const libc::c_void,
9861 ) -> libc::c_int,
9862 ),
9863 keyDestructor: Some(
9864 dictSdsDestructor
9865 as unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
9866 ),
9867 valDestructor: Some(
9868 dictListDestructor
9869 as unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
9870 ),
9871 expandAllowed: None,
9872 dictEntryMetadataBytes: None,
9873 };
9874 init
9875 }
9876};
9877#[no_mangle]
9878pub static mut clusterManagerCommands: [clusterManagerCommandDef; 13] = unsafe {
9879 [
9880 {
9881 let mut init = clusterManagerCommandDef {
9882 name: b"create\0" as *const u8 as *const libc::c_char
9883 as *mut libc::c_char,
9884 proc_0: Some(
9885 clusterManagerCommandCreate
9886 as unsafe extern "C" fn(
9887 libc::c_int,
9888 *mut *mut libc::c_char,
9889 ) -> libc::c_int,
9890 ),
9891 arity: -(2 as libc::c_int),
9892 args: b"host1:port1 ... hostN:portN\0" as *const u8
9893 as *const libc::c_char as *mut libc::c_char,
9894 options: b"replicas <arg>\0" as *const u8 as *const libc::c_char
9895 as *mut libc::c_char,
9896 };
9897 init
9898 },
9899 {
9900 let mut init = clusterManagerCommandDef {
9901 name: b"check\0" as *const u8 as *const libc::c_char
9902 as *mut libc::c_char,
9903 proc_0: Some(
9904 clusterManagerCommandCheck
9905 as unsafe extern "C" fn(
9906 libc::c_int,
9907 *mut *mut libc::c_char,
9908 ) -> libc::c_int,
9909 ),
9910 arity: -(1 as libc::c_int),
9911 args: b"<host:port> or <host> <port> - separated by either colon or space\0"
9912 as *const u8 as *const libc::c_char as *mut libc::c_char,
9913 options: b"search-multiple-owners\0" as *const u8 as *const libc::c_char
9914 as *mut libc::c_char,
9915 };
9916 init
9917 },
9918 {
9919 let mut init = clusterManagerCommandDef {
9920 name: b"info\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
9921 proc_0: Some(
9922 clusterManagerCommandInfo
9923 as unsafe extern "C" fn(
9924 libc::c_int,
9925 *mut *mut libc::c_char,
9926 ) -> libc::c_int,
9927 ),
9928 arity: -(1 as libc::c_int),
9929 args: b"<host:port> or <host> <port> - separated by either colon or space\0"
9930 as *const u8 as *const libc::c_char as *mut libc::c_char,
9931 options: 0 as *const libc::c_char as *mut libc::c_char,
9932 };
9933 init
9934 },
9935 {
9936 let mut init = clusterManagerCommandDef {
9937 name: b"fix\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
9938 proc_0: Some(
9939 clusterManagerCommandFix
9940 as unsafe extern "C" fn(
9941 libc::c_int,
9942 *mut *mut libc::c_char,
9943 ) -> libc::c_int,
9944 ),
9945 arity: -(1 as libc::c_int),
9946 args: b"<host:port> or <host> <port> - separated by either colon or space\0"
9947 as *const u8 as *const libc::c_char as *mut libc::c_char,
9948 options: b"search-multiple-owners,fix-with-unreachable-masters\0"
9949 as *const u8 as *const libc::c_char as *mut libc::c_char,
9950 };
9951 init
9952 },
9953 {
9954 let mut init = clusterManagerCommandDef {
9955 name: b"reshard\0" as *const u8 as *const libc::c_char
9956 as *mut libc::c_char,
9957 proc_0: Some(
9958 clusterManagerCommandReshard
9959 as unsafe extern "C" fn(
9960 libc::c_int,
9961 *mut *mut libc::c_char,
9962 ) -> libc::c_int,
9963 ),
9964 arity: -(1 as libc::c_int),
9965 args: b"<host:port> or <host> <port> - separated by either colon or space\0"
9966 as *const u8 as *const libc::c_char as *mut libc::c_char,
9967 options: b"from <arg>,to <arg>,slots <arg>,yes,timeout <arg>,pipeline <arg>,replace\0"
9968 as *const u8 as *const libc::c_char as *mut libc::c_char,
9969 };
9970 init
9971 },
9972 {
9973 let mut init = clusterManagerCommandDef {
9974 name: b"rebalance\0" as *const u8 as *const libc::c_char
9975 as *mut libc::c_char,
9976 proc_0: Some(
9977 clusterManagerCommandRebalance
9978 as unsafe extern "C" fn(
9979 libc::c_int,
9980 *mut *mut libc::c_char,
9981 ) -> libc::c_int,
9982 ),
9983 arity: -(1 as libc::c_int),
9984 args: b"<host:port> or <host> <port> - separated by either colon or space\0"
9985 as *const u8 as *const libc::c_char as *mut libc::c_char,
9986 options: b"weight <node1=w1...nodeN=wN>,use-empty-masters,timeout <arg>,simulate,pipeline <arg>,threshold <arg>,replace\0"
9987 as *const u8 as *const libc::c_char as *mut libc::c_char,
9988 };
9989 init
9990 },
9991 {
9992 let mut init = clusterManagerCommandDef {
9993 name: b"add-node\0" as *const u8 as *const libc::c_char
9994 as *mut libc::c_char,
9995 proc_0: Some(
9996 clusterManagerCommandAddNode
9997 as unsafe extern "C" fn(
9998 libc::c_int,
9999 *mut *mut libc::c_char,
10000 ) -> libc::c_int,
10001 ),
10002 arity: 2 as libc::c_int,
10003 args: b"new_host:new_port existing_host:existing_port\0" as *const u8
10004 as *const libc::c_char as *mut libc::c_char,
10005 options: b"slave,master-id <arg>\0" as *const u8 as *const libc::c_char
10006 as *mut libc::c_char,
10007 };
10008 init
10009 },
10010 {
10011 let mut init = clusterManagerCommandDef {
10012 name: b"del-node\0" as *const u8 as *const libc::c_char
10013 as *mut libc::c_char,
10014 proc_0: Some(
10015 clusterManagerCommandDeleteNode
10016 as unsafe extern "C" fn(
10017 libc::c_int,
10018 *mut *mut libc::c_char,
10019 ) -> libc::c_int,
10020 ),
10021 arity: 2 as libc::c_int,
10022 args: b"host:port node_id\0" as *const u8 as *const libc::c_char
10023 as *mut libc::c_char,
10024 options: 0 as *const libc::c_char as *mut libc::c_char,
10025 };
10026 init
10027 },
10028 {
10029 let mut init = clusterManagerCommandDef {
10030 name: b"call\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
10031 proc_0: Some(
10032 clusterManagerCommandCall
10033 as unsafe extern "C" fn(
10034 libc::c_int,
10035 *mut *mut libc::c_char,
10036 ) -> libc::c_int,
10037 ),
10038 arity: -(2 as libc::c_int),
10039 args: b"host:port command arg arg .. arg\0" as *const u8
10040 as *const libc::c_char as *mut libc::c_char,
10041 options: b"only-masters,only-replicas\0" as *const u8
10042 as *const libc::c_char as *mut libc::c_char,
10043 };
10044 init
10045 },
10046 {
10047 let mut init = clusterManagerCommandDef {
10048 name: b"set-timeout\0" as *const u8 as *const libc::c_char
10049 as *mut libc::c_char,
10050 proc_0: Some(
10051 clusterManagerCommandSetTimeout
10052 as unsafe extern "C" fn(
10053 libc::c_int,
10054 *mut *mut libc::c_char,
10055 ) -> libc::c_int,
10056 ),
10057 arity: 2 as libc::c_int,
10058 args: b"host:port milliseconds\0" as *const u8 as *const libc::c_char
10059 as *mut libc::c_char,
10060 options: 0 as *const libc::c_char as *mut libc::c_char,
10061 };
10062 init
10063 },
10064 {
10065 let mut init = clusterManagerCommandDef {
10066 name: b"import\0" as *const u8 as *const libc::c_char
10067 as *mut libc::c_char,
10068 proc_0: Some(
10069 clusterManagerCommandImport
10070 as unsafe extern "C" fn(
10071 libc::c_int,
10072 *mut *mut libc::c_char,
10073 ) -> libc::c_int,
10074 ),
10075 arity: 1 as libc::c_int,
10076 args: b"host:port\0" as *const u8 as *const libc::c_char
10077 as *mut libc::c_char,
10078 options: b"from <arg>,from-user <arg>,from-pass <arg>,from-askpass,copy,replace\0"
10079 as *const u8 as *const libc::c_char as *mut libc::c_char,
10080 };
10081 init
10082 },
10083 {
10084 let mut init = clusterManagerCommandDef {
10085 name: b"backup\0" as *const u8 as *const libc::c_char
10086 as *mut libc::c_char,
10087 proc_0: Some(
10088 clusterManagerCommandBackup
10089 as unsafe extern "C" fn(
10090 libc::c_int,
10091 *mut *mut libc::c_char,
10092 ) -> libc::c_int,
10093 ),
10094 arity: 2 as libc::c_int,
10095 args: b"host:port backup_directory\0" as *const u8 as *const libc::c_char
10096 as *mut libc::c_char,
10097 options: 0 as *const libc::c_char as *mut libc::c_char,
10098 };
10099 init
10100 },
10101 {
10102 let mut init = clusterManagerCommandDef {
10103 name: b"help\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
10104 proc_0: Some(
10105 clusterManagerCommandHelp
10106 as unsafe extern "C" fn(
10107 libc::c_int,
10108 *mut *mut libc::c_char,
10109 ) -> libc::c_int,
10110 ),
10111 arity: 0 as libc::c_int,
10112 args: 0 as *const libc::c_char as *mut libc::c_char,
10113 options: 0 as *const libc::c_char as *mut libc::c_char,
10114 };
10115 init
10116 },
10117 ]
10118};
10119#[no_mangle]
10120pub static mut clusterManagerOptions: [clusterManagerOptionDef; 1] = [
10121 {
10122 let mut init = clusterManagerOptionDef {
10123 name: b"--cluster-yes\0" as *const u8 as *const libc::c_char
10124 as *mut libc::c_char,
10125 desc: b"Automatic yes to cluster commands prompts\0" as *const u8
10126 as *const libc::c_char as *mut libc::c_char,
10127 };
10128 init
10129 },
10130];
10131unsafe extern "C" fn createClusterManagerCommand(
10132 mut cmdname: *mut libc::c_char,
10133 mut argc: libc::c_int,
10134 mut argv: *mut *mut libc::c_char,
10135) -> libc::c_int {
10136 let mut cmd: *mut clusterManagerCommand = &mut config.cluster_manager_command;
10137 (*cmd).name = cmdname;
10138 (*cmd).argc = argc;
10139 (*cmd).argv = if argc != 0 { argv } else { 0 as *mut *mut libc::c_char };
10140 if isColorTerm() != 0 {
10141 (*cmd).flags |= (1 as libc::c_int) << 8 as libc::c_int;
10142 }
10143 if config.stdin_lastarg != 0 {
10144 let mut new_argv: *mut *mut libc::c_char = zmalloc(
10145 (core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong)
10146 .wrapping_mul(((*cmd).argc + 1 as libc::c_int) as libc::c_ulong),
10147 ) as *mut *mut libc::c_char;
10148 memcpy(
10149 new_argv as *mut libc::c_void,
10150 (*cmd).argv as *const libc::c_void,
10151 (core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong)
10152 .wrapping_mul((*cmd).argc as libc::c_ulong),
10153 );
10154 (*cmd).stdin_arg = readArgFromStdin();
10155 let fresh20 = (*cmd).argc;
10156 (*cmd).argc = (*cmd).argc + 1;
10157 let ref mut fresh21 = *new_argv.offset(fresh20 as isize);
10158 *fresh21 = (*cmd).stdin_arg;
10159 (*cmd).argv = new_argv;
10160 } else if config.stdin_tag_arg != 0 {
10161 let mut i: libc::c_int = 0 as libc::c_int;
10162 let mut tag_match: libc::c_int = 0 as libc::c_int;
10163 (*cmd).stdin_arg = readArgFromStdin();
10164 while i < argc {
10165 if strcmp(*argv.offset(i as isize), config.stdin_tag_name)
10166 != 0 as libc::c_int
10167 {
10168 i += 1;
10169 } else {
10170 tag_match = 1 as libc::c_int;
10171 let ref mut fresh22 = *((*cmd).argv).offset(i as isize);
10172 *fresh22 = (*cmd).stdin_arg;
10173 break;
10174 }
10175 }
10176 if tag_match == 0 {
10177 hi_sdsfree((*cmd).stdin_arg);
10178 fprintf(
10179 stderr,
10180 b"Using -X option but stdin tag not match.\n\0" as *const u8
10181 as *const libc::c_char,
10182 );
10183 return 1 as libc::c_int;
10184 }
10185 }
10186 return 0 as libc::c_int;
10187}
10188unsafe extern "C" fn validateClusterManagerCommand() -> Option::<
10189 clusterManagerCommandProc,
10190> {
10191 let mut i: libc::c_int = 0;
10192 let mut commands_count: libc::c_int = (core::mem::size_of::<
10193 [clusterManagerCommandDef; 13],
10194 >() as libc::c_ulong)
10195 .wrapping_div(
10196 core::mem::size_of::<clusterManagerCommandDef>() as libc::c_ulong,
10197 ) as libc::c_int;
10198 let mut proc_0: Option::<clusterManagerCommandProc> = None;
10199 let mut cmdname: *mut libc::c_char = config.cluster_manager_command.name;
10200 let mut argc: libc::c_int = config.cluster_manager_command.argc;
10201 i = 0 as libc::c_int;
10202 while i < commands_count {
10203 let mut cmddef: clusterManagerCommandDef = clusterManagerCommands[i as usize];
10204 if strcmp(cmddef.name, cmdname) == 0 {
10205 if cmddef.arity > 0 as libc::c_int && argc != cmddef.arity
10206 || cmddef.arity < 0 as libc::c_int
10207 && argc < cmddef.arity * -(1 as libc::c_int)
10208 {
10209 fprintf(
10210 stderr,
10211 b"[ERR] Wrong number of arguments for specified --cluster sub command\n\0"
10212 as *const u8 as *const libc::c_char,
10213 );
10214 return None;
10215 }
10216 proc_0 = cmddef.proc_0;
10217 }
10218 i += 1;
10219 }
10220 if proc_0.is_none() {
10221 fprintf(
10222 stderr,
10223 b"Unknown --cluster subcommand\n\0" as *const u8 as *const libc::c_char,
10224 );
10225 }
10226 return proc_0;
10227}
10228unsafe extern "C" fn parseClusterNodeAddress(
10229 mut addr: *mut libc::c_char,
10230 mut ip_ptr: *mut *mut libc::c_char,
10231 mut port_ptr: *mut libc::c_int,
10232 mut bus_port_ptr: *mut libc::c_int,
10233) -> libc::c_int {
10234 let mut c: *mut libc::c_char = strrchr(addr, '@' as i32);
10235 if !c.is_null() {
10236 *c = '\0' as i32 as libc::c_char;
10237 if !bus_port_ptr.is_null() {
10238 *bus_port_ptr = atoi(c.offset(1 as libc::c_int as isize));
10239 }
10240 }
10241 c = strrchr(addr, ':' as i32);
10242 if !c.is_null() {
10243 *c = '\0' as i32 as libc::c_char;
10244 *ip_ptr = addr;
10245 c = c.offset(1);
10246 *port_ptr = atoi(c);
10247 } else {
10248 return 0 as libc::c_int
10249 }
10250 return 1 as libc::c_int;
10251}
10252unsafe extern "C" fn getClusterHostFromCmdArgs(
10253 mut argc: libc::c_int,
10254 mut argv: *mut *mut libc::c_char,
10255 mut ip_ptr: *mut *mut libc::c_char,
10256 mut port_ptr: *mut libc::c_int,
10257) -> libc::c_int {
10258 let mut port: libc::c_int = 0 as libc::c_int;
10259 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
10260 if argc == 1 as libc::c_int {
10261 let mut addr: *mut libc::c_char = *argv.offset(0 as libc::c_int as isize);
10262 if parseClusterNodeAddress(addr, &mut ip, &mut port, 0 as *mut libc::c_int) == 0
10263 {
10264 return 0 as libc::c_int;
10265 }
10266 } else {
10267 ip = *argv.offset(0 as libc::c_int as isize);
10268 port = atoi(*argv.offset(1 as libc::c_int as isize));
10269 }
10270 if ip.is_null() || port == 0 {
10271 return 0 as libc::c_int
10272 } else {
10273 *ip_ptr = ip;
10274 *port_ptr = port;
10275 }
10276 return 1 as libc::c_int;
10277}
10278unsafe extern "C" fn freeClusterManagerNodeFlags(mut flags: *mut list) {
10279 let mut li: listIter = listIter {
10280 next: 0 as *mut listNode,
10281 direction: 0,
10282 };
10283 let mut ln: *mut listNode = 0 as *mut listNode;
10284 listRewind(flags, &mut li);
10285 loop {
10286 ln = listNext(&mut li);
10287 if ln.is_null() {
10288 break;
10289 }
10290 let mut flag: hisds = (*ln).value as hisds;
10291 hi_sdsfree(flag);
10292 }
10293 listRelease(flags);
10294}
10295unsafe extern "C" fn freeClusterManagerNode(mut node: *mut clusterManagerNode) {
10296 if !((*node).context).is_null() {
10297 redisFree((*node).context);
10298 }
10299 if !((*node).friends).is_null() {
10300 let mut li: listIter = listIter {
10301 next: 0 as *mut listNode,
10302 direction: 0,
10303 };
10304 let mut ln: *mut listNode = 0 as *mut listNode;
10305 listRewind((*node).friends, &mut li);
10306 loop {
10307 ln = listNext(&mut li);
10308 if ln.is_null() {
10309 break;
10310 }
10311 let mut fn_0: *mut clusterManagerNode = (*ln).value
10312 as *mut clusterManagerNode;
10313 freeClusterManagerNode(fn_0);
10314 }
10315 listRelease((*node).friends);
10316 (*node).friends = 0 as *mut list;
10317 }
10318 if !((*node).name).is_null() {
10319 hi_sdsfree((*node).name);
10320 }
10321 if !((*node).replicate).is_null() {
10322 hi_sdsfree((*node).replicate);
10323 }
10324 if (*node).flags & (1 as libc::c_int) << 2 as libc::c_int != 0
10325 && !((*node).ip).is_null()
10326 {
10327 hi_sdsfree((*node).ip);
10328 }
10329 let mut i: libc::c_int = 0;
10330 if !((*node).migrating).is_null() {
10331 i = 0 as libc::c_int;
10332 while i < (*node).migrating_count {
10333 hi_sdsfree(*((*node).migrating).offset(i as isize));
10334 i += 1;
10335 }
10336 zfree((*node).migrating as *mut libc::c_void);
10337 }
10338 if !((*node).importing).is_null() {
10339 i = 0 as libc::c_int;
10340 while i < (*node).importing_count {
10341 hi_sdsfree(*((*node).importing).offset(i as isize));
10342 i += 1;
10343 }
10344 zfree((*node).importing as *mut libc::c_void);
10345 }
10346 if !((*node).flags_str).is_null() {
10347 freeClusterManagerNodeFlags((*node).flags_str);
10348 (*node).flags_str = 0 as *mut list;
10349 }
10350 zfree(node as *mut libc::c_void);
10351}
10352unsafe extern "C" fn freeClusterManager() {
10353 let mut li: listIter = listIter {
10354 next: 0 as *mut listNode,
10355 direction: 0,
10356 };
10357 let mut ln: *mut listNode = 0 as *mut listNode;
10358 if !(cluster_manager.nodes).is_null() {
10359 listRewind(cluster_manager.nodes, &mut li);
10360 loop {
10361 ln = listNext(&mut li);
10362 if ln.is_null() {
10363 break;
10364 }
10365 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
10366 freeClusterManagerNode(n);
10367 }
10368 listRelease(cluster_manager.nodes);
10369 cluster_manager.nodes = 0 as *mut list;
10370 }
10371 if !(cluster_manager.errors).is_null() {
10372 listRewind(cluster_manager.errors, &mut li);
10373 loop {
10374 ln = listNext(&mut li);
10375 if ln.is_null() {
10376 break;
10377 }
10378 let mut err: hisds = (*ln).value as hisds;
10379 hi_sdsfree(err);
10380 }
10381 listRelease(cluster_manager.errors);
10382 cluster_manager.errors = 0 as *mut list;
10383 }
10384 if !clusterManagerUncoveredSlots.is_null() {
10385 dictRelease(clusterManagerUncoveredSlots);
10386 }
10387}
10388unsafe extern "C" fn clusterManagerNewNode(
10389 mut ip: *mut libc::c_char,
10390 mut port: libc::c_int,
10391 mut bus_port: libc::c_int,
10392) -> *mut clusterManagerNode {
10393 let mut node: *mut clusterManagerNode = zmalloc(
10394 core::mem::size_of::<clusterManagerNode>() as libc::c_ulong,
10395 ) as *mut clusterManagerNode;
10396 (*node).context = 0 as *mut redisContext;
10397 (*node).name = 0 as hisds;
10398 (*node).ip = ip;
10399 (*node).port = port;
10400 (*node)
10401 .bus_port = if bus_port != 0 { bus_port } else { port + 10000 as libc::c_int };
10402 (*node).current_epoch = 0 as libc::c_int as uint64_t;
10403 (*node).ping_sent = 0 as libc::c_int as time_t;
10404 (*node).ping_recv = 0 as libc::c_int as time_t;
10405 (*node).flags = 0 as libc::c_int;
10406 (*node).flags_str = 0 as *mut list;
10407 (*node).replicate = 0 as hisds;
10408 (*node).dirty = 0 as libc::c_int;
10409 (*node).friends = 0 as *mut list;
10410 (*node).migrating = 0 as *mut hisds;
10411 (*node).importing = 0 as *mut hisds;
10412 (*node).migrating_count = 0 as libc::c_int;
10413 (*node).importing_count = 0 as libc::c_int;
10414 (*node).replicas_count = 0 as libc::c_int;
10415 (*node).weight = 1.0f32;
10416 (*node).balance = 0 as libc::c_int;
10417 clusterManagerNodeResetSlots(node);
10418 return node;
10419}
10420unsafe extern "C" fn clusterManagerGetNodeRDBFilename(
10421 mut node: *mut clusterManagerNode,
10422) -> hisds {
10423 if !(config.cluster_manager_command.backup_dir).is_null() {} else {
10424 __assert_fail(
10425 b"config.cluster_manager_command.backup_dir\0" as *const u8
10426 as *const libc::c_char,
10427 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
10428 3238 as libc::c_int as libc::c_uint,
10429 (*core::mem::transmute::<
10430 &[u8; 61],
10431 &[libc::c_char; 61],
10432 >(b"hisds clusterManagerGetNodeRDBFilename(clusterManagerNode *)\0"))
10433 .as_ptr(),
10434 );
10435 };
10436 let mut filename: hisds = hi_sdsnew(config.cluster_manager_command.backup_dir);
10437 if *filename
10438 .offset(
10439 (hi_sdslen(filename)).wrapping_sub(1 as libc::c_int as libc::c_ulong)
10440 as isize,
10441 ) as libc::c_int != '/' as i32
10442 {
10443 filename = hi_sdscat(filename, b"/\0" as *const u8 as *const libc::c_char);
10444 }
10445 filename = hi_sdscatprintf(
10446 filename,
10447 b"redis-node-%s-%d-%s.rdb\0" as *const u8 as *const libc::c_char,
10448 (*node).ip,
10449 (*node).port,
10450 (*node).name,
10451 );
10452 return filename;
10453}
10454unsafe extern "C" fn clusterManagerCheckRedisReply(
10455 mut n: *mut clusterManagerNode,
10456 mut r: *mut redisReply,
10457 mut err: *mut *mut libc::c_char,
10458) -> libc::c_int {
10459 let mut is_err: libc::c_int = 0 as libc::c_int;
10460 if r.is_null()
10461 || {
10462 is_err = ((*r).type_0 == 6 as libc::c_int) as libc::c_int;
10463 is_err != 0
10464 }
10465 {
10466 if is_err != 0 {
10467 if !err.is_null() {
10468 *err = zmalloc(
10469 ((*r).len)
10470 .wrapping_add(1 as libc::c_int as libc::c_ulong)
10471 .wrapping_mul(
10472 core::mem::size_of::<libc::c_char>() as libc::c_ulong,
10473 ),
10474 ) as *mut libc::c_char;
10475 strcpy(*err, (*r).str_0);
10476 } else {
10477 clusterManagerLog(
10478 3 as libc::c_int,
10479 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
10480 as *const libc::c_char,
10481 (*n).ip,
10482 (*n).port,
10483 (*r).str_0,
10484 );
10485 }
10486 }
10487 return 0 as libc::c_int;
10488 }
10489 return 1 as libc::c_int;
10490}
10491unsafe extern "C" fn clusterManagerStartTransaction(
10492 mut node: *mut clusterManagerNode,
10493) -> libc::c_int {
10494 let mut reply: *mut redisReply = redisCommand(
10495 (*node).context,
10496 b"MULTI\0" as *const u8 as *const libc::c_char,
10497 ) as *mut redisReply;
10498 let mut success: libc::c_int = clusterManagerCheckRedisReply(
10499 node,
10500 reply,
10501 0 as *mut *mut libc::c_char,
10502 );
10503 if !reply.is_null() {
10504 freeReplyObject(reply as *mut libc::c_void);
10505 }
10506 return success;
10507}
10508unsafe extern "C" fn clusterManagerExecTransaction(
10509 mut node: *mut clusterManagerNode,
10510 mut onerror: clusterManagerOnReplyError,
10511) -> libc::c_int {
10512 let mut reply: *mut redisReply = redisCommand(
10513 (*node).context,
10514 b"EXEC\0" as *const u8 as *const libc::c_char,
10515 ) as *mut redisReply;
10516 let mut success: libc::c_int = clusterManagerCheckRedisReply(
10517 node,
10518 reply,
10519 0 as *mut *mut libc::c_char,
10520 );
10521 if success != 0 {
10522 if (*reply).type_0 != 2 as libc::c_int {
10523 success = 0 as libc::c_int;
10524 } else {
10525 let mut i: size_t = 0;
10526 i = 0 as libc::c_int as size_t;
10527 while i < (*reply).elements {
10528 let mut r: *mut redisReply = *((*reply).element).offset(i as isize);
10529 let mut err: *mut libc::c_char = 0 as *mut libc::c_char;
10530 success = clusterManagerCheckRedisReply(node, r, &mut err);
10531 if success == 0 && onerror.is_some() {
10532 success = onerror
10533 .expect("non-null function pointer")(r, node, i as libc::c_int);
10534 }
10535 if !err.is_null() {
10536 if success == 0 {
10537 clusterManagerLog(
10538 3 as libc::c_int,
10539 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
10540 as *const libc::c_char,
10541 (*node).ip,
10542 (*node).port,
10543 err,
10544 );
10545 }
10546 zfree(err as *mut libc::c_void);
10547 }
10548 if success == 0 {
10549 break;
10550 }
10551 i = i.wrapping_add(1);
10552 }
10553 }
10554 }
10555 if !reply.is_null() {
10556 freeReplyObject(reply as *mut libc::c_void);
10557 }
10558 return success;
10559}
10560unsafe extern "C" fn clusterManagerNodeConnect(
10561 mut node: *mut clusterManagerNode,
10562) -> libc::c_int {
10563 if !((*node).context).is_null() {
10564 redisFree((*node).context);
10565 }
10566 (*node).context = redisConnect((*node).ip, (*node).port);
10567 if (*(*node).context).err == 0 && config.tls != 0 {
10568 let mut err: *const libc::c_char = 0 as *const libc::c_char;
10569 if cliSecureConnection((*node).context, config.sslconfig, &mut err)
10570 == -(1 as libc::c_int) && !err.is_null()
10571 {
10572 fprintf(
10573 stderr,
10574 b"TLS Error: %s\n\0" as *const u8 as *const libc::c_char,
10575 err,
10576 );
10577 redisFree((*node).context);
10578 (*node).context = 0 as *mut redisContext;
10579 return 0 as libc::c_int;
10580 }
10581 }
10582 if (*(*node).context).err != 0 {
10583 fprintf(
10584 stderr,
10585 b"Could not connect to Redis at \0" as *const u8 as *const libc::c_char,
10586 );
10587 fprintf(
10588 stderr,
10589 b"%s:%d: %s\n\0" as *const u8 as *const libc::c_char,
10590 (*node).ip,
10591 (*node).port,
10592 ((*(*node).context).errstr).as_mut_ptr(),
10593 );
10594 redisFree((*node).context);
10595 (*node).context = 0 as *mut redisContext;
10596 return 0 as libc::c_int;
10597 }
10598 anetKeepAlive(0 as *mut libc::c_char, (*(*node).context).fd, 15 as libc::c_int);
10599 if !(config.conn_info.auth).is_null() {
10600 let mut reply: *mut redisReply = 0 as *mut redisReply;
10601 if (config.conn_info.user).is_null() {
10602 reply = redisCommand(
10603 (*node).context,
10604 b"AUTH %s\0" as *const u8 as *const libc::c_char,
10605 config.conn_info.auth,
10606 ) as *mut redisReply;
10607 } else {
10608 reply = redisCommand(
10609 (*node).context,
10610 b"AUTH %s %s\0" as *const u8 as *const libc::c_char,
10611 config.conn_info.user,
10612 config.conn_info.auth,
10613 ) as *mut redisReply;
10614 }
10615 let mut ok: libc::c_int = clusterManagerCheckRedisReply(
10616 node,
10617 reply,
10618 0 as *mut *mut libc::c_char,
10619 );
10620 if !reply.is_null() {
10621 freeReplyObject(reply as *mut libc::c_void);
10622 }
10623 if ok == 0 {
10624 return 0 as libc::c_int;
10625 }
10626 }
10627 return 1 as libc::c_int;
10628}
10629unsafe extern "C" fn clusterManagerRemoveNodeFromList(
10630 mut nodelist: *mut list,
10631 mut node: *mut clusterManagerNode,
10632) {
10633 let mut li: listIter = listIter {
10634 next: 0 as *mut listNode,
10635 direction: 0,
10636 };
10637 let mut ln: *mut listNode = 0 as *mut listNode;
10638 listRewind(nodelist, &mut li);
10639 loop {
10640 ln = listNext(&mut li);
10641 if ln.is_null() {
10642 break;
10643 }
10644 if !(node == (*ln).value as *mut clusterManagerNode) {
10645 continue;
10646 }
10647 listDelNode(nodelist, ln);
10648 break;
10649 };
10650}
10651unsafe extern "C" fn clusterManagerNodeByName(
10652 mut name: *const libc::c_char,
10653) -> *mut clusterManagerNode {
10654 if (cluster_manager.nodes).is_null() {
10655 return 0 as *mut clusterManagerNode;
10656 }
10657 let mut found: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
10658 let mut lcname: hisds = hi_sdsempty();
10659 lcname = hi_sdscpy(lcname, name);
10660 hi_sdstolower(lcname);
10661 let mut li: listIter = listIter {
10662 next: 0 as *mut listNode,
10663 direction: 0,
10664 };
10665 let mut ln: *mut listNode = 0 as *mut listNode;
10666 listRewind(cluster_manager.nodes, &mut li);
10667 loop {
10668 ln = listNext(&mut li);
10669 if ln.is_null() {
10670 break;
10671 }
10672 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
10673 if !(!((*n).name).is_null() && hi_sdscmp((*n).name, lcname) == 0) {
10674 continue;
10675 }
10676 found = n;
10677 break;
10678 }
10679 hi_sdsfree(lcname);
10680 return found;
10681}
10682unsafe extern "C" fn clusterManagerNodeByAbbreviatedName(
10683 mut name: *const libc::c_char,
10684) -> *mut clusterManagerNode {
10685 if (cluster_manager.nodes).is_null() {
10686 return 0 as *mut clusterManagerNode;
10687 }
10688 let mut found: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
10689 let mut lcname: hisds = hi_sdsempty();
10690 lcname = hi_sdscpy(lcname, name);
10691 hi_sdstolower(lcname);
10692 let mut li: listIter = listIter {
10693 next: 0 as *mut listNode,
10694 direction: 0,
10695 };
10696 let mut ln: *mut listNode = 0 as *mut listNode;
10697 listRewind(cluster_manager.nodes, &mut li);
10698 loop {
10699 ln = listNext(&mut li);
10700 if ln.is_null() {
10701 break;
10702 }
10703 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
10704 if !(!((*n).name).is_null()
10705 && strstr((*n).name as *const libc::c_char, lcname as *const libc::c_char)
10706 == (*n).name)
10707 {
10708 continue;
10709 }
10710 found = n;
10711 break;
10712 }
10713 hi_sdsfree(lcname);
10714 return found;
10715}
10716unsafe extern "C" fn clusterManagerNodeResetSlots(mut node: *mut clusterManagerNode) {
10717 memset(
10718 ((*node).slots).as_mut_ptr() as *mut libc::c_void,
10719 0 as libc::c_int,
10720 core::mem::size_of::<[uint8_t; 16384]>() as libc::c_ulong,
10721 );
10722 (*node).slots_count = 0 as libc::c_int;
10723}
10724unsafe extern "C" fn clusterManagerGetNodeRedisInfo(
10725 mut node: *mut clusterManagerNode,
10726 mut err: *mut *mut libc::c_char,
10727) -> *mut redisReply {
10728 let mut info: *mut redisReply = redisCommand(
10729 (*node).context,
10730 b"INFO\0" as *const u8 as *const libc::c_char,
10731 ) as *mut redisReply;
10732 if !err.is_null() {
10733 *err = 0 as *mut libc::c_char;
10734 }
10735 if info.is_null() {
10736 return 0 as *mut redisReply;
10737 }
10738 if (*info).type_0 == 6 as libc::c_int {
10739 if !err.is_null() {
10740 *err = zmalloc(
10741 ((*info).len)
10742 .wrapping_add(1 as libc::c_int as libc::c_ulong)
10743 .wrapping_mul(
10744 core::mem::size_of::<libc::c_char>() as libc::c_ulong,
10745 ),
10746 ) as *mut libc::c_char;
10747 strcpy(*err, (*info).str_0);
10748 }
10749 freeReplyObject(info as *mut libc::c_void);
10750 return 0 as *mut redisReply;
10751 }
10752 return info;
10753}
10754unsafe extern "C" fn clusterManagerNodeIsCluster(
10755 mut node: *mut clusterManagerNode,
10756 mut err: *mut *mut libc::c_char,
10757) -> libc::c_int {
10758 let mut info: *mut redisReply = clusterManagerGetNodeRedisInfo(node, err);
10759 if info.is_null() {
10760 return 0 as libc::c_int;
10761 }
10762 let mut is_cluster: libc::c_int = getLongInfoField(
10763 (*info).str_0,
10764 b"cluster_enabled\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
10765 ) as libc::c_int;
10766 freeReplyObject(info as *mut libc::c_void);
10767 return is_cluster;
10768}
10769unsafe extern "C" fn clusterManagerNodeIsEmpty(
10770 mut node: *mut clusterManagerNode,
10771 mut err: *mut *mut libc::c_char,
10772) -> libc::c_int {
10773 let mut known_nodes: libc::c_long = 0;
10774 let mut info: *mut redisReply = clusterManagerGetNodeRedisInfo(node, err);
10775 let mut is_empty: libc::c_int = 1 as libc::c_int;
10776 if info.is_null() {
10777 return 0 as libc::c_int;
10778 }
10779 if !(strstr((*info).str_0, b"db0:\0" as *const u8 as *const libc::c_char)).is_null()
10780 {
10781 is_empty = 0 as libc::c_int;
10782 } else {
10783 freeReplyObject(info as *mut libc::c_void);
10784 info = redisCommand(
10785 (*node).context,
10786 b"CLUSTER INFO\0" as *const u8 as *const libc::c_char,
10787 ) as *mut redisReply;
10788 if !err.is_null() {
10789 *err = 0 as *mut libc::c_char;
10790 }
10791 if clusterManagerCheckRedisReply(node, info, err) == 0 {
10792 is_empty = 0 as libc::c_int;
10793 } else {
10794 known_nodes = getLongInfoField(
10795 (*info).str_0,
10796 b"cluster_known_nodes\0" as *const u8 as *const libc::c_char
10797 as *mut libc::c_char,
10798 );
10799 is_empty = (known_nodes == 1 as libc::c_int as libc::c_long) as libc::c_int;
10800 }
10801 }
10802 freeReplyObject(info as *mut libc::c_void);
10803 return is_empty;
10804}
10805unsafe extern "C" fn clusterManagerGetAntiAffinityScore(
10806 mut ipnodes: *mut clusterManagerNodeArray,
10807 mut ip_count: libc::c_int,
10808 mut offending: *mut *mut *mut clusterManagerNode,
10809 mut offending_len: *mut libc::c_int,
10810) -> libc::c_int {
10811 let mut score: libc::c_int = 0 as libc::c_int;
10812 let mut i: libc::c_int = 0;
10813 let mut j: libc::c_int = 0;
10814 let mut node_len: libc::c_int = (*cluster_manager.nodes).len as libc::c_int;
10815 let mut offending_p: *mut *mut clusterManagerNode = 0
10816 as *mut *mut clusterManagerNode;
10817 if !offending.is_null() {
10818 *offending = zcalloc(
10819 (node_len as libc::c_ulong)
10820 .wrapping_mul(
10821 core::mem::size_of::<*mut clusterManagerNode>() as libc::c_ulong,
10822 ),
10823 ) as *mut *mut clusterManagerNode;
10824 offending_p = *offending;
10825 }
10826 i = 0 as libc::c_int;
10827 while i < ip_count {
10828 let mut node_array: *mut clusterManagerNodeArray = &mut *ipnodes
10829 .offset(i as isize) as *mut clusterManagerNodeArray;
10830 let mut related: *mut dict = dictCreate(&mut clusterManagerDictType);
10831 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
10832 j = 0 as libc::c_int;
10833 while j < (*node_array).len {
10834 let mut node: *mut clusterManagerNode = *((*node_array).nodes)
10835 .offset(j as isize);
10836 if !node.is_null() {
10837 if ip.is_null() {
10838 ip = (*node).ip;
10839 }
10840 let mut types: hisds = 0 as *mut libc::c_char;
10841 let mut key: hisds = if ((*node).replicate).is_null() {
10842 (*node).name
10843 } else {
10844 (*node).replicate
10845 };
10846 if !key.is_null() {} else {
10847 __assert_fail(
10848 b"key != NULL\0" as *const u8 as *const libc::c_char,
10849 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
10850 3512 as libc::c_int as libc::c_uint,
10851 (*core::mem::transmute::<
10852 &[u8; 102],
10853 &[libc::c_char; 102],
10854 >(
10855 b"int clusterManagerGetAntiAffinityScore(clusterManagerNodeArray *, int, clusterManagerNode ***, int *)\0",
10856 ))
10857 .as_ptr(),
10858 );
10859 };
10860 let mut entry: *mut dictEntry = dictFind(
10861 related,
10862 key as *const libc::c_void,
10863 );
10864 if !entry.is_null() {
10865 types = hi_sdsdup((*entry).v.val as hisds);
10866 } else {
10867 types = hi_sdsempty();
10868 }
10869 if !((*node).replicate).is_null() {
10870 types = hi_sdscat(types, b"s\0" as *const u8 as *const libc::c_char);
10871 } else {
10872 let mut s: hisds = hi_sdscatsds(
10873 hi_sdsnew(b"m\0" as *const u8 as *const libc::c_char),
10874 types,
10875 );
10876 hi_sdsfree(types);
10877 types = s;
10878 }
10879 dictReplace(
10880 related,
10881 key as *mut libc::c_void,
10882 types as *mut libc::c_void,
10883 );
10884 }
10885 j += 1;
10886 }
10887 let mut iter: *mut dictIterator = dictGetIterator(related);
10888 let mut entry_0: *mut dictEntry = 0 as *mut dictEntry;
10889 loop {
10890 entry_0 = dictNext(iter);
10891 if entry_0.is_null() {
10892 break;
10893 }
10894 let mut types_0: hisds = (*entry_0).v.val as hisds;
10895 let mut name: hisds = (*entry_0).key as hisds;
10896 let mut typeslen: libc::c_int = hi_sdslen(types_0) as libc::c_int;
10897 if typeslen < 2 as libc::c_int {
10898 continue;
10899 }
10900 if *types_0.offset(0 as libc::c_int as isize) as libc::c_int == 'm' as i32 {
10901 score += 10000 as libc::c_int * (typeslen - 1 as libc::c_int);
10902 } else {
10903 score += 1 as libc::c_int * typeslen;
10904 }
10905 if offending.is_null() {
10906 continue;
10907 }
10908 let mut li: listIter = listIter {
10909 next: 0 as *mut listNode,
10910 direction: 0,
10911 };
10912 let mut ln: *mut listNode = 0 as *mut listNode;
10913 listRewind(cluster_manager.nodes, &mut li);
10914 loop {
10915 ln = listNext(&mut li);
10916 if ln.is_null() {
10917 break;
10918 }
10919 let mut n: *mut clusterManagerNode = (*ln).value
10920 as *mut clusterManagerNode;
10921 if ((*n).replicate).is_null() {
10922 continue;
10923 }
10924 if !(strcmp(
10925 (*n).replicate as *const libc::c_char,
10926 name as *const libc::c_char,
10927 ) == 0 && strcmp((*n).ip, ip) == 0)
10928 {
10929 continue;
10930 }
10931 let fresh23 = offending_p;
10932 offending_p = offending_p.offset(1);
10933 *fresh23 = n;
10934 if !offending_len.is_null() {
10935 *offending_len += 1;
10936 }
10937 break;
10938 }
10939 }
10940 dictReleaseIterator(iter);
10941 dictRelease(related);
10942 i += 1;
10943 }
10944 return score;
10945}
10946unsafe extern "C" fn clusterManagerOptimizeAntiAffinity(
10947 mut ipnodes: *mut clusterManagerNodeArray,
10948 mut ip_count: libc::c_int,
10949) {
10950 let mut node_len: libc::c_int = 0;
10951 let mut maxiter: libc::c_int = 0;
10952 let mut msg: *mut libc::c_char = 0 as *mut libc::c_char;
10953 let mut perfect: libc::c_int = 0;
10954 let mut log_level: libc::c_int = 0;
10955 let mut offenders: *mut *mut clusterManagerNode = 0 as *mut *mut clusterManagerNode;
10956 let mut score: libc::c_int = clusterManagerGetAntiAffinityScore(
10957 ipnodes,
10958 ip_count,
10959 0 as *mut *mut *mut clusterManagerNode,
10960 0 as *mut libc::c_int,
10961 );
10962 if !(score == 0 as libc::c_int) {
10963 clusterManagerLog(
10964 1 as libc::c_int,
10965 b">>> Trying to optimize slaves allocation for anti-affinity\n\0"
10966 as *const u8 as *const libc::c_char,
10967 );
10968 node_len = (*cluster_manager.nodes).len as libc::c_int;
10969 maxiter = 500 as libc::c_int * node_len;
10970 srand(time(0 as *mut time_t) as libc::c_uint);
10971 while maxiter > 0 as libc::c_int {
10972 let mut offending_len: libc::c_int = 0 as libc::c_int;
10973 if !offenders.is_null() {
10974 zfree(offenders as *mut libc::c_void);
10975 offenders = 0 as *mut *mut clusterManagerNode;
10976 }
10977 score = clusterManagerGetAntiAffinityScore(
10978 ipnodes,
10979 ip_count,
10980 &mut offenders,
10981 &mut offending_len,
10982 );
10983 if score == 0 as libc::c_int || offending_len == 0 as libc::c_int {
10984 break;
10985 }
10986 let mut rand_idx: libc::c_int = rand() % offending_len;
10987 let mut first: *mut clusterManagerNode = *offenders
10988 .offset(rand_idx as isize);
10989 let mut second: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
10990 let mut other_replicas: *mut *mut clusterManagerNode = zcalloc(
10991 ((node_len - 1 as libc::c_int) as libc::c_ulong)
10992 .wrapping_mul(
10993 core::mem::size_of::<*mut clusterManagerNode>()
10994 as libc::c_ulong,
10995 ),
10996 ) as *mut *mut clusterManagerNode;
10997 let mut other_replicas_count: libc::c_int = 0 as libc::c_int;
10998 let mut li: listIter = listIter {
10999 next: 0 as *mut listNode,
11000 direction: 0,
11001 };
11002 let mut ln: *mut listNode = 0 as *mut listNode;
11003 listRewind(cluster_manager.nodes, &mut li);
11004 loop {
11005 ln = listNext(&mut li);
11006 if ln.is_null() {
11007 break;
11008 }
11009 let mut n: *mut clusterManagerNode = (*ln).value
11010 as *mut clusterManagerNode;
11011 if n != first && !((*n).replicate).is_null() {
11012 let fresh24 = other_replicas_count;
11013 other_replicas_count = other_replicas_count + 1;
11014 let ref mut fresh25 = *other_replicas.offset(fresh24 as isize);
11015 *fresh25 = n;
11016 }
11017 }
11018 if other_replicas_count == 0 as libc::c_int {
11019 zfree(other_replicas as *mut libc::c_void);
11020 break;
11021 } else {
11022 rand_idx = rand() % other_replicas_count;
11023 second = *other_replicas.offset(rand_idx as isize);
11024 let mut first_master: *mut libc::c_char = (*first).replicate;
11025 let mut second_master: *mut libc::c_char = (*second).replicate;
11026 (*first).replicate = second_master;
11027 (*first).dirty = 1 as libc::c_int;
11028 (*second).replicate = first_master;
11029 (*second).dirty = 1 as libc::c_int;
11030 let mut new_score: libc::c_int = clusterManagerGetAntiAffinityScore(
11031 ipnodes,
11032 ip_count,
11033 0 as *mut *mut *mut clusterManagerNode,
11034 0 as *mut libc::c_int,
11035 );
11036 if new_score > score {
11037 (*first).replicate = first_master;
11038 (*second).replicate = second_master;
11039 }
11040 zfree(other_replicas as *mut libc::c_void);
11041 maxiter -= 1;
11042 }
11043 }
11044 score = clusterManagerGetAntiAffinityScore(
11045 ipnodes,
11046 ip_count,
11047 0 as *mut *mut *mut clusterManagerNode,
11048 0 as *mut libc::c_int,
11049 );
11050 msg = 0 as *mut libc::c_char;
11051 perfect = (score == 0 as libc::c_int) as libc::c_int;
11052 log_level = if perfect != 0 { 4 as libc::c_int } else { 2 as libc::c_int };
11053 if perfect != 0 {
11054 msg = b"[OK] Perfect anti-affinity obtained!\0" as *const u8
11055 as *const libc::c_char as *mut libc::c_char;
11056 } else if score >= 10000 as libc::c_int {
11057 msg = b"[WARNING] Some slaves are in the same host as their master\0"
11058 as *const u8 as *const libc::c_char as *mut libc::c_char;
11059 } else {
11060 msg = b"[WARNING] Some slaves of the same master are in the same host\0"
11061 as *const u8 as *const libc::c_char as *mut libc::c_char;
11062 }
11063 clusterManagerLog(log_level, b"%s\n\0" as *const u8 as *const libc::c_char, msg);
11064 }
11065 zfree(offenders as *mut libc::c_void);
11066}
11067unsafe extern "C" fn clusterManagerNodeFlagString(
11068 mut node: *mut clusterManagerNode,
11069) -> hisds {
11070 let mut flags: hisds = hi_sdsempty();
11071 if ((*node).flags_str).is_null() {
11072 return flags;
11073 }
11074 let mut empty: libc::c_int = 1 as libc::c_int;
11075 let mut li: listIter = listIter {
11076 next: 0 as *mut listNode,
11077 direction: 0,
11078 };
11079 let mut ln: *mut listNode = 0 as *mut listNode;
11080 listRewind((*node).flags_str, &mut li);
11081 loop {
11082 ln = listNext(&mut li);
11083 if ln.is_null() {
11084 break;
11085 }
11086 let mut flag: hisds = (*ln).value as hisds;
11087 if strcmp(
11088 flag as *const libc::c_char,
11089 b"myself\0" as *const u8 as *const libc::c_char,
11090 ) == 0 as libc::c_int
11091 {
11092 continue;
11093 }
11094 if empty == 0 {
11095 flags = hi_sdscat(flags, b",\0" as *const u8 as *const libc::c_char);
11096 }
11097 flags = hi_sdscatfmt(flags, b"%S\0" as *const u8 as *const libc::c_char, flag);
11098 empty = 0 as libc::c_int;
11099 }
11100 return flags;
11101}
11102unsafe extern "C" fn clusterManagerNodeSlotsString(
11103 mut node: *mut clusterManagerNode,
11104) -> hisds {
11105 let mut slots: hisds = hi_sdsempty();
11106 let mut first_range_idx: libc::c_int = -(1 as libc::c_int);
11107 let mut last_slot_idx: libc::c_int = -(1 as libc::c_int);
11108 let mut i: libc::c_int = 0;
11109 i = 0 as libc::c_int;
11110 while i < 16384 as libc::c_int {
11111 let mut has_slot: libc::c_int = (*node).slots[i as usize] as libc::c_int;
11112 if has_slot != 0 {
11113 if first_range_idx == -(1 as libc::c_int) {
11114 if hi_sdslen(slots) != 0 {
11115 slots = hi_sdscat(slots, b",\0" as *const u8 as *const libc::c_char);
11116 }
11117 first_range_idx = i;
11118 slots = hi_sdscatfmt(
11119 slots,
11120 b"[%u\0" as *const u8 as *const libc::c_char,
11121 i,
11122 );
11123 }
11124 last_slot_idx = i;
11125 } else {
11126 if last_slot_idx >= 0 as libc::c_int {
11127 if first_range_idx == last_slot_idx {
11128 slots = hi_sdscat(slots, b"]\0" as *const u8 as *const libc::c_char);
11129 } else {
11130 slots = hi_sdscatfmt(
11131 slots,
11132 b"-%u]\0" as *const u8 as *const libc::c_char,
11133 last_slot_idx,
11134 );
11135 }
11136 }
11137 last_slot_idx = -(1 as libc::c_int);
11138 first_range_idx = -(1 as libc::c_int);
11139 }
11140 i += 1;
11141 }
11142 if last_slot_idx >= 0 as libc::c_int {
11143 if first_range_idx == last_slot_idx {
11144 slots = hi_sdscat(slots, b"]\0" as *const u8 as *const libc::c_char);
11145 } else {
11146 slots = hi_sdscatfmt(
11147 slots,
11148 b"-%u]\0" as *const u8 as *const libc::c_char,
11149 last_slot_idx,
11150 );
11151 }
11152 }
11153 return slots;
11154}
11155unsafe extern "C" fn clusterManagerNodeGetJSON(
11156 mut node: *mut clusterManagerNode,
11157 mut error_count: libc::c_ulong,
11158) -> hisds {
11159 let mut json: hisds = hi_sdsempty();
11160 let mut replicate: hisds = hi_sdsempty();
11161 if !((*node).replicate).is_null() {
11162 replicate = hi_sdscatprintf(
11163 replicate,
11164 b"\"%s\"\0" as *const u8 as *const libc::c_char,
11165 (*node).replicate,
11166 );
11167 } else {
11168 replicate = hi_sdscat(replicate, b"null\0" as *const u8 as *const libc::c_char);
11169 }
11170 let mut slots: hisds = clusterManagerNodeSlotsString(node);
11171 let mut flags: hisds = clusterManagerNodeFlagString(node);
11172 let mut p: *mut libc::c_char = slots;
11173 loop {
11174 p = strchr(p, '-' as i32);
11175 if p.is_null() {
11176 break;
11177 }
11178 let fresh26 = p;
11179 p = p.offset(1);
11180 *fresh26 = ',' as i32 as libc::c_char;
11181 }
11182 json = hi_sdscatprintf(
11183 json,
11184 b" {\n \"name\": \"%s\",\n \"host\": \"%s\",\n \"port\": %d,\n \"replicate\": %s,\n \"slots\": [%s],\n \"slots_count\": %d,\n \"flags\": \"%s\",\n \"current_epoch\": %llu\0"
11185 as *const u8 as *const libc::c_char,
11186 (*node).name,
11187 (*node).ip,
11188 (*node).port,
11189 replicate,
11190 slots,
11191 (*node).slots_count,
11192 flags,
11193 (*node).current_epoch as libc::c_ulonglong,
11194 );
11195 if error_count > 0 as libc::c_int as libc::c_ulong {
11196 json = hi_sdscatprintf(
11197 json,
11198 b",\n \"cluster_errors\": %lu\0" as *const u8 as *const libc::c_char,
11199 error_count,
11200 );
11201 }
11202 if (*node).migrating_count > 0 as libc::c_int && !((*node).migrating).is_null() {
11203 let mut i: libc::c_int = 0 as libc::c_int;
11204 let mut migrating: hisds = hi_sdsempty();
11205 while i < (*node).migrating_count {
11206 let mut slot: hisds = *((*node).migrating).offset(i as isize);
11207 let mut dest: hisds = *((*node).migrating)
11208 .offset((i + 1 as libc::c_int) as isize);
11209 if !slot.is_null() && !dest.is_null() {
11210 if hi_sdslen(migrating) > 0 as libc::c_int as libc::c_ulong {
11211 migrating = hi_sdscat(
11212 migrating,
11213 b",\0" as *const u8 as *const libc::c_char,
11214 );
11215 }
11216 migrating = hi_sdscatfmt(
11217 migrating,
11218 b"\"%S\": \"%S\"\0" as *const u8 as *const libc::c_char,
11219 slot,
11220 dest,
11221 );
11222 }
11223 i += 2 as libc::c_int;
11224 }
11225 if hi_sdslen(migrating) > 0 as libc::c_int as libc::c_ulong {
11226 json = hi_sdscatfmt(
11227 json,
11228 b",\n \"migrating\": {%S}\0" as *const u8 as *const libc::c_char,
11229 migrating,
11230 );
11231 }
11232 hi_sdsfree(migrating);
11233 }
11234 if (*node).importing_count > 0 as libc::c_int && !((*node).importing).is_null() {
11235 let mut i_0: libc::c_int = 0 as libc::c_int;
11236 let mut importing: hisds = hi_sdsempty();
11237 while i_0 < (*node).importing_count {
11238 let mut slot_0: hisds = *((*node).importing).offset(i_0 as isize);
11239 let mut from: hisds = *((*node).importing)
11240 .offset((i_0 + 1 as libc::c_int) as isize);
11241 if !slot_0.is_null() && !from.is_null() {
11242 if hi_sdslen(importing) > 0 as libc::c_int as libc::c_ulong {
11243 importing = hi_sdscat(
11244 importing,
11245 b",\0" as *const u8 as *const libc::c_char,
11246 );
11247 }
11248 importing = hi_sdscatfmt(
11249 importing,
11250 b"\"%S\": \"%S\"\0" as *const u8 as *const libc::c_char,
11251 slot_0,
11252 from,
11253 );
11254 }
11255 i_0 += 2 as libc::c_int;
11256 }
11257 if hi_sdslen(importing) > 0 as libc::c_int as libc::c_ulong {
11258 json = hi_sdscatfmt(
11259 json,
11260 b",\n \"importing\": {%S}\0" as *const u8 as *const libc::c_char,
11261 importing,
11262 );
11263 }
11264 hi_sdsfree(importing);
11265 }
11266 json = hi_sdscat(json, b"\n }\0" as *const u8 as *const libc::c_char);
11267 hi_sdsfree(replicate);
11268 hi_sdsfree(slots);
11269 hi_sdsfree(flags);
11270 return json;
11271}
11272unsafe extern "C" fn clusterManagerKeyHashSlot(
11273 mut key: *mut libc::c_char,
11274 mut keylen: libc::c_int,
11275) -> libc::c_uint {
11276 let mut s: libc::c_int = 0;
11277 let mut e: libc::c_int = 0;
11278 s = 0 as libc::c_int;
11279 while s < keylen {
11280 if *key.offset(s as isize) as libc::c_int == '{' as i32 {
11281 break;
11282 }
11283 s += 1;
11284 }
11285 if s == keylen {
11286 return (crc16(key, keylen) as libc::c_int & 0x3fff as libc::c_int)
11287 as libc::c_uint;
11288 }
11289 e = s + 1 as libc::c_int;
11290 while e < keylen {
11291 if *key.offset(e as isize) as libc::c_int == '}' as i32 {
11292 break;
11293 }
11294 e += 1;
11295 }
11296 if e == keylen || e == s + 1 as libc::c_int {
11297 return (crc16(key, keylen) as libc::c_int & 0x3fff as libc::c_int)
11298 as libc::c_uint;
11299 }
11300 return (crc16(
11301 key.offset(s as isize).offset(1 as libc::c_int as isize),
11302 e - s - 1 as libc::c_int,
11303 ) as libc::c_int & 0x3fff as libc::c_int) as libc::c_uint;
11304}
11305unsafe extern "C" fn clusterManagerNodeInfo(
11306 mut node: *mut clusterManagerNode,
11307 mut indent: libc::c_int,
11308) -> hisds {
11309 let mut info: hisds = hi_sdsempty();
11310 let mut spaces: hisds = hi_sdsempty();
11311 let mut i: libc::c_int = 0;
11312 i = 0 as libc::c_int;
11313 while i < indent {
11314 spaces = hi_sdscat(spaces, b" \0" as *const u8 as *const libc::c_char);
11315 i += 1;
11316 }
11317 if indent != 0 {
11318 info = hi_sdscat(info, spaces as *const libc::c_char);
11319 }
11320 let mut is_master: libc::c_int = ((*node).flags
11321 & (1 as libc::c_int) << 1 as libc::c_int == 0) as libc::c_int;
11322 let mut role: *mut libc::c_char = (if is_master != 0 {
11323 b"M\0" as *const u8 as *const libc::c_char
11324 } else {
11325 b"S\0" as *const u8 as *const libc::c_char
11326 }) as *mut libc::c_char;
11327 let mut slots: hisds = 0 as hisds;
11328 if (*node).dirty != 0 && !((*node).replicate).is_null() {
11329 info = hi_sdscatfmt(
11330 info,
11331 b"S: %S %s:%u\0" as *const u8 as *const libc::c_char,
11332 (*node).name,
11333 (*node).ip,
11334 (*node).port,
11335 );
11336 } else {
11337 slots = clusterManagerNodeSlotsString(node);
11338 let mut flags: hisds = clusterManagerNodeFlagString(node);
11339 info = hi_sdscatfmt(
11340 info,
11341 b"%s: %S %s:%u\n%s slots:%S (%u slots) %S\0" as *const u8
11342 as *const libc::c_char,
11343 role,
11344 (*node).name,
11345 (*node).ip,
11346 (*node).port,
11347 spaces,
11348 slots,
11349 (*node).slots_count,
11350 flags,
11351 );
11352 hi_sdsfree(slots);
11353 hi_sdsfree(flags);
11354 }
11355 if !((*node).replicate).is_null() {
11356 info = hi_sdscatfmt(
11357 info,
11358 b"\n%s replicates %S\0" as *const u8 as *const libc::c_char,
11359 spaces,
11360 (*node).replicate,
11361 );
11362 } else if (*node).replicas_count != 0 {
11363 info = hi_sdscatfmt(
11364 info,
11365 b"\n%s %U additional replica(s)\0" as *const u8 as *const libc::c_char,
11366 spaces,
11367 (*node).replicas_count,
11368 );
11369 }
11370 hi_sdsfree(spaces);
11371 return info;
11372}
11373unsafe extern "C" fn clusterManagerShowNodes() {
11374 let mut li: listIter = listIter {
11375 next: 0 as *mut listNode,
11376 direction: 0,
11377 };
11378 let mut ln: *mut listNode = 0 as *mut listNode;
11379 listRewind(cluster_manager.nodes, &mut li);
11380 loop {
11381 ln = listNext(&mut li);
11382 if ln.is_null() {
11383 break;
11384 }
11385 let mut node: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
11386 let mut info: hisds = clusterManagerNodeInfo(node, 0 as libc::c_int);
11387 printf(b"%s\n\0" as *const u8 as *const libc::c_char, info);
11388 hi_sdsfree(info);
11389 };
11390}
11391unsafe extern "C" fn clusterManagerShowClusterInfo() {
11392 let mut masters: libc::c_int = 0 as libc::c_int;
11393 let mut keys: libc::c_int = 0 as libc::c_int;
11394 let mut li: listIter = listIter {
11395 next: 0 as *mut listNode,
11396 direction: 0,
11397 };
11398 let mut ln: *mut listNode = 0 as *mut listNode;
11399 listRewind(cluster_manager.nodes, &mut li);
11400 loop {
11401 ln = listNext(&mut li);
11402 if ln.is_null() {
11403 break;
11404 }
11405 let mut node: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
11406 if !((*node).flags & (1 as libc::c_int) << 1 as libc::c_int == 0) {
11407 continue;
11408 }
11409 if ((*node).name).is_null() {
11410 continue;
11411 }
11412 let mut replicas: libc::c_int = 0 as libc::c_int;
11413 let mut dbsize: libc::c_int = -(1 as libc::c_int);
11414 let mut name: [libc::c_char; 9] = [0; 9];
11415 memcpy(
11416 name.as_mut_ptr() as *mut libc::c_void,
11417 (*node).name as *const libc::c_void,
11418 8 as libc::c_int as libc::c_ulong,
11419 );
11420 name[8 as libc::c_int as usize] = '\0' as i32 as libc::c_char;
11421 let mut ri: listIter = listIter {
11422 next: 0 as *mut listNode,
11423 direction: 0,
11424 };
11425 let mut rn: *mut listNode = 0 as *mut listNode;
11426 listRewind(cluster_manager.nodes, &mut ri);
11427 loop {
11428 rn = listNext(&mut ri);
11429 if rn.is_null() {
11430 break;
11431 }
11432 let mut n: *mut clusterManagerNode = (*rn).value as *mut clusterManagerNode;
11433 if n == node || (*n).flags & (1 as libc::c_int) << 1 as libc::c_int == 0 {
11434 continue;
11435 }
11436 if !((*n).replicate).is_null()
11437 && strcmp(
11438 (*n).replicate as *const libc::c_char,
11439 (*node).name as *const libc::c_char,
11440 ) == 0
11441 {
11442 replicas += 1;
11443 }
11444 }
11445 let mut reply: *mut redisReply = redisCommand(
11446 (*node).context,
11447 b"DBSIZE\0" as *const u8 as *const libc::c_char,
11448 ) as *mut redisReply;
11449 if !reply.is_null() && (*reply).type_0 == 3 as libc::c_int {
11450 dbsize = (*reply).integer as libc::c_int;
11451 }
11452 if dbsize < 0 as libc::c_int {
11453 let mut err: *mut libc::c_char = b"\0" as *const u8 as *const libc::c_char
11454 as *mut libc::c_char;
11455 if !reply.is_null() && (*reply).type_0 == 6 as libc::c_int {
11456 err = (*reply).str_0;
11457 }
11458 clusterManagerLog(
11459 3 as libc::c_int,
11460 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
11461 as *const libc::c_char,
11462 (*node).ip,
11463 (*node).port,
11464 err,
11465 );
11466 if !reply.is_null() {
11467 freeReplyObject(reply as *mut libc::c_void);
11468 }
11469 return;
11470 }
11471 if !reply.is_null() {
11472 freeReplyObject(reply as *mut libc::c_void);
11473 }
11474 printf(
11475 b"%s:%d (%s...) -> %d keys | %d slots | %d slaves.\n\0" as *const u8
11476 as *const libc::c_char,
11477 (*node).ip,
11478 (*node).port,
11479 name.as_mut_ptr(),
11480 dbsize,
11481 (*node).slots_count,
11482 replicas,
11483 );
11484 masters += 1;
11485 keys += dbsize;
11486 }
11487 clusterManagerLog(
11488 4 as libc::c_int,
11489 b"[OK] %d keys in %d masters.\n\0" as *const u8 as *const libc::c_char,
11490 keys,
11491 masters,
11492 );
11493 let mut keys_per_slot: libc::c_float = keys as libc::c_float
11494 / 16384 as libc::c_int as libc::c_float;
11495 printf(
11496 b"%.2f keys per slot on average.\n\0" as *const u8 as *const libc::c_char,
11497 keys_per_slot as libc::c_double,
11498 );
11499}
11500unsafe extern "C" fn clusterManagerAddSlots(
11501 mut node: *mut clusterManagerNode,
11502 mut err: *mut *mut libc::c_char,
11503) -> libc::c_int {
11504 let mut reply: *mut redisReply = 0 as *mut redisReply;
11505 let mut _reply: *mut libc::c_void = 0 as *mut libc::c_void;
11506 let mut success: libc::c_int = 1 as libc::c_int;
11507 let mut argc: libc::c_int = (*node).slots_count + 2 as libc::c_int;
11508 let mut argv: *mut hisds = zmalloc(
11509 (argc as libc::c_ulong)
11510 .wrapping_mul(core::mem::size_of::<hisds>() as libc::c_ulong),
11511 ) as *mut hisds;
11512 let mut argvlen: *mut size_t = zmalloc(
11513 (argc as libc::c_ulong)
11514 .wrapping_mul(core::mem::size_of::<size_t>() as libc::c_ulong),
11515 ) as *mut size_t;
11516 let ref mut fresh27 = *argv.offset(0 as libc::c_int as isize);
11517 *fresh27 = b"CLUSTER\0" as *const u8 as *const libc::c_char as hisds;
11518 let ref mut fresh28 = *argv.offset(1 as libc::c_int as isize);
11519 *fresh28 = b"ADDSLOTS\0" as *const u8 as *const libc::c_char as hisds;
11520 *argvlen.offset(0 as libc::c_int as isize) = 7 as libc::c_int as size_t;
11521 *argvlen.offset(1 as libc::c_int as isize) = 8 as libc::c_int as size_t;
11522 *err = 0 as *mut libc::c_char;
11523 let mut i: libc::c_int = 0;
11524 let mut argv_idx: libc::c_int = 2 as libc::c_int;
11525 i = 0 as libc::c_int;
11526 while i < 16384 as libc::c_int {
11527 if argv_idx >= argc {
11528 break;
11529 }
11530 if (*node).slots[i as usize] != 0 {
11531 let ref mut fresh29 = *argv.offset(argv_idx as isize);
11532 *fresh29 = hi_sdsfromlonglong(i as libc::c_longlong);
11533 *argvlen
11534 .offset(argv_idx as isize) = hi_sdslen(*argv.offset(argv_idx as isize));
11535 argv_idx += 1;
11536 }
11537 i += 1;
11538 }
11539 if argv_idx == 2 as libc::c_int {
11540 success = 0 as libc::c_int;
11541 } else {
11542 redisAppendCommandArgv(
11543 (*node).context,
11544 argc,
11545 argv as *mut *const libc::c_char,
11546 argvlen,
11547 );
11548 if redisGetReply((*node).context, &mut _reply) != 0 as libc::c_int {
11549 success = 0 as libc::c_int;
11550 } else {
11551 reply = _reply as *mut redisReply;
11552 success = clusterManagerCheckRedisReply(node, reply, err);
11553 }
11554 }
11555 zfree(argvlen as *mut libc::c_void);
11556 if !argv.is_null() {
11557 i = 2 as libc::c_int;
11558 while i < argc {
11559 hi_sdsfree(*argv.offset(i as isize));
11560 i += 1;
11561 }
11562 zfree(argv as *mut libc::c_void);
11563 }
11564 if !reply.is_null() {
11565 freeReplyObject(reply as *mut libc::c_void);
11566 }
11567 return success;
11568}
11569unsafe extern "C" fn clusterManagerGetSlotOwner(
11570 mut n: *mut clusterManagerNode,
11571 mut slot: libc::c_int,
11572 mut err: *mut *mut libc::c_char,
11573) -> *mut clusterManagerNode {
11574 if slot >= 0 as libc::c_int && slot < 16384 as libc::c_int {} else {
11575 __assert_fail(
11576 b"slot >= 0 && slot < CLUSTER_MANAGER_SLOTS\0" as *const u8
11577 as *const libc::c_char,
11578 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
11579 3936 as libc::c_int as libc::c_uint,
11580 (*core::mem::transmute::<
11581 &[u8; 83],
11582 &[libc::c_char; 83],
11583 >(
11584 b"clusterManagerNode *clusterManagerGetSlotOwner(clusterManagerNode *, int, char **)\0",
11585 ))
11586 .as_ptr(),
11587 );
11588 };
11589 let mut owner: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
11590 let mut reply: *mut redisReply = redisCommand(
11591 (*n).context,
11592 b"CLUSTER SLOTS\0" as *const u8 as *const libc::c_char,
11593 ) as *mut redisReply;
11594 if clusterManagerCheckRedisReply(n, reply, err) != 0 {
11595 if (*reply).type_0 == 2 as libc::c_int {} else {
11596 __assert_fail(
11597 b"reply->type == REDIS_REPLY_ARRAY\0" as *const u8
11598 as *const libc::c_char,
11599 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
11600 3940 as libc::c_int as libc::c_uint,
11601 (*core::mem::transmute::<
11602 &[u8; 83],
11603 &[libc::c_char; 83],
11604 >(
11605 b"clusterManagerNode *clusterManagerGetSlotOwner(clusterManagerNode *, int, char **)\0",
11606 ))
11607 .as_ptr(),
11608 );
11609 };
11610 let mut i: size_t = 0;
11611 i = 0 as libc::c_int as size_t;
11612 while i < (*reply).elements {
11613 let mut r: *mut redisReply = *((*reply).element).offset(i as isize);
11614 if (*r).type_0 == 2 as libc::c_int
11615 && (*r).elements >= 3 as libc::c_int as libc::c_ulong
11616 {} else {
11617 __assert_fail(
11618 b"r->type == REDIS_REPLY_ARRAY && r->elements >= 3\0" as *const u8
11619 as *const libc::c_char,
11620 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
11621 3944 as libc::c_int as libc::c_uint,
11622 (*core::mem::transmute::<
11623 &[u8; 83],
11624 &[libc::c_char; 83],
11625 >(
11626 b"clusterManagerNode *clusterManagerGetSlotOwner(clusterManagerNode *, int, char **)\0",
11627 ))
11628 .as_ptr(),
11629 );
11630 };
11631 let mut from: libc::c_int = 0;
11632 let mut to: libc::c_int = 0;
11633 from = (**((*r).element).offset(0 as libc::c_int as isize)).integer
11634 as libc::c_int;
11635 to = (**((*r).element).offset(1 as libc::c_int as isize)).integer
11636 as libc::c_int;
11637 if !(slot < from || slot > to) {
11638 let mut nr: *mut redisReply = *((*r).element)
11639 .offset(2 as libc::c_int as isize);
11640 if (*nr).type_0 == 2 as libc::c_int
11641 && (*nr).elements >= 2 as libc::c_int as libc::c_ulong
11642 {} else {
11643 __assert_fail(
11644 b"nr->type == REDIS_REPLY_ARRAY && nr->elements >= 2\0"
11645 as *const u8 as *const libc::c_char,
11646 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
11647 3950 as libc::c_int as libc::c_uint,
11648 (*core::mem::transmute::<
11649 &[u8; 83],
11650 &[libc::c_char; 83],
11651 >(
11652 b"clusterManagerNode *clusterManagerGetSlotOwner(clusterManagerNode *, int, char **)\0",
11653 ))
11654 .as_ptr(),
11655 );
11656 };
11657 let mut name: *mut libc::c_char = 0 as *mut libc::c_char;
11658 if (*nr).elements >= 3 as libc::c_int as libc::c_ulong {
11659 name = (**((*nr).element).offset(2 as libc::c_int as isize)).str_0;
11660 }
11661 if !name.is_null() {
11662 owner = clusterManagerNodeByName(name);
11663 } else {
11664 let mut ip: *mut libc::c_char = (**((*nr).element)
11665 .offset(0 as libc::c_int as isize))
11666 .str_0;
11667 if !ip.is_null() {} else {
11668 __assert_fail(
11669 b"ip != NULL\0" as *const u8 as *const libc::c_char,
11670 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
11671 3958 as libc::c_int as libc::c_uint,
11672 (*core::mem::transmute::<
11673 &[u8; 83],
11674 &[libc::c_char; 83],
11675 >(
11676 b"clusterManagerNode *clusterManagerGetSlotOwner(clusterManagerNode *, int, char **)\0",
11677 ))
11678 .as_ptr(),
11679 );
11680 };
11681 let mut port: libc::c_int = (**((*nr).element)
11682 .offset(1 as libc::c_int as isize))
11683 .integer as libc::c_int;
11684 let mut li: listIter = listIter {
11685 next: 0 as *mut listNode,
11686 direction: 0,
11687 };
11688 let mut ln: *mut listNode = 0 as *mut listNode;
11689 listRewind(cluster_manager.nodes, &mut li);
11690 loop {
11691 ln = listNext(&mut li);
11692 if ln.is_null() {
11693 break;
11694 }
11695 let mut nd: *mut clusterManagerNode = (*ln).value
11696 as *mut clusterManagerNode;
11697 if !(strcmp((*nd).ip, ip) == 0 as libc::c_int
11698 && port == (*nd).port)
11699 {
11700 continue;
11701 }
11702 owner = nd;
11703 break;
11704 }
11705 }
11706 if !owner.is_null() {
11707 break;
11708 }
11709 }
11710 i = i.wrapping_add(1);
11711 }
11712 }
11713 if !reply.is_null() {
11714 freeReplyObject(reply as *mut libc::c_void);
11715 }
11716 return owner;
11717}
11718unsafe extern "C" fn clusterManagerSetSlot(
11719 mut node1: *mut clusterManagerNode,
11720 mut node2: *mut clusterManagerNode,
11721 mut slot: libc::c_int,
11722 mut status: *const libc::c_char,
11723 mut err: *mut *mut libc::c_char,
11724) -> libc::c_int {
11725 let mut reply: *mut redisReply = redisCommand(
11726 (*node1).context,
11727 b"CLUSTER SETSLOT %d %s %s\0" as *const u8 as *const libc::c_char,
11728 slot,
11729 status,
11730 (*node2).name,
11731 ) as *mut redisReply;
11732 if !err.is_null() {
11733 *err = 0 as *mut libc::c_char;
11734 }
11735 if reply.is_null() {
11736 if !err.is_null() {
11737 *err = zstrdup(
11738 b"CLUSTER SETSLOT failed to run\0" as *const u8 as *const libc::c_char,
11739 );
11740 }
11741 return 0 as libc::c_int;
11742 }
11743 let mut success: libc::c_int = 1 as libc::c_int;
11744 if (*reply).type_0 == 6 as libc::c_int {
11745 success = 0 as libc::c_int;
11746 if !err.is_null() {
11747 *err = zmalloc(
11748 ((*reply).len)
11749 .wrapping_add(1 as libc::c_int as libc::c_ulong)
11750 .wrapping_mul(
11751 core::mem::size_of::<libc::c_char>() as libc::c_ulong,
11752 ),
11753 ) as *mut libc::c_char;
11754 strcpy(*err, (*reply).str_0);
11755 } else {
11756 clusterManagerLog(
11757 3 as libc::c_int,
11758 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
11759 as *const libc::c_char,
11760 (*node1).ip,
11761 (*node1).port,
11762 (*reply).str_0,
11763 );
11764 }
11765 }
11766 freeReplyObject(reply as *mut libc::c_void);
11767 return success;
11768}
11769unsafe extern "C" fn clusterManagerClearSlotStatus(
11770 mut node: *mut clusterManagerNode,
11771 mut slot: libc::c_int,
11772) -> libc::c_int {
11773 let mut reply: *mut redisReply = redisCommand(
11774 (*node).context,
11775 b"CLUSTER SETSLOT %d %s\0" as *const u8 as *const libc::c_char,
11776 slot,
11777 b"STABLE\0" as *const u8 as *const libc::c_char,
11778 ) as *mut redisReply;
11779 let mut success: libc::c_int = clusterManagerCheckRedisReply(
11780 node,
11781 reply,
11782 0 as *mut *mut libc::c_char,
11783 );
11784 if !reply.is_null() {
11785 freeReplyObject(reply as *mut libc::c_void);
11786 }
11787 return success;
11788}
11789unsafe extern "C" fn clusterManagerDelSlot(
11790 mut node: *mut clusterManagerNode,
11791 mut slot: libc::c_int,
11792 mut ignore_unassigned_err: libc::c_int,
11793) -> libc::c_int {
11794 let mut reply: *mut redisReply = redisCommand(
11795 (*node).context,
11796 b"CLUSTER DELSLOTS %d\0" as *const u8 as *const libc::c_char,
11797 slot,
11798 ) as *mut redisReply;
11799 let mut err: *mut libc::c_char = 0 as *mut libc::c_char;
11800 let mut success: libc::c_int = clusterManagerCheckRedisReply(node, reply, &mut err);
11801 if success == 0 && !reply.is_null() && (*reply).type_0 == 6 as libc::c_int
11802 && ignore_unassigned_err != 0
11803 {
11804 let mut get_owner_err: *mut libc::c_char = 0 as *mut libc::c_char;
11805 let mut assigned_to: *mut clusterManagerNode = clusterManagerGetSlotOwner(
11806 node,
11807 slot,
11808 &mut get_owner_err,
11809 );
11810 if assigned_to.is_null() {
11811 if get_owner_err.is_null() {
11812 success = 1 as libc::c_int;
11813 } else {
11814 clusterManagerLog(
11815 3 as libc::c_int,
11816 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
11817 as *const libc::c_char,
11818 (*node).ip,
11819 (*node).port,
11820 get_owner_err,
11821 );
11822 zfree(get_owner_err as *mut libc::c_void);
11823 }
11824 }
11825 }
11826 if success == 0 && !err.is_null() {
11827 clusterManagerLog(
11828 3 as libc::c_int,
11829 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
11830 as *const libc::c_char,
11831 (*node).ip,
11832 (*node).port,
11833 err,
11834 );
11835 zfree(err as *mut libc::c_void);
11836 }
11837 if !reply.is_null() {
11838 freeReplyObject(reply as *mut libc::c_void);
11839 }
11840 return success;
11841}
11842unsafe extern "C" fn clusterManagerAddSlot(
11843 mut node: *mut clusterManagerNode,
11844 mut slot: libc::c_int,
11845) -> libc::c_int {
11846 let mut reply: *mut redisReply = redisCommand(
11847 (*node).context,
11848 b"CLUSTER ADDSLOTS %d\0" as *const u8 as *const libc::c_char,
11849 slot,
11850 ) as *mut redisReply;
11851 let mut success: libc::c_int = clusterManagerCheckRedisReply(
11852 node,
11853 reply,
11854 0 as *mut *mut libc::c_char,
11855 );
11856 if !reply.is_null() {
11857 freeReplyObject(reply as *mut libc::c_void);
11858 }
11859 return success;
11860}
11861unsafe extern "C" fn clusterManagerCountKeysInSlot(
11862 mut node: *mut clusterManagerNode,
11863 mut slot: libc::c_int,
11864) -> libc::c_int {
11865 let mut reply: *mut redisReply = redisCommand(
11866 (*node).context,
11867 b"CLUSTER COUNTKEYSINSLOT %d\0" as *const u8 as *const libc::c_char,
11868 slot,
11869 ) as *mut redisReply;
11870 let mut count: libc::c_int = -(1 as libc::c_int);
11871 let mut success: libc::c_int = clusterManagerCheckRedisReply(
11872 node,
11873 reply,
11874 0 as *mut *mut libc::c_char,
11875 );
11876 if success != 0 && (*reply).type_0 == 3 as libc::c_int {
11877 count = (*reply).integer as libc::c_int;
11878 }
11879 if !reply.is_null() {
11880 freeReplyObject(reply as *mut libc::c_void);
11881 }
11882 return count;
11883}
11884unsafe extern "C" fn clusterManagerBumpEpoch(
11885 mut node: *mut clusterManagerNode,
11886) -> libc::c_int {
11887 let mut reply: *mut redisReply = redisCommand(
11888 (*node).context,
11889 b"CLUSTER BUMPEPOCH\0" as *const u8 as *const libc::c_char,
11890 ) as *mut redisReply;
11891 let mut success: libc::c_int = clusterManagerCheckRedisReply(
11892 node,
11893 reply,
11894 0 as *mut *mut libc::c_char,
11895 );
11896 if !reply.is_null() {
11897 freeReplyObject(reply as *mut libc::c_void);
11898 }
11899 return success;
11900}
11901unsafe extern "C" fn clusterManagerOnSetOwnerErr(
11902 mut reply: *mut redisReply,
11903 mut n: *mut clusterManagerNode,
11904 mut bulk_idx: libc::c_int,
11905) -> libc::c_int {
11906 return (bulk_idx != 1 as libc::c_int) as libc::c_int;
11907}
11908unsafe extern "C" fn clusterManagerSetSlotOwner(
11909 mut owner: *mut clusterManagerNode,
11910 mut slot: libc::c_int,
11911 mut do_clear: libc::c_int,
11912) -> libc::c_int {
11913 let mut success: libc::c_int = clusterManagerStartTransaction(owner);
11914 if success == 0 {
11915 return 0 as libc::c_int;
11916 }
11917 clusterManagerDelSlot(owner, slot, 1 as libc::c_int);
11918 clusterManagerAddSlot(owner, slot);
11919 if do_clear != 0 {
11920 clusterManagerClearSlotStatus(owner, slot);
11921 }
11922 clusterManagerBumpEpoch(owner);
11923 success = clusterManagerExecTransaction(
11924 owner,
11925 Some(
11926 clusterManagerOnSetOwnerErr
11927 as unsafe extern "C" fn(
11928 *mut redisReply,
11929 *mut clusterManagerNode,
11930 libc::c_int,
11931 ) -> libc::c_int,
11932 ),
11933 );
11934 return success;
11935}
11936unsafe extern "C" fn clusterManagerCompareKeysValues(
11937 mut n1: *mut clusterManagerNode,
11938 mut n2: *mut clusterManagerNode,
11939 mut keys_reply: *mut redisReply,
11940 mut diffs: *mut list,
11941) -> libc::c_int {
11942 let mut i: size_t = 0;
11943 let mut argc: size_t = ((*keys_reply).elements)
11944 .wrapping_add(2 as libc::c_int as libc::c_ulong);
11945 static mut hash_zero: *const libc::c_char = b"0000000000000000000000000000000000000000\0"
11946 as *const u8 as *const libc::c_char;
11947 let mut argv: *mut *mut libc::c_char = zcalloc(
11948 argc.wrapping_mul(core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong),
11949 ) as *mut *mut libc::c_char;
11950 let mut argv_len: *mut size_t = zcalloc(
11951 argc.wrapping_mul(core::mem::size_of::<size_t>() as libc::c_ulong),
11952 ) as *mut size_t;
11953 let ref mut fresh30 = *argv.offset(0 as libc::c_int as isize);
11954 *fresh30 = b"DEBUG\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
11955 *argv_len.offset(0 as libc::c_int as isize) = 5 as libc::c_int as size_t;
11956 let ref mut fresh31 = *argv.offset(1 as libc::c_int as isize);
11957 *fresh31 = b"DIGEST-VALUE\0" as *const u8 as *const libc::c_char
11958 as *mut libc::c_char;
11959 *argv_len.offset(1 as libc::c_int as isize) = 12 as libc::c_int as size_t;
11960 i = 0 as libc::c_int as size_t;
11961 while i < (*keys_reply).elements {
11962 let mut entry: *mut redisReply = *((*keys_reply).element).offset(i as isize);
11963 let mut idx: libc::c_int = i.wrapping_add(2 as libc::c_int as libc::c_ulong)
11964 as libc::c_int;
11965 let ref mut fresh32 = *argv.offset(idx as isize);
11966 *fresh32 = (*entry).str_0;
11967 *argv_len.offset(idx as isize) = (*entry).len;
11968 i = i.wrapping_add(1);
11969 }
11970 let mut success: libc::c_int = 0 as libc::c_int;
11971 let mut _reply1: *mut libc::c_void = 0 as *mut libc::c_void;
11972 let mut _reply2: *mut libc::c_void = 0 as *mut libc::c_void;
11973 let mut r1: *mut redisReply = 0 as *mut redisReply;
11974 let mut r2: *mut redisReply = 0 as *mut redisReply;
11975 redisAppendCommandArgv(
11976 (*n1).context,
11977 argc as libc::c_int,
11978 argv as *mut *const libc::c_char,
11979 argv_len,
11980 );
11981 success = (redisGetReply((*n1).context, &mut _reply1) == 0 as libc::c_int)
11982 as libc::c_int;
11983 if !(success == 0) {
11984 r1 = _reply1 as *mut redisReply;
11985 redisAppendCommandArgv(
11986 (*n2).context,
11987 argc as libc::c_int,
11988 argv as *mut *const libc::c_char,
11989 argv_len,
11990 );
11991 success = (redisGetReply((*n2).context, &mut _reply2) == 0 as libc::c_int)
11992 as libc::c_int;
11993 if !(success == 0) {
11994 r2 = _reply2 as *mut redisReply;
11995 success = ((*r1).type_0 != 6 as libc::c_int
11996 && (*r2).type_0 != 6 as libc::c_int) as libc::c_int;
11997 if (*r1).type_0 == 6 as libc::c_int {
11998 clusterManagerLog(
11999 3 as libc::c_int,
12000 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
12001 as *const libc::c_char,
12002 (*n1).ip,
12003 (*n1).port,
12004 (*r1).str_0,
12005 );
12006 success = 0 as libc::c_int;
12007 }
12008 if (*r2).type_0 == 6 as libc::c_int {
12009 clusterManagerLog(
12010 3 as libc::c_int,
12011 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
12012 as *const libc::c_char,
12013 (*n2).ip,
12014 (*n2).port,
12015 (*r2).str_0,
12016 );
12017 success = 0 as libc::c_int;
12018 }
12019 if !(success == 0) {
12020 if (*keys_reply).elements == (*r1).elements
12021 && (*keys_reply).elements == (*r2).elements
12022 {} else {
12023 __assert_fail(
12024 b"keys_reply->elements == r1->elements && keys_reply->elements == r2->elements\0"
12025 as *const u8 as *const libc::c_char,
12026 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
12027 4143 as libc::c_int as libc::c_uint,
12028 (*core::mem::transmute::<
12029 &[u8; 102],
12030 &[libc::c_char; 102],
12031 >(
12032 b"int clusterManagerCompareKeysValues(clusterManagerNode *, clusterManagerNode *, redisReply *, list *)\0",
12033 ))
12034 .as_ptr(),
12035 );
12036 };
12037 i = 0 as libc::c_int as size_t;
12038 while i < (*keys_reply).elements {
12039 let mut key: *mut libc::c_char = (**((*keys_reply).element)
12040 .offset(i as isize))
12041 .str_0;
12042 let mut hash1: *mut libc::c_char = (**((*r1).element)
12043 .offset(i as isize))
12044 .str_0;
12045 let mut hash2: *mut libc::c_char = (**((*r2).element)
12046 .offset(i as isize))
12047 .str_0;
12048 if !(strcmp(hash1, hash_zero) == 0 as libc::c_int
12049 || strcmp(hash2, hash_zero) == 0 as libc::c_int)
12050 {
12051 if strcmp(hash1, hash2) != 0 as libc::c_int {
12052 listAddNodeTail(diffs, key as *mut libc::c_void);
12053 }
12054 }
12055 i = i.wrapping_add(1);
12056 }
12057 }
12058 }
12059 }
12060 if !r1.is_null() {
12061 freeReplyObject(r1 as *mut libc::c_void);
12062 }
12063 if !r2.is_null() {
12064 freeReplyObject(r2 as *mut libc::c_void);
12065 }
12066 zfree(argv as *mut libc::c_void);
12067 zfree(argv_len as *mut libc::c_void);
12068 return success;
12069}
12070unsafe extern "C" fn clusterManagerMigrateKeysInReply(
12071 mut source: *mut clusterManagerNode,
12072 mut target: *mut clusterManagerNode,
12073 mut reply: *mut redisReply,
12074 mut replace: libc::c_int,
12075 mut timeout: libc::c_int,
12076 mut dots: *mut libc::c_char,
12077) -> *mut redisReply {
12078 let mut migrate_reply: *mut redisReply = 0 as *mut redisReply;
12079 let mut argv: *mut *mut libc::c_char = 0 as *mut *mut libc::c_char;
12080 let mut argv_len: *mut size_t = 0 as *mut size_t;
12081 let mut c: libc::c_int = if replace != 0 {
12082 8 as libc::c_int
12083 } else {
12084 7 as libc::c_int
12085 };
12086 if !(config.conn_info.auth).is_null() {
12087 c += 2 as libc::c_int;
12088 }
12089 if !(config.conn_info.user).is_null() {
12090 c += 1 as libc::c_int;
12091 }
12092 let mut argc: size_t = (c as libc::c_ulong).wrapping_add((*reply).elements);
12093 let mut i: size_t = 0;
12094 let mut offset: size_t = 6 as libc::c_int as size_t;
12095 argv = zcalloc(
12096 argc.wrapping_mul(core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong),
12097 ) as *mut *mut libc::c_char;
12098 argv_len = zcalloc(
12099 argc.wrapping_mul(core::mem::size_of::<size_t>() as libc::c_ulong),
12100 ) as *mut size_t;
12101 let mut portstr: [libc::c_char; 255] = [0; 255];
12102 let mut timeoutstr: [libc::c_char; 255] = [0; 255];
12103 snprintf(
12104 portstr.as_mut_ptr(),
12105 10 as libc::c_int as libc::c_ulong,
12106 b"%d\0" as *const u8 as *const libc::c_char,
12107 (*target).port,
12108 );
12109 snprintf(
12110 timeoutstr.as_mut_ptr(),
12111 10 as libc::c_int as libc::c_ulong,
12112 b"%d\0" as *const u8 as *const libc::c_char,
12113 timeout,
12114 );
12115 let ref mut fresh33 = *argv.offset(0 as libc::c_int as isize);
12116 *fresh33 = b"MIGRATE\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
12117 *argv_len.offset(0 as libc::c_int as isize) = 7 as libc::c_int as size_t;
12118 let ref mut fresh34 = *argv.offset(1 as libc::c_int as isize);
12119 *fresh34 = (*target).ip;
12120 *argv_len.offset(1 as libc::c_int as isize) = strlen((*target).ip);
12121 let ref mut fresh35 = *argv.offset(2 as libc::c_int as isize);
12122 *fresh35 = portstr.as_mut_ptr();
12123 *argv_len.offset(2 as libc::c_int as isize) = strlen(portstr.as_mut_ptr());
12124 let ref mut fresh36 = *argv.offset(3 as libc::c_int as isize);
12125 *fresh36 = b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
12126 *argv_len.offset(3 as libc::c_int as isize) = 0 as libc::c_int as size_t;
12127 let ref mut fresh37 = *argv.offset(4 as libc::c_int as isize);
12128 *fresh37 = b"0\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
12129 *argv_len.offset(4 as libc::c_int as isize) = 1 as libc::c_int as size_t;
12130 let ref mut fresh38 = *argv.offset(5 as libc::c_int as isize);
12131 *fresh38 = timeoutstr.as_mut_ptr();
12132 *argv_len.offset(5 as libc::c_int as isize) = strlen(timeoutstr.as_mut_ptr());
12133 if replace != 0 {
12134 let ref mut fresh39 = *argv.offset(offset as isize);
12135 *fresh39 = b"REPLACE\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
12136 *argv_len.offset(offset as isize) = 7 as libc::c_int as size_t;
12137 offset = offset.wrapping_add(1);
12138 }
12139 if !(config.conn_info.auth).is_null() {
12140 if !(config.conn_info.user).is_null() {
12141 let ref mut fresh40 = *argv.offset(offset as isize);
12142 *fresh40 = b"AUTH2\0" as *const u8 as *const libc::c_char
12143 as *mut libc::c_char;
12144 *argv_len.offset(offset as isize) = 5 as libc::c_int as size_t;
12145 offset = offset.wrapping_add(1);
12146 let ref mut fresh41 = *argv.offset(offset as isize);
12147 *fresh41 = config.conn_info.user;
12148 *argv_len.offset(offset as isize) = strlen(config.conn_info.user);
12149 offset = offset.wrapping_add(1);
12150 let ref mut fresh42 = *argv.offset(offset as isize);
12151 *fresh42 = config.conn_info.auth;
12152 *argv_len.offset(offset as isize) = strlen(config.conn_info.auth);
12153 offset = offset.wrapping_add(1);
12154 } else {
12155 let ref mut fresh43 = *argv.offset(offset as isize);
12156 *fresh43 = b"AUTH\0" as *const u8 as *const libc::c_char
12157 as *mut libc::c_char;
12158 *argv_len.offset(offset as isize) = 4 as libc::c_int as size_t;
12159 offset = offset.wrapping_add(1);
12160 let ref mut fresh44 = *argv.offset(offset as isize);
12161 *fresh44 = config.conn_info.auth;
12162 *argv_len.offset(offset as isize) = strlen(config.conn_info.auth);
12163 offset = offset.wrapping_add(1);
12164 }
12165 }
12166 let ref mut fresh45 = *argv.offset(offset as isize);
12167 *fresh45 = b"KEYS\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
12168 *argv_len.offset(offset as isize) = 4 as libc::c_int as size_t;
12169 offset = offset.wrapping_add(1);
12170 i = 0 as libc::c_int as size_t;
12171 while i < (*reply).elements {
12172 let mut entry: *mut redisReply = *((*reply).element).offset(i as isize);
12173 let mut idx: size_t = i.wrapping_add(offset);
12174 if (*entry).type_0 == 1 as libc::c_int {} else {
12175 __assert_fail(
12176 b"entry->type == REDIS_REPLY_STRING\0" as *const u8
12177 as *const libc::c_char,
12178 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
12179 4227 as libc::c_int as libc::c_uint,
12180 (*core::mem::transmute::<
12181 &[u8; 121],
12182 &[libc::c_char; 121],
12183 >(
12184 b"redisReply *clusterManagerMigrateKeysInReply(clusterManagerNode *, clusterManagerNode *, redisReply *, int, int, char *)\0",
12185 ))
12186 .as_ptr(),
12187 );
12188 };
12189 let ref mut fresh46 = *argv.offset(idx as isize);
12190 *fresh46 = hi_sdsnewlen((*entry).str_0 as *const libc::c_void, (*entry).len);
12191 *argv_len.offset(idx as isize) = (*entry).len;
12192 if !dots.is_null() {
12193 *dots.offset(i as isize) = '.' as i32 as libc::c_char;
12194 }
12195 i = i.wrapping_add(1);
12196 }
12197 if !dots.is_null() {
12198 *dots.offset((*reply).elements as isize) = '\0' as i32 as libc::c_char;
12199 }
12200 let mut _reply: *mut libc::c_void = 0 as *mut libc::c_void;
12201 redisAppendCommandArgv(
12202 (*source).context,
12203 argc as libc::c_int,
12204 argv as *mut *const libc::c_char,
12205 argv_len,
12206 );
12207 let mut success: libc::c_int = (redisGetReply((*source).context, &mut _reply)
12208 == 0 as libc::c_int) as libc::c_int;
12209 i = 0 as libc::c_int as size_t;
12210 while i < (*reply).elements {
12211 hi_sdsfree(*argv.offset(i.wrapping_add(offset) as isize));
12212 i = i.wrapping_add(1);
12213 }
12214 if !(success == 0) {
12215 migrate_reply = _reply as *mut redisReply;
12216 }
12217 zfree(argv as *mut libc::c_void);
12218 zfree(argv_len as *mut libc::c_void);
12219 return migrate_reply;
12220}
12221unsafe extern "C" fn clusterManagerMigrateKeysInSlot(
12222 mut source: *mut clusterManagerNode,
12223 mut target: *mut clusterManagerNode,
12224 mut slot: libc::c_int,
12225 mut timeout: libc::c_int,
12226 mut pipeline: libc::c_int,
12227 mut verbose: libc::c_int,
12228 mut err: *mut *mut libc::c_char,
12229) -> libc::c_int {
12230 let mut count: size_t = 0;
12231 let mut current_block: u64;
12232 let mut success: libc::c_int = 1 as libc::c_int;
12233 let mut do_fix: libc::c_int = config.cluster_manager_command.flags
12234 & (1 as libc::c_int) << 0 as libc::c_int;
12235 let mut do_replace: libc::c_int = config.cluster_manager_command.flags
12236 & (1 as libc::c_int) << 6 as libc::c_int;
12237 loop {
12238 let mut dots: *mut libc::c_char = 0 as *mut libc::c_char;
12239 let mut reply: *mut redisReply = 0 as *mut redisReply;
12240 let mut migrate_reply: *mut redisReply = 0 as *mut redisReply;
12241 reply = redisCommand(
12242 (*source).context,
12243 b"CLUSTER GETKEYSINSLOT %d %d\0" as *const u8 as *const libc::c_char,
12244 slot,
12245 pipeline,
12246 ) as *mut redisReply;
12247 success = (reply != 0 as *mut libc::c_void as *mut redisReply) as libc::c_int;
12248 if success == 0 {
12249 return 0 as libc::c_int;
12250 }
12251 if (*reply).type_0 == 6 as libc::c_int {
12252 success = 0 as libc::c_int;
12253 if !err.is_null() {
12254 *err = zmalloc(
12255 ((*reply).len)
12256 .wrapping_add(1 as libc::c_int as libc::c_ulong)
12257 .wrapping_mul(
12258 core::mem::size_of::<libc::c_char>() as libc::c_ulong,
12259 ),
12260 ) as *mut libc::c_char;
12261 strcpy(*err, (*reply).str_0);
12262 clusterManagerLog(
12263 3 as libc::c_int,
12264 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
12265 as *const libc::c_char,
12266 (*source).ip,
12267 (*source).port,
12268 *err,
12269 );
12270 }
12271 } else {
12272 if (*reply).type_0 == 2 as libc::c_int {} else {
12273 __assert_fail(
12274 b"reply->type == REDIS_REPLY_ARRAY\0" as *const u8
12275 as *const libc::c_char,
12276 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
12277 4275 as libc::c_int as libc::c_uint,
12278 (*core::mem::transmute::<
12279 &[u8; 109],
12280 &[libc::c_char; 109],
12281 >(
12282 b"int clusterManagerMigrateKeysInSlot(clusterManagerNode *, clusterManagerNode *, int, int, int, int, char **)\0",
12283 ))
12284 .as_ptr(),
12285 );
12286 };
12287 count = (*reply).elements;
12288 if count == 0 as libc::c_int as libc::c_ulong {
12289 freeReplyObject(reply as *mut libc::c_void);
12290 break;
12291 } else {
12292 if verbose != 0 {
12293 dots = zmalloc(
12294 count
12295 .wrapping_add(1 as libc::c_int as libc::c_ulong)
12296 .wrapping_mul(
12297 core::mem::size_of::<libc::c_char>() as libc::c_ulong,
12298 ),
12299 ) as *mut libc::c_char;
12300 }
12301 migrate_reply = clusterManagerMigrateKeysInReply(
12302 source,
12303 target,
12304 reply,
12305 0 as libc::c_int,
12306 timeout,
12307 dots,
12308 );
12309 if !migrate_reply.is_null() {
12310 if (*migrate_reply).type_0 == 6 as libc::c_int {
12311 let mut is_busy: libc::c_int = (strstr(
12312 (*migrate_reply).str_0,
12313 b"BUSYKEY\0" as *const u8 as *const libc::c_char,
12314 ) != 0 as *mut libc::c_void as *mut libc::c_char) as libc::c_int;
12315 let mut not_served: libc::c_int = 0 as libc::c_int;
12316 if is_busy == 0 {
12317 let mut get_owner_err: *mut libc::c_char = 0
12318 as *mut libc::c_char;
12319 let mut served_by: *mut clusterManagerNode = clusterManagerGetSlotOwner(
12320 source,
12321 slot,
12322 &mut get_owner_err,
12323 );
12324 if served_by.is_null() {
12325 if get_owner_err.is_null() {
12326 not_served = 1 as libc::c_int;
12327 } else {
12328 clusterManagerLog(
12329 3 as libc::c_int,
12330 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
12331 as *const libc::c_char,
12332 (*source).ip,
12333 (*source).port,
12334 get_owner_err,
12335 );
12336 zfree(get_owner_err as *mut libc::c_void);
12337 }
12338 }
12339 }
12340 if is_busy != 0 || not_served != 0 {
12341 if do_fix != 0 && not_served != 0 {
12342 clusterManagerLog(
12343 2 as libc::c_int,
12344 b"*** Slot was not served, setting owner to node %s:%d.\n\0"
12345 as *const u8 as *const libc::c_char,
12346 (*target).ip,
12347 (*target).port,
12348 );
12349 clusterManagerSetSlot(
12350 source,
12351 target,
12352 slot,
12353 b"node\0" as *const u8 as *const libc::c_char,
12354 0 as *mut *mut libc::c_char,
12355 );
12356 }
12357 if is_busy != 0 {
12358 clusterManagerLog(
12359 2 as libc::c_int,
12360 b"\n*** Target key exists\n\0" as *const u8
12361 as *const libc::c_char,
12362 );
12363 if do_replace == 0 {
12364 clusterManagerLog(
12365 2 as libc::c_int,
12366 b"*** Checking key values on both nodes...\n\0" as *const u8
12367 as *const libc::c_char,
12368 );
12369 let mut diffs: *mut list = listCreate();
12370 success = clusterManagerCompareKeysValues(
12371 source,
12372 target,
12373 reply,
12374 diffs,
12375 );
12376 if success == 0 {
12377 clusterManagerLog(
12378 3 as libc::c_int,
12379 b"*** Value check failed!\n\0" as *const u8
12380 as *const libc::c_char,
12381 );
12382 listRelease(diffs);
12383 current_block = 7487061004554222981;
12384 } else if (*diffs).len > 0 as libc::c_int as libc::c_ulong {
12385 success = 0 as libc::c_int;
12386 clusterManagerLog(
12387 3 as libc::c_int,
12388 b"*** Found %d key(s) in both source node and target node having different values.\n Source node: %s:%d\n Target node: %s:%d\n Keys(s):\n\0"
12389 as *const u8 as *const libc::c_char,
12390 (*diffs).len,
12391 (*source).ip,
12392 (*source).port,
12393 (*target).ip,
12394 (*target).port,
12395 );
12396 let mut dli: listIter = listIter {
12397 next: 0 as *mut listNode,
12398 direction: 0,
12399 };
12400 let mut dln: *mut listNode = 0 as *mut listNode;
12401 listRewind(diffs, &mut dli);
12402 loop {
12403 dln = listNext(&mut dli);
12404 if dln.is_null() {
12405 break;
12406 }
12407 let mut k: *mut libc::c_char = (*dln).value
12408 as *mut libc::c_char;
12409 clusterManagerLog(
12410 3 as libc::c_int,
12411 b" - %s\n\0" as *const u8 as *const libc::c_char,
12412 k,
12413 );
12414 }
12415 clusterManagerLog(
12416 3 as libc::c_int,
12417 b"Please fix the above key(s) manually and try again or relaunch the command \nwith --cluster-replace option to force key overriding.\n\0"
12418 as *const u8 as *const libc::c_char,
12419 );
12420 listRelease(diffs);
12421 current_block = 7487061004554222981;
12422 } else {
12423 listRelease(diffs);
12424 current_block = 10399321362245223758;
12425 }
12426 } else {
12427 current_block = 10399321362245223758;
12428 }
12429 match current_block {
12430 7487061004554222981 => {}
12431 _ => {
12432 clusterManagerLog(
12433 2 as libc::c_int,
12434 b"*** Replacing target keys...\n\0" as *const u8
12435 as *const libc::c_char,
12436 );
12437 current_block = 1924505913685386279;
12438 }
12439 }
12440 } else {
12441 current_block = 1924505913685386279;
12442 }
12443 match current_block {
12444 7487061004554222981 => {}
12445 _ => {
12446 freeReplyObject(migrate_reply as *mut libc::c_void);
12447 migrate_reply = clusterManagerMigrateKeysInReply(
12448 source,
12449 target,
12450 reply,
12451 is_busy,
12452 timeout,
12453 0 as *mut libc::c_char,
12454 );
12455 success = (!migrate_reply.is_null()
12456 && (*migrate_reply).type_0 != 6 as libc::c_int)
12457 as libc::c_int;
12458 current_block = 11777552016271000781;
12459 }
12460 }
12461 } else {
12462 success = 0 as libc::c_int;
12463 current_block = 11777552016271000781;
12464 }
12465 match current_block {
12466 7487061004554222981 => {}
12467 _ => {
12468 if success == 0 {
12469 if !migrate_reply.is_null() {
12470 if !err.is_null() {
12471 *err = zmalloc(
12472 ((*migrate_reply).len)
12473 .wrapping_add(1 as libc::c_int as libc::c_ulong)
12474 .wrapping_mul(
12475 core::mem::size_of::<libc::c_char>() as libc::c_ulong,
12476 ),
12477 ) as *mut libc::c_char;
12478 strcpy(*err, (*migrate_reply).str_0);
12479 }
12480 printf(b"\n\0" as *const u8 as *const libc::c_char);
12481 clusterManagerLog(
12482 3 as libc::c_int,
12483 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
12484 as *const libc::c_char,
12485 (*source).ip,
12486 (*source).port,
12487 (*migrate_reply).str_0,
12488 );
12489 }
12490 current_block = 7487061004554222981;
12491 } else {
12492 current_block = 17836213544692497527;
12493 }
12494 }
12495 }
12496 } else {
12497 current_block = 17836213544692497527;
12498 }
12499 match current_block {
12500 7487061004554222981 => {}
12501 _ => {
12502 if verbose != 0 {
12503 printf(b"%s\0" as *const u8 as *const libc::c_char, dots);
12504 fflush(stdout);
12505 }
12506 }
12507 }
12508 }
12509 }
12510 }
12511 if !reply.is_null() {
12512 freeReplyObject(reply as *mut libc::c_void);
12513 }
12514 if !migrate_reply.is_null() {
12515 freeReplyObject(migrate_reply as *mut libc::c_void);
12516 }
12517 if !dots.is_null() {
12518 zfree(dots as *mut libc::c_void);
12519 }
12520 if success == 0 {
12521 break;
12522 }
12523 }
12524 return success;
12525}
12526unsafe extern "C" fn clusterManagerMoveSlot(
12527 mut source: *mut clusterManagerNode,
12528 mut target: *mut clusterManagerNode,
12529 mut slot: libc::c_int,
12530 mut opts: libc::c_int,
12531 mut err: *mut *mut libc::c_char,
12532) -> libc::c_int {
12533 if opts & (1 as libc::c_int) << 6 as libc::c_int == 0 {
12534 printf(
12535 b"Moving slot %d from %s:%d to %s:%d: \0" as *const u8
12536 as *const libc::c_char,
12537 slot,
12538 (*source).ip,
12539 (*source).port,
12540 (*target).ip,
12541 (*target).port,
12542 );
12543 fflush(stdout);
12544 }
12545 if !err.is_null() {
12546 *err = 0 as *mut libc::c_char;
12547 }
12548 let mut pipeline: libc::c_int = config.cluster_manager_command.pipeline;
12549 let mut timeout: libc::c_int = config.cluster_manager_command.timeout;
12550 let mut print_dots: libc::c_int = opts & (1 as libc::c_int) << 7 as libc::c_int;
12551 let mut option_cold: libc::c_int = opts & (1 as libc::c_int) << 1 as libc::c_int;
12552 let mut success: libc::c_int = 1 as libc::c_int;
12553 if option_cold == 0 {
12554 success = clusterManagerSetSlot(
12555 target,
12556 source,
12557 slot,
12558 b"importing\0" as *const u8 as *const libc::c_char,
12559 err,
12560 );
12561 if success == 0 {
12562 return 0 as libc::c_int;
12563 }
12564 success = clusterManagerSetSlot(
12565 source,
12566 target,
12567 slot,
12568 b"migrating\0" as *const u8 as *const libc::c_char,
12569 err,
12570 );
12571 if success == 0 {
12572 return 0 as libc::c_int;
12573 }
12574 }
12575 success = clusterManagerMigrateKeysInSlot(
12576 source,
12577 target,
12578 slot,
12579 timeout,
12580 pipeline,
12581 print_dots,
12582 err,
12583 );
12584 if opts & (1 as libc::c_int) << 6 as libc::c_int == 0 {
12585 printf(b"\n\0" as *const u8 as *const libc::c_char);
12586 }
12587 if success == 0 {
12588 return 0 as libc::c_int;
12589 }
12590 if option_cold == 0 {
12591 success = clusterManagerSetSlot(
12592 target,
12593 target,
12594 slot,
12595 b"node\0" as *const u8 as *const libc::c_char,
12596 err,
12597 );
12598 if success == 0 {
12599 return 0 as libc::c_int;
12600 }
12601 success = clusterManagerSetSlot(
12602 source,
12603 target,
12604 slot,
12605 b"node\0" as *const u8 as *const libc::c_char,
12606 err,
12607 );
12608 let mut acceptable: *const libc::c_char = b"ERR Please use SETSLOT only with masters.\0"
12609 as *const u8 as *const libc::c_char;
12610 if success == 0 && !err.is_null()
12611 && strncmp(*err, acceptable, strlen(acceptable)) == 0
12612 {
12613 zfree(*err as *mut libc::c_void);
12614 *err = 0 as *mut libc::c_char;
12615 } else if success == 0 && !err.is_null() {
12616 return 0 as libc::c_int
12617 }
12618 let mut li: listIter = listIter {
12619 next: 0 as *mut listNode,
12620 direction: 0,
12621 };
12622 let mut ln: *mut listNode = 0 as *mut listNode;
12623 listRewind(cluster_manager.nodes, &mut li);
12624 loop {
12625 ln = listNext(&mut li);
12626 if ln.is_null() {
12627 break;
12628 }
12629 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
12630 if n == target || n == source {
12631 continue;
12632 }
12633 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
12634 continue;
12635 }
12636 success = clusterManagerSetSlot(
12637 n,
12638 target,
12639 slot,
12640 b"node\0" as *const u8 as *const libc::c_char,
12641 err,
12642 );
12643 if success == 0 {
12644 return 0 as libc::c_int;
12645 }
12646 }
12647 }
12648 if opts & (1 as libc::c_int) << 2 as libc::c_int != 0 {
12649 (*source).slots[slot as usize] = 0 as libc::c_int as uint8_t;
12650 (*target).slots[slot as usize] = 1 as libc::c_int as uint8_t;
12651 }
12652 return 1 as libc::c_int;
12653}
12654unsafe extern "C" fn clusterManagerFlushNodeConfig(
12655 mut node: *mut clusterManagerNode,
12656 mut err: *mut *mut libc::c_char,
12657) -> libc::c_int {
12658 let mut current_block: u64;
12659 if (*node).dirty == 0 {
12660 return 0 as libc::c_int;
12661 }
12662 let mut reply: *mut redisReply = 0 as *mut redisReply;
12663 let mut is_err: libc::c_int = 0 as libc::c_int;
12664 let mut success: libc::c_int = 1 as libc::c_int;
12665 if !err.is_null() {
12666 *err = 0 as *mut libc::c_char;
12667 }
12668 if !((*node).replicate).is_null() {
12669 reply = redisCommand(
12670 (*node).context,
12671 b"CLUSTER REPLICATE %s\0" as *const u8 as *const libc::c_char,
12672 (*node).replicate,
12673 ) as *mut redisReply;
12674 if reply.is_null()
12675 || {
12676 is_err = ((*reply).type_0 == 6 as libc::c_int) as libc::c_int;
12677 is_err != 0
12678 }
12679 {
12680 if is_err != 0 && !err.is_null() {
12681 *err = zmalloc(
12682 ((*reply).len)
12683 .wrapping_add(1 as libc::c_int as libc::c_ulong)
12684 .wrapping_mul(
12685 core::mem::size_of::<libc::c_char>() as libc::c_ulong,
12686 ),
12687 ) as *mut libc::c_char;
12688 strcpy(*err, (*reply).str_0);
12689 }
12690 success = 0 as libc::c_int;
12691 current_block = 2913733023007058749;
12692 } else {
12693 current_block = 10599921512955367680;
12694 }
12695 } else {
12696 let mut added: libc::c_int = clusterManagerAddSlots(node, err);
12697 if added == 0 || !(*err).is_null() {
12698 success = 0 as libc::c_int;
12699 }
12700 current_block = 10599921512955367680;
12701 }
12702 match current_block {
12703 10599921512955367680 => {
12704 (*node).dirty = 0 as libc::c_int;
12705 }
12706 _ => {}
12707 }
12708 if !reply.is_null() {
12709 freeReplyObject(reply as *mut libc::c_void);
12710 }
12711 return success;
12712}
12713unsafe extern "C" fn clusterManagerWaitForClusterJoin() {
12714 printf(b"Waiting for the cluster to join\n\0" as *const u8 as *const libc::c_char);
12715 let mut counter: libc::c_int = 0 as libc::c_int;
12716 let mut check_after: libc::c_int = 20 as libc::c_int
12717 + ((*cluster_manager.nodes).len as libc::c_float * 0.15f32) as libc::c_int;
12718 while clusterManagerIsConfigConsistent() == 0 {
12719 printf(b".\0" as *const u8 as *const libc::c_char);
12720 fflush(stdout);
12721 sleep(1 as libc::c_int as libc::c_uint);
12722 counter += 1;
12723 if counter > check_after {
12724 let mut status: *mut dict = clusterManagerGetLinkStatus();
12725 let mut iter: *mut dictIterator = 0 as *mut dictIterator;
12726 if !status.is_null()
12727 && ((*status).ht_used[0 as libc::c_int as usize])
12728 .wrapping_add((*status).ht_used[1 as libc::c_int as usize])
12729 > 0 as libc::c_int as libc::c_ulong
12730 {
12731 printf(b"\n\0" as *const u8 as *const libc::c_char);
12732 clusterManagerLog(
12733 3 as libc::c_int,
12734 b"Warning: %d node(s) may be unreachable\n\0" as *const u8
12735 as *const libc::c_char,
12736 ((*status).ht_used[0 as libc::c_int as usize])
12737 .wrapping_add((*status).ht_used[1 as libc::c_int as usize]),
12738 );
12739 iter = dictGetIterator(status);
12740 let mut entry: *mut dictEntry = 0 as *mut dictEntry;
12741 loop {
12742 entry = dictNext(iter);
12743 if entry.is_null() {
12744 break;
12745 }
12746 let mut nodeaddr: hisds = (*entry).key as hisds;
12747 let mut node_ip: *mut libc::c_char = 0 as *mut libc::c_char;
12748 let mut node_port: libc::c_int = 0 as libc::c_int;
12749 let mut node_bus_port: libc::c_int = 0 as libc::c_int;
12750 let mut from: *mut list = (*entry).v.val as *mut list;
12751 if parseClusterNodeAddress(
12752 nodeaddr,
12753 &mut node_ip,
12754 &mut node_port,
12755 &mut node_bus_port,
12756 ) != 0 && node_bus_port != 0
12757 {
12758 clusterManagerLog(
12759 3 as libc::c_int,
12760 b" - The port %d of node %s may be unreachable from:\n\0"
12761 as *const u8 as *const libc::c_char,
12762 node_bus_port,
12763 node_ip,
12764 );
12765 } else {
12766 clusterManagerLog(
12767 3 as libc::c_int,
12768 b" - Node %s may be unreachable from:\n\0" as *const u8
12769 as *const libc::c_char,
12770 nodeaddr,
12771 );
12772 }
12773 let mut li: listIter = listIter {
12774 next: 0 as *mut listNode,
12775 direction: 0,
12776 };
12777 let mut ln: *mut listNode = 0 as *mut listNode;
12778 listRewind(from, &mut li);
12779 loop {
12780 ln = listNext(&mut li);
12781 if ln.is_null() {
12782 break;
12783 }
12784 let mut from_addr: hisds = (*ln).value as hisds;
12785 clusterManagerLog(
12786 3 as libc::c_int,
12787 b" %s\n\0" as *const u8 as *const libc::c_char,
12788 from_addr,
12789 );
12790 hi_sdsfree(from_addr);
12791 }
12792 clusterManagerLog(
12793 3 as libc::c_int,
12794 b"Cluster bus ports must be reachable by every node.\nRemember that cluster bus ports are different from standard instance ports.\n\0"
12795 as *const u8 as *const libc::c_char,
12796 );
12797 listEmpty(from);
12798 }
12799 }
12800 if !iter.is_null() {
12801 dictReleaseIterator(iter);
12802 }
12803 if !status.is_null() {
12804 dictRelease(status);
12805 }
12806 counter = 0 as libc::c_int;
12807 }
12808 }
12809 printf(b"\n\0" as *const u8 as *const libc::c_char);
12810}
12811unsafe extern "C" fn clusterManagerNodeLoadInfo(
12812 mut node: *mut clusterManagerNode,
12813 mut opts: libc::c_int,
12814 mut err: *mut *mut libc::c_char,
12815) -> libc::c_int {
12816 let mut getfriends: libc::c_int = 0;
12817 let mut lines: *mut libc::c_char = 0 as *mut libc::c_char;
12818 let mut p: *mut libc::c_char = 0 as *mut libc::c_char;
12819 let mut line: *mut libc::c_char = 0 as *mut libc::c_char;
12820 let mut reply: *mut redisReply = redisCommand(
12821 (*node).context,
12822 b"CLUSTER NODES\0" as *const u8 as *const libc::c_char,
12823 ) as *mut redisReply;
12824 let mut success: libc::c_int = 1 as libc::c_int;
12825 *err = 0 as *mut libc::c_char;
12826 if clusterManagerCheckRedisReply(node, reply, err) == 0 {
12827 success = 0 as libc::c_int;
12828 } else {
12829 getfriends = opts & (1 as libc::c_int) << 0 as libc::c_int;
12830 lines = (*reply).str_0;
12831 p = 0 as *mut libc::c_char;
12832 line = 0 as *mut libc::c_char;
12833 loop {
12834 p = strstr(lines, b"\n\0" as *const u8 as *const libc::c_char);
12835 if p.is_null() {
12836 break;
12837 }
12838 *p = '\0' as i32 as libc::c_char;
12839 line = lines;
12840 lines = p.offset(1 as libc::c_int as isize);
12841 let mut name: *mut libc::c_char = 0 as *mut libc::c_char;
12842 let mut addr: *mut libc::c_char = 0 as *mut libc::c_char;
12843 let mut flags: *mut libc::c_char = 0 as *mut libc::c_char;
12844 let mut master_id: *mut libc::c_char = 0 as *mut libc::c_char;
12845 let mut ping_sent: *mut libc::c_char = 0 as *mut libc::c_char;
12846 let mut ping_recv: *mut libc::c_char = 0 as *mut libc::c_char;
12847 let mut config_epoch: *mut libc::c_char = 0 as *mut libc::c_char;
12848 let mut link_status: *mut libc::c_char = 0 as *mut libc::c_char;
12849 let mut i: libc::c_int = 0 as libc::c_int;
12850 loop {
12851 p = strchr(line, ' ' as i32);
12852 if p.is_null() {
12853 break;
12854 }
12855 *p = '\0' as i32 as libc::c_char;
12856 let mut token: *mut libc::c_char = line;
12857 line = p.offset(1 as libc::c_int as isize);
12858 let fresh47 = i;
12859 i = i + 1;
12860 match fresh47 {
12861 0 => {
12862 name = token;
12863 }
12864 1 => {
12865 addr = token;
12866 }
12867 2 => {
12868 flags = token;
12869 }
12870 3 => {
12871 master_id = token;
12872 }
12873 4 => {
12874 ping_sent = token;
12875 }
12876 5 => {
12877 ping_recv = token;
12878 }
12879 6 => {
12880 config_epoch = token;
12881 }
12882 7 => {
12883 link_status = token;
12884 }
12885 _ => {}
12886 }
12887 if i == 8 as libc::c_int {
12888 break;
12889 }
12890 }
12891 if flags.is_null() {
12892 success = 0 as libc::c_int;
12893 break;
12894 } else {
12895 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
12896 let mut port: libc::c_int = 0 as libc::c_int;
12897 let mut bus_port: libc::c_int = 0 as libc::c_int;
12898 if addr.is_null()
12899 || parseClusterNodeAddress(addr, &mut ip, &mut port, &mut bus_port)
12900 == 0
12901 {
12902 fprintf(
12903 stderr,
12904 b"Error: invalid CLUSTER NODES reply\n\0" as *const u8
12905 as *const libc::c_char,
12906 );
12907 success = 0 as libc::c_int;
12908 break;
12909 } else {
12910 let mut myself: libc::c_int = (strstr(
12911 flags,
12912 b"myself\0" as *const u8 as *const libc::c_char,
12913 ) != 0 as *mut libc::c_void as *mut libc::c_char) as libc::c_int;
12914 let mut currentNode: *mut clusterManagerNode = 0
12915 as *mut clusterManagerNode;
12916 if myself != 0 {
12917 (*node).bus_port = bus_port;
12918 (*node).flags |= (1 as libc::c_int) << 0 as libc::c_int;
12919 currentNode = node;
12920 clusterManagerNodeResetSlots(node);
12921 if i == 8 as libc::c_int {
12922 let mut remaining: libc::c_int = strlen(line) as libc::c_int;
12923 while remaining > 0 as libc::c_int {
12924 p = strchr(line, ' ' as i32);
12925 if p.is_null() {
12926 p = line.offset(remaining as isize);
12927 }
12928 remaining = (remaining as libc::c_long
12929 - p.offset_from(line) as libc::c_long) as libc::c_int;
12930 let mut slotsdef: *mut libc::c_char = line;
12931 *p = '\0' as i32 as libc::c_char;
12932 if remaining != 0 {
12933 line = p.offset(1 as libc::c_int as isize);
12934 remaining -= 1;
12935 } else {
12936 line = p;
12937 }
12938 let mut dash: *mut libc::c_char = 0 as *mut libc::c_char;
12939 if *slotsdef.offset(0 as libc::c_int as isize)
12940 as libc::c_int == '[' as i32
12941 {
12942 slotsdef = slotsdef.offset(1);
12943 p = strstr(
12944 slotsdef,
12945 b"->-\0" as *const u8 as *const libc::c_char,
12946 );
12947 if !p.is_null() {
12948 *p = '\0' as i32 as libc::c_char;
12949 p = p.offset(3 as libc::c_int as isize);
12950 let mut closing_bracket: *mut libc::c_char = strchr(
12951 p,
12952 ']' as i32,
12953 );
12954 if !closing_bracket.is_null() {
12955 *closing_bracket = '\0' as i32 as libc::c_char;
12956 }
12957 let mut slot: hisds = hi_sdsnew(slotsdef);
12958 let mut dst: hisds = hi_sdsnew(p);
12959 (*node).migrating_count += 2 as libc::c_int;
12960 (*node)
12961 .migrating = zrealloc(
12962 (*node).migrating as *mut libc::c_void,
12963 ((*node).migrating_count as libc::c_ulong)
12964 .wrapping_mul(
12965 core::mem::size_of::<hisds>() as libc::c_ulong,
12966 ),
12967 ) as *mut hisds;
12968 let ref mut fresh48 = *((*node).migrating)
12969 .offset(
12970 ((*node).migrating_count - 2 as libc::c_int) as isize,
12971 );
12972 *fresh48 = slot;
12973 let ref mut fresh49 = *((*node).migrating)
12974 .offset(
12975 ((*node).migrating_count - 1 as libc::c_int) as isize,
12976 );
12977 *fresh49 = dst;
12978 } else {
12979 p = strstr(
12980 slotsdef,
12981 b"-<-\0" as *const u8 as *const libc::c_char,
12982 );
12983 if !p.is_null() {
12984 *p = '\0' as i32 as libc::c_char;
12985 p = p.offset(3 as libc::c_int as isize);
12986 let mut closing_bracket_0: *mut libc::c_char = strchr(
12987 p,
12988 ']' as i32,
12989 );
12990 if !closing_bracket_0.is_null() {
12991 *closing_bracket_0 = '\0' as i32 as libc::c_char;
12992 }
12993 let mut slot_0: hisds = hi_sdsnew(slotsdef);
12994 let mut src: hisds = hi_sdsnew(p);
12995 (*node).importing_count += 2 as libc::c_int;
12996 (*node)
12997 .importing = zrealloc(
12998 (*node).importing as *mut libc::c_void,
12999 ((*node).importing_count as libc::c_ulong)
13000 .wrapping_mul(
13001 core::mem::size_of::<hisds>() as libc::c_ulong,
13002 ),
13003 ) as *mut hisds;
13004 let ref mut fresh50 = *((*node).importing)
13005 .offset(
13006 ((*node).importing_count - 2 as libc::c_int) as isize,
13007 );
13008 *fresh50 = slot_0;
13009 let ref mut fresh51 = *((*node).importing)
13010 .offset(
13011 ((*node).importing_count - 1 as libc::c_int) as isize,
13012 );
13013 *fresh51 = src;
13014 }
13015 }
13016 } else {
13017 dash = strchr(slotsdef, '-' as i32);
13018 if !dash.is_null() {
13019 p = dash;
13020 let mut start: libc::c_int = 0;
13021 let mut stop: libc::c_int = 0;
13022 *p = '\0' as i32 as libc::c_char;
13023 start = atoi(slotsdef);
13024 stop = atoi(p.offset(1 as libc::c_int as isize));
13025 (*node).slots_count += stop - (start - 1 as libc::c_int);
13026 while start <= stop {
13027 let fresh52 = start;
13028 start = start + 1;
13029 (*node)
13030 .slots[fresh52 as usize] = 1 as libc::c_int as uint8_t;
13031 }
13032 } else if p > slotsdef {
13033 (*node)
13034 .slots[atoi(slotsdef)
13035 as usize] = 1 as libc::c_int as uint8_t;
13036 (*node).slots_count += 1;
13037 }
13038 }
13039 }
13040 }
13041 (*node).dirty = 0 as libc::c_int;
13042 } else if getfriends == 0 {
13043 if (*node).flags & (1 as libc::c_int) << 0 as libc::c_int == 0 {
13044 continue;
13045 } else {
13046 break;
13047 }
13048 } else {
13049 currentNode = clusterManagerNewNode(
13050 hi_sdsnew(ip),
13051 port,
13052 bus_port,
13053 );
13054 (*currentNode).flags |= (1 as libc::c_int) << 2 as libc::c_int;
13055 if ((*node).friends).is_null() {
13056 (*node).friends = listCreate();
13057 }
13058 listAddNodeTail(
13059 (*node).friends,
13060 currentNode as *mut libc::c_void,
13061 );
13062 }
13063 if !name.is_null() {
13064 if !((*currentNode).name).is_null() {
13065 hi_sdsfree((*currentNode).name);
13066 }
13067 (*currentNode).name = hi_sdsnew(name);
13068 }
13069 if !((*currentNode).flags_str).is_null() {
13070 freeClusterManagerNodeFlags((*currentNode).flags_str);
13071 }
13072 (*currentNode).flags_str = listCreate();
13073 let mut flag_len: libc::c_int = 0;
13074 loop {
13075 flag_len = strlen(flags) as libc::c_int;
13076 if !(flag_len > 0 as libc::c_int) {
13077 break;
13078 }
13079 let mut flag: hisds = 0 as hisds;
13080 let mut fp: *mut libc::c_char = strchr(flags, ',' as i32);
13081 if !fp.is_null() {
13082 *fp = '\0' as i32 as libc::c_char;
13083 flag = hi_sdsnew(flags);
13084 flags = fp.offset(1 as libc::c_int as isize);
13085 } else {
13086 flag = hi_sdsnew(flags);
13087 flags = flags.offset(flag_len as isize);
13088 }
13089 if strcmp(
13090 flag as *const libc::c_char,
13091 b"noaddr\0" as *const u8 as *const libc::c_char,
13092 ) == 0 as libc::c_int
13093 {
13094 (*currentNode).flags
13095 |= (1 as libc::c_int) << 3 as libc::c_int;
13096 } else if strcmp(
13097 flag as *const libc::c_char,
13098 b"disconnected\0" as *const u8 as *const libc::c_char,
13099 ) == 0 as libc::c_int
13100 {
13101 (*currentNode).flags
13102 |= (1 as libc::c_int) << 4 as libc::c_int;
13103 } else if strcmp(
13104 flag as *const libc::c_char,
13105 b"fail\0" as *const u8 as *const libc::c_char,
13106 ) == 0 as libc::c_int
13107 {
13108 (*currentNode).flags
13109 |= (1 as libc::c_int) << 5 as libc::c_int;
13110 } else if strcmp(
13111 flag as *const libc::c_char,
13112 b"slave\0" as *const u8 as *const libc::c_char,
13113 ) == 0 as libc::c_int
13114 {
13115 (*currentNode).flags
13116 |= (1 as libc::c_int) << 1 as libc::c_int;
13117 if !master_id.is_null() {
13118 if !((*currentNode).replicate).is_null() {
13119 hi_sdsfree((*currentNode).replicate);
13120 }
13121 (*currentNode).replicate = hi_sdsnew(master_id);
13122 }
13123 }
13124 listAddNodeTail(
13125 (*currentNode).flags_str,
13126 flag as *mut libc::c_void,
13127 );
13128 }
13129 if !config_epoch.is_null() {
13130 (*currentNode).current_epoch = atoll(config_epoch) as uint64_t;
13131 }
13132 if !ping_sent.is_null() {
13133 (*currentNode).ping_sent = atoll(ping_sent) as time_t;
13134 }
13135 if !ping_recv.is_null() {
13136 (*currentNode).ping_recv = atoll(ping_recv) as time_t;
13137 }
13138 if getfriends == 0 && myself != 0 {
13139 break;
13140 }
13141 }
13142 }
13143 }
13144 }
13145 if !reply.is_null() {
13146 freeReplyObject(reply as *mut libc::c_void);
13147 }
13148 return success;
13149}
13150unsafe extern "C" fn clusterManagerLoadInfoFromNode(
13151 mut node: *mut clusterManagerNode,
13152) -> libc::c_int {
13153 if ((*node).context).is_null() && clusterManagerNodeConnect(node) == 0 {
13154 freeClusterManagerNode(node);
13155 return 0 as libc::c_int;
13156 }
13157 let mut e: *mut libc::c_char = 0 as *mut libc::c_char;
13158 if clusterManagerNodeIsCluster(node, &mut e) == 0 {
13159 clusterManagerPrintNotClusterNodeError(node, e);
13160 if !e.is_null() {
13161 zfree(e as *mut libc::c_void);
13162 }
13163 freeClusterManagerNode(node);
13164 return 0 as libc::c_int;
13165 }
13166 e = 0 as *mut libc::c_char;
13167 if clusterManagerNodeLoadInfo(node, (1 as libc::c_int) << 0 as libc::c_int, &mut e)
13168 == 0
13169 {
13170 if !e.is_null() {
13171 clusterManagerLog(
13172 3 as libc::c_int,
13173 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
13174 as *const libc::c_char,
13175 (*node).ip,
13176 (*node).port,
13177 e,
13178 );
13179 zfree(e as *mut libc::c_void);
13180 }
13181 freeClusterManagerNode(node);
13182 return 0 as libc::c_int;
13183 }
13184 let mut li: listIter = listIter {
13185 next: 0 as *mut listNode,
13186 direction: 0,
13187 };
13188 let mut ln: *mut listNode = 0 as *mut listNode;
13189 if !(cluster_manager.nodes).is_null() {
13190 listRewind(cluster_manager.nodes, &mut li);
13191 loop {
13192 ln = listNext(&mut li);
13193 if ln.is_null() {
13194 break;
13195 }
13196 freeClusterManagerNode((*ln).value as *mut clusterManagerNode);
13197 }
13198 listRelease(cluster_manager.nodes);
13199 }
13200 cluster_manager.nodes = listCreate();
13201 listAddNodeTail(cluster_manager.nodes, node as *mut libc::c_void);
13202 if !((*node).friends).is_null() {
13203 listRewind((*node).friends, &mut li);
13204 loop {
13205 ln = listNext(&mut li);
13206 if ln.is_null() {
13207 break;
13208 }
13209 let mut friend: *mut clusterManagerNode = (*ln).value
13210 as *mut clusterManagerNode;
13211 if !(((*friend).ip).is_null() || (*friend).port == 0) {
13212 if !(((*friend).context).is_null()
13213 && clusterManagerNodeConnect(friend) == 0)
13214 {
13215 e = 0 as *mut libc::c_char;
13216 if clusterManagerNodeLoadInfo(friend, 0 as libc::c_int, &mut e) != 0
13217 {
13218 if !((*friend).flags
13219 & ((1 as libc::c_int) << 3 as libc::c_int
13220 | (1 as libc::c_int) << 4 as libc::c_int
13221 | (1 as libc::c_int) << 5 as libc::c_int) != 0)
13222 {
13223 listAddNodeTail(
13224 cluster_manager.nodes,
13225 friend as *mut libc::c_void,
13226 );
13227 continue;
13228 }
13229 } else {
13230 clusterManagerLog(
13231 3 as libc::c_int,
13232 b"[ERR] Unable to load info for node %s:%d\n\0" as *const u8
13233 as *const libc::c_char,
13234 (*friend).ip,
13235 (*friend).port,
13236 );
13237 }
13238 }
13239 }
13240 if (*friend).flags & (1 as libc::c_int) << 1 as libc::c_int == 0 {
13241 cluster_manager.unreachable_masters += 1;
13242 }
13243 freeClusterManagerNode(friend);
13244 }
13245 listRelease((*node).friends);
13246 (*node).friends = 0 as *mut list;
13247 }
13248 listRewind(cluster_manager.nodes, &mut li);
13249 loop {
13250 ln = listNext(&mut li);
13251 if ln.is_null() {
13252 break;
13253 }
13254 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13255 if !((*n).replicate).is_null() {
13256 let mut master: *mut clusterManagerNode = clusterManagerNodeByName(
13257 (*n).replicate as *const libc::c_char,
13258 );
13259 if master.is_null() {
13260 clusterManagerLog(
13261 2 as libc::c_int,
13262 b"*** WARNING: %s:%d claims to be slave of unknown node ID %s.\n\0"
13263 as *const u8 as *const libc::c_char,
13264 (*n).ip,
13265 (*n).port,
13266 (*n).replicate,
13267 );
13268 } else {
13269 (*master).replicas_count += 1;
13270 }
13271 }
13272 }
13273 return 1 as libc::c_int;
13274}
13275#[no_mangle]
13276pub unsafe extern "C" fn clusterManagerSlotCompare(
13277 mut slot1: *const libc::c_void,
13278 mut slot2: *const libc::c_void,
13279) -> libc::c_int {
13280 let mut i1: *mut *const libc::c_char = slot1 as *mut *const libc::c_char;
13281 let mut i2: *mut *const libc::c_char = slot2 as *mut *const libc::c_char;
13282 return strcmp(*i1, *i2);
13283}
13284#[no_mangle]
13285pub unsafe extern "C" fn clusterManagerSlotCountCompareDesc(
13286 mut n1: *const libc::c_void,
13287 mut n2: *const libc::c_void,
13288) -> libc::c_int {
13289 let mut node1: *mut clusterManagerNode = *(n1 as *mut *mut clusterManagerNode);
13290 let mut node2: *mut clusterManagerNode = *(n2 as *mut *mut clusterManagerNode);
13291 return (*node2).slots_count - (*node1).slots_count;
13292}
13293#[no_mangle]
13294pub unsafe extern "C" fn clusterManagerCompareNodeBalance(
13295 mut n1: *const libc::c_void,
13296 mut n2: *const libc::c_void,
13297) -> libc::c_int {
13298 let mut node1: *mut clusterManagerNode = *(n1 as *mut *mut clusterManagerNode);
13299 let mut node2: *mut clusterManagerNode = *(n2 as *mut *mut clusterManagerNode);
13300 return (*node1).balance - (*node2).balance;
13301}
13302unsafe extern "C" fn clusterManagerGetConfigSignature(
13303 mut node: *mut clusterManagerNode,
13304) -> hisds {
13305 let mut lines: *mut libc::c_char = 0 as *mut libc::c_char;
13306 let mut p: *mut libc::c_char = 0 as *mut libc::c_char;
13307 let mut line: *mut libc::c_char = 0 as *mut libc::c_char;
13308 let mut signature: hisds = 0 as hisds;
13309 let mut node_count: libc::c_int = 0 as libc::c_int;
13310 let mut i: libc::c_int = 0 as libc::c_int;
13311 let mut name_len: libc::c_int = 0 as libc::c_int;
13312 let mut node_configs: *mut *mut libc::c_char = 0 as *mut *mut libc::c_char;
13313 let mut reply: *mut redisReply = redisCommand(
13314 (*node).context,
13315 b"CLUSTER NODES\0" as *const u8 as *const libc::c_char,
13316 ) as *mut redisReply;
13317 if !(reply.is_null() || (*reply).type_0 == 6 as libc::c_int) {
13318 lines = (*reply).str_0;
13319 p = 0 as *mut libc::c_char;
13320 line = 0 as *mut libc::c_char;
13321 loop {
13322 p = strstr(lines, b"\n\0" as *const u8 as *const libc::c_char);
13323 if p.is_null() {
13324 break;
13325 }
13326 i = 0 as libc::c_int;
13327 *p = '\0' as i32 as libc::c_char;
13328 line = lines;
13329 lines = p.offset(1 as libc::c_int as isize);
13330 let mut nodename: *mut libc::c_char = 0 as *mut libc::c_char;
13331 let mut tot_size: libc::c_int = 0 as libc::c_int;
13332 loop {
13333 p = strchr(line, ' ' as i32);
13334 if p.is_null() {
13335 break;
13336 }
13337 *p = '\0' as i32 as libc::c_char;
13338 let mut token: *mut libc::c_char = line;
13339 line = p.offset(1 as libc::c_int as isize);
13340 if i == 0 as libc::c_int {
13341 nodename = token;
13342 tot_size = p.offset_from(token) as libc::c_long as libc::c_int;
13343 let fresh53 = tot_size;
13344 tot_size = tot_size + 1;
13345 name_len = fresh53;
13346 }
13347 i += 1;
13348 if i == 8 as libc::c_int {
13349 break;
13350 }
13351 }
13352 if i != 8 as libc::c_int {
13353 continue;
13354 }
13355 if nodename.is_null() {
13356 continue;
13357 }
13358 let mut remaining: libc::c_int = strlen(line) as libc::c_int;
13359 if remaining == 0 as libc::c_int {
13360 continue;
13361 }
13362 let mut slots: *mut *mut libc::c_char = 0 as *mut *mut libc::c_char;
13363 let mut c: libc::c_int = 0 as libc::c_int;
13364 while remaining > 0 as libc::c_int {
13365 p = strchr(line, ' ' as i32);
13366 if p.is_null() {
13367 p = line.offset(remaining as isize);
13368 }
13369 let mut size: libc::c_int = p.offset_from(line) as libc::c_long
13370 as libc::c_int;
13371 remaining -= size;
13372 tot_size += size;
13373 let mut slotsdef: *mut libc::c_char = line;
13374 *p = '\0' as i32 as libc::c_char;
13375 if remaining != 0 {
13376 line = p.offset(1 as libc::c_int as isize);
13377 remaining -= 1;
13378 } else {
13379 line = p;
13380 }
13381 if *slotsdef.offset(0 as libc::c_int as isize) as libc::c_int
13382 != '[' as i32
13383 {
13384 c += 1;
13385 slots = zrealloc(
13386 slots as *mut libc::c_void,
13387 (c as libc::c_ulong)
13388 .wrapping_mul(
13389 core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong,
13390 ),
13391 ) as *mut *mut libc::c_char;
13392 let ref mut fresh54 = *slots.offset((c - 1 as libc::c_int) as isize);
13393 *fresh54 = slotsdef;
13394 }
13395 }
13396 if c > 0 as libc::c_int {
13397 if c > 1 as libc::c_int {
13398 qsort(
13399 slots as *mut libc::c_void,
13400 c as size_t,
13401 core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong,
13402 Some(
13403 clusterManagerSlotCompare
13404 as unsafe extern "C" fn(
13405 *const libc::c_void,
13406 *const libc::c_void,
13407 ) -> libc::c_int,
13408 ),
13409 );
13410 }
13411 node_count += 1;
13412 node_configs = zrealloc(
13413 node_configs as *mut libc::c_void,
13414 (node_count as libc::c_ulong)
13415 .wrapping_mul(
13416 core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong,
13417 ),
13418 ) as *mut *mut libc::c_char;
13419 tot_size = (tot_size as libc::c_ulong)
13420 .wrapping_add(
13421 (core::mem::size_of::<libc::c_char>() as libc::c_ulong)
13422 .wrapping_mul((c - 1 as libc::c_int) as libc::c_ulong),
13423 ) as libc::c_int as libc::c_int;
13424 let mut cfg: *mut libc::c_char = zmalloc(
13425 (core::mem::size_of::<libc::c_char>() as libc::c_ulong)
13426 .wrapping_mul(tot_size as libc::c_ulong)
13427 .wrapping_add(1 as libc::c_int as libc::c_ulong),
13428 ) as *mut libc::c_char;
13429 memcpy(
13430 cfg as *mut libc::c_void,
13431 nodename as *const libc::c_void,
13432 name_len as libc::c_ulong,
13433 );
13434 let mut sp: *mut libc::c_char = cfg.offset(name_len as isize);
13435 let fresh55 = sp;
13436 sp = sp.offset(1);
13437 *fresh55 = ':' as i32 as libc::c_char;
13438 i = 0 as libc::c_int;
13439 while i < c {
13440 if i > 0 as libc::c_int {
13441 let fresh56 = sp;
13442 sp = sp.offset(1);
13443 *fresh56 = ',' as i32 as libc::c_char;
13444 }
13445 let mut slen: libc::c_int = strlen(*slots.offset(i as isize))
13446 as libc::c_int;
13447 memcpy(
13448 sp as *mut libc::c_void,
13449 *slots.offset(i as isize) as *const libc::c_void,
13450 slen as libc::c_ulong,
13451 );
13452 sp = sp.offset(slen as isize);
13453 i += 1;
13454 }
13455 let fresh57 = sp;
13456 sp = sp.offset(1);
13457 *fresh57 = '\0' as i32 as libc::c_char;
13458 let ref mut fresh58 = *node_configs
13459 .offset((node_count - 1 as libc::c_int) as isize);
13460 *fresh58 = cfg;
13461 }
13462 zfree(slots as *mut libc::c_void);
13463 }
13464 if node_count > 0 as libc::c_int {
13465 if node_count > 1 as libc::c_int {
13466 qsort(
13467 node_configs as *mut libc::c_void,
13468 node_count as size_t,
13469 core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong,
13470 Some(
13471 clusterManagerSlotCompare
13472 as unsafe extern "C" fn(
13473 *const libc::c_void,
13474 *const libc::c_void,
13475 ) -> libc::c_int,
13476 ),
13477 );
13478 }
13479 signature = hi_sdsempty();
13480 i = 0 as libc::c_int;
13481 while i < node_count {
13482 if i > 0 as libc::c_int {
13483 signature = hi_sdscatprintf(
13484 signature,
13485 b"%c\0" as *const u8 as *const libc::c_char,
13486 '|' as i32,
13487 );
13488 }
13489 signature = hi_sdscatfmt(
13490 signature,
13491 b"%s\0" as *const u8 as *const libc::c_char,
13492 *node_configs.offset(i as isize),
13493 );
13494 i += 1;
13495 }
13496 }
13497 }
13498 if !reply.is_null() {
13499 freeReplyObject(reply as *mut libc::c_void);
13500 }
13501 if !node_configs.is_null() {
13502 i = 0 as libc::c_int;
13503 while i < node_count {
13504 zfree(*node_configs.offset(i as isize) as *mut libc::c_void);
13505 i += 1;
13506 }
13507 zfree(node_configs as *mut libc::c_void);
13508 }
13509 return signature;
13510}
13511unsafe extern "C" fn clusterManagerIsConfigConsistent() -> libc::c_int {
13512 if (cluster_manager.nodes).is_null() {
13513 return 0 as libc::c_int;
13514 }
13515 let mut consistent: libc::c_int = ((*cluster_manager.nodes).len
13516 <= 1 as libc::c_int as libc::c_ulong) as libc::c_int;
13517 if consistent != 0 {
13518 return 1 as libc::c_int;
13519 }
13520 let mut first_cfg: hisds = 0 as hisds;
13521 let mut li: listIter = listIter {
13522 next: 0 as *mut listNode,
13523 direction: 0,
13524 };
13525 let mut ln: *mut listNode = 0 as *mut listNode;
13526 listRewind(cluster_manager.nodes, &mut li);
13527 loop {
13528 ln = listNext(&mut li);
13529 if ln.is_null() {
13530 break;
13531 }
13532 let mut node: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13533 let mut cfg: hisds = clusterManagerGetConfigSignature(node);
13534 if cfg.is_null() {
13535 consistent = 0 as libc::c_int;
13536 break;
13537 } else if first_cfg.is_null() {
13538 first_cfg = cfg;
13539 } else {
13540 consistent = (hi_sdscmp(first_cfg, cfg) == 0) as libc::c_int;
13541 hi_sdsfree(cfg);
13542 if consistent == 0 {
13543 break;
13544 }
13545 }
13546 }
13547 if !first_cfg.is_null() {
13548 hi_sdsfree(first_cfg);
13549 }
13550 return consistent;
13551}
13552unsafe extern "C" fn clusterManagerGetDisconnectedLinks(
13553 mut node: *mut clusterManagerNode,
13554) -> *mut list {
13555 let mut lines: *mut libc::c_char = 0 as *mut libc::c_char;
13556 let mut p: *mut libc::c_char = 0 as *mut libc::c_char;
13557 let mut line: *mut libc::c_char = 0 as *mut libc::c_char;
13558 let mut links: *mut list = 0 as *mut list;
13559 let mut reply: *mut redisReply = redisCommand(
13560 (*node).context,
13561 b"CLUSTER NODES\0" as *const u8 as *const libc::c_char,
13562 ) as *mut redisReply;
13563 if !(clusterManagerCheckRedisReply(node, reply, 0 as *mut *mut libc::c_char) == 0) {
13564 links = listCreate();
13565 lines = (*reply).str_0;
13566 p = 0 as *mut libc::c_char;
13567 line = 0 as *mut libc::c_char;
13568 loop {
13569 p = strstr(lines, b"\n\0" as *const u8 as *const libc::c_char);
13570 if p.is_null() {
13571 break;
13572 }
13573 let mut i: libc::c_int = 0 as libc::c_int;
13574 *p = '\0' as i32 as libc::c_char;
13575 line = lines;
13576 lines = p.offset(1 as libc::c_int as isize);
13577 let mut nodename: *mut libc::c_char = 0 as *mut libc::c_char;
13578 let mut addr: *mut libc::c_char = 0 as *mut libc::c_char;
13579 let mut flags: *mut libc::c_char = 0 as *mut libc::c_char;
13580 let mut link_status: *mut libc::c_char = 0 as *mut libc::c_char;
13581 loop {
13582 p = strchr(line, ' ' as i32);
13583 if p.is_null() {
13584 break;
13585 }
13586 *p = '\0' as i32 as libc::c_char;
13587 let mut token: *mut libc::c_char = line;
13588 line = p.offset(1 as libc::c_int as isize);
13589 if i == 0 as libc::c_int {
13590 nodename = token;
13591 } else if i == 1 as libc::c_int {
13592 addr = token;
13593 } else if i == 2 as libc::c_int {
13594 flags = token;
13595 } else if i == 7 as libc::c_int {
13596 link_status = token;
13597 } else if i == 8 as libc::c_int {
13598 break;
13599 }
13600 i += 1;
13601 }
13602 if i == 7 as libc::c_int {
13603 link_status = line;
13604 }
13605 if nodename.is_null() || addr.is_null() || flags.is_null()
13606 || link_status.is_null()
13607 {
13608 continue;
13609 }
13610 if !(strstr(flags, b"myself\0" as *const u8 as *const libc::c_char))
13611 .is_null()
13612 {
13613 continue;
13614 }
13615 let mut disconnected: libc::c_int = (!(strstr(
13616 flags,
13617 b"disconnected\0" as *const u8 as *const libc::c_char,
13618 ))
13619 .is_null()
13620 || !(strstr(
13621 link_status,
13622 b"disconnected\0" as *const u8 as *const libc::c_char,
13623 ))
13624 .is_null()) as libc::c_int;
13625 let mut handshaking: libc::c_int = (strstr(
13626 flags,
13627 b"handshake\0" as *const u8 as *const libc::c_char,
13628 ) != 0 as *mut libc::c_void as *mut libc::c_char) as libc::c_int;
13629 if disconnected != 0 || handshaking != 0 {
13630 let mut link: *mut clusterManagerLink = zmalloc(
13631 core::mem::size_of::<clusterManagerLink>() as libc::c_ulong,
13632 ) as *mut clusterManagerLink;
13633 (*link).node_name = hi_sdsnew(nodename);
13634 (*link).node_addr = hi_sdsnew(addr);
13635 (*link).connected = 0 as libc::c_int;
13636 (*link).handshaking = handshaking;
13637 listAddNodeTail(links, link as *mut libc::c_void);
13638 }
13639 }
13640 }
13641 if !reply.is_null() {
13642 freeReplyObject(reply as *mut libc::c_void);
13643 }
13644 return links;
13645}
13646unsafe extern "C" fn clusterManagerGetLinkStatus() -> *mut dict {
13647 if (cluster_manager.nodes).is_null() {
13648 return 0 as *mut dict;
13649 }
13650 let mut status: *mut dict = dictCreate(&mut clusterManagerLinkDictType);
13651 let mut li: listIter = listIter {
13652 next: 0 as *mut listNode,
13653 direction: 0,
13654 };
13655 let mut ln: *mut listNode = 0 as *mut listNode;
13656 listRewind(cluster_manager.nodes, &mut li);
13657 loop {
13658 ln = listNext(&mut li);
13659 if ln.is_null() {
13660 break;
13661 }
13662 let mut node: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13663 let mut links: *mut list = clusterManagerGetDisconnectedLinks(node);
13664 if !links.is_null() {
13665 let mut lli: listIter = listIter {
13666 next: 0 as *mut listNode,
13667 direction: 0,
13668 };
13669 let mut lln: *mut listNode = 0 as *mut listNode;
13670 listRewind(links, &mut lli);
13671 loop {
13672 lln = listNext(&mut lli);
13673 if lln.is_null() {
13674 break;
13675 }
13676 let mut link: *mut clusterManagerLink = (*lln).value
13677 as *mut clusterManagerLink;
13678 let mut from: *mut list = 0 as *mut list;
13679 let mut entry: *mut dictEntry = dictFind(
13680 status,
13681 (*link).node_addr as *const libc::c_void,
13682 );
13683 if !entry.is_null() {
13684 from = (*entry).v.val as *mut list;
13685 } else {
13686 from = listCreate();
13687 dictAdd(
13688 status,
13689 hi_sdsdup((*link).node_addr) as *mut libc::c_void,
13690 from as *mut libc::c_void,
13691 );
13692 }
13693 let mut myaddr: hisds = hi_sdsempty();
13694 myaddr = hi_sdscatfmt(
13695 myaddr,
13696 b"%s:%u\0" as *const u8 as *const libc::c_char,
13697 (*node).ip,
13698 (*node).port,
13699 );
13700 listAddNodeTail(from, myaddr as *mut libc::c_void);
13701 hi_sdsfree((*link).node_name);
13702 hi_sdsfree((*link).node_addr);
13703 zfree(link as *mut libc::c_void);
13704 }
13705 listRelease(links);
13706 }
13707 }
13708 return status;
13709}
13710unsafe extern "C" fn clusterManagerOnError(mut err: hisds) {
13711 if (cluster_manager.errors).is_null() {
13712 cluster_manager.errors = listCreate();
13713 }
13714 listAddNodeTail(cluster_manager.errors, err as *mut libc::c_void);
13715 clusterManagerLog(
13716 3 as libc::c_int,
13717 b"%s\n\0" as *const u8 as *const libc::c_char,
13718 err,
13719 );
13720}
13721unsafe extern "C" fn clusterManagerGetCoveredSlots(
13722 mut all_slots: *mut libc::c_char,
13723) -> libc::c_int {
13724 if (cluster_manager.nodes).is_null() {
13725 return 0 as libc::c_int;
13726 }
13727 let mut li: listIter = listIter {
13728 next: 0 as *mut listNode,
13729 direction: 0,
13730 };
13731 let mut ln: *mut listNode = 0 as *mut listNode;
13732 listRewind(cluster_manager.nodes, &mut li);
13733 let mut totslots: libc::c_int = 0 as libc::c_int;
13734 let mut i: libc::c_int = 0;
13735 loop {
13736 ln = listNext(&mut li);
13737 if ln.is_null() {
13738 break;
13739 }
13740 let mut node: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13741 i = 0 as libc::c_int;
13742 while i < 16384 as libc::c_int {
13743 if (*node).slots[i as usize] as libc::c_int != 0
13744 && *all_slots.offset(i as isize) == 0
13745 {
13746 *all_slots.offset(i as isize) = 1 as libc::c_int as libc::c_char;
13747 totslots += 1;
13748 }
13749 i += 1;
13750 }
13751 }
13752 return totslots;
13753}
13754unsafe extern "C" fn clusterManagerPrintSlotsList(mut slots: *mut list) {
13755 let mut n: clusterManagerNode = {
13756 let mut init = clusterManagerNode {
13757 context: 0 as *mut redisContext,
13758 name: 0 as *mut libc::c_char,
13759 ip: 0 as *mut libc::c_char,
13760 port: 0,
13761 bus_port: 0,
13762 current_epoch: 0,
13763 ping_sent: 0,
13764 ping_recv: 0,
13765 flags: 0,
13766 flags_str: 0 as *mut list,
13767 replicate: 0 as *mut libc::c_char,
13768 dirty: 0,
13769 slots: [0; 16384],
13770 slots_count: 0,
13771 replicas_count: 0,
13772 friends: 0 as *mut list,
13773 migrating: 0 as *mut hisds,
13774 importing: 0 as *mut hisds,
13775 migrating_count: 0,
13776 importing_count: 0,
13777 weight: 0.,
13778 balance: 0,
13779 };
13780 init
13781 };
13782 let mut li: listIter = listIter {
13783 next: 0 as *mut listNode,
13784 direction: 0,
13785 };
13786 let mut ln: *mut listNode = 0 as *mut listNode;
13787 listRewind(slots, &mut li);
13788 loop {
13789 ln = listNext(&mut li);
13790 if ln.is_null() {
13791 break;
13792 }
13793 let mut slot: libc::c_int = atoi((*ln).value as *const libc::c_char);
13794 if slot >= 0 as libc::c_int && slot < 16384 as libc::c_int {
13795 n.slots[slot as usize] = 1 as libc::c_int as uint8_t;
13796 }
13797 }
13798 let mut nodeslist: hisds = clusterManagerNodeSlotsString(&mut n);
13799 printf(b"%s\n\0" as *const u8 as *const libc::c_char, nodeslist);
13800 hi_sdsfree(nodeslist);
13801}
13802unsafe extern "C" fn clusterManagerGetNodeWithMostKeysInSlot(
13803 mut nodes: *mut list,
13804 mut slot: libc::c_int,
13805 mut err: *mut *mut libc::c_char,
13806) -> *mut clusterManagerNode {
13807 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
13808 let mut numkeys: libc::c_int = 0 as libc::c_int;
13809 let mut li: listIter = listIter {
13810 next: 0 as *mut listNode,
13811 direction: 0,
13812 };
13813 let mut ln: *mut listNode = 0 as *mut listNode;
13814 listRewind(nodes, &mut li);
13815 if !err.is_null() {
13816 *err = 0 as *mut libc::c_char;
13817 }
13818 loop {
13819 ln = listNext(&mut li);
13820 if ln.is_null() {
13821 break;
13822 }
13823 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13824 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0
13825 || !((*n).replicate).is_null()
13826 {
13827 continue;
13828 }
13829 let mut r: *mut redisReply = redisCommand(
13830 (*n).context,
13831 b"CLUSTER COUNTKEYSINSLOT %d\0" as *const u8 as *const libc::c_char,
13832 slot,
13833 ) as *mut redisReply;
13834 let mut success: libc::c_int = clusterManagerCheckRedisReply(n, r, err);
13835 if success != 0 {
13836 if (*r).integer > numkeys as libc::c_longlong || node.is_null() {
13837 numkeys = (*r).integer as libc::c_int;
13838 node = n;
13839 }
13840 }
13841 if !r.is_null() {
13842 freeReplyObject(r as *mut libc::c_void);
13843 }
13844 if !(success == 0) {
13845 continue;
13846 }
13847 if !err.is_null() && !(*err).is_null() {
13848 clusterManagerLog(
13849 3 as libc::c_int,
13850 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
13851 as *const libc::c_char,
13852 (*n).ip,
13853 (*n).port,
13854 err,
13855 );
13856 }
13857 node = 0 as *mut clusterManagerNode;
13858 break;
13859 }
13860 return node;
13861}
13862unsafe extern "C" fn clusterManagerNodeWithLeastReplicas() -> *mut clusterManagerNode {
13863 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
13864 let mut lowest_count: libc::c_int = 0 as libc::c_int;
13865 let mut li: listIter = listIter {
13866 next: 0 as *mut listNode,
13867 direction: 0,
13868 };
13869 let mut ln: *mut listNode = 0 as *mut listNode;
13870 listRewind(cluster_manager.nodes, &mut li);
13871 loop {
13872 ln = listNext(&mut li);
13873 if ln.is_null() {
13874 break;
13875 }
13876 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13877 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
13878 continue;
13879 }
13880 if node.is_null() || (*n).replicas_count < lowest_count {
13881 node = n;
13882 lowest_count = (*n).replicas_count;
13883 }
13884 }
13885 return node;
13886}
13887unsafe extern "C" fn clusterManagerNodeMasterRandom() -> *mut clusterManagerNode {
13888 let mut master_count: libc::c_int = 0 as libc::c_int;
13889 let mut idx: libc::c_int = 0;
13890 let mut li: listIter = listIter {
13891 next: 0 as *mut listNode,
13892 direction: 0,
13893 };
13894 let mut ln: *mut listNode = 0 as *mut listNode;
13895 listRewind(cluster_manager.nodes, &mut li);
13896 loop {
13897 ln = listNext(&mut li);
13898 if ln.is_null() {
13899 break;
13900 }
13901 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13902 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
13903 continue;
13904 }
13905 master_count += 1;
13906 }
13907 if master_count > 0 as libc::c_int {} else {
13908 __assert_fail(
13909 b"master_count > 0\0" as *const u8 as *const libc::c_char,
13910 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
13911 5170 as libc::c_int as libc::c_uint,
13912 (*core::mem::transmute::<
13913 &[u8; 53],
13914 &[libc::c_char; 53],
13915 >(b"clusterManagerNode *clusterManagerNodeMasterRandom()\0"))
13916 .as_ptr(),
13917 );
13918 };
13919 srand(time(0 as *mut time_t) as libc::c_uint);
13920 idx = rand() % master_count;
13921 listRewind(cluster_manager.nodes, &mut li);
13922 loop {
13923 ln = listNext(&mut li);
13924 if ln.is_null() {
13925 break;
13926 }
13927 let mut n_0: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
13928 if (*n_0).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
13929 continue;
13930 }
13931 let fresh59 = idx;
13932 idx = idx - 1;
13933 if fresh59 == 0 {
13934 return n_0;
13935 }
13936 }
13937 if 0 as libc::c_int != 0 {} else {
13938 __assert_fail(
13939 b"0\0" as *const u8 as *const libc::c_char,
13940 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
13941 5182 as libc::c_int as libc::c_uint,
13942 (*core::mem::transmute::<
13943 &[u8; 53],
13944 &[libc::c_char; 53],
13945 >(b"clusterManagerNode *clusterManagerNodeMasterRandom()\0"))
13946 .as_ptr(),
13947 );
13948 };
13949 panic!("Reached end of non-void function without returning");
13950}
13951unsafe extern "C" fn clusterManagerFixSlotsCoverage(
13952 mut all_slots: *mut libc::c_char,
13953) -> libc::c_int {
13954 let mut iter: *mut dictIterator = 0 as *mut dictIterator;
13955 let mut entry: *mut dictEntry = 0 as *mut dictEntry;
13956 let mut ignore_force: libc::c_int = 0;
13957 let mut current_block: u64;
13958 let mut force_fix: libc::c_int = config.cluster_manager_command.flags
13959 & (1 as libc::c_int) << 10 as libc::c_int;
13960 if cluster_manager.unreachable_masters > 0 as libc::c_int && force_fix == 0 {
13961 clusterManagerLog(
13962 2 as libc::c_int,
13963 b"*** Fixing slots coverage with %d unreachable masters is dangerous: redis-cli will assume that slots about masters that are not reachable are not covered, and will try to reassign them to the reachable nodes. This can cause data loss and is rarely what you want to do. If you really want to proceed use the --cluster-fix-with-unreachable-masters option.\n\0"
13964 as *const u8 as *const libc::c_char,
13965 cluster_manager.unreachable_masters,
13966 );
13967 exit(1 as libc::c_int);
13968 }
13969 let mut i: libc::c_int = 0;
13970 let mut fixed: libc::c_int = 0 as libc::c_int;
13971 let mut none: *mut list = 0 as *mut list;
13972 let mut single: *mut list = 0 as *mut list;
13973 let mut multi: *mut list = 0 as *mut list;
13974 clusterManagerLog(
13975 1 as libc::c_int,
13976 b">>> Fixing slots coverage...\n\0" as *const u8 as *const libc::c_char,
13977 );
13978 i = 0 as libc::c_int;
13979 's_24: loop {
13980 if !(i < 16384 as libc::c_int) {
13981 current_block = 9828876828309294594;
13982 break;
13983 }
13984 let mut covered: libc::c_int = *all_slots.offset(i as isize) as libc::c_int;
13985 if covered == 0 {
13986 let mut slot: hisds = hi_sdsfromlonglong(i as libc::c_longlong);
13987 let mut slot_nodes: *mut list = listCreate();
13988 let mut slot_nodes_str: hisds = hi_sdsempty();
13989 let mut li: listIter = listIter {
13990 next: 0 as *mut listNode,
13991 direction: 0,
13992 };
13993 let mut ln: *mut listNode = 0 as *mut listNode;
13994 listRewind(cluster_manager.nodes, &mut li);
13995 loop {
13996 ln = listNext(&mut li);
13997 if ln.is_null() {
13998 break;
13999 }
14000 let mut n: *mut clusterManagerNode = (*ln).value
14001 as *mut clusterManagerNode;
14002 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0
14003 || !((*n).replicate).is_null()
14004 {
14005 continue;
14006 }
14007 let mut reply: *mut redisReply = redisCommand(
14008 (*n).context,
14009 b"CLUSTER GETKEYSINSLOT %d %d\0" as *const u8 as *const libc::c_char,
14010 i,
14011 1 as libc::c_int,
14012 ) as *mut redisReply;
14013 if clusterManagerCheckRedisReply(n, reply, 0 as *mut *mut libc::c_char)
14014 == 0
14015 {
14016 fixed = -(1 as libc::c_int);
14017 if !reply.is_null() {
14018 freeReplyObject(reply as *mut libc::c_void);
14019 }
14020 current_block = 3891736614445177135;
14021 break 's_24;
14022 } else {
14023 if (*reply).type_0 == 2 as libc::c_int {} else {
14024 __assert_fail(
14025 b"reply->type == REDIS_REPLY_ARRAY\0" as *const u8
14026 as *const libc::c_char,
14027 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
14028 5217 as libc::c_int as libc::c_uint,
14029 (*core::mem::transmute::<
14030 &[u8; 43],
14031 &[libc::c_char; 43],
14032 >(b"int clusterManagerFixSlotsCoverage(char *)\0"))
14033 .as_ptr(),
14034 );
14035 };
14036 if (*reply).elements > 0 as libc::c_int as libc::c_ulong {
14037 listAddNodeTail(slot_nodes, n as *mut libc::c_void);
14038 if (*slot_nodes).len > 1 as libc::c_int as libc::c_ulong {
14039 slot_nodes_str = hi_sdscat(
14040 slot_nodes_str,
14041 b", \0" as *const u8 as *const libc::c_char,
14042 );
14043 }
14044 slot_nodes_str = hi_sdscatfmt(
14045 slot_nodes_str,
14046 b"%s:%u\0" as *const u8 as *const libc::c_char,
14047 (*n).ip,
14048 (*n).port,
14049 );
14050 }
14051 freeReplyObject(reply as *mut libc::c_void);
14052 }
14053 }
14054 hi_sdsfree(slot_nodes_str);
14055 dictAdd(
14056 clusterManagerUncoveredSlots,
14057 slot as *mut libc::c_void,
14058 slot_nodes as *mut libc::c_void,
14059 );
14060 }
14061 i += 1;
14062 }
14063 match current_block {
14064 9828876828309294594 => {
14065 none = listCreate();
14066 single = listCreate();
14067 multi = listCreate();
14068 iter = dictGetIterator(clusterManagerUncoveredSlots);
14069 entry = 0 as *mut dictEntry;
14070 loop {
14071 entry = dictNext(iter);
14072 if entry.is_null() {
14073 break;
14074 }
14075 let mut slot_0: hisds = (*entry).key as hisds;
14076 let mut nodes: *mut list = (*entry).v.val as *mut list;
14077 match (*nodes).len {
14078 0 => {
14079 listAddNodeTail(none, slot_0 as *mut libc::c_void);
14080 }
14081 1 => {
14082 listAddNodeTail(single, slot_0 as *mut libc::c_void);
14083 }
14084 _ => {
14085 listAddNodeTail(multi, slot_0 as *mut libc::c_void);
14086 }
14087 }
14088 }
14089 dictReleaseIterator(iter);
14090 ignore_force = 1 as libc::c_int;
14091 if (*none).len > 0 as libc::c_int as libc::c_ulong {
14092 printf(
14093 b"The following uncovered slots have no keys across the cluster:\n\0"
14094 as *const u8 as *const libc::c_char,
14095 );
14096 clusterManagerPrintSlotsList(none);
14097 if confirmWithYes(
14098 b"Fix these slots by covering with a random node?\0" as *const u8
14099 as *const libc::c_char as *mut libc::c_char,
14100 ignore_force,
14101 ) != 0
14102 {
14103 let mut li_0: listIter = listIter {
14104 next: 0 as *mut listNode,
14105 direction: 0,
14106 };
14107 let mut ln_0: *mut listNode = 0 as *mut listNode;
14108 listRewind(none, &mut li_0);
14109 loop {
14110 ln_0 = listNext(&mut li_0);
14111 if ln_0.is_null() {
14112 current_block = 16738040538446813684;
14113 break;
14114 }
14115 let mut slot_1: hisds = (*ln_0).value as hisds;
14116 let mut s: libc::c_int = atoi(slot_1 as *const libc::c_char);
14117 let mut n_0: *mut clusterManagerNode = clusterManagerNodeMasterRandom();
14118 clusterManagerLog(
14119 1 as libc::c_int,
14120 b">>> Covering slot %s with %s:%d\n\0" as *const u8
14121 as *const libc::c_char,
14122 slot_1,
14123 (*n_0).ip,
14124 (*n_0).port,
14125 );
14126 if clusterManagerSetSlotOwner(n_0, s, 0 as libc::c_int) == 0 {
14127 fixed = -(1 as libc::c_int);
14128 current_block = 3891736614445177135;
14129 break;
14130 } else {
14131 (*n_0).slots[s as usize] = 1 as libc::c_int as uint8_t;
14132 fixed += 1;
14133 }
14134 }
14135 } else {
14136 current_block = 16738040538446813684;
14137 }
14138 } else {
14139 current_block = 16738040538446813684;
14140 }
14141 match current_block {
14142 3891736614445177135 => {}
14143 _ => {
14144 if (*single).len > 0 as libc::c_int as libc::c_ulong {
14145 printf(
14146 b"The following uncovered slots have keys in just one node:\n\0"
14147 as *const u8 as *const libc::c_char,
14148 );
14149 clusterManagerPrintSlotsList(single);
14150 if confirmWithYes(
14151 b"Fix these slots by covering with those nodes?\0"
14152 as *const u8 as *const libc::c_char as *mut libc::c_char,
14153 ignore_force,
14154 ) != 0
14155 {
14156 let mut li_1: listIter = listIter {
14157 next: 0 as *mut listNode,
14158 direction: 0,
14159 };
14160 let mut ln_1: *mut listNode = 0 as *mut listNode;
14161 listRewind(single, &mut li_1);
14162 loop {
14163 ln_1 = listNext(&mut li_1);
14164 if ln_1.is_null() {
14165 current_block = 14001958660280927786;
14166 break;
14167 }
14168 let mut slot_2: hisds = (*ln_1).value as hisds;
14169 let mut s_0: libc::c_int = atoi(
14170 slot_2 as *const libc::c_char,
14171 );
14172 let mut entry_0: *mut dictEntry = dictFind(
14173 clusterManagerUncoveredSlots,
14174 slot_2 as *const libc::c_void,
14175 );
14176 if !entry_0.is_null() {} else {
14177 __assert_fail(
14178 b"entry != NULL\0" as *const u8 as *const libc::c_char,
14179 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
14180 5296 as libc::c_int as libc::c_uint,
14181 (*core::mem::transmute::<
14182 &[u8; 43],
14183 &[libc::c_char; 43],
14184 >(b"int clusterManagerFixSlotsCoverage(char *)\0"))
14185 .as_ptr(),
14186 );
14187 };
14188 let mut nodes_0: *mut list = (*entry_0).v.val as *mut list;
14189 let mut fn_0: *mut listNode = (*nodes_0).head;
14190 if !fn_0.is_null() {} else {
14191 __assert_fail(
14192 b"fn != NULL\0" as *const u8 as *const libc::c_char,
14193 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
14194 5299 as libc::c_int as libc::c_uint,
14195 (*core::mem::transmute::<
14196 &[u8; 43],
14197 &[libc::c_char; 43],
14198 >(b"int clusterManagerFixSlotsCoverage(char *)\0"))
14199 .as_ptr(),
14200 );
14201 };
14202 let mut n_1: *mut clusterManagerNode = (*fn_0).value
14203 as *mut clusterManagerNode;
14204 clusterManagerLog(
14205 1 as libc::c_int,
14206 b">>> Covering slot %s with %s:%d\n\0" as *const u8
14207 as *const libc::c_char,
14208 slot_2,
14209 (*n_1).ip,
14210 (*n_1).port,
14211 );
14212 if clusterManagerSetSlotOwner(n_1, s_0, 0 as libc::c_int)
14213 == 0
14214 {
14215 fixed = -(1 as libc::c_int);
14216 current_block = 3891736614445177135;
14217 break;
14218 } else {
14219 (*n_1)
14220 .slots[atoi(slot_2 as *const libc::c_char)
14221 as usize] = 1 as libc::c_int as uint8_t;
14222 fixed += 1;
14223 }
14224 }
14225 } else {
14226 current_block = 14001958660280927786;
14227 }
14228 } else {
14229 current_block = 14001958660280927786;
14230 }
14231 match current_block {
14232 3891736614445177135 => {}
14233 _ => {
14234 if (*multi).len > 0 as libc::c_int as libc::c_ulong {
14235 printf(
14236 b"The following uncovered slots have keys in multiple nodes:\n\0"
14237 as *const u8 as *const libc::c_char,
14238 );
14239 clusterManagerPrintSlotsList(multi);
14240 if confirmWithYes(
14241 b"Fix these slots by moving keys into a single node?\0"
14242 as *const u8 as *const libc::c_char as *mut libc::c_char,
14243 ignore_force,
14244 ) != 0
14245 {
14246 let mut li_2: listIter = listIter {
14247 next: 0 as *mut listNode,
14248 direction: 0,
14249 };
14250 let mut ln_2: *mut listNode = 0 as *mut listNode;
14251 listRewind(multi, &mut li_2);
14252 's_338: loop {
14253 ln_2 = listNext(&mut li_2);
14254 if ln_2.is_null() {
14255 break;
14256 }
14257 let mut slot_3: hisds = (*ln_2).value as hisds;
14258 let mut entry_1: *mut dictEntry = dictFind(
14259 clusterManagerUncoveredSlots,
14260 slot_3 as *const libc::c_void,
14261 );
14262 if !entry_1.is_null() {} else {
14263 __assert_fail(
14264 b"entry != NULL\0" as *const u8 as *const libc::c_char,
14265 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
14266 5327 as libc::c_int as libc::c_uint,
14267 (*core::mem::transmute::<
14268 &[u8; 43],
14269 &[libc::c_char; 43],
14270 >(b"int clusterManagerFixSlotsCoverage(char *)\0"))
14271 .as_ptr(),
14272 );
14273 };
14274 let mut nodes_1: *mut list = (*entry_1).v.val as *mut list;
14275 let mut s_1: libc::c_int = atoi(
14276 slot_3 as *const libc::c_char,
14277 );
14278 let mut target: *mut clusterManagerNode = clusterManagerGetNodeWithMostKeysInSlot(
14279 nodes_1,
14280 s_1,
14281 0 as *mut *mut libc::c_char,
14282 );
14283 if target.is_null() {
14284 fixed = -(1 as libc::c_int);
14285 break;
14286 } else {
14287 clusterManagerLog(
14288 1 as libc::c_int,
14289 b">>> Covering slot %s moving keys to %s:%d\n\0"
14290 as *const u8 as *const libc::c_char,
14291 slot_3,
14292 (*target).ip,
14293 (*target).port,
14294 );
14295 if clusterManagerSetSlotOwner(target, s_1, 1 as libc::c_int)
14296 == 0
14297 {
14298 fixed = -(1 as libc::c_int);
14299 break;
14300 } else {
14301 (*target)
14302 .slots[atoi(slot_3 as *const libc::c_char)
14303 as usize] = 1 as libc::c_int as uint8_t;
14304 let mut nli: listIter = listIter {
14305 next: 0 as *mut listNode,
14306 direction: 0,
14307 };
14308 let mut nln: *mut listNode = 0 as *mut listNode;
14309 listRewind(nodes_1, &mut nli);
14310 loop {
14311 nln = listNext(&mut nli);
14312 if nln.is_null() {
14313 break;
14314 }
14315 let mut src: *mut clusterManagerNode = (*nln).value
14316 as *mut clusterManagerNode;
14317 if src == target {
14318 continue;
14319 }
14320 if clusterManagerSetSlot(
14321 src,
14322 target,
14323 s_1,
14324 b"NODE\0" as *const u8 as *const libc::c_char,
14325 0 as *mut *mut libc::c_char,
14326 ) == 0
14327 {
14328 fixed = -(1 as libc::c_int);
14329 }
14330 if fixed < 0 as libc::c_int {
14331 break 's_338;
14332 }
14333 if clusterManagerSetSlot(
14334 src,
14335 target,
14336 s_1,
14337 b"IMPORTING\0" as *const u8 as *const libc::c_char,
14338 0 as *mut *mut libc::c_char,
14339 ) == 0
14340 {
14341 fixed = -(1 as libc::c_int);
14342 }
14343 if fixed < 0 as libc::c_int {
14344 break 's_338;
14345 }
14346 let mut opts: libc::c_int = (1 as libc::c_int)
14347 << 7 as libc::c_int
14348 | (1 as libc::c_int) << 1 as libc::c_int;
14349 if clusterManagerMoveSlot(
14350 src,
14351 target,
14352 s_1,
14353 opts,
14354 0 as *mut *mut libc::c_char,
14355 ) == 0
14356 {
14357 fixed = -(1 as libc::c_int);
14358 break 's_338;
14359 } else {
14360 if clusterManagerClearSlotStatus(src, s_1) == 0 {
14361 fixed = -(1 as libc::c_int);
14362 }
14363 if fixed < 0 as libc::c_int {
14364 break 's_338;
14365 }
14366 }
14367 }
14368 fixed += 1;
14369 }
14370 }
14371 }
14372 }
14373 }
14374 }
14375 }
14376 }
14377 }
14378 }
14379 _ => {}
14380 }
14381 if !none.is_null() {
14382 listRelease(none);
14383 }
14384 if !single.is_null() {
14385 listRelease(single);
14386 }
14387 if !multi.is_null() {
14388 listRelease(multi);
14389 }
14390 return fixed;
14391}
14392unsafe extern "C" fn clusterManagerFixOpenSlot(mut slot: libc::c_int) -> libc::c_int {
14393 let mut try_to_close_slot: libc::c_int = 0;
14394 let mut move_opts: libc::c_int = 0;
14395 let mut current_block: u64;
14396 let mut force_fix: libc::c_int = config.cluster_manager_command.flags
14397 & (1 as libc::c_int) << 10 as libc::c_int;
14398 if cluster_manager.unreachable_masters > 0 as libc::c_int && force_fix == 0 {
14399 clusterManagerLog(
14400 2 as libc::c_int,
14401 b"*** Fixing open slots with %d unreachable masters is dangerous: redis-cli will assume that slots about masters that are not reachable are not covered, and will try to reassign them to the reachable nodes. This can cause data loss and is rarely what you want to do. If you really want to proceed use the --cluster-fix-with-unreachable-masters option.\n\0"
14402 as *const u8 as *const libc::c_char,
14403 cluster_manager.unreachable_masters,
14404 );
14405 exit(1 as libc::c_int);
14406 }
14407 clusterManagerLog(
14408 1 as libc::c_int,
14409 b">>> Fixing open slot %d\n\0" as *const u8 as *const libc::c_char,
14410 slot,
14411 );
14412 let mut success: libc::c_int = 1 as libc::c_int;
14413 let mut owners: *mut list = listCreate();
14414 let mut migrating: *mut list = listCreate();
14415 let mut importing: *mut list = listCreate();
14416 let mut migrating_str: hisds = hi_sdsempty();
14417 let mut importing_str: hisds = hi_sdsempty();
14418 let mut owner: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
14419 let mut li: listIter = listIter {
14420 next: 0 as *mut listNode,
14421 direction: 0,
14422 };
14423 let mut ln: *mut listNode = 0 as *mut listNode;
14424 listRewind(cluster_manager.nodes, &mut li);
14425 loop {
14426 ln = listNext(&mut li);
14427 if ln.is_null() {
14428 current_block = 4808432441040389987;
14429 break;
14430 }
14431 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
14432 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
14433 continue;
14434 }
14435 if (*n).slots[slot as usize] != 0 {
14436 listAddNodeTail(owners, n as *mut libc::c_void);
14437 } else {
14438 let mut r: *mut redisReply = redisCommand(
14439 (*n).context,
14440 b"CLUSTER COUNTKEYSINSLOT %d\0" as *const u8 as *const libc::c_char,
14441 slot,
14442 ) as *mut redisReply;
14443 success = clusterManagerCheckRedisReply(n, r, 0 as *mut *mut libc::c_char);
14444 if success != 0 && (*r).integer > 0 as libc::c_int as libc::c_longlong {
14445 clusterManagerLog(
14446 2 as libc::c_int,
14447 b"*** Found keys about slot %d in non-owner node %s:%d!\n\0"
14448 as *const u8 as *const libc::c_char,
14449 slot,
14450 (*n).ip,
14451 (*n).port,
14452 );
14453 listAddNodeTail(owners, n as *mut libc::c_void);
14454 }
14455 if !r.is_null() {
14456 freeReplyObject(r as *mut libc::c_void);
14457 }
14458 if success == 0 {
14459 current_block = 10287032174686567;
14460 break;
14461 }
14462 }
14463 }
14464 match current_block {
14465 4808432441040389987 => {
14466 if (*owners).len == 1 as libc::c_int as libc::c_ulong {
14467 owner = (*(*owners).head).value as *mut clusterManagerNode;
14468 }
14469 listRewind(cluster_manager.nodes, &mut li);
14470 loop {
14471 ln = listNext(&mut li);
14472 if ln.is_null() {
14473 current_block = 10095721787123848864;
14474 break;
14475 }
14476 let mut n_0: *mut clusterManagerNode = (*ln).value
14477 as *mut clusterManagerNode;
14478 if (*n_0).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
14479 continue;
14480 }
14481 let mut is_migrating: libc::c_int = 0 as libc::c_int;
14482 let mut is_importing: libc::c_int = 0 as libc::c_int;
14483 if !((*n_0).migrating).is_null() {
14484 let mut i: libc::c_int = 0 as libc::c_int;
14485 while i < (*n_0).migrating_count {
14486 let mut migrating_slot: hisds = *((*n_0).migrating)
14487 .offset(i as isize);
14488 if atoi(migrating_slot as *const libc::c_char) == slot {
14489 let mut sep: *mut libc::c_char = (if (*migrating).len
14490 == 0 as libc::c_int as libc::c_ulong
14491 {
14492 b"\0" as *const u8 as *const libc::c_char
14493 } else {
14494 b",\0" as *const u8 as *const libc::c_char
14495 }) as *mut libc::c_char;
14496 migrating_str = hi_sdscatfmt(
14497 migrating_str,
14498 b"%s%s:%u\0" as *const u8 as *const libc::c_char,
14499 sep,
14500 (*n_0).ip,
14501 (*n_0).port,
14502 );
14503 listAddNodeTail(migrating, n_0 as *mut libc::c_void);
14504 is_migrating = 1 as libc::c_int;
14505 break;
14506 } else {
14507 i += 2 as libc::c_int;
14508 }
14509 }
14510 }
14511 if is_migrating == 0 && !((*n_0).importing).is_null() {
14512 let mut i_0: libc::c_int = 0 as libc::c_int;
14513 while i_0 < (*n_0).importing_count {
14514 let mut importing_slot: hisds = *((*n_0).importing)
14515 .offset(i_0 as isize);
14516 if atoi(importing_slot as *const libc::c_char) == slot {
14517 let mut sep_0: *mut libc::c_char = (if (*importing).len
14518 == 0 as libc::c_int as libc::c_ulong
14519 {
14520 b"\0" as *const u8 as *const libc::c_char
14521 } else {
14522 b",\0" as *const u8 as *const libc::c_char
14523 }) as *mut libc::c_char;
14524 importing_str = hi_sdscatfmt(
14525 importing_str,
14526 b"%s%s:%u\0" as *const u8 as *const libc::c_char,
14527 sep_0,
14528 (*n_0).ip,
14529 (*n_0).port,
14530 );
14531 listAddNodeTail(importing, n_0 as *mut libc::c_void);
14532 is_importing = 1 as libc::c_int;
14533 break;
14534 } else {
14535 i_0 += 2 as libc::c_int;
14536 }
14537 }
14538 }
14539 if !(is_migrating == 0 && is_importing == 0 && n_0 != owner) {
14540 continue;
14541 }
14542 let mut r_0: *mut redisReply = redisCommand(
14543 (*n_0).context,
14544 b"CLUSTER COUNTKEYSINSLOT %d\0" as *const u8 as *const libc::c_char,
14545 slot,
14546 ) as *mut redisReply;
14547 success = clusterManagerCheckRedisReply(
14548 n_0,
14549 r_0,
14550 0 as *mut *mut libc::c_char,
14551 );
14552 if success != 0 && (*r_0).integer > 0 as libc::c_int as libc::c_longlong
14553 {
14554 clusterManagerLog(
14555 2 as libc::c_int,
14556 b"*** Found keys about slot %d in node %s:%d!\n\0" as *const u8
14557 as *const libc::c_char,
14558 slot,
14559 (*n_0).ip,
14560 (*n_0).port,
14561 );
14562 let mut sep_1: *mut libc::c_char = (if (*importing).len
14563 == 0 as libc::c_int as libc::c_ulong
14564 {
14565 b"\0" as *const u8 as *const libc::c_char
14566 } else {
14567 b",\0" as *const u8 as *const libc::c_char
14568 }) as *mut libc::c_char;
14569 importing_str = hi_sdscatfmt(
14570 importing_str,
14571 b"%s%s:%u\0" as *const u8 as *const libc::c_char,
14572 sep_1,
14573 (*n_0).ip,
14574 (*n_0).port,
14575 );
14576 listAddNodeTail(importing, n_0 as *mut libc::c_void);
14577 }
14578 if !r_0.is_null() {
14579 freeReplyObject(r_0 as *mut libc::c_void);
14580 }
14581 if success == 0 {
14582 current_block = 10287032174686567;
14583 break;
14584 }
14585 }
14586 match current_block {
14587 10287032174686567 => {}
14588 _ => {
14589 if hi_sdslen(migrating_str) > 0 as libc::c_int as libc::c_ulong {
14590 printf(
14591 b"Set as migrating in: %s\n\0" as *const u8
14592 as *const libc::c_char,
14593 migrating_str,
14594 );
14595 }
14596 if hi_sdslen(importing_str) > 0 as libc::c_int as libc::c_ulong {
14597 printf(
14598 b"Set as importing in: %s\n\0" as *const u8
14599 as *const libc::c_char,
14600 importing_str,
14601 );
14602 }
14603 if owner.is_null() {
14604 clusterManagerLog(
14605 1 as libc::c_int,
14606 b">>> No single clear owner for the slot, selecting an owner by # of keys...\n\0"
14607 as *const u8 as *const libc::c_char,
14608 );
14609 owner = clusterManagerGetNodeWithMostKeysInSlot(
14610 cluster_manager.nodes,
14611 slot,
14612 0 as *mut *mut libc::c_char,
14613 );
14614 if owner.is_null() {
14615 clusterManagerLog(
14616 3 as libc::c_int,
14617 b"[ERR] Can't select a slot owner. Impossible to fix.\n\0"
14618 as *const u8 as *const libc::c_char,
14619 );
14620 success = 0 as libc::c_int;
14621 current_block = 10287032174686567;
14622 } else {
14623 clusterManagerLog(
14624 2 as libc::c_int,
14625 b"*** Configuring %s:%d as the slot owner\n\0" as *const u8
14626 as *const libc::c_char,
14627 (*owner).ip,
14628 (*owner).port,
14629 );
14630 success = clusterManagerClearSlotStatus(owner, slot);
14631 if success == 0 {
14632 current_block = 10287032174686567;
14633 } else {
14634 success = clusterManagerSetSlotOwner(
14635 owner,
14636 slot,
14637 0 as libc::c_int,
14638 );
14639 if success == 0 {
14640 current_block = 10287032174686567;
14641 } else {
14642 (*owner).slots[slot as usize] = 1 as libc::c_int as uint8_t;
14643 clusterManagerRemoveNodeFromList(migrating, owner);
14644 clusterManagerRemoveNodeFromList(importing, owner);
14645 current_block = 981995395831942902;
14646 }
14647 }
14648 }
14649 } else {
14650 current_block = 981995395831942902;
14651 }
14652 match current_block {
14653 10287032174686567 => {}
14654 _ => {
14655 if (*owners).len > 1 as libc::c_int as libc::c_ulong {
14656 if !owner.is_null() {} else {
14657 __assert_fail(
14658 b"owner != NULL\0" as *const u8 as *const libc::c_char,
14659 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
14660 5540 as libc::c_int as libc::c_uint,
14661 (*core::mem::transmute::<
14662 &[u8; 35],
14663 &[libc::c_char; 35],
14664 >(b"int clusterManagerFixOpenSlot(int)\0"))
14665 .as_ptr(),
14666 );
14667 };
14668 listRewind(owners, &mut li);
14669 loop {
14670 ln = listNext(&mut li);
14671 if ln.is_null() {
14672 current_block = 1352918242886884122;
14673 break;
14674 }
14675 let mut n_1: *mut clusterManagerNode = (*ln).value
14676 as *mut clusterManagerNode;
14677 if n_1 == owner {
14678 continue;
14679 }
14680 success = clusterManagerDelSlot(
14681 n_1,
14682 slot,
14683 1 as libc::c_int,
14684 );
14685 if success == 0 {
14686 current_block = 10287032174686567;
14687 break;
14688 }
14689 (*n_1).slots[slot as usize] = 0 as libc::c_int as uint8_t;
14690 success = clusterManagerSetSlot(
14691 n_1,
14692 owner,
14693 slot,
14694 b"node\0" as *const u8 as *const libc::c_char,
14695 0 as *mut *mut libc::c_char,
14696 );
14697 if success == 0 {
14698 current_block = 10287032174686567;
14699 break;
14700 }
14701 success = clusterManagerSetSlot(
14702 n_1,
14703 owner,
14704 slot,
14705 b"importing\0" as *const u8 as *const libc::c_char,
14706 0 as *mut *mut libc::c_char,
14707 );
14708 if success == 0 {
14709 current_block = 10287032174686567;
14710 break;
14711 }
14712 clusterManagerRemoveNodeFromList(importing, n_1);
14713 listAddNodeTail(importing, n_1 as *mut libc::c_void);
14714 clusterManagerRemoveNodeFromList(migrating, n_1);
14715 }
14716 } else {
14717 current_block = 1352918242886884122;
14718 }
14719 match current_block {
14720 10287032174686567 => {}
14721 _ => {
14722 move_opts = (1 as libc::c_int) << 7 as libc::c_int;
14723 if (*migrating).len == 1 as libc::c_int as libc::c_ulong
14724 && (*importing).len == 1 as libc::c_int as libc::c_ulong
14725 {
14726 let mut src: *mut clusterManagerNode = (*(*migrating).head)
14727 .value as *mut clusterManagerNode;
14728 let mut dst: *mut clusterManagerNode = (*(*importing).head)
14729 .value as *mut clusterManagerNode;
14730 clusterManagerLog(
14731 1 as libc::c_int,
14732 b">>> Case 1: Moving slot %d from %s:%d to %s:%d\n\0"
14733 as *const u8 as *const libc::c_char,
14734 slot,
14735 (*src).ip,
14736 (*src).port,
14737 (*dst).ip,
14738 (*dst).port,
14739 );
14740 move_opts |= (1 as libc::c_int) << 2 as libc::c_int;
14741 success = clusterManagerMoveSlot(
14742 src,
14743 dst,
14744 slot,
14745 move_opts,
14746 0 as *mut *mut libc::c_char,
14747 );
14748 } else if (*migrating).len
14749 == 0 as libc::c_int as libc::c_ulong
14750 && (*importing).len > 0 as libc::c_int as libc::c_ulong
14751 {
14752 clusterManagerLog(
14753 1 as libc::c_int,
14754 b">>> Case 2: Moving all the %d slot keys to its owner %s:%d\n\0"
14755 as *const u8 as *const libc::c_char,
14756 slot,
14757 (*owner).ip,
14758 (*owner).port,
14759 );
14760 move_opts |= (1 as libc::c_int) << 1 as libc::c_int;
14761 listRewind(importing, &mut li);
14762 loop {
14763 ln = listNext(&mut li);
14764 if ln.is_null() {
14765 current_block = 5687667889785024198;
14766 break;
14767 }
14768 let mut n_2: *mut clusterManagerNode = (*ln).value
14769 as *mut clusterManagerNode;
14770 if n_2 == owner {
14771 continue;
14772 }
14773 success = clusterManagerMoveSlot(
14774 n_2,
14775 owner,
14776 slot,
14777 move_opts,
14778 0 as *mut *mut libc::c_char,
14779 );
14780 if success == 0 {
14781 current_block = 10287032174686567;
14782 break;
14783 }
14784 clusterManagerLog(
14785 1 as libc::c_int,
14786 b">>> Setting %d as STABLE in %s:%d\n\0" as *const u8
14787 as *const libc::c_char,
14788 slot,
14789 (*n_2).ip,
14790 (*n_2).port,
14791 );
14792 success = clusterManagerClearSlotStatus(n_2, slot);
14793 if success == 0 {
14794 current_block = 10287032174686567;
14795 break;
14796 }
14797 }
14798 match current_block {
14799 10287032174686567 => {}
14800 _ => {
14801 listRewind(cluster_manager.nodes, &mut li);
14802 loop {
14803 ln = listNext(&mut li);
14804 if ln.is_null() {
14805 break;
14806 }
14807 let mut n_3: *mut clusterManagerNode = (*ln).value
14808 as *mut clusterManagerNode;
14809 if n_3 == owner {
14810 continue;
14811 }
14812 if (*n_3).flags & (1 as libc::c_int) << 1 as libc::c_int
14813 != 0
14814 {
14815 continue;
14816 }
14817 success = clusterManagerSetSlot(
14818 n_3,
14819 owner,
14820 slot,
14821 b"NODE\0" as *const u8 as *const libc::c_char,
14822 0 as *mut *mut libc::c_char,
14823 );
14824 if success == 0 {
14825 break;
14826 }
14827 }
14828 }
14829 }
14830 } else {
14831 if (*migrating).len == 1 as libc::c_int as libc::c_ulong
14832 && (*importing).len > 1 as libc::c_int as libc::c_ulong
14833 {
14834 let mut try_to_fix: libc::c_int = 1 as libc::c_int;
14835 let mut src_0: *mut clusterManagerNode = (*(*migrating)
14836 .head)
14837 .value as *mut clusterManagerNode;
14838 let mut dst_0: *mut clusterManagerNode = 0
14839 as *mut clusterManagerNode;
14840 let mut target_id: hisds = 0 as hisds;
14841 let mut i_1: libc::c_int = 0 as libc::c_int;
14842 while i_1 < (*src_0).migrating_count {
14843 let mut migrating_slot_0: hisds = *((*src_0).migrating)
14844 .offset(i_1 as isize);
14845 if atoi(migrating_slot_0 as *const libc::c_char) == slot {
14846 target_id = *((*src_0).migrating)
14847 .offset((i_1 + 1 as libc::c_int) as isize);
14848 break;
14849 } else {
14850 i_1 += 2 as libc::c_int;
14851 }
14852 }
14853 if !target_id.is_null() {} else {
14854 __assert_fail(
14855 b"target_id != NULL\0" as *const u8 as *const libc::c_char,
14856 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
14857 5626 as libc::c_int as libc::c_uint,
14858 (*core::mem::transmute::<
14859 &[u8; 35],
14860 &[libc::c_char; 35],
14861 >(b"int clusterManagerFixOpenSlot(int)\0"))
14862 .as_ptr(),
14863 );
14864 };
14865 let mut li_0: listIter = listIter {
14866 next: 0 as *mut listNode,
14867 direction: 0,
14868 };
14869 let mut ln_0: *mut listNode = 0 as *mut listNode;
14870 listRewind(importing, &mut li_0);
14871 loop {
14872 ln_0 = listNext(&mut li_0);
14873 if ln_0.is_null() {
14874 break;
14875 }
14876 let mut n_4: *mut clusterManagerNode = (*ln_0).value
14877 as *mut clusterManagerNode;
14878 let mut count: libc::c_int = clusterManagerCountKeysInSlot(
14879 n_4,
14880 slot,
14881 );
14882 if count > 0 as libc::c_int {
14883 try_to_fix = 0 as libc::c_int;
14884 break;
14885 } else if strcmp(
14886 (*n_4).name as *const libc::c_char,
14887 target_id as *const libc::c_char,
14888 ) == 0 as libc::c_int
14889 {
14890 dst_0 = n_4;
14891 }
14892 }
14893 if try_to_fix == 0 {
14894 current_block = 12137613406420127454;
14895 } else {
14896 if !dst_0.is_null() {
14897 clusterManagerLog(
14898 1 as libc::c_int,
14899 b">>> Case 3: Moving slot %d from %s:%d to %s:%d and closing it on all the other importing nodes.\n\0"
14900 as *const u8 as *const libc::c_char,
14901 slot,
14902 (*src_0).ip,
14903 (*src_0).port,
14904 (*dst_0).ip,
14905 (*dst_0).port,
14906 );
14907 success = clusterManagerMoveSlot(
14908 src_0,
14909 dst_0,
14910 slot,
14911 move_opts,
14912 0 as *mut *mut libc::c_char,
14913 );
14914 if !(success == 0) {
14915 listRewind(importing, &mut li_0);
14916 loop {
14917 ln_0 = listNext(&mut li_0);
14918 if ln_0.is_null() {
14919 break;
14920 }
14921 let mut n_5: *mut clusterManagerNode = (*ln_0).value
14922 as *mut clusterManagerNode;
14923 if dst_0 == n_5 {
14924 continue;
14925 }
14926 success = clusterManagerClearSlotStatus(n_5, slot);
14927 if success == 0 {
14928 break;
14929 }
14930 }
14931 }
14932 } else {
14933 clusterManagerLog(
14934 1 as libc::c_int,
14935 b">>> Case 3: Closing slot %d on both migrating and importing nodes.\n\0"
14936 as *const u8 as *const libc::c_char,
14937 slot,
14938 );
14939 success = clusterManagerClearSlotStatus(src_0, slot);
14940 if !(success == 0) {
14941 listRewind(importing, &mut li_0);
14942 loop {
14943 ln_0 = listNext(&mut li_0);
14944 if ln_0.is_null() {
14945 break;
14946 }
14947 let mut n_6: *mut clusterManagerNode = (*ln_0).value
14948 as *mut clusterManagerNode;
14949 success = clusterManagerClearSlotStatus(n_6, slot);
14950 if success == 0 {
14951 break;
14952 }
14953 }
14954 }
14955 }
14956 current_block = 10287032174686567;
14957 }
14958 } else {
14959 try_to_close_slot = ((*importing).len
14960 == 0 as libc::c_int as libc::c_ulong
14961 && (*migrating).len == 1 as libc::c_int as libc::c_ulong)
14962 as libc::c_int;
14963 if try_to_close_slot != 0 {
14964 let mut n_7: *mut clusterManagerNode = (*(*migrating).head)
14965 .value as *mut clusterManagerNode;
14966 if owner.is_null() || owner != n_7 {
14967 let mut r_1: *mut redisReply = redisCommand(
14968 (*n_7).context,
14969 b"CLUSTER GETKEYSINSLOT %d %d\0" as *const u8
14970 as *const libc::c_char,
14971 slot,
14972 10 as libc::c_int,
14973 ) as *mut redisReply;
14974 success = clusterManagerCheckRedisReply(
14975 n_7,
14976 r_1,
14977 0 as *mut *mut libc::c_char,
14978 );
14979 if !r_1.is_null() {
14980 if success != 0 {
14981 try_to_close_slot = ((*r_1).elements
14982 == 0 as libc::c_int as libc::c_ulong) as libc::c_int;
14983 }
14984 freeReplyObject(r_1 as *mut libc::c_void);
14985 }
14986 if success == 0 {
14987 current_block = 10287032174686567;
14988 } else {
14989 current_block = 16077153431071379266;
14990 }
14991 } else {
14992 current_block = 16077153431071379266;
14993 }
14994 } else {
14995 current_block = 16077153431071379266;
14996 }
14997 match current_block {
14998 10287032174686567 => {}
14999 _ => {
15000 if try_to_close_slot != 0 {
15001 let mut n_8: *mut clusterManagerNode = (*(*migrating).head)
15002 .value as *mut clusterManagerNode;
15003 clusterManagerLog(
15004 1 as libc::c_int,
15005 b">>> Case 4: Closing slot %d on %s:%d\n\0" as *const u8
15006 as *const libc::c_char,
15007 slot,
15008 (*n_8).ip,
15009 (*n_8).port,
15010 );
15011 let mut r_2: *mut redisReply = redisCommand(
15012 (*n_8).context,
15013 b"CLUSTER SETSLOT %d %s\0" as *const u8
15014 as *const libc::c_char,
15015 slot,
15016 b"STABLE\0" as *const u8 as *const libc::c_char,
15017 ) as *mut redisReply;
15018 success = clusterManagerCheckRedisReply(
15019 n_8,
15020 r_2,
15021 0 as *mut *mut libc::c_char,
15022 );
15023 if !r_2.is_null() {
15024 freeReplyObject(r_2 as *mut libc::c_void);
15025 }
15026 success == 0;
15027 current_block = 10287032174686567;
15028 } else {
15029 current_block = 12137613406420127454;
15030 }
15031 }
15032 }
15033 }
15034 match current_block {
15035 10287032174686567 => {}
15036 _ => {
15037 success = 0 as libc::c_int;
15038 clusterManagerLog(
15039 3 as libc::c_int,
15040 b"[ERR] Sorry, redis-cli can't fix this slot yet (work in progress). Slot is set as migrating in %s, as importing in %s, owner is %s:%d\n\0"
15041 as *const u8 as *const libc::c_char,
15042 migrating_str,
15043 importing_str,
15044 (*owner).ip,
15045 (*owner).port,
15046 );
15047 }
15048 }
15049 }
15050 }
15051 }
15052 }
15053 }
15054 }
15055 }
15056 }
15057 _ => {}
15058 }
15059 listRelease(owners);
15060 listRelease(migrating);
15061 listRelease(importing);
15062 hi_sdsfree(migrating_str);
15063 hi_sdsfree(importing_str);
15064 return success;
15065}
15066unsafe extern "C" fn clusterManagerFixMultipleSlotOwners(
15067 mut slot: libc::c_int,
15068 mut owners: *mut list,
15069) -> libc::c_int {
15070 clusterManagerLog(
15071 1 as libc::c_int,
15072 b">>> Fixing multiple owners for slot %d...\n\0" as *const u8
15073 as *const libc::c_char,
15074 slot,
15075 );
15076 let mut success: libc::c_int = 0 as libc::c_int;
15077 if (*owners).len > 1 as libc::c_int as libc::c_ulong {} else {
15078 __assert_fail(
15079 b"listLength(owners) > 1\0" as *const u8 as *const libc::c_char,
15080 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
15081 5722 as libc::c_int as libc::c_uint,
15082 (*core::mem::transmute::<
15083 &[u8; 53],
15084 &[libc::c_char; 53],
15085 >(b"int clusterManagerFixMultipleSlotOwners(int, list *)\0"))
15086 .as_ptr(),
15087 );
15088 };
15089 let mut owner: *mut clusterManagerNode = clusterManagerGetNodeWithMostKeysInSlot(
15090 owners,
15091 slot,
15092 0 as *mut *mut libc::c_char,
15093 );
15094 if owner.is_null() {
15095 owner = (*(*owners).head).value as *mut clusterManagerNode;
15096 }
15097 clusterManagerLog(
15098 1 as libc::c_int,
15099 b">>> Setting slot %d owner: %s:%d\n\0" as *const u8 as *const libc::c_char,
15100 slot,
15101 (*owner).ip,
15102 (*owner).port,
15103 );
15104 if clusterManagerSetSlotOwner(owner, slot, 0 as libc::c_int) == 0 {
15105 return 0 as libc::c_int;
15106 }
15107 let mut li: listIter = listIter {
15108 next: 0 as *mut listNode,
15109 direction: 0,
15110 };
15111 let mut ln: *mut listNode = 0 as *mut listNode;
15112 listRewind(cluster_manager.nodes, &mut li);
15113 loop {
15114 ln = listNext(&mut li);
15115 if ln.is_null() {
15116 break;
15117 }
15118 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
15119 if n == owner {
15120 continue;
15121 }
15122 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
15123 continue;
15124 }
15125 let mut count: libc::c_int = clusterManagerCountKeysInSlot(n, slot);
15126 success = (count >= 0 as libc::c_int) as libc::c_int;
15127 if success == 0 {
15128 break;
15129 }
15130 clusterManagerDelSlot(n, slot, 1 as libc::c_int);
15131 if clusterManagerSetSlot(
15132 n,
15133 owner,
15134 slot,
15135 b"node\0" as *const u8 as *const libc::c_char,
15136 0 as *mut *mut libc::c_char,
15137 ) == 0
15138 {
15139 return 0 as libc::c_int;
15140 }
15141 if !(count > 0 as libc::c_int) {
15142 continue;
15143 }
15144 let mut opts: libc::c_int = (1 as libc::c_int) << 7 as libc::c_int
15145 | (1 as libc::c_int) << 1 as libc::c_int;
15146 success = clusterManagerMoveSlot(
15147 n,
15148 owner,
15149 slot,
15150 opts,
15151 0 as *mut *mut libc::c_char,
15152 );
15153 if success == 0 {
15154 break;
15155 }
15156 }
15157 return success;
15158}
15159unsafe extern "C" fn clusterManagerCheckCluster(mut quiet: libc::c_int) -> libc::c_int {
15160 let mut ln: *mut listNode = (*cluster_manager.nodes).head;
15161 if ln.is_null() {
15162 return 0 as libc::c_int;
15163 }
15164 let mut node: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
15165 clusterManagerLog(
15166 1 as libc::c_int,
15167 b">>> Performing Cluster Check (using node %s:%d)\n\0" as *const u8
15168 as *const libc::c_char,
15169 (*node).ip,
15170 (*node).port,
15171 );
15172 let mut result: libc::c_int = 1 as libc::c_int;
15173 let mut consistent: libc::c_int = 0 as libc::c_int;
15174 let mut do_fix: libc::c_int = config.cluster_manager_command.flags
15175 & (1 as libc::c_int) << 0 as libc::c_int;
15176 if quiet == 0 {
15177 clusterManagerShowNodes();
15178 }
15179 consistent = clusterManagerIsConfigConsistent();
15180 if consistent == 0 {
15181 let mut err: hisds = hi_sdsnew(
15182 b"[ERR] Nodes don't agree about configuration!\0" as *const u8
15183 as *const libc::c_char,
15184 );
15185 clusterManagerOnError(err);
15186 result = 0 as libc::c_int;
15187 } else {
15188 clusterManagerLog(
15189 4 as libc::c_int,
15190 b"[OK] All nodes agree about slots configuration.\n\0" as *const u8
15191 as *const libc::c_char,
15192 );
15193 }
15194 clusterManagerLog(
15195 1 as libc::c_int,
15196 b">>> Check for open slots...\n\0" as *const u8 as *const libc::c_char,
15197 );
15198 let mut li: listIter = listIter {
15199 next: 0 as *mut listNode,
15200 direction: 0,
15201 };
15202 listRewind(cluster_manager.nodes, &mut li);
15203 let mut i: libc::c_int = 0;
15204 let mut open_slots: *mut dict = 0 as *mut dict;
15205 loop {
15206 ln = listNext(&mut li);
15207 if ln.is_null() {
15208 break;
15209 }
15210 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
15211 if !((*n).migrating).is_null() {
15212 if open_slots.is_null() {
15213 open_slots = dictCreate(&mut clusterManagerDictType);
15214 }
15215 let mut errstr: hisds = hi_sdsempty();
15216 errstr = hi_sdscatprintf(
15217 errstr,
15218 b"[WARNING] Node %s:%d has slots in migrating state \0" as *const u8
15219 as *const libc::c_char,
15220 (*n).ip,
15221 (*n).port,
15222 );
15223 i = 0 as libc::c_int;
15224 while i < (*n).migrating_count {
15225 let mut slot: hisds = *((*n).migrating).offset(i as isize);
15226 dictReplace(
15227 open_slots,
15228 slot as *mut libc::c_void,
15229 hi_sdsdup(*((*n).migrating).offset((i + 1 as libc::c_int) as isize))
15230 as *mut libc::c_void,
15231 );
15232 let mut fmt: *mut libc::c_char = (if i > 0 as libc::c_int {
15233 b",%S\0" as *const u8 as *const libc::c_char
15234 } else {
15235 b"%S\0" as *const u8 as *const libc::c_char
15236 }) as *mut libc::c_char;
15237 errstr = hi_sdscatfmt(errstr, fmt, slot);
15238 i += 2 as libc::c_int;
15239 }
15240 errstr = hi_sdscat(errstr, b".\0" as *const u8 as *const libc::c_char);
15241 clusterManagerOnError(errstr);
15242 }
15243 if !((*n).importing).is_null() {
15244 if open_slots.is_null() {
15245 open_slots = dictCreate(&mut clusterManagerDictType);
15246 }
15247 let mut errstr_0: hisds = hi_sdsempty();
15248 errstr_0 = hi_sdscatprintf(
15249 errstr_0,
15250 b"[WARNING] Node %s:%d has slots in importing state \0" as *const u8
15251 as *const libc::c_char,
15252 (*n).ip,
15253 (*n).port,
15254 );
15255 i = 0 as libc::c_int;
15256 while i < (*n).importing_count {
15257 let mut slot_0: hisds = *((*n).importing).offset(i as isize);
15258 dictReplace(
15259 open_slots,
15260 slot_0 as *mut libc::c_void,
15261 hi_sdsdup(*((*n).importing).offset((i + 1 as libc::c_int) as isize))
15262 as *mut libc::c_void,
15263 );
15264 let mut fmt_0: *mut libc::c_char = (if i > 0 as libc::c_int {
15265 b",%S\0" as *const u8 as *const libc::c_char
15266 } else {
15267 b"%S\0" as *const u8 as *const libc::c_char
15268 }) as *mut libc::c_char;
15269 errstr_0 = hi_sdscatfmt(errstr_0, fmt_0, slot_0);
15270 i += 2 as libc::c_int;
15271 }
15272 errstr_0 = hi_sdscat(errstr_0, b".\0" as *const u8 as *const libc::c_char);
15273 clusterManagerOnError(errstr_0);
15274 }
15275 }
15276 if !open_slots.is_null() {
15277 result = 0 as libc::c_int;
15278 let mut iter: *mut dictIterator = dictGetIterator(open_slots);
15279 let mut entry: *mut dictEntry = 0 as *mut dictEntry;
15280 let mut errstr_1: hisds = hi_sdsnew(
15281 b"[WARNING] The following slots are open: \0" as *const u8
15282 as *const libc::c_char,
15283 );
15284 i = 0 as libc::c_int;
15285 loop {
15286 entry = dictNext(iter);
15287 if entry.is_null() {
15288 break;
15289 }
15290 let mut slot_1: hisds = (*entry).key as hisds;
15291 let fresh60 = i;
15292 i = i + 1;
15293 let mut fmt_1: *mut libc::c_char = (if fresh60 > 0 as libc::c_int {
15294 b",%S\0" as *const u8 as *const libc::c_char
15295 } else {
15296 b"%S\0" as *const u8 as *const libc::c_char
15297 }) as *mut libc::c_char;
15298 errstr_1 = hi_sdscatfmt(errstr_1, fmt_1, slot_1);
15299 }
15300 clusterManagerLog(
15301 3 as libc::c_int,
15302 b"%s.\n\0" as *const u8 as *const libc::c_char,
15303 errstr_1,
15304 );
15305 hi_sdsfree(errstr_1);
15306 if do_fix != 0 {
15307 dictReleaseIterator(iter);
15308 iter = dictGetIterator(open_slots);
15309 loop {
15310 entry = dictNext(iter);
15311 if entry.is_null() {
15312 break;
15313 }
15314 let mut slot_2: hisds = (*entry).key as hisds;
15315 result = clusterManagerFixOpenSlot(atoi(slot_2 as *const libc::c_char));
15316 if result == 0 {
15317 break;
15318 }
15319 }
15320 }
15321 dictReleaseIterator(iter);
15322 dictRelease(open_slots);
15323 }
15324 clusterManagerLog(
15325 1 as libc::c_int,
15326 b">>> Check slots coverage...\n\0" as *const u8 as *const libc::c_char,
15327 );
15328 let mut slots: [libc::c_char; 16384] = [0; 16384];
15329 memset(
15330 slots.as_mut_ptr() as *mut libc::c_void,
15331 0 as libc::c_int,
15332 16384 as libc::c_int as libc::c_ulong,
15333 );
15334 let mut coverage: libc::c_int = clusterManagerGetCoveredSlots(slots.as_mut_ptr());
15335 if coverage == 16384 as libc::c_int {
15336 clusterManagerLog(
15337 4 as libc::c_int,
15338 b"[OK] All %d slots covered.\n\0" as *const u8 as *const libc::c_char,
15339 16384 as libc::c_int,
15340 );
15341 } else {
15342 let mut err_0: hisds = hi_sdsempty();
15343 err_0 = hi_sdscatprintf(
15344 err_0,
15345 b"[ERR] Not all %d slots are covered by nodes.\n\0" as *const u8
15346 as *const libc::c_char,
15347 16384 as libc::c_int,
15348 );
15349 clusterManagerOnError(err_0);
15350 result = 0 as libc::c_int;
15351 if do_fix != 0 {
15352 let mut dtype: dictType = clusterManagerDictType;
15353 dtype
15354 .keyDestructor = Some(
15355 dictSdsDestructor
15356 as unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
15357 );
15358 dtype
15359 .valDestructor = Some(
15360 dictListDestructor
15361 as unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
15362 );
15363 clusterManagerUncoveredSlots = dictCreate(&mut dtype);
15364 let mut fixed: libc::c_int = clusterManagerFixSlotsCoverage(
15365 slots.as_mut_ptr(),
15366 );
15367 if fixed > 0 as libc::c_int {
15368 result = 1 as libc::c_int;
15369 }
15370 }
15371 }
15372 let mut search_multiple_owners: libc::c_int = config.cluster_manager_command.flags
15373 & (1 as libc::c_int) << 9 as libc::c_int;
15374 if search_multiple_owners != 0 {
15375 clusterManagerLog(
15376 1 as libc::c_int,
15377 b">>> Check for multiple slot owners...\n\0" as *const u8
15378 as *const libc::c_char,
15379 );
15380 let mut slot_3: libc::c_int = 0 as libc::c_int;
15381 let mut slots_with_multiple_owners: libc::c_int = 0 as libc::c_int;
15382 while slot_3 < 16384 as libc::c_int {
15383 let mut li_0: listIter = listIter {
15384 next: 0 as *mut listNode,
15385 direction: 0,
15386 };
15387 let mut ln_0: *mut listNode = 0 as *mut listNode;
15388 listRewind(cluster_manager.nodes, &mut li_0);
15389 let mut owners: *mut list = listCreate();
15390 loop {
15391 ln_0 = listNext(&mut li_0);
15392 if ln_0.is_null() {
15393 break;
15394 }
15395 let mut n_0: *mut clusterManagerNode = (*ln_0).value
15396 as *mut clusterManagerNode;
15397 if (*n_0).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
15398 continue;
15399 }
15400 if (*n_0).slots[slot_3 as usize] != 0 {
15401 listAddNodeTail(owners, n_0 as *mut libc::c_void);
15402 } else {
15403 let mut count: libc::c_int = clusterManagerCountKeysInSlot(
15404 n_0,
15405 slot_3,
15406 );
15407 if count > 0 as libc::c_int {
15408 listAddNodeTail(owners, n_0 as *mut libc::c_void);
15409 }
15410 }
15411 }
15412 if (*owners).len > 1 as libc::c_int as libc::c_ulong {
15413 result = 0 as libc::c_int;
15414 clusterManagerLog(
15415 3 as libc::c_int,
15416 b"[WARNING] Slot %d has %d owners:\n\0" as *const u8
15417 as *const libc::c_char,
15418 slot_3,
15419 (*owners).len,
15420 );
15421 listRewind(owners, &mut li_0);
15422 loop {
15423 ln_0 = listNext(&mut li_0);
15424 if ln_0.is_null() {
15425 break;
15426 }
15427 let mut n_1: *mut clusterManagerNode = (*ln_0).value
15428 as *mut clusterManagerNode;
15429 clusterManagerLog(
15430 3 as libc::c_int,
15431 b" %s:%d\n\0" as *const u8 as *const libc::c_char,
15432 (*n_1).ip,
15433 (*n_1).port,
15434 );
15435 }
15436 slots_with_multiple_owners += 1;
15437 if do_fix != 0 {
15438 result = clusterManagerFixMultipleSlotOwners(slot_3, owners);
15439 if result == 0 {
15440 clusterManagerLog(
15441 3 as libc::c_int,
15442 b"Failed to fix multiple owners for slot %d\n\0" as *const u8
15443 as *const libc::c_char,
15444 slot_3,
15445 );
15446 listRelease(owners);
15447 break;
15448 } else {
15449 slots_with_multiple_owners -= 1;
15450 }
15451 }
15452 }
15453 listRelease(owners);
15454 slot_3 += 1;
15455 }
15456 if slots_with_multiple_owners == 0 as libc::c_int {
15457 clusterManagerLog(
15458 4 as libc::c_int,
15459 b"[OK] No multiple owners found.\n\0" as *const u8 as *const libc::c_char,
15460 );
15461 }
15462 }
15463 return result;
15464}
15465unsafe extern "C" fn clusterNodeForResharding(
15466 mut id: *mut libc::c_char,
15467 mut target: *mut clusterManagerNode,
15468 mut raise_err: *mut libc::c_int,
15469) -> *mut clusterManagerNode {
15470 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
15471 let mut invalid_node_msg: *const libc::c_char = b"*** The specified node (%s) is not known or not a master, please retry.\n\0"
15472 as *const u8 as *const libc::c_char;
15473 node = clusterManagerNodeByName(id);
15474 *raise_err = 0 as libc::c_int;
15475 if node.is_null() || (*node).flags & (1 as libc::c_int) << 1 as libc::c_int != 0 {
15476 clusterManagerLog(3 as libc::c_int, invalid_node_msg, id);
15477 *raise_err = 1 as libc::c_int;
15478 return 0 as *mut clusterManagerNode;
15479 } else {
15480 if !target.is_null() {
15481 if strcmp(
15482 (*node).name as *const libc::c_char,
15483 (*target).name as *const libc::c_char,
15484 ) == 0
15485 {
15486 clusterManagerLog(
15487 3 as libc::c_int,
15488 b"*** It is not possible to use the target node as source node.\n\0"
15489 as *const u8 as *const libc::c_char,
15490 );
15491 return 0 as *mut clusterManagerNode;
15492 }
15493 }
15494 }
15495 return node;
15496}
15497unsafe extern "C" fn clusterManagerComputeReshardTable(
15498 mut sources: *mut list,
15499 mut numslots: libc::c_int,
15500) -> *mut list {
15501 let mut moved: *mut list = listCreate();
15502 let mut src_count: libc::c_int = (*sources).len as libc::c_int;
15503 let mut i: libc::c_int = 0 as libc::c_int;
15504 let mut tot_slots: libc::c_int = 0 as libc::c_int;
15505 let mut j: libc::c_int = 0;
15506 let mut sorted: *mut *mut clusterManagerNode = zmalloc(
15507 (src_count as libc::c_ulong)
15508 .wrapping_mul(
15509 core::mem::size_of::<*mut clusterManagerNode>() as libc::c_ulong,
15510 ),
15511 ) as *mut *mut clusterManagerNode;
15512 let mut li: listIter = listIter {
15513 next: 0 as *mut listNode,
15514 direction: 0,
15515 };
15516 let mut ln: *mut listNode = 0 as *mut listNode;
15517 listRewind(sources, &mut li);
15518 loop {
15519 ln = listNext(&mut li);
15520 if ln.is_null() {
15521 break;
15522 }
15523 let mut node: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
15524 tot_slots += (*node).slots_count;
15525 let fresh61 = i;
15526 i = i + 1;
15527 let ref mut fresh62 = *sorted.offset(fresh61 as isize);
15528 *fresh62 = node;
15529 }
15530 qsort(
15531 sorted as *mut libc::c_void,
15532 src_count as size_t,
15533 core::mem::size_of::<*mut clusterManagerNode>() as libc::c_ulong,
15534 Some(
15535 clusterManagerSlotCountCompareDesc
15536 as unsafe extern "C" fn(
15537 *const libc::c_void,
15538 *const libc::c_void,
15539 ) -> libc::c_int,
15540 ),
15541 );
15542 i = 0 as libc::c_int;
15543 while i < src_count {
15544 let mut node_0: *mut clusterManagerNode = *sorted.offset(i as isize);
15545 let mut n: libc::c_float = numslots as libc::c_float / tot_slots as libc::c_float
15546 * (*node_0).slots_count as libc::c_float;
15547 if i == 0 as libc::c_int {
15548 n = ceil(n as libc::c_double) as libc::c_float;
15549 } else {
15550 n = floor(n as libc::c_double) as libc::c_float;
15551 }
15552 let mut max: libc::c_int = n as libc::c_int;
15553 let mut count: libc::c_int = 0 as libc::c_int;
15554 j = 0 as libc::c_int;
15555 while j < 16384 as libc::c_int {
15556 let mut slot: libc::c_int = (*node_0).slots[j as usize] as libc::c_int;
15557 if !(slot == 0) {
15558 if count >= max || (*moved).len as libc::c_int >= numslots {
15559 break;
15560 }
15561 let mut item: *mut clusterManagerReshardTableItem = zmalloc(
15562 core::mem::size_of::<clusterManagerReshardTableItem>()
15563 as libc::c_ulong,
15564 ) as *mut clusterManagerReshardTableItem;
15565 (*item).source = node_0;
15566 (*item).slot = j;
15567 listAddNodeTail(moved, item as *mut libc::c_void);
15568 count += 1;
15569 }
15570 j += 1;
15571 }
15572 i += 1;
15573 }
15574 zfree(sorted as *mut libc::c_void);
15575 return moved;
15576}
15577unsafe extern "C" fn clusterManagerShowReshardTable(mut table: *mut list) {
15578 let mut li: listIter = listIter {
15579 next: 0 as *mut listNode,
15580 direction: 0,
15581 };
15582 let mut ln: *mut listNode = 0 as *mut listNode;
15583 listRewind(table, &mut li);
15584 loop {
15585 ln = listNext(&mut li);
15586 if ln.is_null() {
15587 break;
15588 }
15589 let mut item: *mut clusterManagerReshardTableItem = (*ln).value
15590 as *mut clusterManagerReshardTableItem;
15591 let mut n: *mut clusterManagerNode = (*item).source;
15592 printf(
15593 b" Moving slot %d from %s\n\0" as *const u8 as *const libc::c_char,
15594 (*item).slot,
15595 (*n).name,
15596 );
15597 };
15598}
15599unsafe extern "C" fn clusterManagerReleaseReshardTable(mut table: *mut list) {
15600 if !table.is_null() {
15601 let mut li: listIter = listIter {
15602 next: 0 as *mut listNode,
15603 direction: 0,
15604 };
15605 let mut ln: *mut listNode = 0 as *mut listNode;
15606 listRewind(table, &mut li);
15607 loop {
15608 ln = listNext(&mut li);
15609 if ln.is_null() {
15610 break;
15611 }
15612 let mut item: *mut clusterManagerReshardTableItem = (*ln).value
15613 as *mut clusterManagerReshardTableItem;
15614 zfree(item as *mut libc::c_void);
15615 }
15616 listRelease(table);
15617 }
15618}
15619unsafe extern "C" fn clusterManagerLog(
15620 mut level: libc::c_int,
15621 mut fmt: *const libc::c_char,
15622 mut args: ...
15623) {
15624 let mut use_colors: libc::c_int = config.cluster_manager_command.flags
15625 & (1 as libc::c_int) << 8 as libc::c_int;
15626 if use_colors != 0 {
15627 printf(b"\x1B[\0" as *const u8 as *const libc::c_char);
15628 match level {
15629 1 => {
15630 printf(b"29;1m\0" as *const u8 as *const libc::c_char);
15631 }
15632 2 => {
15633 printf(b"33;1m\0" as *const u8 as *const libc::c_char);
15634 }
15635 3 => {
15636 printf(b"31;1m\0" as *const u8 as *const libc::c_char);
15637 }
15638 4 => {
15639 printf(b"32;1m\0" as *const u8 as *const libc::c_char);
15640 }
15641 _ => {
15642 printf(b"0m\0" as *const u8 as *const libc::c_char);
15643 }
15644 }
15645 }
15646 let mut ap: core::ffi::VaListImpl;
15647 ap = args.clone();
15648 vprintf(fmt, ap.as_va_list());
15649 if use_colors != 0 {
15650 printf(b"\x1B[0m\0" as *const u8 as *const libc::c_char);
15651 }
15652}
15653unsafe extern "C" fn clusterManagerNodeArrayInit(
15654 mut array: *mut clusterManagerNodeArray,
15655 mut alloc_len: libc::c_int,
15656) {
15657 (*array)
15658 .nodes = zcalloc(
15659 (alloc_len as libc::c_ulong)
15660 .wrapping_mul(
15661 core::mem::size_of::<*mut clusterManagerNode>() as libc::c_ulong,
15662 ),
15663 ) as *mut *mut clusterManagerNode;
15664 (*array).alloc = (*array).nodes;
15665 (*array).len = alloc_len;
15666 (*array).count = 0 as libc::c_int;
15667}
15668unsafe extern "C" fn clusterManagerNodeArrayReset(
15669 mut array: *mut clusterManagerNodeArray,
15670) {
15671 if (*array).nodes > (*array).alloc {
15672 (*array)
15673 .len = ((*array).nodes).offset_from((*array).alloc) as libc::c_long
15674 as libc::c_int;
15675 (*array).nodes = (*array).alloc;
15676 (*array).count = 0 as libc::c_int;
15677 let mut i: libc::c_int = 0 as libc::c_int;
15678 while i < (*array).len {
15679 if !(*((*array).nodes).offset(i as isize)).is_null() {
15680 (*array).count += 1;
15681 }
15682 i += 1;
15683 }
15684 }
15685}
15686unsafe extern "C" fn clusterManagerNodeArrayShift(
15687 mut array: *mut clusterManagerNodeArray,
15688 mut nodeptr: *mut *mut clusterManagerNode,
15689) {
15690 if (*array).len > 0 as libc::c_int {} else {
15691 __assert_fail(
15692 b"array->len > 0\0" as *const u8 as *const libc::c_char,
15693 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
15694 6050 as libc::c_int as libc::c_uint,
15695 (*core::mem::transmute::<
15696 &[u8; 84],
15697 &[libc::c_char; 84],
15698 >(
15699 b"void clusterManagerNodeArrayShift(clusterManagerNodeArray *, clusterManagerNode **)\0",
15700 ))
15701 .as_ptr(),
15702 );
15703 };
15704 if !(*(*array).nodes).is_null() {
15705 (*array).count -= 1;
15706 }
15707 *nodeptr = *(*array).nodes;
15708 (*array).nodes = ((*array).nodes).offset(1);
15709 (*array).len -= 1;
15710}
15711unsafe extern "C" fn clusterManagerNodeArrayAdd(
15712 mut array: *mut clusterManagerNodeArray,
15713 mut node: *mut clusterManagerNode,
15714) {
15715 if (*array).len > 0 as libc::c_int {} else {
15716 __assert_fail(
15717 b"array->len > 0\0" as *const u8 as *const libc::c_char,
15718 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
15719 6063 as libc::c_int as libc::c_uint,
15720 (*core::mem::transmute::<
15721 &[u8; 81],
15722 &[libc::c_char; 81],
15723 >(
15724 b"void clusterManagerNodeArrayAdd(clusterManagerNodeArray *, clusterManagerNode *)\0",
15725 ))
15726 .as_ptr(),
15727 );
15728 };
15729 if !node.is_null() {} else {
15730 __assert_fail(
15731 b"node != NULL\0" as *const u8 as *const libc::c_char,
15732 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
15733 6064 as libc::c_int as libc::c_uint,
15734 (*core::mem::transmute::<
15735 &[u8; 81],
15736 &[libc::c_char; 81],
15737 >(
15738 b"void clusterManagerNodeArrayAdd(clusterManagerNodeArray *, clusterManagerNode *)\0",
15739 ))
15740 .as_ptr(),
15741 );
15742 };
15743 if (*array).count < (*array).len {} else {
15744 __assert_fail(
15745 b"array->count < array->len\0" as *const u8 as *const libc::c_char,
15746 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
15747 6065 as libc::c_int as libc::c_uint,
15748 (*core::mem::transmute::<
15749 &[u8; 81],
15750 &[libc::c_char; 81],
15751 >(
15752 b"void clusterManagerNodeArrayAdd(clusterManagerNodeArray *, clusterManagerNode *)\0",
15753 ))
15754 .as_ptr(),
15755 );
15756 };
15757 let fresh63 = (*array).count;
15758 (*array).count = (*array).count + 1;
15759 let ref mut fresh64 = *((*array).nodes).offset(fresh63 as isize);
15760 *fresh64 = node;
15761}
15762unsafe extern "C" fn clusterManagerPrintNotEmptyNodeError(
15763 mut node: *mut clusterManagerNode,
15764 mut err: *mut libc::c_char,
15765) {
15766 let mut msg: *mut libc::c_char = 0 as *mut libc::c_char;
15767 if !err.is_null() {
15768 msg = err;
15769 } else {
15770 msg = b"is not empty. Either the node already knows other nodes (check with CLUSTER NODES) or contains some key in database 0.\0"
15771 as *const u8 as *const libc::c_char as *mut libc::c_char;
15772 }
15773 clusterManagerLog(
15774 3 as libc::c_int,
15775 b"[ERR] Node %s:%d %s\n\0" as *const u8 as *const libc::c_char,
15776 (*node).ip,
15777 (*node).port,
15778 msg,
15779 );
15780}
15781unsafe extern "C" fn clusterManagerPrintNotClusterNodeError(
15782 mut node: *mut clusterManagerNode,
15783 mut err: *mut libc::c_char,
15784) {
15785 let mut msg: *mut libc::c_char = (if !err.is_null() {
15786 err as *const libc::c_char
15787 } else {
15788 b"is not configured as a cluster node.\0" as *const u8 as *const libc::c_char
15789 }) as *mut libc::c_char;
15790 clusterManagerLog(
15791 3 as libc::c_int,
15792 b"[ERR] Node %s:%d %s\n\0" as *const u8 as *const libc::c_char,
15793 (*node).ip,
15794 (*node).port,
15795 msg,
15796 );
15797}
15798unsafe extern "C" fn clusterManagerMode(
15799 mut proc_0: Option::<clusterManagerCommandProc>,
15800) {
15801 let mut argc: libc::c_int = config.cluster_manager_command.argc;
15802 let mut argv: *mut *mut libc::c_char = config.cluster_manager_command.argv;
15803 cluster_manager.nodes = 0 as *mut list;
15804 let mut success: libc::c_int = proc_0
15805 .expect("non-null function pointer")(argc, argv);
15806 if config.stdin_lastarg != 0 {
15807 zfree(config.cluster_manager_command.argv as *mut libc::c_void);
15808 hi_sdsfree(config.cluster_manager_command.stdin_arg);
15809 } else if config.stdin_tag_arg != 0 {
15810 hi_sdsfree(config.cluster_manager_command.stdin_arg);
15811 }
15812 freeClusterManager();
15813 exit(if success != 0 { 0 as libc::c_int } else { 1 as libc::c_int });
15814}
15815unsafe extern "C" fn clusterManagerCommandCreate(
15816 mut argc: libc::c_int,
15817 mut argv: *mut *mut libc::c_char,
15818) -> libc::c_int {
15819 let mut current_block: u64;
15820 let mut i: libc::c_int = 0;
15821 let mut j: libc::c_int = 0;
15822 let mut success: libc::c_int = 1 as libc::c_int;
15823 cluster_manager.nodes = listCreate();
15824 i = 0 as libc::c_int;
15825 while i < argc {
15826 let mut addr: *mut libc::c_char = *argv.offset(i as isize);
15827 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
15828 let mut port: libc::c_int = 0 as libc::c_int;
15829 if parseClusterNodeAddress(addr, &mut ip, &mut port, 0 as *mut libc::c_int) == 0
15830 {
15831 fprintf(
15832 stderr,
15833 b"Invalid address format: %s\n\0" as *const u8 as *const libc::c_char,
15834 addr,
15835 );
15836 return 0 as libc::c_int;
15837 }
15838 let mut node: *mut clusterManagerNode = clusterManagerNewNode(
15839 ip,
15840 port,
15841 0 as libc::c_int,
15842 );
15843 if clusterManagerNodeConnect(node) == 0 {
15844 freeClusterManagerNode(node);
15845 return 0 as libc::c_int;
15846 }
15847 let mut err: *mut libc::c_char = 0 as *mut libc::c_char;
15848 if clusterManagerNodeIsCluster(node, &mut err) == 0 {
15849 clusterManagerPrintNotClusterNodeError(node, err);
15850 if !err.is_null() {
15851 zfree(err as *mut libc::c_void);
15852 }
15853 freeClusterManagerNode(node);
15854 return 0 as libc::c_int;
15855 }
15856 err = 0 as *mut libc::c_char;
15857 if clusterManagerNodeLoadInfo(node, 0 as libc::c_int, &mut err) == 0 {
15858 if !err.is_null() {
15859 clusterManagerLog(
15860 3 as libc::c_int,
15861 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
15862 as *const libc::c_char,
15863 (*node).ip,
15864 (*node).port,
15865 err,
15866 );
15867 zfree(err as *mut libc::c_void);
15868 }
15869 freeClusterManagerNode(node);
15870 return 0 as libc::c_int;
15871 }
15872 err = 0 as *mut libc::c_char;
15873 if clusterManagerNodeIsEmpty(node, &mut err) == 0 {
15874 clusterManagerPrintNotEmptyNodeError(node, err);
15875 if !err.is_null() {
15876 zfree(err as *mut libc::c_void);
15877 }
15878 freeClusterManagerNode(node);
15879 return 0 as libc::c_int;
15880 }
15881 listAddNodeTail(cluster_manager.nodes, node as *mut libc::c_void);
15882 i += 1;
15883 }
15884 let mut node_len: libc::c_int = (*cluster_manager.nodes).len as libc::c_int;
15885 let mut replicas: libc::c_int = config.cluster_manager_command.replicas;
15886 let mut masters_count: libc::c_int = node_len / (replicas + 1 as libc::c_int);
15887 if masters_count < 3 as libc::c_int {
15888 clusterManagerLog(
15889 3 as libc::c_int,
15890 b"*** ERROR: Invalid configuration for cluster creation.\n*** Redis Cluster requires at least 3 master nodes.\n*** This is not possible with %d nodes and %d replicas per node.\0"
15891 as *const u8 as *const libc::c_char,
15892 node_len,
15893 replicas,
15894 );
15895 clusterManagerLog(
15896 3 as libc::c_int,
15897 b"\n*** At least %d nodes are required.\n\0" as *const u8
15898 as *const libc::c_char,
15899 3 as libc::c_int * (replicas + 1 as libc::c_int),
15900 );
15901 return 0 as libc::c_int;
15902 }
15903 clusterManagerLog(
15904 1 as libc::c_int,
15905 b">>> Performing hash slots allocation on %d nodes...\n\0" as *const u8
15906 as *const libc::c_char,
15907 node_len,
15908 );
15909 let mut interleaved_len: libc::c_int = 0 as libc::c_int;
15910 let mut ip_count: libc::c_int = 0 as libc::c_int;
15911 let mut interleaved: *mut *mut clusterManagerNode = zcalloc(
15912 (node_len as libc::c_ulong)
15913 .wrapping_mul(core::mem::size_of::<clusterManagerNode>() as libc::c_ulong),
15914 ) as *mut *mut clusterManagerNode;
15915 let mut ips: *mut *mut libc::c_char = zcalloc(
15916 (node_len as libc::c_ulong)
15917 .wrapping_mul(core::mem::size_of::<*mut libc::c_char>() as libc::c_ulong),
15918 ) as *mut *mut libc::c_char;
15919 let mut ip_nodes: *mut clusterManagerNodeArray = zcalloc(
15920 (node_len as libc::c_ulong)
15921 .wrapping_mul(
15922 core::mem::size_of::<clusterManagerNodeArray>() as libc::c_ulong,
15923 ),
15924 ) as *mut clusterManagerNodeArray;
15925 let mut li: listIter = listIter {
15926 next: 0 as *mut listNode,
15927 direction: 0,
15928 };
15929 let mut ln: *mut listNode = 0 as *mut listNode;
15930 listRewind(cluster_manager.nodes, &mut li);
15931 loop {
15932 ln = listNext(&mut li);
15933 if ln.is_null() {
15934 break;
15935 }
15936 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
15937 let mut found: libc::c_int = 0 as libc::c_int;
15938 i = 0 as libc::c_int;
15939 while i < ip_count {
15940 let mut ip_0: *mut libc::c_char = *ips.offset(i as isize);
15941 if strcmp(ip_0, (*n).ip) == 0 {
15942 found = 1 as libc::c_int;
15943 break;
15944 } else {
15945 i += 1;
15946 }
15947 }
15948 if found == 0 {
15949 let fresh65 = ip_count;
15950 ip_count = ip_count + 1;
15951 let ref mut fresh66 = *ips.offset(fresh65 as isize);
15952 *fresh66 = (*n).ip;
15953 }
15954 let mut node_array: *mut clusterManagerNodeArray = &mut *ip_nodes
15955 .offset(i as isize) as *mut clusterManagerNodeArray;
15956 if ((*node_array).nodes).is_null() {
15957 clusterManagerNodeArrayInit(node_array, node_len);
15958 }
15959 clusterManagerNodeArrayAdd(node_array, n);
15960 }
15961 while interleaved_len < node_len {
15962 i = 0 as libc::c_int;
15963 while i < ip_count {
15964 let mut node_array_0: *mut clusterManagerNodeArray = &mut *ip_nodes
15965 .offset(i as isize) as *mut clusterManagerNodeArray;
15966 if (*node_array_0).count > 0 as libc::c_int {
15967 let mut n_0: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
15968 clusterManagerNodeArrayShift(node_array_0, &mut n_0);
15969 let fresh67 = interleaved_len;
15970 interleaved_len = interleaved_len + 1;
15971 let ref mut fresh68 = *interleaved.offset(fresh67 as isize);
15972 *fresh68 = n_0;
15973 }
15974 i += 1;
15975 }
15976 }
15977 let mut masters: *mut *mut clusterManagerNode = interleaved;
15978 interleaved = interleaved.offset(masters_count as isize);
15979 interleaved_len -= masters_count;
15980 let mut slots_per_node: libc::c_float = 16384 as libc::c_int as libc::c_float
15981 / masters_count as libc::c_float;
15982 let mut first: libc::c_long = 0 as libc::c_int as libc::c_long;
15983 let mut cursor: libc::c_float = 0.0f32;
15984 i = 0 as libc::c_int;
15985 while i < masters_count {
15986 let mut master: *mut clusterManagerNode = *masters.offset(i as isize);
15987 let mut last: libc::c_long = lround(
15988 (cursor + slots_per_node - 1 as libc::c_int as libc::c_float)
15989 as libc::c_double,
15990 );
15991 if last > 16384 as libc::c_int as libc::c_long
15992 || i == masters_count - 1 as libc::c_int
15993 {
15994 last = (16384 as libc::c_int - 1 as libc::c_int) as libc::c_long;
15995 }
15996 if last < first {
15997 last = first;
15998 }
15999 printf(
16000 b"Master[%d] -> Slots %ld - %ld\n\0" as *const u8 as *const libc::c_char,
16001 i,
16002 first,
16003 last,
16004 );
16005 (*master).slots_count = 0 as libc::c_int;
16006 j = first as libc::c_int;
16007 while j as libc::c_long <= last {
16008 (*master).slots[j as usize] = 1 as libc::c_int as uint8_t;
16009 (*master).slots_count += 1;
16010 j += 1;
16011 }
16012 (*master).dirty = 1 as libc::c_int;
16013 first = last + 1 as libc::c_int as libc::c_long;
16014 cursor += slots_per_node;
16015 i += 1;
16016 }
16017 let mut first_node: *mut clusterManagerNode = *interleaved
16018 .offset(0 as libc::c_int as isize);
16019 i = 0 as libc::c_int;
16020 while i < interleaved_len - 1 as libc::c_int {
16021 let ref mut fresh69 = *interleaved.offset(i as isize);
16022 *fresh69 = *interleaved.offset((i + 1 as libc::c_int) as isize);
16023 i += 1;
16024 }
16025 let ref mut fresh70 = *interleaved
16026 .offset((interleaved_len - 1 as libc::c_int) as isize);
16027 *fresh70 = first_node;
16028 let mut assign_unused: libc::c_int = 0 as libc::c_int;
16029 let mut available_count: libc::c_int = interleaved_len;
16030 loop {
16031 i = 0 as libc::c_int;
16032 while i < masters_count {
16033 let mut master_0: *mut clusterManagerNode = *masters.offset(i as isize);
16034 let mut assigned_replicas: libc::c_int = 0 as libc::c_int;
16035 while assigned_replicas < replicas {
16036 if available_count == 0 as libc::c_int {
16037 break;
16038 }
16039 let mut found_0: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16040 let mut slave: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16041 let mut firstNodeIdx: libc::c_int = -(1 as libc::c_int);
16042 j = 0 as libc::c_int;
16043 while j < interleaved_len {
16044 let mut n_1: *mut clusterManagerNode = *interleaved
16045 .offset(j as isize);
16046 if !n_1.is_null() {
16047 if strcmp((*n_1).ip, (*master_0).ip) != 0 {
16048 found_0 = n_1;
16049 let ref mut fresh71 = *interleaved.offset(j as isize);
16050 *fresh71 = 0 as *mut clusterManagerNode;
16051 break;
16052 } else if firstNodeIdx < 0 as libc::c_int {
16053 firstNodeIdx = j;
16054 }
16055 }
16056 j += 1;
16057 }
16058 if !found_0.is_null() {
16059 slave = found_0;
16060 } else if firstNodeIdx >= 0 as libc::c_int {
16061 slave = *interleaved.offset(firstNodeIdx as isize);
16062 interleaved_len -= firstNodeIdx + 1 as libc::c_int;
16063 interleaved = interleaved
16064 .offset((firstNodeIdx + 1 as libc::c_int) as isize);
16065 }
16066 if slave.is_null() {
16067 break;
16068 }
16069 assigned_replicas += 1;
16070 available_count -= 1;
16071 if !((*slave).replicate).is_null() {
16072 hi_sdsfree((*slave).replicate);
16073 }
16074 (*slave).replicate = hi_sdsnew((*master_0).name as *const libc::c_char);
16075 (*slave).dirty = 1 as libc::c_int;
16076 printf(
16077 b"Adding replica %s:%d to %s:%d\n\0" as *const u8
16078 as *const libc::c_char,
16079 (*slave).ip,
16080 (*slave).port,
16081 (*master_0).ip,
16082 (*master_0).port,
16083 );
16084 if assign_unused != 0 {
16085 break;
16086 }
16087 }
16088 i += 1;
16089 }
16090 if !(assign_unused == 0 && available_count > 0 as libc::c_int) {
16091 break;
16092 }
16093 assign_unused = 1 as libc::c_int;
16094 printf(b"Adding extra replicas...\n\0" as *const u8 as *const libc::c_char);
16095 }
16096 i = 0 as libc::c_int;
16097 while i < ip_count {
16098 let mut node_array_1: *mut clusterManagerNodeArray = ip_nodes.offset(i as isize);
16099 clusterManagerNodeArrayReset(node_array_1);
16100 i += 1;
16101 }
16102 clusterManagerOptimizeAntiAffinity(ip_nodes, ip_count);
16103 clusterManagerShowNodes();
16104 let mut ignore_force: libc::c_int = 0 as libc::c_int;
16105 if confirmWithYes(
16106 b"Can I set the above configuration?\0" as *const u8 as *const libc::c_char
16107 as *mut libc::c_char,
16108 ignore_force,
16109 ) != 0
16110 {
16111 listRewind(cluster_manager.nodes, &mut li);
16112 loop {
16113 ln = listNext(&mut li);
16114 if ln.is_null() {
16115 current_block = 6988365858197790817;
16116 break;
16117 }
16118 let mut node_0: *mut clusterManagerNode = (*ln).value
16119 as *mut clusterManagerNode;
16120 let mut err_0: *mut libc::c_char = 0 as *mut libc::c_char;
16121 let mut flushed: libc::c_int = clusterManagerFlushNodeConfig(
16122 node_0,
16123 &mut err_0,
16124 );
16125 if flushed == 0 && (*node_0).dirty != 0 && ((*node_0).replicate).is_null() {
16126 if !err_0.is_null() {
16127 clusterManagerLog(
16128 3 as libc::c_int,
16129 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
16130 as *const libc::c_char,
16131 (*node_0).ip,
16132 (*node_0).port,
16133 err_0,
16134 );
16135 zfree(err_0 as *mut libc::c_void);
16136 }
16137 success = 0 as libc::c_int;
16138 current_block = 4878356980533367297;
16139 break;
16140 } else if !err_0.is_null() {
16141 zfree(err_0 as *mut libc::c_void);
16142 }
16143 }
16144 match current_block {
16145 4878356980533367297 => {}
16146 _ => {
16147 clusterManagerLog(
16148 1 as libc::c_int,
16149 b">>> Nodes configuration updated\n\0" as *const u8
16150 as *const libc::c_char,
16151 );
16152 clusterManagerLog(
16153 1 as libc::c_int,
16154 b">>> Assign a different config epoch to each node\n\0" as *const u8
16155 as *const libc::c_char,
16156 );
16157 let mut config_epoch: libc::c_int = 1 as libc::c_int;
16158 listRewind(cluster_manager.nodes, &mut li);
16159 loop {
16160 ln = listNext(&mut li);
16161 if ln.is_null() {
16162 break;
16163 }
16164 let mut node_1: *mut clusterManagerNode = (*ln).value
16165 as *mut clusterManagerNode;
16166 let mut reply: *mut redisReply = 0 as *mut redisReply;
16167 let fresh72 = config_epoch;
16168 config_epoch = config_epoch + 1;
16169 reply = redisCommand(
16170 (*node_1).context,
16171 b"cluster set-config-epoch %d\0" as *const u8
16172 as *const libc::c_char,
16173 fresh72,
16174 ) as *mut redisReply;
16175 if !reply.is_null() {
16176 freeReplyObject(reply as *mut libc::c_void);
16177 }
16178 }
16179 clusterManagerLog(
16180 1 as libc::c_int,
16181 b">>> Sending CLUSTER MEET messages to join the cluster\n\0"
16182 as *const u8 as *const libc::c_char,
16183 );
16184 let mut first_0: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16185 let mut first_ip: [libc::c_char; 46] = [0; 46];
16186 listRewind(cluster_manager.nodes, &mut li);
16187 loop {
16188 ln = listNext(&mut li);
16189 if ln.is_null() {
16190 current_block = 12129449210080749085;
16191 break;
16192 }
16193 let mut node_2: *mut clusterManagerNode = (*ln).value
16194 as *mut clusterManagerNode;
16195 if first_0.is_null() {
16196 first_0 = node_2;
16197 if !(anetResolve(
16198 0 as *mut libc::c_char,
16199 (*first_0).ip,
16200 first_ip.as_mut_ptr(),
16201 core::mem::size_of::<[libc::c_char; 46]>()
16202 as libc::c_ulong,
16203 0 as libc::c_int,
16204 ) == -(1 as libc::c_int))
16205 {
16206 continue;
16207 }
16208 fprintf(
16209 stderr,
16210 b"Invalid IP address or hostname specified: %s\n\0"
16211 as *const u8 as *const libc::c_char,
16212 (*first_0).ip,
16213 );
16214 success = 0 as libc::c_int;
16215 current_block = 4878356980533367297;
16216 break;
16217 } else {
16218 let mut reply_0: *mut redisReply = 0 as *mut redisReply;
16219 if (*first_0).bus_port == 0 as libc::c_int
16220 || (*first_0).bus_port
16221 == (*first_0).port + 10000 as libc::c_int
16222 {
16223 reply_0 = redisCommand(
16224 (*node_2).context,
16225 b"cluster meet %s %d\0" as *const u8 as *const libc::c_char,
16226 first_ip.as_mut_ptr(),
16227 (*first_0).port,
16228 ) as *mut redisReply;
16229 } else {
16230 reply_0 = redisCommand(
16231 (*node_2).context,
16232 b"cluster meet %s %d %d\0" as *const u8
16233 as *const libc::c_char,
16234 first_ip.as_mut_ptr(),
16235 (*first_0).port,
16236 (*first_0).bus_port,
16237 ) as *mut redisReply;
16238 }
16239 let mut is_err: libc::c_int = 0 as libc::c_int;
16240 if !reply_0.is_null() {
16241 is_err = ((*reply_0).type_0 == 6 as libc::c_int)
16242 as libc::c_int;
16243 if is_err != 0 {
16244 clusterManagerLog(
16245 3 as libc::c_int,
16246 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
16247 as *const libc::c_char,
16248 (*node_2).ip,
16249 (*node_2).port,
16250 (*reply_0).str_0,
16251 );
16252 }
16253 freeReplyObject(reply_0 as *mut libc::c_void);
16254 } else {
16255 is_err = 1 as libc::c_int;
16256 fprintf(
16257 stderr,
16258 b"Failed to send CLUSTER MEET command.\n\0" as *const u8
16259 as *const libc::c_char,
16260 );
16261 }
16262 if !(is_err != 0) {
16263 continue;
16264 }
16265 success = 0 as libc::c_int;
16266 current_block = 4878356980533367297;
16267 break;
16268 }
16269 }
16270 match current_block {
16271 4878356980533367297 => {}
16272 _ => {
16273 sleep(1 as libc::c_int as libc::c_uint);
16274 clusterManagerWaitForClusterJoin();
16275 listRewind(cluster_manager.nodes, &mut li);
16276 loop {
16277 ln = listNext(&mut li);
16278 if ln.is_null() {
16279 current_block = 6880299496751257707;
16280 break;
16281 }
16282 let mut node_3: *mut clusterManagerNode = (*ln).value
16283 as *mut clusterManagerNode;
16284 if (*node_3).dirty == 0 {
16285 continue;
16286 }
16287 let mut err_1: *mut libc::c_char = 0 as *mut libc::c_char;
16288 let mut flushed_0: libc::c_int = clusterManagerFlushNodeConfig(
16289 node_3,
16290 &mut err_1,
16291 );
16292 if flushed_0 == 0 && ((*node_3).replicate).is_null() {
16293 if !err_1.is_null() {
16294 clusterManagerLog(
16295 3 as libc::c_int,
16296 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
16297 as *const libc::c_char,
16298 (*node_3).ip,
16299 (*node_3).port,
16300 err_1,
16301 );
16302 zfree(err_1 as *mut libc::c_void);
16303 }
16304 success = 0 as libc::c_int;
16305 current_block = 4878356980533367297;
16306 break;
16307 } else if !err_1.is_null() {
16308 zfree(err_1 as *mut libc::c_void);
16309 }
16310 }
16311 match current_block {
16312 4878356980533367297 => {}
16313 _ => {
16314 listRewind(cluster_manager.nodes, &mut li);
16315 let mut first_node_0: *mut clusterManagerNode = 0
16316 as *mut clusterManagerNode;
16317 loop {
16318 ln = listNext(&mut li);
16319 if ln.is_null() {
16320 break;
16321 }
16322 let mut node_4: *mut clusterManagerNode = (*ln).value
16323 as *mut clusterManagerNode;
16324 if first_node_0.is_null() {
16325 first_node_0 = node_4;
16326 } else {
16327 freeClusterManagerNode(node_4);
16328 }
16329 }
16330 listEmpty(cluster_manager.nodes);
16331 if clusterManagerLoadInfoFromNode(first_node_0) == 0 {
16332 success = 0 as libc::c_int;
16333 } else {
16334 clusterManagerCheckCluster(0 as libc::c_int);
16335 }
16336 }
16337 }
16338 }
16339 }
16340 }
16341 }
16342 }
16343 zfree(masters as *mut libc::c_void);
16344 zfree(ips as *mut libc::c_void);
16345 i = 0 as libc::c_int;
16346 while i < node_len {
16347 let mut node_array_2: *mut clusterManagerNodeArray = ip_nodes.offset(i as isize);
16348 zfree((*node_array_2).alloc as *mut libc::c_void);
16349 i += 1;
16350 }
16351 zfree(ip_nodes as *mut libc::c_void);
16352 return success;
16353}
16354unsafe extern "C" fn clusterManagerCommandAddNode(
16355 mut argc: libc::c_int,
16356 mut argv: *mut *mut libc::c_char,
16357) -> libc::c_int {
16358 let mut err: *mut libc::c_char = 0 as *mut libc::c_char;
16359 let mut first: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16360 let mut first_ip: [libc::c_char; 46] = [0; 46];
16361 let mut refnode: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16362 let mut master_node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16363 let mut new_node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16364 let mut added: libc::c_int = 0;
16365 let mut current_block: u64;
16366 let mut success: libc::c_int = 1 as libc::c_int;
16367 let mut reply: *mut redisReply = 0 as *mut redisReply;
16368 let mut function_restore_reply: *mut redisReply = 0 as *mut redisReply;
16369 let mut function_list_reply: *mut redisReply = 0 as *mut redisReply;
16370 let mut ref_ip: *mut libc::c_char = 0 as *mut libc::c_char;
16371 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
16372 let mut ref_port: libc::c_int = 0 as libc::c_int;
16373 let mut port: libc::c_int = 0 as libc::c_int;
16374 if !(getClusterHostFromCmdArgs(
16375 argc - 1 as libc::c_int,
16376 argv.offset(1 as libc::c_int as isize),
16377 &mut ref_ip,
16378 &mut ref_port,
16379 ) == 0)
16380 {
16381 if !(getClusterHostFromCmdArgs(1 as libc::c_int, argv, &mut ip, &mut port) == 0)
16382 {
16383 clusterManagerLog(
16384 1 as libc::c_int,
16385 b">>> Adding node %s:%d to cluster %s:%d\n\0" as *const u8
16386 as *const libc::c_char,
16387 ip,
16388 port,
16389 ref_ip,
16390 ref_port,
16391 );
16392 refnode = clusterManagerNewNode(ref_ip, ref_port, 0 as libc::c_int);
16393 if clusterManagerLoadInfoFromNode(refnode) == 0 {
16394 return 0 as libc::c_int;
16395 }
16396 if clusterManagerCheckCluster(0 as libc::c_int) == 0 {
16397 return 0 as libc::c_int;
16398 }
16399 master_node = 0 as *mut clusterManagerNode;
16400 if config.cluster_manager_command.flags
16401 & (1 as libc::c_int) << 1 as libc::c_int != 0
16402 {
16403 let mut master_id: *mut libc::c_char = config
16404 .cluster_manager_command
16405 .master_id;
16406 if !master_id.is_null() {
16407 master_node = clusterManagerNodeByName(master_id);
16408 if master_node.is_null() {
16409 clusterManagerLog(
16410 3 as libc::c_int,
16411 b"[ERR] No such master ID %s\n\0" as *const u8
16412 as *const libc::c_char,
16413 master_id,
16414 );
16415 return 0 as libc::c_int;
16416 }
16417 } else {
16418 master_node = clusterManagerNodeWithLeastReplicas();
16419 if !master_node.is_null() {} else {
16420 __assert_fail(
16421 b"master_node != NULL\0" as *const u8 as *const libc::c_char,
16422 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
16423 6434 as libc::c_int as libc::c_uint,
16424 (*core::mem::transmute::<
16425 &[u8; 47],
16426 &[libc::c_char; 47],
16427 >(b"int clusterManagerCommandAddNode(int, char **)\0"))
16428 .as_ptr(),
16429 );
16430 };
16431 printf(
16432 b"Automatically selected master %s:%d\n\0" as *const u8
16433 as *const libc::c_char,
16434 (*master_node).ip,
16435 (*master_node).port,
16436 );
16437 }
16438 }
16439 new_node = clusterManagerNewNode(ip, port, 0 as libc::c_int);
16440 added = 0 as libc::c_int;
16441 if clusterManagerNodeConnect(new_node) == 0 {
16442 clusterManagerLog(
16443 3 as libc::c_int,
16444 b"[ERR] Sorry, can't connect to node %s:%d\n\0" as *const u8
16445 as *const libc::c_char,
16446 ip,
16447 port,
16448 );
16449 success = 0 as libc::c_int;
16450 } else {
16451 err = 0 as *mut libc::c_char;
16452 success = clusterManagerNodeIsCluster(new_node, &mut err);
16453 if success == 0 {
16454 clusterManagerPrintNotClusterNodeError(new_node, err);
16455 if !err.is_null() {
16456 zfree(err as *mut libc::c_void);
16457 }
16458 } else if clusterManagerNodeLoadInfo(
16459 new_node,
16460 0 as libc::c_int,
16461 &mut err,
16462 ) == 0
16463 {
16464 if !err.is_null() {
16465 clusterManagerLog(
16466 3 as libc::c_int,
16467 b"Node %s:%d replied with error:\n%s\n\0" as *const u8
16468 as *const libc::c_char,
16469 (*new_node).ip,
16470 (*new_node).port,
16471 err,
16472 );
16473 zfree(err as *mut libc::c_void);
16474 }
16475 success = 0 as libc::c_int;
16476 } else {
16477 success = clusterManagerNodeIsEmpty(new_node, &mut err);
16478 if success == 0 {
16479 clusterManagerPrintNotEmptyNodeError(new_node, err);
16480 if !err.is_null() {
16481 zfree(err as *mut libc::c_void);
16482 }
16483 } else {
16484 first = (*(*cluster_manager.nodes).head).value
16485 as *mut clusterManagerNode;
16486 listAddNodeTail(
16487 cluster_manager.nodes,
16488 new_node as *mut libc::c_void,
16489 );
16490 added = 1 as libc::c_int;
16491 if master_node.is_null() {
16492 clusterManagerLog(
16493 1 as libc::c_int,
16494 b">>> Getting functions from cluster\n\0" as *const u8
16495 as *const libc::c_char,
16496 );
16497 reply = redisCommand(
16498 (*refnode).context,
16499 b"FUNCTION DUMP\0" as *const u8 as *const libc::c_char,
16500 ) as *mut redisReply;
16501 if clusterManagerCheckRedisReply(refnode, reply, &mut err)
16502 == 0
16503 {
16504 clusterManagerLog(
16505 1 as libc::c_int,
16506 b">>> Failed retrieving Functions from the cluster, skip this step as Redis version do not support function command (error = '%s')\n\0"
16507 as *const u8 as *const libc::c_char,
16508 if !err.is_null() {
16509 err as *const libc::c_char
16510 } else {
16511 b"NULL reply\0" as *const u8 as *const libc::c_char
16512 },
16513 );
16514 if !err.is_null() {
16515 zfree(err as *mut libc::c_void);
16516 }
16517 current_block = 6560072651652764009;
16518 } else {
16519 if (*reply).type_0 == 1 as libc::c_int {} else {
16520 __assert_fail(
16521 b"reply->type == REDIS_REPLY_STRING\0" as *const u8
16522 as *const libc::c_char,
16523 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
16524 6481 as libc::c_int as libc::c_uint,
16525 (*core::mem::transmute::<
16526 &[u8; 47],
16527 &[libc::c_char; 47],
16528 >(b"int clusterManagerCommandAddNode(int, char **)\0"))
16529 .as_ptr(),
16530 );
16531 };
16532 clusterManagerLog(
16533 1 as libc::c_int,
16534 b">>> Send FUNCTION LIST to %s:%d to verify there is no functions in it\n\0"
16535 as *const u8 as *const libc::c_char,
16536 ip,
16537 port,
16538 );
16539 function_list_reply = redisCommand(
16540 (*new_node).context,
16541 b"FUNCTION LIST\0" as *const u8 as *const libc::c_char,
16542 ) as *mut redisReply;
16543 if clusterManagerCheckRedisReply(
16544 new_node,
16545 function_list_reply,
16546 &mut err,
16547 ) == 0
16548 {
16549 clusterManagerLog(
16550 3 as libc::c_int,
16551 b">>> Failed on CLUSTER LIST (error = '%s')\r\n\0"
16552 as *const u8 as *const libc::c_char,
16553 if !err.is_null() {
16554 err as *const libc::c_char
16555 } else {
16556 b"NULL reply\0" as *const u8 as *const libc::c_char
16557 },
16558 );
16559 if !err.is_null() {
16560 zfree(err as *mut libc::c_void);
16561 }
16562 success = 0 as libc::c_int;
16563 current_block = 231212672767030328;
16564 } else {
16565 if (*function_list_reply).type_0 == 2 as libc::c_int
16566 {} else {
16567 __assert_fail(
16568 b"function_list_reply->type == REDIS_REPLY_ARRAY\0"
16569 as *const u8 as *const libc::c_char,
16570 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
16571 6490 as libc::c_int as libc::c_uint,
16572 (*core::mem::transmute::<
16573 &[u8; 47],
16574 &[libc::c_char; 47],
16575 >(b"int clusterManagerCommandAddNode(int, char **)\0"))
16576 .as_ptr(),
16577 );
16578 };
16579 if (*function_list_reply).elements
16580 > 0 as libc::c_int as libc::c_ulong
16581 {
16582 clusterManagerLog(
16583 3 as libc::c_int,
16584 b">>> New node already contains functions and can not be added to the cluster. Use FUNCTION FLUSH and try again.\r\n\0"
16585 as *const u8 as *const libc::c_char,
16586 );
16587 success = 0 as libc::c_int;
16588 current_block = 231212672767030328;
16589 } else {
16590 clusterManagerLog(
16591 1 as libc::c_int,
16592 b">>> Send FUNCTION RESTORE to %s:%d\n\0" as *const u8
16593 as *const libc::c_char,
16594 ip,
16595 port,
16596 );
16597 function_restore_reply = redisCommand(
16598 (*new_node).context,
16599 b"FUNCTION RESTORE %b\0" as *const u8
16600 as *const libc::c_char,
16601 (*reply).str_0,
16602 (*reply).len,
16603 ) as *mut redisReply;
16604 if clusterManagerCheckRedisReply(
16605 new_node,
16606 function_restore_reply,
16607 &mut err,
16608 ) == 0
16609 {
16610 clusterManagerLog(
16611 3 as libc::c_int,
16612 b">>> Failed loading functions to the new node (error = '%s')\r\n\0"
16613 as *const u8 as *const libc::c_char,
16614 if !err.is_null() {
16615 err as *const libc::c_char
16616 } else {
16617 b"NULL reply\0" as *const u8 as *const libc::c_char
16618 },
16619 );
16620 if !err.is_null() {
16621 zfree(err as *mut libc::c_void);
16622 }
16623 success = 0 as libc::c_int;
16624 current_block = 231212672767030328;
16625 } else {
16626 current_block = 6560072651652764009;
16627 }
16628 }
16629 }
16630 }
16631 } else {
16632 current_block = 6560072651652764009;
16633 }
16634 match current_block {
16635 231212672767030328 => {}
16636 _ => {
16637 if !reply.is_null() {
16638 freeReplyObject(reply as *mut libc::c_void);
16639 }
16640 clusterManagerLog(
16641 1 as libc::c_int,
16642 b">>> Send CLUSTER MEET to node %s:%d to make it join the cluster.\n\0"
16643 as *const u8 as *const libc::c_char,
16644 ip,
16645 port,
16646 );
16647 first_ip = [0; 46];
16648 if anetResolve(
16649 0 as *mut libc::c_char,
16650 (*first).ip,
16651 first_ip.as_mut_ptr(),
16652 core::mem::size_of::<[libc::c_char; 46]>()
16653 as libc::c_ulong,
16654 0 as libc::c_int,
16655 ) == -(1 as libc::c_int)
16656 {
16657 fprintf(
16658 stderr,
16659 b"Invalid IP address or hostname specified: %s\n\0"
16660 as *const u8 as *const libc::c_char,
16661 (*first).ip,
16662 );
16663 success = 0 as libc::c_int;
16664 } else {
16665 if (*first).bus_port == 0 as libc::c_int
16666 || (*first).bus_port == (*first).port + 10000 as libc::c_int
16667 {
16668 reply = redisCommand(
16669 (*new_node).context,
16670 b"CLUSTER MEET %s %d\0" as *const u8 as *const libc::c_char,
16671 first_ip.as_mut_ptr(),
16672 (*first).port,
16673 ) as *mut redisReply;
16674 } else {
16675 reply = redisCommand(
16676 (*new_node).context,
16677 b"CLUSTER MEET %s %d %d\0" as *const u8
16678 as *const libc::c_char,
16679 first_ip.as_mut_ptr(),
16680 (*first).port,
16681 (*first).bus_port,
16682 ) as *mut redisReply;
16683 }
16684 success = clusterManagerCheckRedisReply(
16685 new_node,
16686 reply,
16687 0 as *mut *mut libc::c_char,
16688 );
16689 if !(success == 0) {
16690 if !master_node.is_null() {
16691 sleep(1 as libc::c_int as libc::c_uint);
16692 clusterManagerWaitForClusterJoin();
16693 clusterManagerLog(
16694 1 as libc::c_int,
16695 b">>> Configure node as replica of %s:%d.\n\0" as *const u8
16696 as *const libc::c_char,
16697 (*master_node).ip,
16698 (*master_node).port,
16699 );
16700 freeReplyObject(reply as *mut libc::c_void);
16701 reply = redisCommand(
16702 (*new_node).context,
16703 b"CLUSTER REPLICATE %s\0" as *const u8
16704 as *const libc::c_char,
16705 (*master_node).name,
16706 ) as *mut redisReply;
16707 success = clusterManagerCheckRedisReply(
16708 new_node,
16709 reply,
16710 0 as *mut *mut libc::c_char,
16711 );
16712 if success == 0 {
16713 current_block = 231212672767030328;
16714 } else {
16715 current_block = 3229571381435211107;
16716 }
16717 } else {
16718 current_block = 3229571381435211107;
16719 }
16720 match current_block {
16721 231212672767030328 => {}
16722 _ => {
16723 clusterManagerLog(
16724 4 as libc::c_int,
16725 b"[OK] New node added correctly.\n\0" as *const u8
16726 as *const libc::c_char,
16727 );
16728 }
16729 }
16730 }
16731 }
16732 }
16733 }
16734 }
16735 }
16736 }
16737 if added == 0 && !new_node.is_null() {
16738 freeClusterManagerNode(new_node);
16739 }
16740 if !reply.is_null() {
16741 freeReplyObject(reply as *mut libc::c_void);
16742 }
16743 if !function_restore_reply.is_null() {
16744 freeReplyObject(function_restore_reply as *mut libc::c_void);
16745 }
16746 if !function_list_reply.is_null() {
16747 freeReplyObject(function_list_reply as *mut libc::c_void);
16748 }
16749 return success;
16750 }
16751 }
16752 fprintf(
16753 stderr,
16754 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
16755 as *const u8 as *const libc::c_char,
16756 );
16757 return 0 as libc::c_int;
16758}
16759unsafe extern "C" fn clusterManagerCommandDeleteNode(
16760 mut argc: libc::c_int,
16761 mut argv: *mut *mut libc::c_char,
16762) -> libc::c_int {
16763 let mut node_id: *mut libc::c_char = 0 as *mut libc::c_char;
16764 let mut ref_node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16765 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16766 let mut li: listIter = listIter {
16767 next: 0 as *mut listNode,
16768 direction: 0,
16769 };
16770 let mut ln: *mut listNode = 0 as *mut listNode;
16771 let mut r_1: *mut redisReply = 0 as *mut redisReply;
16772 let mut success: libc::c_int = 1 as libc::c_int;
16773 let mut port: libc::c_int = 0 as libc::c_int;
16774 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
16775 if getClusterHostFromCmdArgs(1 as libc::c_int, argv, &mut ip, &mut port) == 0 {
16776 fprintf(
16777 stderr,
16778 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
16779 as *const u8 as *const libc::c_char,
16780 );
16781 return 0 as libc::c_int;
16782 } else {
16783 node_id = *argv.offset(1 as libc::c_int as isize);
16784 clusterManagerLog(
16785 1 as libc::c_int,
16786 b">>> Removing node %s from cluster %s:%d\n\0" as *const u8
16787 as *const libc::c_char,
16788 node_id,
16789 ip,
16790 port,
16791 );
16792 ref_node = clusterManagerNewNode(ip, port, 0 as libc::c_int);
16793 node = 0 as *mut clusterManagerNode;
16794 if clusterManagerLoadInfoFromNode(ref_node) == 0 {
16795 return 0 as libc::c_int;
16796 }
16797 node = clusterManagerNodeByName(node_id);
16798 if node.is_null() {
16799 clusterManagerLog(
16800 3 as libc::c_int,
16801 b"[ERR] No such node ID %s\n\0" as *const u8 as *const libc::c_char,
16802 node_id,
16803 );
16804 return 0 as libc::c_int;
16805 }
16806 if (*node).slots_count != 0 as libc::c_int {
16807 clusterManagerLog(
16808 3 as libc::c_int,
16809 b"[ERR] Node %s:%d is not empty! Reshard data away and try again.\n\0"
16810 as *const u8 as *const libc::c_char,
16811 (*node).ip,
16812 (*node).port,
16813 );
16814 return 0 as libc::c_int;
16815 }
16816 clusterManagerLog(
16817 1 as libc::c_int,
16818 b">>> Sending CLUSTER FORGET messages to the cluster...\n\0" as *const u8
16819 as *const libc::c_char,
16820 );
16821 li = listIter {
16822 next: 0 as *mut listNode,
16823 direction: 0,
16824 };
16825 ln = 0 as *mut listNode;
16826 listRewind(cluster_manager.nodes, &mut li);
16827 loop {
16828 ln = listNext(&mut li);
16829 if ln.is_null() {
16830 break;
16831 }
16832 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
16833 if n == node {
16834 continue;
16835 }
16836 if !((*n).replicate).is_null()
16837 && strcasecmp((*n).replicate as *const libc::c_char, node_id) == 0
16838 {
16839 let mut master: *mut clusterManagerNode = clusterManagerNodeWithLeastReplicas();
16840 if !master.is_null() {} else {
16841 __assert_fail(
16842 b"master != NULL\0" as *const u8 as *const libc::c_char,
16843 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
16844 6597 as libc::c_int as libc::c_uint,
16845 (*core::mem::transmute::<
16846 &[u8; 50],
16847 &[libc::c_char; 50],
16848 >(b"int clusterManagerCommandDeleteNode(int, char **)\0"))
16849 .as_ptr(),
16850 );
16851 };
16852 clusterManagerLog(
16853 1 as libc::c_int,
16854 b">>> %s:%d as replica of %s:%d\n\0" as *const u8
16855 as *const libc::c_char,
16856 (*n).ip,
16857 (*n).port,
16858 (*master).ip,
16859 (*master).port,
16860 );
16861 let mut r: *mut redisReply = redisCommand(
16862 (*n).context,
16863 b"CLUSTER REPLICATE %s\0" as *const u8 as *const libc::c_char,
16864 (*master).name,
16865 ) as *mut redisReply;
16866 success = clusterManagerCheckRedisReply(
16867 n,
16868 r,
16869 0 as *mut *mut libc::c_char,
16870 );
16871 if !r.is_null() {
16872 freeReplyObject(r as *mut libc::c_void);
16873 }
16874 if success == 0 {
16875 return 0 as libc::c_int;
16876 }
16877 }
16878 let mut r_0: *mut redisReply = redisCommand(
16879 (*n).context,
16880 b"CLUSTER FORGET %s\0" as *const u8 as *const libc::c_char,
16881 node_id,
16882 ) as *mut redisReply;
16883 success = clusterManagerCheckRedisReply(n, r_0, 0 as *mut *mut libc::c_char);
16884 if !r_0.is_null() {
16885 freeReplyObject(r_0 as *mut libc::c_void);
16886 }
16887 if success == 0 {
16888 return 0 as libc::c_int;
16889 }
16890 }
16891 clusterManagerLog(
16892 1 as libc::c_int,
16893 b">>> Sending CLUSTER RESET SOFT to the deleted node.\n\0" as *const u8
16894 as *const libc::c_char,
16895 );
16896 r_1 = redisCommand(
16897 (*node).context,
16898 b"CLUSTER RESET %s\0" as *const u8 as *const libc::c_char,
16899 b"SOFT\0" as *const u8 as *const libc::c_char,
16900 ) as *mut redisReply;
16901 success = clusterManagerCheckRedisReply(node, r_1, 0 as *mut *mut libc::c_char);
16902 if !r_1.is_null() {
16903 freeReplyObject(r_1 as *mut libc::c_void);
16904 }
16905 return success;
16906 };
16907}
16908unsafe extern "C" fn clusterManagerCommandInfo(
16909 mut argc: libc::c_int,
16910 mut argv: *mut *mut libc::c_char,
16911) -> libc::c_int {
16912 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16913 let mut port: libc::c_int = 0 as libc::c_int;
16914 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
16915 if getClusterHostFromCmdArgs(argc, argv, &mut ip, &mut port) == 0 {
16916 fprintf(
16917 stderr,
16918 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
16919 as *const u8 as *const libc::c_char,
16920 );
16921 return 0 as libc::c_int;
16922 } else {
16923 node = clusterManagerNewNode(ip, port, 0 as libc::c_int);
16924 if clusterManagerLoadInfoFromNode(node) == 0 {
16925 return 0 as libc::c_int;
16926 }
16927 clusterManagerShowClusterInfo();
16928 return 1 as libc::c_int;
16929 };
16930}
16931unsafe extern "C" fn clusterManagerCommandCheck(
16932 mut argc: libc::c_int,
16933 mut argv: *mut *mut libc::c_char,
16934) -> libc::c_int {
16935 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16936 let mut port: libc::c_int = 0 as libc::c_int;
16937 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
16938 if getClusterHostFromCmdArgs(argc, argv, &mut ip, &mut port) == 0 {
16939 fprintf(
16940 stderr,
16941 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
16942 as *const u8 as *const libc::c_char,
16943 );
16944 return 0 as libc::c_int;
16945 } else {
16946 node = clusterManagerNewNode(ip, port, 0 as libc::c_int);
16947 if clusterManagerLoadInfoFromNode(node) == 0 {
16948 return 0 as libc::c_int;
16949 }
16950 clusterManagerShowClusterInfo();
16951 return clusterManagerCheckCluster(0 as libc::c_int);
16952 };
16953}
16954unsafe extern "C" fn clusterManagerCommandFix(
16955 mut argc: libc::c_int,
16956 mut argv: *mut *mut libc::c_char,
16957) -> libc::c_int {
16958 config.cluster_manager_command.flags |= (1 as libc::c_int) << 0 as libc::c_int;
16959 return clusterManagerCommandCheck(argc, argv);
16960}
16961unsafe extern "C" fn clusterManagerCommandReshard(
16962 mut argc: libc::c_int,
16963 mut argv: *mut *mut libc::c_char,
16964) -> libc::c_int {
16965 let mut li: listIter = listIter {
16966 next: 0 as *mut listNode,
16967 direction: 0,
16968 };
16969 let mut ln: *mut listNode = 0 as *mut listNode;
16970 let mut info_0: hisds = 0 as *mut libc::c_char;
16971 let mut opts: libc::c_int = 0;
16972 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16973 let mut slots: libc::c_int = 0;
16974 let mut buf_0: [libc::c_char; 255] = [0; 255];
16975 let mut to: *mut libc::c_char = 0 as *mut libc::c_char;
16976 let mut from: *mut libc::c_char = 0 as *mut libc::c_char;
16977 let mut raise_err: libc::c_int = 0;
16978 let mut target: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
16979 let mut sources: *mut list = 0 as *mut list;
16980 let mut table: *mut list = 0 as *mut list;
16981 let mut all: libc::c_int = 0;
16982 let mut result: libc::c_int = 0;
16983 let mut current_block: u64;
16984 let mut port: libc::c_int = 0 as libc::c_int;
16985 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
16986 if getClusterHostFromCmdArgs(argc, argv, &mut ip, &mut port) == 0 {
16987 fprintf(
16988 stderr,
16989 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
16990 as *const u8 as *const libc::c_char,
16991 );
16992 return 0 as libc::c_int;
16993 } else {
16994 node = clusterManagerNewNode(ip, port, 0 as libc::c_int);
16995 if clusterManagerLoadInfoFromNode(node) == 0 {
16996 return 0 as libc::c_int;
16997 }
16998 clusterManagerCheckCluster(0 as libc::c_int);
16999 if !(cluster_manager.errors).is_null()
17000 && (*cluster_manager.errors).len > 0 as libc::c_int as libc::c_ulong
17001 {
17002 fflush(stdout);
17003 fprintf(
17004 stderr,
17005 b"*** Please fix your cluster problems before resharding\n\0"
17006 as *const u8 as *const libc::c_char,
17007 );
17008 return 0 as libc::c_int;
17009 }
17010 slots = config.cluster_manager_command.slots;
17011 if slots == 0 {
17012 while slots <= 0 as libc::c_int || slots > 16384 as libc::c_int {
17013 printf(
17014 b"How many slots do you want to move (from 1 to %d)? \0" as *const u8
17015 as *const libc::c_char,
17016 16384 as libc::c_int,
17017 );
17018 fflush(stdout);
17019 let mut buf: [libc::c_char; 6] = [0; 6];
17020 let mut nread: libc::c_int = read(
17021 fileno(stdin),
17022 buf.as_mut_ptr() as *mut libc::c_void,
17023 6 as libc::c_int as size_t,
17024 ) as libc::c_int;
17025 if nread <= 0 as libc::c_int {
17026 continue;
17027 }
17028 let mut last_idx: libc::c_int = nread - 1 as libc::c_int;
17029 if buf[last_idx as usize] as libc::c_int != '\n' as i32 {
17030 let mut ch: libc::c_int = 0;
17031 loop {
17032 ch = getchar();
17033 if !(ch != '\n' as i32 && ch != -(1 as libc::c_int)) {
17034 break;
17035 }
17036 }
17037 }
17038 buf[last_idx as usize] = '\0' as i32 as libc::c_char;
17039 slots = atoi(buf.as_mut_ptr());
17040 }
17041 }
17042 buf_0 = [0; 255];
17043 to = config.cluster_manager_command.to;
17044 from = config.cluster_manager_command.from;
17045 while to.is_null() {
17046 printf(
17047 b"What is the receiving node ID? \0" as *const u8 as *const libc::c_char,
17048 );
17049 fflush(stdout);
17050 let mut nread_0: libc::c_int = read(
17051 fileno(stdin),
17052 buf_0.as_mut_ptr() as *mut libc::c_void,
17053 255 as libc::c_int as size_t,
17054 ) as libc::c_int;
17055 if nread_0 <= 0 as libc::c_int {
17056 continue;
17057 }
17058 let mut last_idx_0: libc::c_int = nread_0 - 1 as libc::c_int;
17059 if buf_0[last_idx_0 as usize] as libc::c_int != '\n' as i32 {
17060 let mut ch_0: libc::c_int = 0;
17061 loop {
17062 ch_0 = getchar();
17063 if !(ch_0 != '\n' as i32 && ch_0 != -(1 as libc::c_int)) {
17064 break;
17065 }
17066 }
17067 }
17068 buf_0[last_idx_0 as usize] = '\0' as i32 as libc::c_char;
17069 if strlen(buf_0.as_mut_ptr()) > 0 as libc::c_int as libc::c_ulong {
17070 to = buf_0.as_mut_ptr();
17071 }
17072 }
17073 raise_err = 0 as libc::c_int;
17074 target = clusterNodeForResharding(
17075 to,
17076 0 as *mut clusterManagerNode,
17077 &mut raise_err,
17078 );
17079 if target.is_null() {
17080 return 0 as libc::c_int;
17081 }
17082 sources = listCreate();
17083 table = 0 as *mut list;
17084 all = 0 as libc::c_int;
17085 result = 1 as libc::c_int;
17086 if from.is_null() {
17087 printf(
17088 b"Please enter all the source node IDs.\n\0" as *const u8
17089 as *const libc::c_char,
17090 );
17091 printf(
17092 b" Type 'all' to use all the nodes as source nodes for the hash slots.\n\0"
17093 as *const u8 as *const libc::c_char,
17094 );
17095 printf(
17096 b" Type 'done' once you entered all the source nodes IDs.\n\0"
17097 as *const u8 as *const libc::c_char,
17098 );
17099 loop {
17100 printf(
17101 b"Source node #%lu: \0" as *const u8 as *const libc::c_char,
17102 ((*sources).len).wrapping_add(1 as libc::c_int as libc::c_ulong),
17103 );
17104 fflush(stdout);
17105 let mut nread_1: libc::c_int = read(
17106 fileno(stdin),
17107 buf_0.as_mut_ptr() as *mut libc::c_void,
17108 255 as libc::c_int as size_t,
17109 ) as libc::c_int;
17110 if nread_1 <= 0 as libc::c_int {
17111 continue;
17112 }
17113 let mut last_idx_1: libc::c_int = nread_1 - 1 as libc::c_int;
17114 if buf_0[last_idx_1 as usize] as libc::c_int != '\n' as i32 {
17115 let mut ch_1: libc::c_int = 0;
17116 loop {
17117 ch_1 = getchar();
17118 if !(ch_1 != '\n' as i32 && ch_1 != -(1 as libc::c_int)) {
17119 break;
17120 }
17121 }
17122 }
17123 buf_0[last_idx_1 as usize] = '\0' as i32 as libc::c_char;
17124 if strcmp(
17125 buf_0.as_mut_ptr(),
17126 b"done\0" as *const u8 as *const libc::c_char,
17127 ) == 0
17128 {
17129 current_block = 2168227384378665163;
17130 break;
17131 }
17132 if strcmp(
17133 buf_0.as_mut_ptr(),
17134 b"all\0" as *const u8 as *const libc::c_char,
17135 ) == 0
17136 {
17137 all = 1 as libc::c_int;
17138 current_block = 2168227384378665163;
17139 break;
17140 } else {
17141 let mut src: *mut clusterManagerNode = clusterNodeForResharding(
17142 buf_0.as_mut_ptr(),
17143 target,
17144 &mut raise_err,
17145 );
17146 if !src.is_null() {
17147 listAddNodeTail(sources, src as *mut libc::c_void);
17148 } else {
17149 if !(raise_err != 0) {
17150 continue;
17151 }
17152 result = 0 as libc::c_int;
17153 current_block = 7153694847983639079;
17154 break;
17155 }
17156 }
17157 }
17158 } else {
17159 let mut p: *mut libc::c_char = 0 as *mut libc::c_char;
17160 loop {
17161 p = strchr(from, ',' as i32);
17162 if p.is_null() {
17163 current_block = 7494008139977416618;
17164 break;
17165 }
17166 *p = '\0' as i32 as libc::c_char;
17167 if strcmp(from, b"all\0" as *const u8 as *const libc::c_char) == 0 {
17168 all = 1 as libc::c_int;
17169 current_block = 7494008139977416618;
17170 break;
17171 } else {
17172 let mut src_0: *mut clusterManagerNode = clusterNodeForResharding(
17173 from,
17174 target,
17175 &mut raise_err,
17176 );
17177 if !src_0.is_null() {
17178 listAddNodeTail(sources, src_0 as *mut libc::c_void);
17179 } else if raise_err != 0 {
17180 result = 0 as libc::c_int;
17181 current_block = 7153694847983639079;
17182 break;
17183 }
17184 from = p.offset(1 as libc::c_int as isize);
17185 }
17186 }
17187 match current_block {
17188 7153694847983639079 => {}
17189 _ => {
17190 if all == 0 && strlen(from) > 0 as libc::c_int as libc::c_ulong {
17191 if strcmp(from, b"all\0" as *const u8 as *const libc::c_char)
17192 == 0
17193 {
17194 all = 1 as libc::c_int;
17195 }
17196 if all == 0 {
17197 let mut src_1: *mut clusterManagerNode = clusterNodeForResharding(
17198 from,
17199 target,
17200 &mut raise_err,
17201 );
17202 if !src_1.is_null() {
17203 listAddNodeTail(sources, src_1 as *mut libc::c_void);
17204 current_block = 2168227384378665163;
17205 } else if raise_err != 0 {
17206 result = 0 as libc::c_int;
17207 current_block = 7153694847983639079;
17208 } else {
17209 current_block = 2168227384378665163;
17210 }
17211 } else {
17212 current_block = 2168227384378665163;
17213 }
17214 } else {
17215 current_block = 2168227384378665163;
17216 }
17217 }
17218 }
17219 }
17220 match current_block {
17221 2168227384378665163 => {
17222 li = listIter {
17223 next: 0 as *mut listNode,
17224 direction: 0,
17225 };
17226 ln = 0 as *mut listNode;
17227 if all != 0 {
17228 listEmpty(sources);
17229 listRewind(cluster_manager.nodes, &mut li);
17230 loop {
17231 ln = listNext(&mut li);
17232 if ln.is_null() {
17233 break;
17234 }
17235 let mut n: *mut clusterManagerNode = (*ln).value
17236 as *mut clusterManagerNode;
17237 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0
17238 || !((*n).replicate).is_null()
17239 {
17240 continue;
17241 }
17242 if hi_sdscmp((*n).name, (*target).name) == 0 {
17243 continue;
17244 }
17245 listAddNodeTail(sources, n as *mut libc::c_void);
17246 }
17247 }
17248 if (*sources).len == 0 as libc::c_int as libc::c_ulong {
17249 fprintf(
17250 stderr,
17251 b"*** No source nodes given, operation aborted.\n\0" as *const u8
17252 as *const libc::c_char,
17253 );
17254 result = 0 as libc::c_int;
17255 } else {
17256 printf(
17257 b"\nReady to move %d slots.\n\0" as *const u8
17258 as *const libc::c_char,
17259 slots,
17260 );
17261 printf(b" Source nodes:\n\0" as *const u8 as *const libc::c_char);
17262 listRewind(sources, &mut li);
17263 loop {
17264 ln = listNext(&mut li);
17265 if ln.is_null() {
17266 break;
17267 }
17268 let mut src_2: *mut clusterManagerNode = (*ln).value
17269 as *mut clusterManagerNode;
17270 let mut info: hisds = clusterManagerNodeInfo(
17271 src_2,
17272 4 as libc::c_int,
17273 );
17274 printf(b"%s\n\0" as *const u8 as *const libc::c_char, info);
17275 hi_sdsfree(info);
17276 }
17277 printf(
17278 b" Destination node:\n\0" as *const u8 as *const libc::c_char,
17279 );
17280 info_0 = clusterManagerNodeInfo(target, 4 as libc::c_int);
17281 printf(b"%s\n\0" as *const u8 as *const libc::c_char, info_0);
17282 hi_sdsfree(info_0);
17283 table = clusterManagerComputeReshardTable(sources, slots);
17284 printf(
17285 b" Resharding plan:\n\0" as *const u8 as *const libc::c_char,
17286 );
17287 clusterManagerShowReshardTable(table);
17288 if config.cluster_manager_command.flags
17289 & (1 as libc::c_int) << 2 as libc::c_int == 0
17290 {
17291 printf(
17292 b"Do you want to proceed with the proposed reshard plan (yes/no)? \0"
17293 as *const u8 as *const libc::c_char,
17294 );
17295 fflush(stdout);
17296 let mut buf_1: [libc::c_char; 4] = [0; 4];
17297 let mut nread_2: libc::c_int = read(
17298 fileno(stdin),
17299 buf_1.as_mut_ptr() as *mut libc::c_void,
17300 4 as libc::c_int as size_t,
17301 ) as libc::c_int;
17302 buf_1[3 as libc::c_int as usize] = '\0' as i32 as libc::c_char;
17303 if nread_2 <= 0 as libc::c_int
17304 || strcmp(
17305 b"yes\0" as *const u8 as *const libc::c_char,
17306 buf_1.as_mut_ptr(),
17307 ) != 0 as libc::c_int
17308 {
17309 result = 0 as libc::c_int;
17310 current_block = 7153694847983639079;
17311 } else {
17312 current_block = 722119776535234387;
17313 }
17314 } else {
17315 current_block = 722119776535234387;
17316 }
17317 match current_block {
17318 7153694847983639079 => {}
17319 _ => {
17320 opts = (1 as libc::c_int) << 7 as libc::c_int;
17321 listRewind(table, &mut li);
17322 loop {
17323 ln = listNext(&mut li);
17324 if ln.is_null() {
17325 break;
17326 }
17327 let mut item: *mut clusterManagerReshardTableItem = (*ln)
17328 .value as *mut clusterManagerReshardTableItem;
17329 let mut err: *mut libc::c_char = 0 as *mut libc::c_char;
17330 result = clusterManagerMoveSlot(
17331 (*item).source,
17332 target,
17333 (*item).slot,
17334 opts,
17335 &mut err,
17336 );
17337 if !(result == 0) {
17338 continue;
17339 }
17340 if !err.is_null() {
17341 clusterManagerLog(
17342 3 as libc::c_int,
17343 b"clusterManagerMoveSlot failed: %s\n\0" as *const u8
17344 as *const libc::c_char,
17345 err,
17346 );
17347 zfree(err as *mut libc::c_void);
17348 }
17349 break;
17350 }
17351 }
17352 }
17353 }
17354 }
17355 _ => {}
17356 }
17357 listRelease(sources);
17358 clusterManagerReleaseReshardTable(table);
17359 return result;
17360 };
17361}
17362unsafe extern "C" fn clusterManagerCommandRebalance(
17363 mut argc: libc::c_int,
17364 mut argv: *mut *mut libc::c_char,
17365) -> libc::c_int {
17366 let mut total_weight: libc::c_float = 0.;
17367 let mut nodes_involved: libc::c_int = 0;
17368 let mut use_empty: libc::c_int = 0;
17369 let mut li: listIter = listIter {
17370 next: 0 as *mut listNode,
17371 direction: 0,
17372 };
17373 let mut ln: *mut listNode = 0 as *mut listNode;
17374 let mut threshold_reached: libc::c_int = 0;
17375 let mut total_balance: libc::c_int = 0;
17376 let mut threshold: libc::c_float = 0.;
17377 let mut dst_idx: libc::c_int = 0;
17378 let mut src_idx: libc::c_int = 0;
17379 let mut simulate: libc::c_int = 0;
17380 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
17381 let mut result: libc::c_int = 0;
17382 let mut i: libc::c_int = 0;
17383 let mut current_block: u64;
17384 let mut port: libc::c_int = 0 as libc::c_int;
17385 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
17386 let mut weightedNodes: *mut *mut clusterManagerNode = 0
17387 as *mut *mut clusterManagerNode;
17388 let mut involved: *mut list = 0 as *mut list;
17389 if getClusterHostFromCmdArgs(argc, argv, &mut ip, &mut port) == 0 {
17390 fprintf(
17391 stderr,
17392 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
17393 as *const u8 as *const libc::c_char,
17394 );
17395 return 0 as libc::c_int;
17396 } else {
17397 node = clusterManagerNewNode(ip, port, 0 as libc::c_int);
17398 if clusterManagerLoadInfoFromNode(node) == 0 {
17399 return 0 as libc::c_int;
17400 }
17401 result = 1 as libc::c_int;
17402 i = 0;
17403 if !(config.cluster_manager_command.weight).is_null() {
17404 i = 0 as libc::c_int;
17405 loop {
17406 if !(i < config.cluster_manager_command.weight_argc) {
17407 current_block = 7149356873433890176;
17408 break;
17409 }
17410 let mut name: *mut libc::c_char = *(config
17411 .cluster_manager_command
17412 .weight)
17413 .offset(i as isize);
17414 let mut p: *mut libc::c_char = strchr(name, '=' as i32);
17415 if p.is_null() {
17416 clusterManagerLog(
17417 3 as libc::c_int,
17418 b"*** invalid input %s\n\0" as *const u8 as *const libc::c_char,
17419 name,
17420 );
17421 result = 0 as libc::c_int;
17422 current_block = 2461195999744060749;
17423 break;
17424 } else {
17425 *p = '\0' as i32 as libc::c_char;
17426 p = p.offset(1);
17427 let mut w: libc::c_float = atof(p) as libc::c_float;
17428 let mut n: *mut clusterManagerNode = clusterManagerNodeByAbbreviatedName(
17429 name,
17430 );
17431 if n.is_null() {
17432 clusterManagerLog(
17433 3 as libc::c_int,
17434 b"*** No such master node %s\n\0" as *const u8
17435 as *const libc::c_char,
17436 name,
17437 );
17438 result = 0 as libc::c_int;
17439 current_block = 2461195999744060749;
17440 break;
17441 } else {
17442 (*n).weight = w;
17443 i += 1;
17444 }
17445 }
17446 }
17447 } else {
17448 current_block = 7149356873433890176;
17449 }
17450 match current_block {
17451 7149356873433890176 => {
17452 total_weight = 0 as libc::c_int as libc::c_float;
17453 nodes_involved = 0 as libc::c_int;
17454 use_empty = config.cluster_manager_command.flags
17455 & (1 as libc::c_int) << 4 as libc::c_int;
17456 involved = listCreate();
17457 li = listIter {
17458 next: 0 as *mut listNode,
17459 direction: 0,
17460 };
17461 ln = 0 as *mut listNode;
17462 listRewind(cluster_manager.nodes, &mut li);
17463 loop {
17464 ln = listNext(&mut li);
17465 if ln.is_null() {
17466 break;
17467 }
17468 let mut n_0: *mut clusterManagerNode = (*ln).value
17469 as *mut clusterManagerNode;
17470 if (*n_0).flags & (1 as libc::c_int) << 1 as libc::c_int != 0
17471 || !((*n_0).replicate).is_null()
17472 {
17473 continue;
17474 }
17475 if use_empty == 0 && (*n_0).slots_count == 0 as libc::c_int {
17476 (*n_0).weight = 0 as libc::c_int as libc::c_float;
17477 } else {
17478 total_weight += (*n_0).weight;
17479 nodes_involved += 1;
17480 listAddNodeTail(involved, n_0 as *mut libc::c_void);
17481 }
17482 }
17483 weightedNodes = zmalloc(
17484 (nodes_involved as libc::c_ulong)
17485 .wrapping_mul(
17486 core::mem::size_of::<*mut clusterManagerNode>()
17487 as libc::c_ulong,
17488 ),
17489 ) as *mut *mut clusterManagerNode;
17490 if !weightedNodes.is_null() {
17491 clusterManagerCheckCluster(1 as libc::c_int);
17492 if !(cluster_manager.errors).is_null()
17493 && (*cluster_manager.errors).len
17494 > 0 as libc::c_int as libc::c_ulong
17495 {
17496 clusterManagerLog(
17497 3 as libc::c_int,
17498 b"*** Please fix your cluster problems before rebalancing\n\0"
17499 as *const u8 as *const libc::c_char,
17500 );
17501 result = 0 as libc::c_int;
17502 } else {
17503 threshold_reached = 0 as libc::c_int;
17504 total_balance = 0 as libc::c_int;
17505 threshold = config.cluster_manager_command.threshold;
17506 i = 0 as libc::c_int;
17507 listRewind(involved, &mut li);
17508 loop {
17509 ln = listNext(&mut li);
17510 if ln.is_null() {
17511 break;
17512 }
17513 let mut n_1: *mut clusterManagerNode = (*ln).value
17514 as *mut clusterManagerNode;
17515 let fresh73 = i;
17516 i = i + 1;
17517 let ref mut fresh74 = *weightedNodes
17518 .offset(fresh73 as isize);
17519 *fresh74 = n_1;
17520 let mut expected: libc::c_int = (16384 as libc::c_int
17521 as libc::c_float / total_weight * (*n_1).weight)
17522 as libc::c_int;
17523 (*n_1).balance = (*n_1).slots_count - expected;
17524 total_balance += (*n_1).balance;
17525 let mut over_threshold: libc::c_int = 0 as libc::c_int;
17526 if threshold > 0 as libc::c_int as libc::c_float {
17527 if (*n_1).slots_count > 0 as libc::c_int {
17528 let mut err_perc: libc::c_float = fabs(
17529 100 as libc::c_int as libc::c_double
17530 - 100.0f64 * expected as libc::c_double
17531 / (*n_1).slots_count as libc::c_double,
17532 ) as libc::c_float;
17533 if err_perc > threshold {
17534 over_threshold = 1 as libc::c_int;
17535 }
17536 } else if expected > 1 as libc::c_int {
17537 over_threshold = 1 as libc::c_int;
17538 }
17539 }
17540 if over_threshold != 0 {
17541 threshold_reached = 1 as libc::c_int;
17542 }
17543 }
17544 if threshold_reached == 0 {
17545 clusterManagerLog(
17546 2 as libc::c_int,
17547 b"*** No rebalancing needed! All nodes are within the %.2f%% threshold.\n\0"
17548 as *const u8 as *const libc::c_char,
17549 config.cluster_manager_command.threshold as libc::c_double,
17550 );
17551 } else {
17552 while total_balance > 0 as libc::c_int {
17553 listRewind(involved, &mut li);
17554 loop {
17555 ln = listNext(&mut li);
17556 if ln.is_null() {
17557 break;
17558 }
17559 let mut n_2: *mut clusterManagerNode = (*ln).value
17560 as *mut clusterManagerNode;
17561 if (*n_2).balance <= 0 as libc::c_int
17562 && total_balance > 0 as libc::c_int
17563 {
17564 (*n_2).balance -= 1;
17565 total_balance -= 1;
17566 }
17567 }
17568 }
17569 qsort(
17570 weightedNodes as *mut libc::c_void,
17571 nodes_involved as size_t,
17572 core::mem::size_of::<*mut clusterManagerNode>()
17573 as libc::c_ulong,
17574 Some(
17575 clusterManagerCompareNodeBalance
17576 as unsafe extern "C" fn(
17577 *const libc::c_void,
17578 *const libc::c_void,
17579 ) -> libc::c_int,
17580 ),
17581 );
17582 clusterManagerLog(
17583 1 as libc::c_int,
17584 b">>> Rebalancing across %d nodes. Total weight = %.2f\n\0"
17585 as *const u8 as *const libc::c_char,
17586 nodes_involved,
17587 total_weight as libc::c_double,
17588 );
17589 if config.verbose != 0 {
17590 i = 0 as libc::c_int;
17591 while i < nodes_involved {
17592 let mut n_3: *mut clusterManagerNode = *weightedNodes
17593 .offset(i as isize);
17594 printf(
17595 b"%s:%d balance is %d slots\n\0" as *const u8
17596 as *const libc::c_char,
17597 (*n_3).ip,
17598 (*n_3).port,
17599 (*n_3).balance,
17600 );
17601 i += 1;
17602 }
17603 }
17604 dst_idx = 0 as libc::c_int;
17605 src_idx = nodes_involved - 1 as libc::c_int;
17606 simulate = config.cluster_manager_command.flags
17607 & (1 as libc::c_int) << 5 as libc::c_int;
17608 while dst_idx < src_idx {
17609 let mut dst: *mut clusterManagerNode = *weightedNodes
17610 .offset(dst_idx as isize);
17611 let mut src: *mut clusterManagerNode = *weightedNodes
17612 .offset(src_idx as isize);
17613 let mut db: libc::c_int = abs((*dst).balance);
17614 let mut sb: libc::c_int = abs((*src).balance);
17615 let mut numslots: libc::c_int = if db < sb {
17616 db
17617 } else {
17618 sb
17619 };
17620 if numslots > 0 as libc::c_int {
17621 printf(
17622 b"Moving %d slots from %s:%d to %s:%d\n\0" as *const u8
17623 as *const libc::c_char,
17624 numslots,
17625 (*src).ip,
17626 (*src).port,
17627 (*dst).ip,
17628 (*dst).port,
17629 );
17630 let mut lsrc: *mut list = listCreate();
17631 let mut table: *mut list = 0 as *mut list;
17632 listAddNodeTail(lsrc, src as *mut libc::c_void);
17633 table = clusterManagerComputeReshardTable(lsrc, numslots);
17634 listRelease(lsrc);
17635 let mut table_len: libc::c_int = (*table).len
17636 as libc::c_int;
17637 if table.is_null() || table_len != numslots {
17638 clusterManagerLog(
17639 3 as libc::c_int,
17640 b"*** Assertion failed: Reshard table != number of slots\0"
17641 as *const u8 as *const libc::c_char,
17642 );
17643 result = 0 as libc::c_int;
17644 } else {
17645 if simulate != 0 {
17646 i = 0 as libc::c_int;
17647 while i < table_len {
17648 printf(b"#\0" as *const u8 as *const libc::c_char);
17649 i += 1;
17650 }
17651 current_block = 1852451392920375136;
17652 } else {
17653 let mut opts: libc::c_int = (1 as libc::c_int)
17654 << 6 as libc::c_int
17655 | (1 as libc::c_int) << 2 as libc::c_int;
17656 listRewind(table, &mut li);
17657 loop {
17658 ln = listNext(&mut li);
17659 if ln.is_null() {
17660 current_block = 1852451392920375136;
17661 break;
17662 }
17663 let mut item: *mut clusterManagerReshardTableItem = (*ln)
17664 .value as *mut clusterManagerReshardTableItem;
17665 let mut err: *mut libc::c_char = 0 as *mut libc::c_char;
17666 result = clusterManagerMoveSlot(
17667 (*item).source,
17668 dst,
17669 (*item).slot,
17670 opts,
17671 &mut err,
17672 );
17673 if result == 0 {
17674 clusterManagerLog(
17675 3 as libc::c_int,
17676 b"*** clusterManagerMoveSlot: %s\n\0" as *const u8
17677 as *const libc::c_char,
17678 err,
17679 );
17680 zfree(err as *mut libc::c_void);
17681 current_block = 11547696158181946830;
17682 break;
17683 } else {
17684 printf(b"#\0" as *const u8 as *const libc::c_char);
17685 fflush(stdout);
17686 }
17687 }
17688 }
17689 match current_block {
17690 11547696158181946830 => {}
17691 _ => {
17692 printf(b"\n\0" as *const u8 as *const libc::c_char);
17693 }
17694 }
17695 }
17696 clusterManagerReleaseReshardTable(table);
17697 if result == 0 {
17698 break;
17699 }
17700 }
17701 (*dst).balance += numslots;
17702 (*src).balance -= numslots;
17703 if (*dst).balance == 0 as libc::c_int {
17704 dst_idx += 1;
17705 }
17706 if (*src).balance == 0 as libc::c_int {
17707 src_idx -= 1;
17708 }
17709 }
17710 }
17711 }
17712 }
17713 }
17714 _ => {}
17715 }
17716 if !involved.is_null() {
17717 listRelease(involved);
17718 }
17719 if !weightedNodes.is_null() {
17720 zfree(weightedNodes as *mut libc::c_void);
17721 }
17722 return result;
17723 };
17724}
17725unsafe extern "C" fn clusterManagerCommandSetTimeout(
17726 mut argc: libc::c_int,
17727 mut argv: *mut *mut libc::c_char,
17728) -> libc::c_int {
17729 let mut ok: libc::c_int = 0;
17730 let mut timeout: libc::c_int = 0;
17731 let mut node: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
17732 let mut ok_count: libc::c_int = 0;
17733 let mut err_count: libc::c_int = 0;
17734 let mut li: listIter = listIter {
17735 next: 0 as *mut listNode,
17736 direction: 0,
17737 };
17738 let mut ln: *mut listNode = 0 as *mut listNode;
17739 let mut port: libc::c_int = 0 as libc::c_int;
17740 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
17741 if getClusterHostFromCmdArgs(1 as libc::c_int, argv, &mut ip, &mut port) == 0 {
17742 fprintf(
17743 stderr,
17744 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
17745 as *const u8 as *const libc::c_char,
17746 );
17747 return 0 as libc::c_int;
17748 } else {
17749 timeout = atoi(*argv.offset(1 as libc::c_int as isize));
17750 if timeout < 100 as libc::c_int {
17751 fprintf(
17752 stderr,
17753 b"Setting a node timeout of less than 100 milliseconds is a bad idea.\n\0"
17754 as *const u8 as *const libc::c_char,
17755 );
17756 return 0 as libc::c_int;
17757 }
17758 node = clusterManagerNewNode(ip, port, 0 as libc::c_int);
17759 if clusterManagerLoadInfoFromNode(node) == 0 {
17760 return 0 as libc::c_int;
17761 }
17762 ok_count = 0 as libc::c_int;
17763 err_count = 0 as libc::c_int;
17764 clusterManagerLog(
17765 1 as libc::c_int,
17766 b">>> Reconfiguring node timeout in every cluster node...\n\0" as *const u8
17767 as *const libc::c_char,
17768 );
17769 li = listIter {
17770 next: 0 as *mut listNode,
17771 direction: 0,
17772 };
17773 ln = 0 as *mut listNode;
17774 listRewind(cluster_manager.nodes, &mut li);
17775 loop {
17776 ln = listNext(&mut li);
17777 if ln.is_null() {
17778 break;
17779 }
17780 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
17781 let mut err: *mut libc::c_char = 0 as *mut libc::c_char;
17782 let mut reply: *mut redisReply = redisCommand(
17783 (*n).context,
17784 b"CONFIG %s %s %d\0" as *const u8 as *const libc::c_char,
17785 b"SET\0" as *const u8 as *const libc::c_char,
17786 b"cluster-node-timeout\0" as *const u8 as *const libc::c_char,
17787 timeout,
17788 ) as *mut redisReply;
17789 if !reply.is_null() {
17790 ok = clusterManagerCheckRedisReply(n, reply, &mut err);
17791 freeReplyObject(reply as *mut libc::c_void);
17792 if !(ok == 0) {
17793 reply = redisCommand(
17794 (*n).context,
17795 b"CONFIG %s\0" as *const u8 as *const libc::c_char,
17796 b"REWRITE\0" as *const u8 as *const libc::c_char,
17797 ) as *mut redisReply;
17798 if !reply.is_null() {
17799 ok = clusterManagerCheckRedisReply(n, reply, &mut err);
17800 freeReplyObject(reply as *mut libc::c_void);
17801 if !(ok == 0) {
17802 clusterManagerLog(
17803 2 as libc::c_int,
17804 b"*** New timeout set for %s:%d\n\0" as *const u8
17805 as *const libc::c_char,
17806 (*n).ip,
17807 (*n).port,
17808 );
17809 ok_count += 1;
17810 continue;
17811 }
17812 }
17813 }
17814 }
17815 let mut need_free: libc::c_int = 0 as libc::c_int;
17816 if err.is_null() {
17817 err = b"\0" as *const u8 as *const libc::c_char as *mut libc::c_char;
17818 } else {
17819 need_free = 1 as libc::c_int;
17820 }
17821 clusterManagerLog(
17822 3 as libc::c_int,
17823 b"ERR setting node-timeout for %s:%d: %s\n\0" as *const u8
17824 as *const libc::c_char,
17825 (*n).ip,
17826 (*n).port,
17827 err,
17828 );
17829 if need_free != 0 {
17830 zfree(err as *mut libc::c_void);
17831 }
17832 err_count += 1;
17833 }
17834 clusterManagerLog(
17835 1 as libc::c_int,
17836 b">>> New node timeout set. %d OK, %d ERR.\n\0" as *const u8
17837 as *const libc::c_char,
17838 ok_count,
17839 err_count,
17840 );
17841 return 1 as libc::c_int;
17842 };
17843}
17844unsafe extern "C" fn clusterManagerCommandImport(
17845 mut argc: libc::c_int,
17846 mut argv: *mut *mut libc::c_char,
17847) -> libc::c_int {
17848 let mut from_user: *mut libc::c_char = 0 as *mut libc::c_char;
17849 let mut from_pass: *mut libc::c_char = 0 as *mut libc::c_char;
17850 let mut size: libc::c_int = 0;
17851 let mut i: libc::c_int = 0;
17852 let mut slots_map: [*mut clusterManagerNode; 16384] = [0
17853 as *mut clusterManagerNode; 16384];
17854 let mut li: listIter = listIter {
17855 next: 0 as *mut listNode,
17856 direction: 0,
17857 };
17858 let mut ln: *mut listNode = 0 as *mut listNode;
17859 let mut cursor: libc::c_int = 0;
17860 let mut timeout: libc::c_int = 0;
17861 let mut src_host: [*mut libc::c_char; 1] = [0 as *mut libc::c_char; 1];
17862 let mut refnode: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
17863 let mut reply_err: *mut libc::c_char = 0 as *mut libc::c_char;
17864 let mut src_reply: *mut redisReply = 0 as *mut redisReply;
17865 let mut src_ctx: *mut redisContext = 0 as *mut redisContext;
17866 let mut success: libc::c_int = 1 as libc::c_int;
17867 let mut port: libc::c_int = 0 as libc::c_int;
17868 let mut src_port: libc::c_int = 0 as libc::c_int;
17869 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
17870 let mut src_ip: *mut libc::c_char = 0 as *mut libc::c_char;
17871 let mut invalid_args_msg: *mut libc::c_char = 0 as *mut libc::c_char;
17872 let mut cmdfmt: hisds = 0 as hisds;
17873 if getClusterHostFromCmdArgs(argc, argv, &mut ip, &mut port) == 0 {
17874 invalid_args_msg = b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
17875 as *const u8 as *const libc::c_char as *mut libc::c_char;
17876 } else if (config.cluster_manager_command.from).is_null() {
17877 invalid_args_msg = b"[ERR] Option '--cluster-from' is required for subcommand 'import'.\n\0"
17878 as *const u8 as *const libc::c_char as *mut libc::c_char;
17879 } else {
17880 src_host = [config.cluster_manager_command.from];
17881 if getClusterHostFromCmdArgs(
17882 1 as libc::c_int,
17883 src_host.as_mut_ptr(),
17884 &mut src_ip,
17885 &mut src_port,
17886 ) == 0
17887 {
17888 invalid_args_msg = b"[ERR] Invalid --cluster-from host. You need to pass a valid address (ie. 120.0.0.1:7000).\n\0"
17889 as *const u8 as *const libc::c_char as *mut libc::c_char;
17890 } else {
17891 clusterManagerLog(
17892 1 as libc::c_int,
17893 b">>> Importing data from %s:%d to cluster %s:%d\n\0" as *const u8
17894 as *const libc::c_char,
17895 src_ip,
17896 src_port,
17897 ip,
17898 port,
17899 );
17900 refnode = clusterManagerNewNode(ip, port, 0 as libc::c_int);
17901 if clusterManagerLoadInfoFromNode(refnode) == 0 {
17902 return 0 as libc::c_int;
17903 }
17904 if clusterManagerCheckCluster(0 as libc::c_int) == 0 {
17905 return 0 as libc::c_int;
17906 }
17907 reply_err = 0 as *mut libc::c_char;
17908 src_reply = 0 as *mut redisReply;
17909 src_ctx = redisConnect(src_ip, src_port);
17910 if (*src_ctx).err != 0 {
17911 success = 0 as libc::c_int;
17912 fprintf(
17913 stderr,
17914 b"Could not connect to Redis at %s:%d: %s.\n\0" as *const u8
17915 as *const libc::c_char,
17916 src_ip,
17917 src_port,
17918 ((*src_ctx).errstr).as_mut_ptr(),
17919 );
17920 } else {
17921 from_user = config.cluster_manager_command.from_user;
17922 from_pass = config.cluster_manager_command.from_pass;
17923 if cliAuth(src_ctx, from_user, from_pass) == -(1 as libc::c_int) {
17924 success = 0 as libc::c_int;
17925 } else {
17926 src_reply = reconnectingRedisCommand(
17927 src_ctx,
17928 b"INFO\0" as *const u8 as *const libc::c_char,
17929 );
17930 if src_reply.is_null() || (*src_reply).type_0 == 6 as libc::c_int {
17931 if !src_reply.is_null() && !((*src_reply).str_0).is_null() {
17932 reply_err = (*src_reply).str_0;
17933 }
17934 success = 0 as libc::c_int;
17935 } else if getLongInfoField(
17936 (*src_reply).str_0,
17937 b"cluster_enabled\0" as *const u8 as *const libc::c_char
17938 as *mut libc::c_char,
17939 ) != 0
17940 {
17941 clusterManagerLog(
17942 3 as libc::c_int,
17943 b"[ERR] The source node should not be a cluster node.\n\0"
17944 as *const u8 as *const libc::c_char,
17945 );
17946 success = 0 as libc::c_int;
17947 } else {
17948 freeReplyObject(src_reply as *mut libc::c_void);
17949 src_reply = reconnectingRedisCommand(
17950 src_ctx,
17951 b"DBSIZE\0" as *const u8 as *const libc::c_char,
17952 );
17953 if src_reply.is_null() || (*src_reply).type_0 == 6 as libc::c_int
17954 {
17955 if !src_reply.is_null() && !((*src_reply).str_0).is_null() {
17956 reply_err = (*src_reply).str_0;
17957 }
17958 success = 0 as libc::c_int;
17959 } else {
17960 size = (*src_reply).integer as libc::c_int;
17961 i = 0;
17962 clusterManagerLog(
17963 2 as libc::c_int,
17964 b"*** Importing %d keys from DB 0\n\0" as *const u8
17965 as *const libc::c_char,
17966 size,
17967 );
17968 slots_map = [0 as *mut clusterManagerNode; 16384];
17969 memset(
17970 slots_map.as_mut_ptr() as *mut libc::c_void,
17971 0 as libc::c_int,
17972 core::mem::size_of::<[*mut clusterManagerNode; 16384]>()
17973 as libc::c_ulong,
17974 );
17975 li = listIter {
17976 next: 0 as *mut listNode,
17977 direction: 0,
17978 };
17979 ln = 0 as *mut listNode;
17980 i = 0 as libc::c_int;
17981 while i < 16384 as libc::c_int {
17982 listRewind(cluster_manager.nodes, &mut li);
17983 loop {
17984 ln = listNext(&mut li);
17985 if ln.is_null() {
17986 break;
17987 }
17988 let mut n: *mut clusterManagerNode = (*ln).value
17989 as *mut clusterManagerNode;
17990 if (*n).flags & (1 as libc::c_int) << 1 as libc::c_int != 0
17991 {
17992 continue;
17993 }
17994 if (*n).slots_count == 0 as libc::c_int {
17995 continue;
17996 }
17997 if !((*n).slots[i as usize] != 0) {
17998 continue;
17999 }
18000 slots_map[i as usize] = n;
18001 break;
18002 }
18003 i += 1;
18004 }
18005 cmdfmt = hi_sdsnew(
18006 b"MIGRATE %s %d %s %d %d\0" as *const u8
18007 as *const libc::c_char,
18008 );
18009 if !(config.conn_info.auth).is_null() {
18010 if !(config.conn_info.user).is_null() {
18011 cmdfmt = hi_sdscatfmt(
18012 cmdfmt,
18013 b" AUTH2 %s %s\0" as *const u8 as *const libc::c_char,
18014 config.conn_info.user,
18015 config.conn_info.auth,
18016 );
18017 } else {
18018 cmdfmt = hi_sdscatfmt(
18019 cmdfmt,
18020 b" AUTH %s\0" as *const u8 as *const libc::c_char,
18021 config.conn_info.auth,
18022 );
18023 }
18024 }
18025 if config.cluster_manager_command.flags
18026 & (1 as libc::c_int) << 7 as libc::c_int != 0
18027 {
18028 cmdfmt = hi_sdscat(
18029 cmdfmt,
18030 b" COPY\0" as *const u8 as *const libc::c_char,
18031 );
18032 }
18033 if config.cluster_manager_command.flags
18034 & (1 as libc::c_int) << 6 as libc::c_int != 0
18035 {
18036 cmdfmt = hi_sdscat(
18037 cmdfmt,
18038 b" REPLACE\0" as *const u8 as *const libc::c_char,
18039 );
18040 }
18041 cursor = -(999 as libc::c_int);
18042 timeout = config.cluster_manager_command.timeout;
18043 's_266: while cursor != 0 as libc::c_int {
18044 if cursor < 0 as libc::c_int {
18045 cursor = 0 as libc::c_int;
18046 }
18047 freeReplyObject(src_reply as *mut libc::c_void);
18048 src_reply = reconnectingRedisCommand(
18049 src_ctx,
18050 b"SCAN %d COUNT %d\0" as *const u8 as *const libc::c_char,
18051 cursor,
18052 1000 as libc::c_int,
18053 );
18054 if src_reply.is_null()
18055 || (*src_reply).type_0 == 6 as libc::c_int
18056 {
18057 if !src_reply.is_null() && !((*src_reply).str_0).is_null() {
18058 reply_err = (*src_reply).str_0;
18059 }
18060 success = 0 as libc::c_int;
18061 break;
18062 } else {
18063 if (*src_reply).type_0 == 2 as libc::c_int {} else {
18064 __assert_fail(
18065 b"src_reply->type == REDIS_REPLY_ARRAY\0" as *const u8
18066 as *const libc::c_char,
18067 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
18068 7207 as libc::c_int as libc::c_uint,
18069 (*core::mem::transmute::<
18070 &[u8; 46],
18071 &[libc::c_char; 46],
18072 >(b"int clusterManagerCommandImport(int, char **)\0"))
18073 .as_ptr(),
18074 );
18075 };
18076 if (*src_reply).elements
18077 >= 2 as libc::c_int as libc::c_ulong
18078 {} else {
18079 __assert_fail(
18080 b"src_reply->elements >= 2\0" as *const u8
18081 as *const libc::c_char,
18082 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
18083 7208 as libc::c_int as libc::c_uint,
18084 (*core::mem::transmute::<
18085 &[u8; 46],
18086 &[libc::c_char; 46],
18087 >(b"int clusterManagerCommandImport(int, char **)\0"))
18088 .as_ptr(),
18089 );
18090 };
18091 if (**((*src_reply).element)
18092 .offset(1 as libc::c_int as isize))
18093 .type_0 == 2 as libc::c_int
18094 {} else {
18095 __assert_fail(
18096 b"src_reply->element[1]->type == REDIS_REPLY_ARRAY\0"
18097 as *const u8 as *const libc::c_char,
18098 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
18099 7209 as libc::c_int as libc::c_uint,
18100 (*core::mem::transmute::<
18101 &[u8; 46],
18102 &[libc::c_char; 46],
18103 >(b"int clusterManagerCommandImport(int, char **)\0"))
18104 .as_ptr(),
18105 );
18106 };
18107 if (**((*src_reply).element)
18108 .offset(0 as libc::c_int as isize))
18109 .type_0 == 1 as libc::c_int
18110 {
18111 cursor = atoi(
18112 (**((*src_reply).element).offset(0 as libc::c_int as isize))
18113 .str_0,
18114 );
18115 } else if (**((*src_reply).element)
18116 .offset(0 as libc::c_int as isize))
18117 .type_0 == 3 as libc::c_int
18118 {
18119 cursor = (**((*src_reply).element)
18120 .offset(0 as libc::c_int as isize))
18121 .integer as libc::c_int;
18122 }
18123 let mut keycount: libc::c_int = (**((*src_reply).element)
18124 .offset(1 as libc::c_int as isize))
18125 .elements as libc::c_int;
18126 i = 0 as libc::c_int;
18127 while i < keycount {
18128 let mut kr: *mut redisReply = *((**((*src_reply).element)
18129 .offset(1 as libc::c_int as isize))
18130 .element)
18131 .offset(i as isize);
18132 if (*kr).type_0 == 1 as libc::c_int {} else {
18133 __assert_fail(
18134 b"kr->type == REDIS_REPLY_STRING\0" as *const u8
18135 as *const libc::c_char,
18136 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
18137 7217 as libc::c_int as libc::c_uint,
18138 (*core::mem::transmute::<
18139 &[u8; 46],
18140 &[libc::c_char; 46],
18141 >(b"int clusterManagerCommandImport(int, char **)\0"))
18142 .as_ptr(),
18143 );
18144 };
18145 let mut key: *mut libc::c_char = (*kr).str_0;
18146 let mut slot: uint16_t = clusterManagerKeyHashSlot(
18147 key,
18148 (*kr).len as libc::c_int,
18149 ) as uint16_t;
18150 let mut target: *mut clusterManagerNode = slots_map[slot
18151 as usize];
18152 printf(
18153 b"Migrating %s to %s:%d: \0" as *const u8
18154 as *const libc::c_char,
18155 key,
18156 (*target).ip,
18157 (*target).port,
18158 );
18159 let mut r: *mut redisReply = reconnectingRedisCommand(
18160 src_ctx,
18161 cmdfmt as *const libc::c_char,
18162 (*target).ip,
18163 (*target).port,
18164 key,
18165 0 as libc::c_int,
18166 timeout,
18167 );
18168 if r.is_null() || (*r).type_0 == 6 as libc::c_int {
18169 if !r.is_null() && !((*r).str_0).is_null() {
18170 clusterManagerLog(
18171 3 as libc::c_int,
18172 b"Source %s:%d replied with error:\n%s\n\0" as *const u8
18173 as *const libc::c_char,
18174 src_ip,
18175 src_port,
18176 (*r).str_0,
18177 );
18178 }
18179 success = 0 as libc::c_int;
18180 }
18181 freeReplyObject(r as *mut libc::c_void);
18182 if success == 0 {
18183 break 's_266;
18184 }
18185 clusterManagerLog(
18186 4 as libc::c_int,
18187 b"OK\n\0" as *const u8 as *const libc::c_char,
18188 );
18189 i += 1;
18190 }
18191 }
18192 }
18193 }
18194 }
18195 }
18196 }
18197 if !reply_err.is_null() {
18198 clusterManagerLog(
18199 3 as libc::c_int,
18200 b"Source %s:%d replied with error:\n%s\n\0" as *const u8
18201 as *const libc::c_char,
18202 src_ip,
18203 src_port,
18204 reply_err,
18205 );
18206 }
18207 if !src_ctx.is_null() {
18208 redisFree(src_ctx);
18209 }
18210 if !src_reply.is_null() {
18211 freeReplyObject(src_reply as *mut libc::c_void);
18212 }
18213 if !cmdfmt.is_null() {
18214 hi_sdsfree(cmdfmt);
18215 }
18216 return success;
18217 }
18218 }
18219 fprintf(stderr, b"%s\0" as *const u8 as *const libc::c_char, invalid_args_msg);
18220 return 0 as libc::c_int;
18221}
18222unsafe extern "C" fn clusterManagerCommandCall(
18223 mut argc: libc::c_int,
18224 mut argv: *mut *mut libc::c_char,
18225) -> libc::c_int {
18226 let mut refnode: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
18227 let mut argvlen: *mut size_t = 0 as *mut size_t;
18228 let mut li: listIter = listIter {
18229 next: 0 as *mut listNode,
18230 direction: 0,
18231 };
18232 let mut ln: *mut listNode = 0 as *mut listNode;
18233 let mut port: libc::c_int = 0 as libc::c_int;
18234 let mut i: libc::c_int = 0;
18235 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
18236 if getClusterHostFromCmdArgs(1 as libc::c_int, argv, &mut ip, &mut port) == 0 {
18237 fprintf(
18238 stderr,
18239 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
18240 as *const u8 as *const libc::c_char,
18241 );
18242 return 0 as libc::c_int;
18243 } else {
18244 refnode = clusterManagerNewNode(ip, port, 0 as libc::c_int);
18245 if clusterManagerLoadInfoFromNode(refnode) == 0 {
18246 return 0 as libc::c_int;
18247 }
18248 argc -= 1;
18249 argv = argv.offset(1);
18250 argvlen = zmalloc(
18251 (argc as libc::c_ulong)
18252 .wrapping_mul(core::mem::size_of::<size_t>() as libc::c_ulong),
18253 ) as *mut size_t;
18254 clusterManagerLog(
18255 1 as libc::c_int,
18256 b">>> Calling\0" as *const u8 as *const libc::c_char,
18257 );
18258 i = 0 as libc::c_int;
18259 while i < argc {
18260 *argvlen.offset(i as isize) = strlen(*argv.offset(i as isize));
18261 printf(
18262 b" %s\0" as *const u8 as *const libc::c_char,
18263 *argv.offset(i as isize),
18264 );
18265 i += 1;
18266 }
18267 printf(b"\n\0" as *const u8 as *const libc::c_char);
18268 li = listIter {
18269 next: 0 as *mut listNode,
18270 direction: 0,
18271 };
18272 ln = 0 as *mut listNode;
18273 listRewind(cluster_manager.nodes, &mut li);
18274 loop {
18275 ln = listNext(&mut li);
18276 if ln.is_null() {
18277 break;
18278 }
18279 let mut n: *mut clusterManagerNode = (*ln).value as *mut clusterManagerNode;
18280 if config.cluster_manager_command.flags
18281 & (1 as libc::c_int) << 11 as libc::c_int != 0
18282 && !((*n).replicate).is_null()
18283 {
18284 continue;
18285 }
18286 if config.cluster_manager_command.flags
18287 & (1 as libc::c_int) << 12 as libc::c_int != 0
18288 && ((*n).replicate).is_null()
18289 {
18290 continue;
18291 }
18292 if ((*n).context).is_null() && clusterManagerNodeConnect(n) == 0 {
18293 continue;
18294 }
18295 let mut reply: *mut redisReply = 0 as *mut redisReply;
18296 redisAppendCommandArgv(
18297 (*n).context,
18298 argc,
18299 argv as *mut *const libc::c_char,
18300 argvlen,
18301 );
18302 let mut status: libc::c_int = redisGetReply(
18303 (*n).context,
18304 &mut reply as *mut *mut redisReply as *mut *mut libc::c_void,
18305 );
18306 if status != 0 as libc::c_int || reply.is_null() {
18307 printf(
18308 b"%s:%d: Failed!\n\0" as *const u8 as *const libc::c_char,
18309 (*n).ip,
18310 (*n).port,
18311 );
18312 } else {
18313 let mut formatted_reply: hisds = cliFormatReplyRaw(reply);
18314 printf(
18315 b"%s:%d: %s\n\0" as *const u8 as *const libc::c_char,
18316 (*n).ip,
18317 (*n).port,
18318 formatted_reply,
18319 );
18320 hi_sdsfree(formatted_reply);
18321 }
18322 if !reply.is_null() {
18323 freeReplyObject(reply as *mut libc::c_void);
18324 }
18325 }
18326 zfree(argvlen as *mut libc::c_void);
18327 return 1 as libc::c_int;
18328 };
18329}
18330unsafe extern "C" fn clusterManagerCommandBackup(
18331 mut argc: libc::c_int,
18332 mut argv: *mut *mut libc::c_char,
18333) -> libc::c_int {
18334 let mut refnode: *mut clusterManagerNode = 0 as *mut clusterManagerNode;
18335 let mut no_issues: libc::c_int = 0;
18336 let mut cluster_errors_count: libc::c_int = 0;
18337 let mut json: hisds = 0 as *mut libc::c_char;
18338 let mut first_node: libc::c_int = 0;
18339 let mut li: listIter = listIter {
18340 next: 0 as *mut listNode,
18341 direction: 0,
18342 };
18343 let mut ln: *mut listNode = 0 as *mut listNode;
18344 let mut jsonpath: hisds = 0 as *mut libc::c_char;
18345 let mut out: *mut FILE = 0 as *mut FILE;
18346 let mut success: libc::c_int = 1 as libc::c_int;
18347 let mut port: libc::c_int = 0 as libc::c_int;
18348 let mut ip: *mut libc::c_char = 0 as *mut libc::c_char;
18349 if getClusterHostFromCmdArgs(1 as libc::c_int, argv, &mut ip, &mut port) == 0 {
18350 fprintf(
18351 stderr,
18352 b"[ERR] Invalid arguments: you need to pass either a valid address (ie. 120.0.0.1:7000) or space separated IP and port (ie. 120.0.0.1 7000)\n\0"
18353 as *const u8 as *const libc::c_char,
18354 );
18355 return 0 as libc::c_int;
18356 } else {
18357 refnode = clusterManagerNewNode(ip, port, 0 as libc::c_int);
18358 if clusterManagerLoadInfoFromNode(refnode) == 0 {
18359 return 0 as libc::c_int;
18360 }
18361 no_issues = clusterManagerCheckCluster(0 as libc::c_int);
18362 cluster_errors_count = (if no_issues != 0 {
18363 0 as libc::c_int as libc::c_ulong
18364 } else {
18365 (*cluster_manager.errors).len
18366 }) as libc::c_int;
18367 config
18368 .cluster_manager_command
18369 .backup_dir = *argv.offset(1 as libc::c_int as isize);
18370 json = hi_sdsnew(b"[\n\0" as *const u8 as *const libc::c_char);
18371 first_node = 0 as libc::c_int;
18372 li = listIter {
18373 next: 0 as *mut listNode,
18374 direction: 0,
18375 };
18376 ln = 0 as *mut listNode;
18377 listRewind(cluster_manager.nodes, &mut li);
18378 loop {
18379 ln = listNext(&mut li);
18380 if ln.is_null() {
18381 break;
18382 }
18383 if first_node == 0 {
18384 first_node = 1 as libc::c_int;
18385 } else {
18386 json = hi_sdscat(json, b",\n\0" as *const u8 as *const libc::c_char);
18387 }
18388 let mut node: *mut clusterManagerNode = (*ln).value
18389 as *mut clusterManagerNode;
18390 let mut node_json: hisds = clusterManagerNodeGetJSON(
18391 node,
18392 cluster_errors_count as libc::c_ulong,
18393 );
18394 json = hi_sdscat(json, node_json as *const libc::c_char);
18395 hi_sdsfree(node_json);
18396 if !((*node).replicate).is_null() {
18397 continue;
18398 }
18399 clusterManagerLog(
18400 1 as libc::c_int,
18401 b">>> Node %s:%d -> Saving RDB...\n\0" as *const u8
18402 as *const libc::c_char,
18403 (*node).ip,
18404 (*node).port,
18405 );
18406 fflush(stdout);
18407 getRDB(node);
18408 }
18409 json = hi_sdscat(json, b"\n]\0" as *const u8 as *const libc::c_char);
18410 jsonpath = hi_sdsnew(config.cluster_manager_command.backup_dir);
18411 if *jsonpath
18412 .offset(
18413 (hi_sdslen(jsonpath)).wrapping_sub(1 as libc::c_int as libc::c_ulong)
18414 as isize,
18415 ) as libc::c_int != '/' as i32
18416 {
18417 jsonpath = hi_sdscat(jsonpath, b"/\0" as *const u8 as *const libc::c_char);
18418 }
18419 jsonpath = hi_sdscat(
18420 jsonpath,
18421 b"nodes.json\0" as *const u8 as *const libc::c_char,
18422 );
18423 fflush(stdout);
18424 clusterManagerLog(
18425 1 as libc::c_int,
18426 b"Saving cluster configuration to: %s\n\0" as *const u8
18427 as *const libc::c_char,
18428 jsonpath,
18429 );
18430 out = fopen(
18431 jsonpath as *const libc::c_char,
18432 b"w+\0" as *const u8 as *const libc::c_char,
18433 );
18434 if out.is_null() {
18435 clusterManagerLog(
18436 3 as libc::c_int,
18437 b"Could not save nodes to: %s\n\0" as *const u8 as *const libc::c_char,
18438 jsonpath,
18439 );
18440 success = 0 as libc::c_int;
18441 } else {
18442 fputs(json as *const libc::c_char, out);
18443 fclose(out);
18444 }
18445 hi_sdsfree(json);
18446 hi_sdsfree(jsonpath);
18447 if success != 0 {
18448 if no_issues == 0 {
18449 clusterManagerLog(
18450 2 as libc::c_int,
18451 b"*** Cluster seems to have some problems, please be aware of it if you're going to restore this backup.\n\0"
18452 as *const u8 as *const libc::c_char,
18453 );
18454 }
18455 clusterManagerLog(
18456 4 as libc::c_int,
18457 b"[OK] Backup created into: %s\n\0" as *const u8 as *const libc::c_char,
18458 config.cluster_manager_command.backup_dir,
18459 );
18460 } else {
18461 clusterManagerLog(
18462 4 as libc::c_int,
18463 b"[ERR] Failed to back cluster!\n\0" as *const u8 as *const libc::c_char,
18464 );
18465 }
18466 return success;
18467 };
18468}
18469unsafe extern "C" fn clusterManagerCommandHelp(
18470 mut argc: libc::c_int,
18471 mut argv: *mut *mut libc::c_char,
18472) -> libc::c_int {
18473 let mut commands_count: libc::c_int = (core::mem::size_of::<
18474 [clusterManagerCommandDef; 13],
18475 >() as libc::c_ulong)
18476 .wrapping_div(
18477 core::mem::size_of::<clusterManagerCommandDef>() as libc::c_ulong,
18478 ) as libc::c_int;
18479 let mut i: libc::c_int = 0 as libc::c_int;
18480 let mut j: libc::c_int = 0;
18481 fprintf(
18482 stdout,
18483 b"Cluster Manager Commands:\n\0" as *const u8 as *const libc::c_char,
18484 );
18485 let mut padding: libc::c_int = 15 as libc::c_int;
18486 while i < commands_count {
18487 let mut def: *mut clusterManagerCommandDef = &mut *clusterManagerCommands
18488 .as_mut_ptr()
18489 .offset(i as isize) as *mut clusterManagerCommandDef;
18490 let mut namelen: libc::c_int = strlen((*def).name) as libc::c_int;
18491 let mut padlen: libc::c_int = padding - namelen;
18492 fprintf(stdout, b" %s\0" as *const u8 as *const libc::c_char, (*def).name);
18493 j = 0 as libc::c_int;
18494 while j < padlen {
18495 fprintf(stdout, b" \0" as *const u8 as *const libc::c_char);
18496 j += 1;
18497 }
18498 fprintf(
18499 stdout,
18500 b"%s\n\0" as *const u8 as *const libc::c_char,
18501 if !((*def).args).is_null() {
18502 (*def).args as *const libc::c_char
18503 } else {
18504 b"\0" as *const u8 as *const libc::c_char
18505 },
18506 );
18507 if !((*def).options).is_null() {
18508 let mut optslen: libc::c_int = strlen((*def).options) as libc::c_int;
18509 let mut p: *mut libc::c_char = (*def).options;
18510 let mut eos: *mut libc::c_char = p.offset(optslen as isize);
18511 let mut comma: *mut libc::c_char = 0 as *mut libc::c_char;
18512 loop {
18513 comma = strchr(p, ',' as i32);
18514 if comma.is_null() {
18515 break;
18516 }
18517 let mut deflen: libc::c_int = comma.offset_from(p) as libc::c_long
18518 as libc::c_int;
18519 let mut buf: [libc::c_char; 255] = [0; 255];
18520 memcpy(
18521 buf.as_mut_ptr() as *mut libc::c_void,
18522 p as *const libc::c_void,
18523 deflen as libc::c_ulong,
18524 );
18525 buf[deflen as usize] = '\0' as i32 as libc::c_char;
18526 j = 0 as libc::c_int;
18527 while j < padding {
18528 fprintf(stdout, b" \0" as *const u8 as *const libc::c_char);
18529 j += 1;
18530 }
18531 fprintf(
18532 stdout,
18533 b" --cluster-%s\n\0" as *const u8 as *const libc::c_char,
18534 buf.as_mut_ptr(),
18535 );
18536 p = comma.offset(1 as libc::c_int as isize);
18537 if p >= eos {
18538 break;
18539 }
18540 }
18541 if p < eos {
18542 j = 0 as libc::c_int;
18543 while j < padding {
18544 fprintf(stdout, b" \0" as *const u8 as *const libc::c_char);
18545 j += 1;
18546 }
18547 fprintf(
18548 stdout,
18549 b" --cluster-%s\n\0" as *const u8 as *const libc::c_char,
18550 p,
18551 );
18552 }
18553 }
18554 i += 1;
18555 }
18556 fprintf(
18557 stdout,
18558 b"\nFor check, fix, reshard, del-node, set-timeout, info, rebalance, call, import, backup you can specify the host and port of any working node in the cluster.\n\0"
18559 as *const u8 as *const libc::c_char,
18560 );
18561 let mut options_count: libc::c_int = (core::mem::size_of::<
18562 [clusterManagerOptionDef; 1],
18563 >() as libc::c_ulong)
18564 .wrapping_div(core::mem::size_of::<clusterManagerOptionDef>() as libc::c_ulong)
18565 as libc::c_int;
18566 i = 0 as libc::c_int;
18567 fprintf(
18568 stdout,
18569 b"\nCluster Manager Options:\n\0" as *const u8 as *const libc::c_char,
18570 );
18571 while i < options_count {
18572 let mut def_0: *mut clusterManagerOptionDef = &mut *clusterManagerOptions
18573 .as_mut_ptr()
18574 .offset(i as isize) as *mut clusterManagerOptionDef;
18575 let mut namelen_0: libc::c_int = strlen((*def_0).name) as libc::c_int;
18576 let mut padlen_0: libc::c_int = padding - namelen_0;
18577 fprintf(stdout, b" %s\0" as *const u8 as *const libc::c_char, (*def_0).name);
18578 j = 0 as libc::c_int;
18579 while j < padlen_0 {
18580 fprintf(stdout, b" \0" as *const u8 as *const libc::c_char);
18581 j += 1;
18582 }
18583 fprintf(stdout, b"%s\n\0" as *const u8 as *const libc::c_char, (*def_0).desc);
18584 i += 1;
18585 }
18586 fprintf(stdout, b"\n\0" as *const u8 as *const libc::c_char);
18587 return 0 as libc::c_int;
18588}
18589unsafe extern "C" fn latencyModePrint(
18590 mut min: libc::c_longlong,
18591 mut max: libc::c_longlong,
18592 mut avg: libc::c_double,
18593 mut count: libc::c_longlong,
18594) {
18595 if config.output == 0 as libc::c_int {
18596 printf(
18597 b"min: %lld, max: %lld, avg: %.2f (%lld samples)\0" as *const u8
18598 as *const libc::c_char,
18599 min,
18600 max,
18601 avg,
18602 count,
18603 );
18604 fflush(stdout);
18605 } else if config.output == 2 as libc::c_int {
18606 printf(
18607 b"%lld,%lld,%.2f,%lld\n\0" as *const u8 as *const libc::c_char,
18608 min,
18609 max,
18610 avg,
18611 count,
18612 );
18613 } else if config.output == 1 as libc::c_int {
18614 printf(
18615 b"%lld %lld %.2f %lld\n\0" as *const u8 as *const libc::c_char,
18616 min,
18617 max,
18618 avg,
18619 count,
18620 );
18621 } else if config.output == 3 as libc::c_int {
18622 printf(
18623 b"{\"min\": %lld, \"max\": %lld, \"avg\": %.2f, \"count\": %lld}\n\0"
18624 as *const u8 as *const libc::c_char,
18625 min,
18626 max,
18627 avg,
18628 count,
18629 );
18630 }
18631}
18632unsafe extern "C" fn latencyMode() {
18633 let mut reply: *mut redisReply = 0 as *mut redisReply;
18634 let mut start: libc::c_longlong = 0;
18635 let mut latency: libc::c_longlong = 0;
18636 let mut min: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
18637 let mut max: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
18638 let mut tot: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
18639 let mut count: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
18640 let mut history_interval: libc::c_longlong = (if config.interval != 0 {
18641 config.interval / 1000 as libc::c_int as libc::c_long
18642 } else {
18643 15000 as libc::c_int as libc::c_long
18644 }) as libc::c_longlong;
18645 let mut avg: libc::c_double = 0.;
18646 let mut history_start: libc::c_longlong = mstime();
18647 if config.interval == 0 as libc::c_int as libc::c_long {
18648 config.interval = 1000 as libc::c_int as libc::c_long;
18649 } else {
18650 config.interval /= 1000 as libc::c_int as libc::c_long;
18651 }
18652 if context.is_null() {
18653 exit(1 as libc::c_int);
18654 }
18655 loop {
18656 start = mstime();
18657 reply = reconnectingRedisCommand(
18658 context,
18659 b"PING\0" as *const u8 as *const libc::c_char,
18660 );
18661 if reply.is_null() {
18662 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
18663 exit(1 as libc::c_int);
18664 }
18665 latency = mstime() - start;
18666 freeReplyObject(reply as *mut libc::c_void);
18667 count += 1;
18668 if count == 1 as libc::c_int as libc::c_longlong {
18669 tot = latency;
18670 max = tot;
18671 min = max;
18672 avg = latency as libc::c_double;
18673 } else {
18674 if latency < min {
18675 min = latency;
18676 }
18677 if latency > max {
18678 max = latency;
18679 }
18680 tot += latency;
18681 avg = tot as libc::c_double / count as libc::c_double;
18682 }
18683 if config.output == 0 as libc::c_int {
18684 printf(b"\x1B[0G\x1B[2K\0" as *const u8 as *const libc::c_char);
18685 latencyModePrint(min, max, avg, count);
18686 } else if config.latency_history != 0 {
18687 latencyModePrint(min, max, avg, count);
18688 } else if mstime() - history_start > config.interval as libc::c_longlong {
18689 latencyModePrint(min, max, avg, count);
18690 exit(0 as libc::c_int);
18691 }
18692 if config.latency_history != 0 && mstime() - history_start > history_interval {
18693 printf(
18694 b" -- %.2f seconds range\n\0" as *const u8 as *const libc::c_char,
18695 ((mstime() - history_start) as libc::c_float
18696 / 1000 as libc::c_int as libc::c_float) as libc::c_double,
18697 );
18698 history_start = mstime();
18699 count = 0 as libc::c_int as libc::c_longlong;
18700 tot = count;
18701 max = tot;
18702 min = max;
18703 }
18704 usleep((10 as libc::c_int * 1000 as libc::c_int) as __useconds_t);
18705 };
18706}
18707#[no_mangle]
18708pub unsafe extern "C" fn showLatencyDistSamples(
18709 mut samples: *mut distsamples,
18710 mut tot: libc::c_longlong,
18711) {
18712 let mut j: libc::c_int = 0;
18713 printf(b"\x1B[38;5;0m\0" as *const u8 as *const libc::c_char);
18714 j = 0 as libc::c_int;
18715 loop {
18716 let mut coloridx: libc::c_int = ceil(
18717 (*samples.offset(j as isize)).count as libc::c_double / tot as libc::c_double
18718 * (spectrum_palette_size - 1 as libc::c_int) as libc::c_double,
18719 ) as libc::c_int;
18720 let mut color: libc::c_int = *spectrum_palette.offset(coloridx as isize);
18721 printf(
18722 b"\x1B[48;5;%dm%c\0" as *const u8 as *const libc::c_char,
18723 color,
18724 (*samples.offset(j as isize)).character,
18725 );
18726 (*samples.offset(j as isize)).count = 0 as libc::c_int as libc::c_longlong;
18727 if (*samples.offset(j as isize)).max == 0 as libc::c_int as libc::c_longlong {
18728 break;
18729 }
18730 j += 1;
18731 }
18732 printf(b"\x1B[0m\n\0" as *const u8 as *const libc::c_char);
18733 fflush(stdout);
18734}
18735#[no_mangle]
18736pub unsafe extern "C" fn showLatencyDistLegend() {
18737 let mut j: libc::c_int = 0;
18738 printf(
18739 b"---------------------------------------------\n\0" as *const u8
18740 as *const libc::c_char,
18741 );
18742 printf(
18743 b". - * # .01 .125 .25 .5 milliseconds\n\0" as *const u8
18744 as *const libc::c_char,
18745 );
18746 printf(
18747 b"1,2,3,...,9 from 1 to 9 milliseconds\n\0" as *const u8
18748 as *const libc::c_char,
18749 );
18750 printf(
18751 b"A,B,C,D,E 10,20,30,40,50 milliseconds\n\0" as *const u8
18752 as *const libc::c_char,
18753 );
18754 printf(
18755 b"F,G,H,I,J .1,.2,.3,.4,.5 seconds\n\0" as *const u8
18756 as *const libc::c_char,
18757 );
18758 printf(
18759 b"K,L,M,N,O,P,Q,? 1,2,4,8,16,30,60,>60 seconds\n\0" as *const u8
18760 as *const libc::c_char,
18761 );
18762 printf(b"From 0 to 100%%: \0" as *const u8 as *const libc::c_char);
18763 j = 0 as libc::c_int;
18764 while j < spectrum_palette_size {
18765 printf(
18766 b"\x1B[48;5;%dm \0" as *const u8 as *const libc::c_char,
18767 *spectrum_palette.offset(j as isize),
18768 );
18769 j += 1;
18770 }
18771 printf(b"\x1B[0m\n\0" as *const u8 as *const libc::c_char);
18772 printf(
18773 b"---------------------------------------------\n\0" as *const u8
18774 as *const libc::c_char,
18775 );
18776}
18777unsafe extern "C" fn latencyDistMode() {
18778 let mut reply: *mut redisReply = 0 as *mut redisReply;
18779 let mut start: libc::c_longlong = 0;
18780 let mut latency: libc::c_longlong = 0;
18781 let mut count: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
18782 let mut history_interval: libc::c_longlong = (if config.interval != 0 {
18783 config.interval / 1000 as libc::c_int as libc::c_long
18784 } else {
18785 1000 as libc::c_int as libc::c_long
18786 }) as libc::c_longlong;
18787 let mut history_start: libc::c_longlong = ustime();
18788 let mut j: libc::c_int = 0;
18789 let mut outputs: libc::c_int = 0 as libc::c_int;
18790 let mut samples: [distsamples; 31] = [
18791 {
18792 let mut init = distsamples {
18793 max: 10 as libc::c_int as libc::c_longlong,
18794 count: 0 as libc::c_int as libc::c_longlong,
18795 character: '.' as i32,
18796 };
18797 init
18798 },
18799 {
18800 let mut init = distsamples {
18801 max: 125 as libc::c_int as libc::c_longlong,
18802 count: 0 as libc::c_int as libc::c_longlong,
18803 character: '-' as i32,
18804 };
18805 init
18806 },
18807 {
18808 let mut init = distsamples {
18809 max: 250 as libc::c_int as libc::c_longlong,
18810 count: 0 as libc::c_int as libc::c_longlong,
18811 character: '*' as i32,
18812 };
18813 init
18814 },
18815 {
18816 let mut init = distsamples {
18817 max: 500 as libc::c_int as libc::c_longlong,
18818 count: 0 as libc::c_int as libc::c_longlong,
18819 character: '#' as i32,
18820 };
18821 init
18822 },
18823 {
18824 let mut init = distsamples {
18825 max: 1000 as libc::c_int as libc::c_longlong,
18826 count: 0 as libc::c_int as libc::c_longlong,
18827 character: '1' as i32,
18828 };
18829 init
18830 },
18831 {
18832 let mut init = distsamples {
18833 max: 2000 as libc::c_int as libc::c_longlong,
18834 count: 0 as libc::c_int as libc::c_longlong,
18835 character: '2' as i32,
18836 };
18837 init
18838 },
18839 {
18840 let mut init = distsamples {
18841 max: 3000 as libc::c_int as libc::c_longlong,
18842 count: 0 as libc::c_int as libc::c_longlong,
18843 character: '3' as i32,
18844 };
18845 init
18846 },
18847 {
18848 let mut init = distsamples {
18849 max: 4000 as libc::c_int as libc::c_longlong,
18850 count: 0 as libc::c_int as libc::c_longlong,
18851 character: '4' as i32,
18852 };
18853 init
18854 },
18855 {
18856 let mut init = distsamples {
18857 max: 5000 as libc::c_int as libc::c_longlong,
18858 count: 0 as libc::c_int as libc::c_longlong,
18859 character: '5' as i32,
18860 };
18861 init
18862 },
18863 {
18864 let mut init = distsamples {
18865 max: 6000 as libc::c_int as libc::c_longlong,
18866 count: 0 as libc::c_int as libc::c_longlong,
18867 character: '6' as i32,
18868 };
18869 init
18870 },
18871 {
18872 let mut init = distsamples {
18873 max: 7000 as libc::c_int as libc::c_longlong,
18874 count: 0 as libc::c_int as libc::c_longlong,
18875 character: '7' as i32,
18876 };
18877 init
18878 },
18879 {
18880 let mut init = distsamples {
18881 max: 8000 as libc::c_int as libc::c_longlong,
18882 count: 0 as libc::c_int as libc::c_longlong,
18883 character: '8' as i32,
18884 };
18885 init
18886 },
18887 {
18888 let mut init = distsamples {
18889 max: 9000 as libc::c_int as libc::c_longlong,
18890 count: 0 as libc::c_int as libc::c_longlong,
18891 character: '9' as i32,
18892 };
18893 init
18894 },
18895 {
18896 let mut init = distsamples {
18897 max: 10000 as libc::c_int as libc::c_longlong,
18898 count: 0 as libc::c_int as libc::c_longlong,
18899 character: 'A' as i32,
18900 };
18901 init
18902 },
18903 {
18904 let mut init = distsamples {
18905 max: 20000 as libc::c_int as libc::c_longlong,
18906 count: 0 as libc::c_int as libc::c_longlong,
18907 character: 'B' as i32,
18908 };
18909 init
18910 },
18911 {
18912 let mut init = distsamples {
18913 max: 30000 as libc::c_int as libc::c_longlong,
18914 count: 0 as libc::c_int as libc::c_longlong,
18915 character: 'C' as i32,
18916 };
18917 init
18918 },
18919 {
18920 let mut init = distsamples {
18921 max: 40000 as libc::c_int as libc::c_longlong,
18922 count: 0 as libc::c_int as libc::c_longlong,
18923 character: 'D' as i32,
18924 };
18925 init
18926 },
18927 {
18928 let mut init = distsamples {
18929 max: 50000 as libc::c_int as libc::c_longlong,
18930 count: 0 as libc::c_int as libc::c_longlong,
18931 character: 'E' as i32,
18932 };
18933 init
18934 },
18935 {
18936 let mut init = distsamples {
18937 max: 100000 as libc::c_int as libc::c_longlong,
18938 count: 0 as libc::c_int as libc::c_longlong,
18939 character: 'F' as i32,
18940 };
18941 init
18942 },
18943 {
18944 let mut init = distsamples {
18945 max: 200000 as libc::c_int as libc::c_longlong,
18946 count: 0 as libc::c_int as libc::c_longlong,
18947 character: 'G' as i32,
18948 };
18949 init
18950 },
18951 {
18952 let mut init = distsamples {
18953 max: 300000 as libc::c_int as libc::c_longlong,
18954 count: 0 as libc::c_int as libc::c_longlong,
18955 character: 'H' as i32,
18956 };
18957 init
18958 },
18959 {
18960 let mut init = distsamples {
18961 max: 400000 as libc::c_int as libc::c_longlong,
18962 count: 0 as libc::c_int as libc::c_longlong,
18963 character: 'I' as i32,
18964 };
18965 init
18966 },
18967 {
18968 let mut init = distsamples {
18969 max: 500000 as libc::c_int as libc::c_longlong,
18970 count: 0 as libc::c_int as libc::c_longlong,
18971 character: 'J' as i32,
18972 };
18973 init
18974 },
18975 {
18976 let mut init = distsamples {
18977 max: 1000000 as libc::c_int as libc::c_longlong,
18978 count: 0 as libc::c_int as libc::c_longlong,
18979 character: 'K' as i32,
18980 };
18981 init
18982 },
18983 {
18984 let mut init = distsamples {
18985 max: 2000000 as libc::c_int as libc::c_longlong,
18986 count: 0 as libc::c_int as libc::c_longlong,
18987 character: 'L' as i32,
18988 };
18989 init
18990 },
18991 {
18992 let mut init = distsamples {
18993 max: 4000000 as libc::c_int as libc::c_longlong,
18994 count: 0 as libc::c_int as libc::c_longlong,
18995 character: 'M' as i32,
18996 };
18997 init
18998 },
18999 {
19000 let mut init = distsamples {
19001 max: 8000000 as libc::c_int as libc::c_longlong,
19002 count: 0 as libc::c_int as libc::c_longlong,
19003 character: 'N' as i32,
19004 };
19005 init
19006 },
19007 {
19008 let mut init = distsamples {
19009 max: 16000000 as libc::c_int as libc::c_longlong,
19010 count: 0 as libc::c_int as libc::c_longlong,
19011 character: 'O' as i32,
19012 };
19013 init
19014 },
19015 {
19016 let mut init = distsamples {
19017 max: 30000000 as libc::c_int as libc::c_longlong,
19018 count: 0 as libc::c_int as libc::c_longlong,
19019 character: 'P' as i32,
19020 };
19021 init
19022 },
19023 {
19024 let mut init = distsamples {
19025 max: 60000000 as libc::c_int as libc::c_longlong,
19026 count: 0 as libc::c_int as libc::c_longlong,
19027 character: 'Q' as i32,
19028 };
19029 init
19030 },
19031 {
19032 let mut init = distsamples {
19033 max: 0 as libc::c_int as libc::c_longlong,
19034 count: 0 as libc::c_int as libc::c_longlong,
19035 character: '?' as i32,
19036 };
19037 init
19038 },
19039 ];
19040 if context.is_null() {
19041 exit(1 as libc::c_int);
19042 }
19043 loop {
19044 start = ustime();
19045 reply = reconnectingRedisCommand(
19046 context,
19047 b"PING\0" as *const u8 as *const libc::c_char,
19048 );
19049 if reply.is_null() {
19050 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
19051 exit(1 as libc::c_int);
19052 }
19053 latency = ustime() - start;
19054 freeReplyObject(reply as *mut libc::c_void);
19055 count += 1;
19056 j = 0 as libc::c_int;
19057 loop {
19058 if samples[j as usize].max == 0 as libc::c_int as libc::c_longlong
19059 || latency <= samples[j as usize].max
19060 {
19061 samples[j as usize].count += 1;
19062 break;
19063 } else {
19064 j += 1;
19065 }
19066 }
19067 if count != 0
19068 && (ustime() - history_start) / 1000 as libc::c_int as libc::c_longlong
19069 > history_interval
19070 {
19071 let fresh75 = outputs;
19072 outputs = outputs + 1;
19073 if fresh75 % 20 as libc::c_int == 0 as libc::c_int {
19074 showLatencyDistLegend();
19075 }
19076 showLatencyDistSamples(samples.as_mut_ptr(), count);
19077 history_start = ustime();
19078 count = 0 as libc::c_int as libc::c_longlong;
19079 }
19080 usleep((10 as libc::c_int * 1000 as libc::c_int) as __useconds_t);
19081 };
19082}
19083#[no_mangle]
19084pub unsafe extern "C" fn sendReplconf(
19085 mut arg1: *const libc::c_char,
19086 mut arg2: *const libc::c_char,
19087) -> libc::c_int {
19088 let mut res: libc::c_int = 1 as libc::c_int;
19089 fprintf(
19090 stderr,
19091 b"sending REPLCONF %s %s\n\0" as *const u8 as *const libc::c_char,
19092 arg1,
19093 arg2,
19094 );
19095 let mut reply: *mut redisReply = redisCommand(
19096 context,
19097 b"REPLCONF %s %s\0" as *const u8 as *const libc::c_char,
19098 arg1,
19099 arg2,
19100 ) as *mut redisReply;
19101 if reply.is_null() {
19102 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
19103 exit(1 as libc::c_int);
19104 } else {
19105 if (*reply).type_0 == 6 as libc::c_int {
19106 fprintf(
19107 stderr,
19108 b"REPLCONF %s error: %s\n\0" as *const u8 as *const libc::c_char,
19109 arg1,
19110 (*reply).str_0,
19111 );
19112 res = 0 as libc::c_int;
19113 }
19114 }
19115 freeReplyObject(reply as *mut libc::c_void);
19116 return res;
19117}
19118#[no_mangle]
19119pub unsafe extern "C" fn sendCapa() {
19120 sendReplconf(
19121 b"capa\0" as *const u8 as *const libc::c_char,
19122 b"eof\0" as *const u8 as *const libc::c_char,
19123 );
19124}
19125#[no_mangle]
19126pub unsafe extern "C" fn sendRdbOnly() {
19127 sendReplconf(
19128 b"rdb-only\0" as *const u8 as *const libc::c_char,
19129 b"1\0" as *const u8 as *const libc::c_char,
19130 );
19131}
19132unsafe extern "C" fn readConn(
19133 mut c: *mut redisContext,
19134 mut buf: *mut libc::c_char,
19135 mut len: size_t,
19136) -> ssize_t {
19137 return ((*(*c).funcs).read).expect("non-null function pointer")(c, buf, len);
19138}
19139#[no_mangle]
19140pub unsafe extern "C" fn sendSync(
19141 mut c: *mut redisContext,
19142 mut out_eof: *mut libc::c_char,
19143) -> libc::c_ulonglong {
19144 let mut buf: [libc::c_char; 4096] = [0; 4096];
19145 let mut p: *mut libc::c_char = 0 as *mut libc::c_char;
19146 let mut nread: ssize_t = 0;
19147 if cliWriteConn(
19148 c,
19149 b"SYNC\r\n\0" as *const u8 as *const libc::c_char,
19150 6 as libc::c_int as size_t,
19151 ) != 6 as libc::c_int as libc::c_long
19152 {
19153 fprintf(
19154 stderr,
19155 b"Error writing to master\n\0" as *const u8 as *const libc::c_char,
19156 );
19157 exit(1 as libc::c_int);
19158 }
19159 p = buf.as_mut_ptr();
19160 loop {
19161 nread = readConn(c, p, 1 as libc::c_int as size_t);
19162 if nread <= 0 as libc::c_int as libc::c_long {
19163 fprintf(
19164 stderr,
19165 b"Error reading bulk length while SYNCing\n\0" as *const u8
19166 as *const libc::c_char,
19167 );
19168 exit(1 as libc::c_int);
19169 }
19170 if *p as libc::c_int == '\n' as i32 && p != buf.as_mut_ptr() {
19171 break;
19172 }
19173 if *p as libc::c_int != '\n' as i32 {
19174 p = p.offset(1);
19175 }
19176 }
19177 *p = '\0' as i32 as libc::c_char;
19178 if buf[0 as libc::c_int as usize] as libc::c_int == '-' as i32 {
19179 fprintf(
19180 stderr,
19181 b"SYNC with master failed: %s\n\0" as *const u8 as *const libc::c_char,
19182 buf.as_mut_ptr(),
19183 );
19184 exit(1 as libc::c_int);
19185 }
19186 if strncmp(
19187 buf.as_mut_ptr().offset(1 as libc::c_int as isize),
19188 b"EOF:\0" as *const u8 as *const libc::c_char,
19189 4 as libc::c_int as libc::c_ulong,
19190 ) == 0 as libc::c_int
19191 && strlen(buf.as_mut_ptr().offset(5 as libc::c_int as isize))
19192 >= 40 as libc::c_int as libc::c_ulong
19193 {
19194 memcpy(
19195 out_eof as *mut libc::c_void,
19196 buf.as_mut_ptr().offset(5 as libc::c_int as isize) as *const libc::c_void,
19197 40 as libc::c_int as libc::c_ulong,
19198 );
19199 return 0 as libc::c_int as libc::c_ulonglong;
19200 }
19201 return strtoull(
19202 buf.as_mut_ptr().offset(1 as libc::c_int as isize),
19203 0 as *mut *mut libc::c_char,
19204 10 as libc::c_int,
19205 );
19206}
19207unsafe extern "C" fn slaveMode() {
19208 static mut eofmark: [libc::c_char; 40] = [0; 40];
19209 static mut lastbytes: [libc::c_char; 40] = [0; 40];
19210 static mut usemark: libc::c_int = 0 as libc::c_int;
19211 let mut payload: libc::c_ulonglong = sendSync(context, eofmark.as_mut_ptr());
19212 let mut buf: [libc::c_char; 1024] = [0; 1024];
19213 let mut original_output: libc::c_int = config.output;
19214 if payload == 0 as libc::c_int as libc::c_ulonglong {
19215 payload = (9223372036854775807 as libc::c_longlong as libc::c_ulonglong)
19216 .wrapping_mul(2 as libc::c_ulonglong)
19217 .wrapping_add(1 as libc::c_ulonglong);
19218 memset(
19219 lastbytes.as_mut_ptr() as *mut libc::c_void,
19220 0 as libc::c_int,
19221 40 as libc::c_int as libc::c_ulong,
19222 );
19223 usemark = 1 as libc::c_int;
19224 fprintf(
19225 stderr,
19226 b"SYNC with master, discarding bytes of bulk transfer until EOF marker...\n\0"
19227 as *const u8 as *const libc::c_char,
19228 );
19229 } else {
19230 fprintf(
19231 stderr,
19232 b"SYNC with master, discarding %llu bytes of bulk transfer...\n\0"
19233 as *const u8 as *const libc::c_char,
19234 payload,
19235 );
19236 }
19237 while payload != 0 {
19238 let mut nread: ssize_t = 0;
19239 nread = readConn(
19240 context,
19241 buf.as_mut_ptr(),
19242 (if payload
19243 > core::mem::size_of::<[libc::c_char; 1024]>() as libc::c_ulong
19244 as libc::c_ulonglong
19245 {
19246 core::mem::size_of::<[libc::c_char; 1024]>() as libc::c_ulong
19247 as libc::c_ulonglong
19248 } else {
19249 payload
19250 }) as size_t,
19251 );
19252 if nread <= 0 as libc::c_int as libc::c_long {
19253 fprintf(
19254 stderr,
19255 b"Error reading RDB payload while SYNCing\n\0" as *const u8
19256 as *const libc::c_char,
19257 );
19258 exit(1 as libc::c_int);
19259 }
19260 payload = payload.wrapping_sub(nread as libc::c_ulonglong);
19261 if !(usemark != 0) {
19262 continue;
19263 }
19264 if nread >= 40 as libc::c_int as libc::c_long {
19265 memcpy(
19266 lastbytes.as_mut_ptr() as *mut libc::c_void,
19267 buf
19268 .as_mut_ptr()
19269 .offset(nread as isize)
19270 .offset(-(40 as libc::c_int as isize)) as *const libc::c_void,
19271 40 as libc::c_int as libc::c_ulong,
19272 );
19273 } else {
19274 let mut rem: libc::c_int = (40 as libc::c_int as libc::c_long - nread)
19275 as libc::c_int;
19276 memmove(
19277 lastbytes.as_mut_ptr() as *mut libc::c_void,
19278 lastbytes.as_mut_ptr().offset(nread as isize) as *const libc::c_void,
19279 rem as libc::c_ulong,
19280 );
19281 memcpy(
19282 lastbytes.as_mut_ptr().offset(rem as isize) as *mut libc::c_void,
19283 buf.as_mut_ptr() as *const libc::c_void,
19284 nread as libc::c_ulong,
19285 );
19286 }
19287 if memcmp(
19288 lastbytes.as_mut_ptr() as *const libc::c_void,
19289 eofmark.as_mut_ptr() as *const libc::c_void,
19290 40 as libc::c_int as libc::c_ulong,
19291 ) == 0 as libc::c_int
19292 {
19293 break;
19294 }
19295 }
19296 if usemark != 0 {
19297 let mut offset: libc::c_ulonglong = (9223372036854775807 as libc::c_longlong
19298 as libc::c_ulonglong)
19299 .wrapping_mul(2 as libc::c_ulonglong)
19300 .wrapping_add(1 as libc::c_ulonglong)
19301 .wrapping_sub(payload);
19302 fprintf(
19303 stderr,
19304 b"SYNC done after %llu bytes. Logging commands from master.\n\0" as *const u8
19305 as *const libc::c_char,
19306 offset,
19307 );
19308 sleep(1 as libc::c_int as libc::c_uint);
19309 sendReplconf(
19310 b"ACK\0" as *const u8 as *const libc::c_char,
19311 b"0\0" as *const u8 as *const libc::c_char,
19312 );
19313 } else {
19314 fprintf(
19315 stderr,
19316 b"SYNC done. Logging commands from master.\n\0" as *const u8
19317 as *const libc::c_char,
19318 );
19319 }
19320 config.output = 2 as libc::c_int;
19321 while cliReadReply(0 as libc::c_int) == 0 as libc::c_int {}
19322 config.output = original_output;
19323}
19324unsafe extern "C" fn getRDB(mut node: *mut clusterManagerNode) {
19325 let mut fd: libc::c_int = 0;
19326 let mut s: *mut redisContext = 0 as *mut redisContext;
19327 let mut filename: *mut libc::c_char = 0 as *mut libc::c_char;
19328 if !node.is_null() {
19329 if !((*node).context).is_null() {} else {
19330 __assert_fail(
19331 b"node->context\0" as *const u8 as *const libc::c_char,
19332 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
19333 7787 as libc::c_int as libc::c_uint,
19334 (*core::mem::transmute::<
19335 &[u8; 34],
19336 &[libc::c_char; 34],
19337 >(b"void getRDB(clusterManagerNode *)\0"))
19338 .as_ptr(),
19339 );
19340 };
19341 s = (*node).context;
19342 filename = clusterManagerGetNodeRDBFilename(node);
19343 } else {
19344 s = context;
19345 filename = config.rdb_filename;
19346 }
19347 static mut eofmark: [libc::c_char; 40] = [0; 40];
19348 static mut lastbytes: [libc::c_char; 40] = [0; 40];
19349 static mut usemark: libc::c_int = 0 as libc::c_int;
19350 let mut payload: libc::c_ulonglong = sendSync(s, eofmark.as_mut_ptr());
19351 let mut buf: [libc::c_char; 4096] = [0; 4096];
19352 if payload == 0 as libc::c_int as libc::c_ulonglong {
19353 payload = (9223372036854775807 as libc::c_longlong as libc::c_ulonglong)
19354 .wrapping_mul(2 as libc::c_ulonglong)
19355 .wrapping_add(1 as libc::c_ulonglong);
19356 memset(
19357 lastbytes.as_mut_ptr() as *mut libc::c_void,
19358 0 as libc::c_int,
19359 40 as libc::c_int as libc::c_ulong,
19360 );
19361 usemark = 1 as libc::c_int;
19362 fprintf(
19363 stderr,
19364 b"SYNC sent to master, writing bytes of bulk transfer until EOF marker to '%s'\n\0"
19365 as *const u8 as *const libc::c_char,
19366 filename,
19367 );
19368 } else {
19369 fprintf(
19370 stderr,
19371 b"SYNC sent to master, writing %llu bytes to '%s'\n\0" as *const u8
19372 as *const libc::c_char,
19373 payload,
19374 filename,
19375 );
19376 }
19377 let mut write_to_stdout: libc::c_int = (strcmp(
19378 filename,
19379 b"-\0" as *const u8 as *const libc::c_char,
19380 ) == 0) as libc::c_int;
19381 if write_to_stdout != 0 {
19382 fd = 1 as libc::c_int;
19383 } else {
19384 fd = open(
19385 filename,
19386 0o100 as libc::c_int | 0o1 as libc::c_int,
19387 0o644 as libc::c_int,
19388 );
19389 if fd == -(1 as libc::c_int) {
19390 fprintf(
19391 stderr,
19392 b"Error opening '%s': %s\n\0" as *const u8 as *const libc::c_char,
19393 filename,
19394 strerror(*__errno_location()),
19395 );
19396 exit(1 as libc::c_int);
19397 }
19398 }
19399 while payload != 0 {
19400 let mut nread: ssize_t = 0;
19401 let mut nwritten: ssize_t = 0;
19402 nread = readConn(
19403 s,
19404 buf.as_mut_ptr(),
19405 (if payload
19406 > core::mem::size_of::<[libc::c_char; 4096]>() as libc::c_ulong
19407 as libc::c_ulonglong
19408 {
19409 core::mem::size_of::<[libc::c_char; 4096]>() as libc::c_ulong
19410 as libc::c_ulonglong
19411 } else {
19412 payload
19413 }) as size_t,
19414 );
19415 if nread <= 0 as libc::c_int as libc::c_long {
19416 fprintf(
19417 stderr,
19418 b"I/O Error reading RDB payload from socket\n\0" as *const u8
19419 as *const libc::c_char,
19420 );
19421 exit(1 as libc::c_int);
19422 }
19423 nwritten = write(fd, buf.as_mut_ptr() as *const libc::c_void, nread as size_t);
19424 if nwritten != nread {
19425 fprintf(
19426 stderr,
19427 b"Error writing data to file: %s\n\0" as *const u8
19428 as *const libc::c_char,
19429 if nwritten == -(1 as libc::c_int) as libc::c_long {
19430 strerror(*__errno_location()) as *const libc::c_char
19431 } else {
19432 b"short write\0" as *const u8 as *const libc::c_char
19433 },
19434 );
19435 exit(1 as libc::c_int);
19436 }
19437 payload = payload.wrapping_sub(nread as libc::c_ulonglong);
19438 if !(usemark != 0) {
19439 continue;
19440 }
19441 if nread >= 40 as libc::c_int as libc::c_long {
19442 memcpy(
19443 lastbytes.as_mut_ptr() as *mut libc::c_void,
19444 buf
19445 .as_mut_ptr()
19446 .offset(nread as isize)
19447 .offset(-(40 as libc::c_int as isize)) as *const libc::c_void,
19448 40 as libc::c_int as libc::c_ulong,
19449 );
19450 } else {
19451 let mut rem: libc::c_int = (40 as libc::c_int as libc::c_long - nread)
19452 as libc::c_int;
19453 memmove(
19454 lastbytes.as_mut_ptr() as *mut libc::c_void,
19455 lastbytes.as_mut_ptr().offset(nread as isize) as *const libc::c_void,
19456 rem as libc::c_ulong,
19457 );
19458 memcpy(
19459 lastbytes.as_mut_ptr().offset(rem as isize) as *mut libc::c_void,
19460 buf.as_mut_ptr() as *const libc::c_void,
19461 nread as libc::c_ulong,
19462 );
19463 }
19464 if memcmp(
19465 lastbytes.as_mut_ptr() as *const libc::c_void,
19466 eofmark.as_mut_ptr() as *const libc::c_void,
19467 40 as libc::c_int as libc::c_ulong,
19468 ) == 0 as libc::c_int
19469 {
19470 break;
19471 }
19472 }
19473 if usemark != 0 {
19474 payload = (9223372036854775807 as libc::c_longlong as libc::c_ulonglong)
19475 .wrapping_mul(2 as libc::c_ulonglong)
19476 .wrapping_add(1 as libc::c_ulonglong)
19477 .wrapping_sub(payload)
19478 .wrapping_sub(40 as libc::c_int as libc::c_ulonglong);
19479 if write_to_stdout == 0
19480 && ftruncate(fd, payload as __off64_t) == -(1 as libc::c_int)
19481 {
19482 fprintf(
19483 stderr,
19484 b"ftruncate failed: %s.\n\0" as *const u8 as *const libc::c_char,
19485 strerror(*__errno_location()),
19486 );
19487 }
19488 fprintf(
19489 stderr,
19490 b"Transfer finished with success after %llu bytes\n\0" as *const u8
19491 as *const libc::c_char,
19492 payload,
19493 );
19494 } else {
19495 fprintf(
19496 stderr,
19497 b"Transfer finished with success.\n\0" as *const u8 as *const libc::c_char,
19498 );
19499 }
19500 redisFree(s);
19501 if !node.is_null() {
19502 (*node).context = 0 as *mut redisContext;
19503 }
19504 if write_to_stdout == 0 && fsync(fd) == -(1 as libc::c_int) {
19505 fprintf(
19506 stderr,
19507 b"Fail to fsync '%s': %s\n\0" as *const u8 as *const libc::c_char,
19508 filename,
19509 strerror(*__errno_location()),
19510 );
19511 exit(1 as libc::c_int);
19512 }
19513 close(fd);
19514 if !node.is_null() {
19515 hi_sdsfree(filename);
19516 return;
19517 }
19518 exit(0 as libc::c_int);
19519}
19520unsafe extern "C" fn pipeMode() {
19521 let mut errors: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
19522 let mut replies: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
19523 let mut obuf_len: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
19524 let mut obuf_pos: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
19525 let mut obuf: [libc::c_char; 16384] = [0; 16384];
19526 let mut aneterr: [libc::c_char; 256] = [0; 256];
19527 let mut reply: *mut redisReply = 0 as *mut redisReply;
19528 let mut eof: libc::c_int = 0 as libc::c_int;
19529 let mut done: libc::c_int = 0 as libc::c_int;
19530 let mut magic: [libc::c_char; 20] = [0; 20];
19531 let mut last_read_time: time_t = time(0 as *mut time_t);
19532 srand(time(0 as *mut time_t) as libc::c_uint);
19533 if anetNonBlock(aneterr.as_mut_ptr(), (*context).fd) == -(1 as libc::c_int) {
19534 fprintf(
19535 stderr,
19536 b"Can't set the socket in non blocking mode: %s\n\0" as *const u8
19537 as *const libc::c_char,
19538 aneterr.as_mut_ptr(),
19539 );
19540 exit(1 as libc::c_int);
19541 }
19542 (*context).flags &= !(0x1 as libc::c_int);
19543 while done == 0 {
19544 let mut mask: libc::c_int = 1 as libc::c_int;
19545 if eof == 0 || obuf_len != 0 as libc::c_int as libc::c_longlong {
19546 mask |= 2 as libc::c_int;
19547 }
19548 mask = aeWait((*context).fd, mask, 1000 as libc::c_int as libc::c_longlong);
19549 if mask & 1 as libc::c_int != 0 {
19550 let mut read_error: libc::c_int = 0 as libc::c_int;
19551 loop {
19552 if read_error == 0 && redisBufferRead(context) == -(1 as libc::c_int) {
19553 read_error = 1 as libc::c_int;
19554 }
19555 reply = 0 as *mut redisReply;
19556 if redisGetReply(
19557 context,
19558 &mut reply as *mut *mut redisReply as *mut *mut libc::c_void,
19559 ) == -(1 as libc::c_int)
19560 {
19561 fprintf(
19562 stderr,
19563 b"Error reading replies from server\n\0" as *const u8
19564 as *const libc::c_char,
19565 );
19566 exit(1 as libc::c_int);
19567 }
19568 if !reply.is_null() {
19569 last_read_time = time(0 as *mut time_t);
19570 if (*reply).type_0 == 6 as libc::c_int {
19571 fprintf(
19572 stderr,
19573 b"%s\n\0" as *const u8 as *const libc::c_char,
19574 (*reply).str_0,
19575 );
19576 errors += 1;
19577 } else if eof != 0 && (*reply).type_0 == 1 as libc::c_int
19578 && (*reply).len == 20 as libc::c_int as libc::c_ulong
19579 {
19580 if memcmp(
19581 (*reply).str_0 as *const libc::c_void,
19582 magic.as_mut_ptr() as *const libc::c_void,
19583 20 as libc::c_int as libc::c_ulong,
19584 ) == 0 as libc::c_int
19585 {
19586 printf(
19587 b"Last reply received from server.\n\0" as *const u8
19588 as *const libc::c_char,
19589 );
19590 done = 1 as libc::c_int;
19591 replies -= 1;
19592 }
19593 }
19594 replies += 1;
19595 freeReplyObject(reply as *mut libc::c_void);
19596 }
19597 if reply.is_null() {
19598 break;
19599 }
19600 }
19601 if read_error != 0 {
19602 exit(1 as libc::c_int);
19603 }
19604 }
19605 if mask & 2 as libc::c_int != 0 {
19606 let mut loop_nwritten: ssize_t = 0 as libc::c_int as ssize_t;
19607 loop {
19608 if obuf_len != 0 as libc::c_int as libc::c_longlong {
19609 let mut nwritten: ssize_t = cliWriteConn(
19610 context,
19611 obuf.as_mut_ptr().offset(obuf_pos as isize),
19612 obuf_len as size_t,
19613 );
19614 if nwritten == -(1 as libc::c_int) as libc::c_long {
19615 if *__errno_location() != 11 as libc::c_int
19616 && *__errno_location() != 4 as libc::c_int
19617 {
19618 fprintf(
19619 stderr,
19620 b"Error writing to the server: %s\n\0" as *const u8
19621 as *const libc::c_char,
19622 strerror(*__errno_location()),
19623 );
19624 exit(1 as libc::c_int);
19625 } else {
19626 nwritten = 0 as libc::c_int as ssize_t;
19627 }
19628 }
19629 obuf_len -= nwritten as libc::c_longlong;
19630 obuf_pos += nwritten as libc::c_longlong;
19631 loop_nwritten += nwritten;
19632 if obuf_len != 0 as libc::c_int as libc::c_longlong {
19633 break;
19634 }
19635 }
19636 if (*context).err != 0 {
19637 fprintf(
19638 stderr,
19639 b"Server I/O Error: %s\n\0" as *const u8 as *const libc::c_char,
19640 ((*context).errstr).as_mut_ptr(),
19641 );
19642 exit(1 as libc::c_int);
19643 }
19644 if obuf_len == 0 as libc::c_int as libc::c_longlong && eof == 0 {
19645 let mut nread: ssize_t = read(
19646 0 as libc::c_int,
19647 obuf.as_mut_ptr() as *mut libc::c_void,
19648 core::mem::size_of::<[libc::c_char; 16384]>() as libc::c_ulong,
19649 );
19650 if nread == 0 as libc::c_int as libc::c_long {
19651 let mut echo: [libc::c_char; 44] = {
19652 let echo_bytes: &[u8; 44] = b"\r\n*2\r\n$4\r\nECHO\r\n$20\r\n01234567890123456789\r\n\0";
19653 let echo_chars: &mut [libc::c_char; 44] = unsafe {
19654 &mut *(&echo_bytes as *const _ as *mut [libc::c_char; 44])
19655 };
19656 let echo_cell = UnsafeCell::new(echo_chars);
19657 unsafe { **echo_cell.get() }
19658 };
19659
19660 let mut j: libc::c_int = 0;
19661 eof = 1 as libc::c_int;
19662 j = 0 as libc::c_int;
19663 while j < 20 as libc::c_int {
19664 magic[j
19665 as usize] = (rand() & 0xff as libc::c_int) as libc::c_char;
19666 j += 1;
19667 }
19668 memcpy(
19669 echo.as_mut_ptr().offset(21 as libc::c_int as isize)
19670 as *mut libc::c_void,
19671 magic.as_mut_ptr() as *const libc::c_void,
19672 20 as libc::c_int as libc::c_ulong,
19673 );
19674 memcpy(
19675 obuf.as_mut_ptr() as *mut libc::c_void,
19676 echo.as_mut_ptr() as *const libc::c_void,
19677 (core::mem::size_of::<[libc::c_char; 44]>()
19678 as libc::c_ulong)
19679 .wrapping_sub(1 as libc::c_int as libc::c_ulong),
19680 );
19681 obuf_len = (core::mem::size_of::<[libc::c_char; 44]>()
19682 as libc::c_ulong)
19683 .wrapping_sub(1 as libc::c_int as libc::c_ulong)
19684 as libc::c_longlong;
19685 obuf_pos = 0 as libc::c_int as libc::c_longlong;
19686 printf(
19687 b"All data transferred. Waiting for the last reply...\n\0"
19688 as *const u8 as *const libc::c_char,
19689 );
19690 } else if nread == -(1 as libc::c_int) as libc::c_long {
19691 fprintf(
19692 stderr,
19693 b"Error reading from stdin: %s\n\0" as *const u8
19694 as *const libc::c_char,
19695 strerror(*__errno_location()),
19696 );
19697 exit(1 as libc::c_int);
19698 } else {
19699 obuf_len = nread as libc::c_longlong;
19700 obuf_pos = 0 as libc::c_int as libc::c_longlong;
19701 }
19702 }
19703 if obuf_len == 0 as libc::c_int as libc::c_longlong && eof != 0
19704 || loop_nwritten
19705 > (128 as libc::c_int * 1024 as libc::c_int) as libc::c_long
19706 {
19707 break;
19708 }
19709 }
19710 }
19711 if !(eof != 0 && config.pipe_timeout > 0 as libc::c_int
19712 && time(0 as *mut time_t) - last_read_time
19713 > config.pipe_timeout as libc::c_long)
19714 {
19715 continue;
19716 }
19717 fprintf(
19718 stderr,
19719 b"No replies for %d seconds: exiting.\n\0" as *const u8
19720 as *const libc::c_char,
19721 config.pipe_timeout,
19722 );
19723 errors += 1;
19724 break;
19725 }
19726 printf(
19727 b"errors: %lld, replies: %lld\n\0" as *const u8 as *const libc::c_char,
19728 errors,
19729 replies,
19730 );
19731 if errors != 0 {
19732 exit(1 as libc::c_int);
19733 } else {
19734 exit(0 as libc::c_int);
19735 };
19736}
19737unsafe extern "C" fn sendScan(mut it: *mut libc::c_ulonglong) -> *mut redisReply {
19738 let mut reply: *mut redisReply = 0 as *mut redisReply;
19739 if !(config.pattern).is_null() {
19740 reply = redisCommand(
19741 context,
19742 b"SCAN %llu MATCH %b\0" as *const u8 as *const libc::c_char,
19743 *it,
19744 config.pattern,
19745 hi_sdslen(config.pattern),
19746 ) as *mut redisReply;
19747 } else {
19748 reply = redisCommand(
19749 context,
19750 b"SCAN %llu\0" as *const u8 as *const libc::c_char,
19751 *it,
19752 ) as *mut redisReply;
19753 }
19754 if reply.is_null() {
19755 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
19756 exit(1 as libc::c_int);
19757 } else {
19758 if (*reply).type_0 == 6 as libc::c_int {
19759 fprintf(
19760 stderr,
19761 b"SCAN error: %s\n\0" as *const u8 as *const libc::c_char,
19762 (*reply).str_0,
19763 );
19764 exit(1 as libc::c_int);
19765 } else {
19766 if (*reply).type_0 != 2 as libc::c_int {
19767 fprintf(
19768 stderr,
19769 b"Non ARRAY response from SCAN!\n\0" as *const u8
19770 as *const libc::c_char,
19771 );
19772 exit(1 as libc::c_int);
19773 } else {
19774 if (*reply).elements != 2 as libc::c_int as libc::c_ulong {
19775 fprintf(
19776 stderr,
19777 b"Invalid element count from SCAN!\n\0" as *const u8
19778 as *const libc::c_char,
19779 );
19780 exit(1 as libc::c_int);
19781 }
19782 }
19783 }
19784 }
19785 if (**((*reply).element).offset(0 as libc::c_int as isize)).type_0
19786 == 1 as libc::c_int
19787 {} else {
19788 __assert_fail(
19789 b"reply->element[0]->type == REDIS_REPLY_STRING\0" as *const u8
19790 as *const libc::c_char,
19791 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
19792 8064 as libc::c_int as libc::c_uint,
19793 (*core::mem::transmute::<
19794 &[u8; 43],
19795 &[libc::c_char; 43],
19796 >(b"redisReply *sendScan(unsigned long long *)\0"))
19797 .as_ptr(),
19798 );
19799 };
19800 if (**((*reply).element).offset(1 as libc::c_int as isize)).type_0
19801 == 2 as libc::c_int
19802 {} else {
19803 __assert_fail(
19804 b"reply->element[1]->type == REDIS_REPLY_ARRAY\0" as *const u8
19805 as *const libc::c_char,
19806 b"redis-cli.c\0" as *const u8 as *const libc::c_char,
19807 8065 as libc::c_int as libc::c_uint,
19808 (*core::mem::transmute::<
19809 &[u8; 43],
19810 &[libc::c_char; 43],
19811 >(b"redisReply *sendScan(unsigned long long *)\0"))
19812 .as_ptr(),
19813 );
19814 };
19815 *it = strtoull(
19816 (**((*reply).element).offset(0 as libc::c_int as isize)).str_0,
19817 0 as *mut *mut libc::c_char,
19818 10 as libc::c_int,
19819 );
19820 return reply;
19821}
19822unsafe extern "C" fn getDbSize() -> libc::c_int {
19823 let mut reply: *mut redisReply = 0 as *mut redisReply;
19824 let mut size: libc::c_int = 0;
19825 reply = redisCommand(context, b"DBSIZE\0" as *const u8 as *const libc::c_char)
19826 as *mut redisReply;
19827 if reply.is_null() {
19828 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
19829 exit(1 as libc::c_int);
19830 } else {
19831 if (*reply).type_0 == 6 as libc::c_int {
19832 fprintf(
19833 stderr,
19834 b"Couldn't determine DBSIZE: %s\n\0" as *const u8 as *const libc::c_char,
19835 (*reply).str_0,
19836 );
19837 exit(1 as libc::c_int);
19838 } else {
19839 if (*reply).type_0 != 3 as libc::c_int {
19840 fprintf(
19841 stderr,
19842 b"Non INTEGER response from DBSIZE!\n\0" as *const u8
19843 as *const libc::c_char,
19844 );
19845 exit(1 as libc::c_int);
19846 }
19847 }
19848 }
19849 size = (*reply).integer as libc::c_int;
19850 freeReplyObject(reply as *mut libc::c_void);
19851 return size;
19852}
19853#[no_mangle]
19854pub static mut type_string: typeinfo = {
19855 let mut init = typeinfo {
19856 name: b"string\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19857 sizecmd: b"STRLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19858 sizeunit: b"bytes\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19859 biggest: 0,
19860 count: 0,
19861 totalsize: 0,
19862 biggest_key: 0 as *const libc::c_char as *mut libc::c_char,
19863 };
19864 init
19865};
19866#[no_mangle]
19867pub static mut type_list: typeinfo = {
19868 let mut init = typeinfo {
19869 name: b"list\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19870 sizecmd: b"LLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19871 sizeunit: b"items\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19872 biggest: 0,
19873 count: 0,
19874 totalsize: 0,
19875 biggest_key: 0 as *const libc::c_char as *mut libc::c_char,
19876 };
19877 init
19878};
19879#[no_mangle]
19880pub static mut type_set: typeinfo = {
19881 let mut init = typeinfo {
19882 name: b"set\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19883 sizecmd: b"SCARD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19884 sizeunit: b"members\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19885 biggest: 0,
19886 count: 0,
19887 totalsize: 0,
19888 biggest_key: 0 as *const libc::c_char as *mut libc::c_char,
19889 };
19890 init
19891};
19892#[no_mangle]
19893pub static mut type_hash: typeinfo = {
19894 let mut init = typeinfo {
19895 name: b"hash\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19896 sizecmd: b"HLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19897 sizeunit: b"fields\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19898 biggest: 0,
19899 count: 0,
19900 totalsize: 0,
19901 biggest_key: 0 as *const libc::c_char as *mut libc::c_char,
19902 };
19903 init
19904};
19905#[no_mangle]
19906pub static mut type_zset: typeinfo = {
19907 let mut init = typeinfo {
19908 name: b"zset\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19909 sizecmd: b"ZCARD\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19910 sizeunit: b"members\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19911 biggest: 0,
19912 count: 0,
19913 totalsize: 0,
19914 biggest_key: 0 as *const libc::c_char as *mut libc::c_char,
19915 };
19916 init
19917};
19918#[no_mangle]
19919pub static mut type_stream: typeinfo = {
19920 let mut init = typeinfo {
19921 name: b"stream\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19922 sizecmd: b"XLEN\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19923 sizeunit: b"entries\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19924 biggest: 0,
19925 count: 0,
19926 totalsize: 0,
19927 biggest_key: 0 as *const libc::c_char as *mut libc::c_char,
19928 };
19929 init
19930};
19931#[no_mangle]
19932pub static mut type_other: typeinfo = {
19933 let mut init = typeinfo {
19934 name: b"other\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19935 sizecmd: 0 as *const libc::c_char as *mut libc::c_char,
19936 sizeunit: b"?\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
19937 biggest: 0,
19938 count: 0,
19939 totalsize: 0,
19940 biggest_key: 0 as *const libc::c_char as *mut libc::c_char,
19941 };
19942 init
19943};
19944unsafe extern "C" fn typeinfo_add(
19945 mut types: *mut dict,
19946 mut name: *mut libc::c_char,
19947 mut type_template: *mut typeinfo,
19948) -> *mut typeinfo {
19949 let mut info: *mut typeinfo = zmalloc(
19950 core::mem::size_of::<typeinfo>() as libc::c_ulong,
19951 ) as *mut typeinfo;
19952 *info = *type_template;
19953 (*info).name = hi_sdsnew(name);
19954 dictAdd(types, (*info).name as *mut libc::c_void, info as *mut libc::c_void);
19955 return info;
19956}
19957#[no_mangle]
19958pub unsafe extern "C" fn type_free(mut d: *mut dict, mut val: *mut libc::c_void) {
19959 let mut info: *mut typeinfo = val as *mut typeinfo;
19960 if !((*info).biggest_key).is_null() {
19961 hi_sdsfree((*info).biggest_key);
19962 }
19963 hi_sdsfree((*info).name);
19964 zfree(info as *mut libc::c_void);
19965}
19966static mut typeinfoDictType: dictType = unsafe {
19967 {
19968 let mut init = dictType {
19969 hashFunction: Some(
19970 dictSdsHash as unsafe extern "C" fn(*const libc::c_void) -> uint64_t,
19971 ),
19972 keyDup: None,
19973 valDup: None,
19974 keyCompare: Some(
19975 dictSdsKeyCompare
19976 as unsafe extern "C" fn(
19977 *mut dict,
19978 *const libc::c_void,
19979 *const libc::c_void,
19980 ) -> libc::c_int,
19981 ),
19982 keyDestructor: None,
19983 valDestructor: Some(
19984 type_free as unsafe extern "C" fn(*mut dict, *mut libc::c_void) -> (),
19985 ),
19986 expandAllowed: None,
19987 dictEntryMetadataBytes: None,
19988 };
19989 init
19990 }
19991};
19992unsafe extern "C" fn getKeyTypes(
19993 mut types_dict: *mut dict,
19994 mut keys: *mut redisReply,
19995 mut types: *mut *mut typeinfo,
19996) {
19997 let mut reply: *mut redisReply = 0 as *mut redisReply;
19998 let mut i: libc::c_uint = 0;
19999 i = 0 as libc::c_int as libc::c_uint;
20000 while (i as libc::c_ulong) < (*keys).elements {
20001 let mut argv: [*const libc::c_char; 2] = [
20002 b"TYPE\0" as *const u8 as *const libc::c_char,
20003 (**((*keys).element).offset(i as isize)).str_0 as *const libc::c_char,
20004 ];
20005 let mut lens: [size_t; 2] = [
20006 4 as libc::c_int as size_t,
20007 (**((*keys).element).offset(i as isize)).len,
20008 ];
20009 redisAppendCommandArgv(
20010 context,
20011 2 as libc::c_int,
20012 argv.as_mut_ptr(),
20013 lens.as_mut_ptr(),
20014 );
20015 i = i.wrapping_add(1);
20016 }
20017 i = 0 as libc::c_int as libc::c_uint;
20018 while (i as libc::c_ulong) < (*keys).elements {
20019 if redisGetReply(
20020 context,
20021 &mut reply as *mut *mut redisReply as *mut *mut libc::c_void,
20022 ) != 0 as libc::c_int
20023 {
20024 fprintf(
20025 stderr,
20026 b"Error getting type for key '%s' (%d: %s)\n\0" as *const u8
20027 as *const libc::c_char,
20028 (**((*keys).element).offset(i as isize)).str_0,
20029 (*context).err,
20030 ((*context).errstr).as_mut_ptr(),
20031 );
20032 exit(1 as libc::c_int);
20033 } else {
20034 if (*reply).type_0 != 5 as libc::c_int {
20035 if (*reply).type_0 == 6 as libc::c_int {
20036 fprintf(
20037 stderr,
20038 b"TYPE returned an error: %s\n\0" as *const u8
20039 as *const libc::c_char,
20040 (*reply).str_0,
20041 );
20042 } else {
20043 fprintf(
20044 stderr,
20045 b"Invalid reply type (%d) for TYPE on key '%s'!\n\0" as *const u8
20046 as *const libc::c_char,
20047 (*reply).type_0,
20048 (**((*keys).element).offset(i as isize)).str_0,
20049 );
20050 }
20051 exit(1 as libc::c_int);
20052 }
20053 }
20054 let mut typereply: hisds = hi_sdsnew((*reply).str_0);
20055 let mut de: *mut dictEntry = dictFind(
20056 types_dict,
20057 typereply as *const libc::c_void,
20058 );
20059 hi_sdsfree(typereply);
20060 let mut type_0: *mut typeinfo = 0 as *mut typeinfo;
20061 if !de.is_null() {
20062 type_0 = (*de).v.val as *mut typeinfo;
20063 } else if strcmp((*reply).str_0, b"none\0" as *const u8 as *const libc::c_char)
20064 != 0
20065 {
20066 type_0 = typeinfo_add(types_dict, (*reply).str_0, &mut type_other);
20067 }
20068 let ref mut fresh76 = *types.offset(i as isize);
20069 *fresh76 = type_0;
20070 freeReplyObject(reply as *mut libc::c_void);
20071 i = i.wrapping_add(1);
20072 }
20073}
20074unsafe extern "C" fn getKeySizes(
20075 mut keys: *mut redisReply,
20076 mut types: *mut *mut typeinfo,
20077 mut sizes: *mut libc::c_ulonglong,
20078 mut memkeys: libc::c_int,
20079 mut memkeys_samples: libc::c_uint,
20080) {
20081 let mut reply: *mut redisReply = 0 as *mut redisReply;
20082 let mut i: libc::c_uint = 0;
20083 i = 0 as libc::c_int as libc::c_uint;
20084 while (i as libc::c_ulong) < (*keys).elements {
20085 if !((*types.offset(i as isize)).is_null()
20086 || ((**types.offset(i as isize)).sizecmd).is_null() && memkeys == 0)
20087 {
20088 if memkeys == 0 {
20089 let mut argv: [*const libc::c_char; 2] = [
20090 (**types.offset(i as isize)).sizecmd as *const libc::c_char,
20091 (**((*keys).element).offset(i as isize)).str_0 as *const libc::c_char,
20092 ];
20093 let mut lens: [size_t; 2] = [
20094 strlen((**types.offset(i as isize)).sizecmd),
20095 (**((*keys).element).offset(i as isize)).len,
20096 ];
20097 redisAppendCommandArgv(
20098 context,
20099 2 as libc::c_int,
20100 argv.as_mut_ptr(),
20101 lens.as_mut_ptr(),
20102 );
20103 } else if memkeys_samples == 0 as libc::c_int as libc::c_uint {
20104 let mut argv_0: [*const libc::c_char; 3] = [
20105 b"MEMORY\0" as *const u8 as *const libc::c_char,
20106 b"USAGE\0" as *const u8 as *const libc::c_char,
20107 (**((*keys).element).offset(i as isize)).str_0 as *const libc::c_char,
20108 ];
20109 let mut lens_0: [size_t; 3] = [
20110 6 as libc::c_int as size_t,
20111 5 as libc::c_int as size_t,
20112 (**((*keys).element).offset(i as isize)).len,
20113 ];
20114 redisAppendCommandArgv(
20115 context,
20116 3 as libc::c_int,
20117 argv_0.as_mut_ptr(),
20118 lens_0.as_mut_ptr(),
20119 );
20120 } else {
20121 let mut samplesstr: hisds = hi_sdsfromlonglong(
20122 memkeys_samples as libc::c_longlong,
20123 );
20124 let mut argv_1: [*const libc::c_char; 5] = [
20125 b"MEMORY\0" as *const u8 as *const libc::c_char,
20126 b"USAGE\0" as *const u8 as *const libc::c_char,
20127 (**((*keys).element).offset(i as isize)).str_0
20128 as *const libc::c_char,
20129 b"SAMPLES\0" as *const u8 as *const libc::c_char,
20130 samplesstr as *const libc::c_char,
20131 ];
20132 let mut lens_1: [size_t; 5] = [
20133 6 as libc::c_int as size_t,
20134 5 as libc::c_int as size_t,
20135 (**((*keys).element).offset(i as isize)).len,
20136 7 as libc::c_int as size_t,
20137 hi_sdslen(samplesstr),
20138 ];
20139 redisAppendCommandArgv(
20140 context,
20141 5 as libc::c_int,
20142 argv_1.as_mut_ptr(),
20143 lens_1.as_mut_ptr(),
20144 );
20145 hi_sdsfree(samplesstr);
20146 }
20147 }
20148 i = i.wrapping_add(1);
20149 }
20150 i = 0 as libc::c_int as libc::c_uint;
20151 while (i as libc::c_ulong) < (*keys).elements {
20152 if (*types.offset(i as isize)).is_null()
20153 || ((**types.offset(i as isize)).sizecmd).is_null() && memkeys == 0
20154 {
20155 *sizes.offset(i as isize) = 0 as libc::c_int as libc::c_ulonglong;
20156 } else {
20157 if redisGetReply(
20158 context,
20159 &mut reply as *mut *mut redisReply as *mut *mut libc::c_void,
20160 ) != 0 as libc::c_int
20161 {
20162 fprintf(
20163 stderr,
20164 b"Error getting size for key '%s' (%d: %s)\n\0" as *const u8
20165 as *const libc::c_char,
20166 (**((*keys).element).offset(i as isize)).str_0,
20167 (*context).err,
20168 ((*context).errstr).as_mut_ptr(),
20169 );
20170 exit(1 as libc::c_int);
20171 } else {
20172 if (*reply).type_0 != 3 as libc::c_int {
20173 fprintf(
20174 stderr,
20175 b"Warning: %s on '%s' failed (may have changed type)\n\0"
20176 as *const u8 as *const libc::c_char,
20177 if memkeys == 0 {
20178 (**types.offset(i as isize)).sizecmd as *const libc::c_char
20179 } else {
20180 b"MEMORY USAGE\0" as *const u8 as *const libc::c_char
20181 },
20182 (**((*keys).element).offset(i as isize)).str_0,
20183 );
20184 *sizes.offset(i as isize) = 0 as libc::c_int as libc::c_ulonglong;
20185 } else {
20186 *sizes.offset(i as isize) = (*reply).integer as libc::c_ulonglong;
20187 }
20188 }
20189 freeReplyObject(reply as *mut libc::c_void);
20190 }
20191 i = i.wrapping_add(1);
20192 }
20193}
20194unsafe extern "C" fn longStatLoopModeStop(mut s: libc::c_int) {
20195 core::ptr::write_volatile(
20196 &mut force_cancel_loop as *mut sig_atomic_t,
20197 1 as libc::c_int,
20198 );
20199}
20200unsafe extern "C" fn findBigKeys(
20201 mut memkeys: libc::c_int,
20202 mut memkeys_samples: libc::c_uint,
20203) {
20204 let mut sampled: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20205 let mut total_keys: libc::c_ulonglong = 0;
20206 let mut totlen: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20207 let mut sizes: *mut libc::c_ulonglong = 0 as *mut libc::c_ulonglong;
20208 let mut it: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20209 let mut scan_loops: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20210 let mut reply: *mut redisReply = 0 as *mut redisReply;
20211 let mut keys: *mut redisReply = 0 as *mut redisReply;
20212 let mut arrsize: libc::c_uint = 0 as libc::c_int as libc::c_uint;
20213 let mut i: libc::c_uint = 0;
20214 let mut di: *mut dictIterator = 0 as *mut dictIterator;
20215 let mut de: *mut dictEntry = 0 as *mut dictEntry;
20216 let mut types: *mut *mut typeinfo = 0 as *mut *mut typeinfo;
20217 let mut pct: libc::c_double = 0.;
20218 let mut types_dict: *mut dict = dictCreate(&mut typeinfoDictType);
20219 typeinfo_add(
20220 types_dict,
20221 b"string\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20222 &mut type_string,
20223 );
20224 typeinfo_add(
20225 types_dict,
20226 b"list\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20227 &mut type_list,
20228 );
20229 typeinfo_add(
20230 types_dict,
20231 b"set\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20232 &mut type_set,
20233 );
20234 typeinfo_add(
20235 types_dict,
20236 b"hash\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20237 &mut type_hash,
20238 );
20239 typeinfo_add(
20240 types_dict,
20241 b"zset\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20242 &mut type_zset,
20243 );
20244 typeinfo_add(
20245 types_dict,
20246 b"stream\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20247 &mut type_stream,
20248 );
20249 signal(
20250 2 as libc::c_int,
20251 Some(longStatLoopModeStop as unsafe extern "C" fn(libc::c_int) -> ()),
20252 );
20253 total_keys = getDbSize() as libc::c_ulonglong;
20254 printf(
20255 b"\n# Scanning the entire keyspace to find biggest keys as well as\n\0"
20256 as *const u8 as *const libc::c_char,
20257 );
20258 printf(
20259 b"# average sizes per key type. You can use -i 0.1 to sleep 0.1 sec\n\0"
20260 as *const u8 as *const libc::c_char,
20261 );
20262 printf(
20263 b"# per 100 SCAN commands (not usually needed).\n\n\0" as *const u8
20264 as *const libc::c_char,
20265 );
20266 loop {
20267 pct = 100 as libc::c_int as libc::c_double * sampled as libc::c_double
20268 / total_keys as libc::c_double;
20269 reply = sendScan(&mut it);
20270 scan_loops = scan_loops.wrapping_add(1);
20271 keys = *((*reply).element).offset(1 as libc::c_int as isize);
20272 if (*keys).elements > arrsize as libc::c_ulong {
20273 types = zrealloc(
20274 types as *mut libc::c_void,
20275 (core::mem::size_of::<*mut typeinfo>() as libc::c_ulong)
20276 .wrapping_mul((*keys).elements),
20277 ) as *mut *mut typeinfo;
20278 sizes = zrealloc(
20279 sizes as *mut libc::c_void,
20280 (core::mem::size_of::<libc::c_ulonglong>() as libc::c_ulong)
20281 .wrapping_mul((*keys).elements),
20282 ) as *mut libc::c_ulonglong;
20283 if types.is_null() || sizes.is_null() {
20284 fprintf(
20285 stderr,
20286 b"Failed to allocate storage for keys!\n\0" as *const u8
20287 as *const libc::c_char,
20288 );
20289 exit(1 as libc::c_int);
20290 }
20291 arrsize = (*keys).elements as libc::c_uint;
20292 }
20293 getKeyTypes(types_dict, keys, types);
20294 getKeySizes(keys, types, sizes, memkeys, memkeys_samples);
20295 i = 0 as libc::c_int as libc::c_uint;
20296 while (i as libc::c_ulong) < (*keys).elements {
20297 let mut type_0: *mut typeinfo = *types.offset(i as isize);
20298 if !type_0.is_null() {
20299 (*type_0)
20300 .totalsize = ((*type_0).totalsize)
20301 .wrapping_add(*sizes.offset(i as isize));
20302 (*type_0).count = ((*type_0).count).wrapping_add(1);
20303 totlen = totlen
20304 .wrapping_add(
20305 (**((*keys).element).offset(i as isize)).len as libc::c_ulonglong,
20306 );
20307 sampled = sampled.wrapping_add(1);
20308 if (*type_0).biggest < *sizes.offset(i as isize) {
20309 if !((*type_0).biggest_key).is_null() {
20310 hi_sdsfree((*type_0).biggest_key);
20311 }
20312 (*type_0)
20313 .biggest_key = hi_sdscatrepr(
20314 hi_sdsempty(),
20315 (**((*keys).element).offset(i as isize)).str_0,
20316 (**((*keys).element).offset(i as isize)).len,
20317 );
20318 if ((*type_0).biggest_key).is_null() {
20319 fprintf(
20320 stderr,
20321 b"Failed to allocate memory for key!\n\0" as *const u8
20322 as *const libc::c_char,
20323 );
20324 exit(1 as libc::c_int);
20325 }
20326 printf(
20327 b"[%05.2f%%] Biggest %-6s found so far '%s' with %llu %s\n\0"
20328 as *const u8 as *const libc::c_char,
20329 pct,
20330 (*type_0).name,
20331 (*type_0).biggest_key,
20332 *sizes.offset(i as isize),
20333 if memkeys == 0 {
20334 (*type_0).sizeunit as *const libc::c_char
20335 } else {
20336 b"bytes\0" as *const u8 as *const libc::c_char
20337 },
20338 );
20339 (*type_0).biggest = *sizes.offset(i as isize);
20340 }
20341 if sampled.wrapping_rem(1000000 as libc::c_int as libc::c_ulonglong)
20342 == 0 as libc::c_int as libc::c_ulonglong
20343 {
20344 printf(
20345 b"[%05.2f%%] Sampled %llu keys so far\n\0" as *const u8
20346 as *const libc::c_char,
20347 pct,
20348 sampled,
20349 );
20350 }
20351 }
20352 i = i.wrapping_add(1);
20353 }
20354 if config.interval != 0
20355 && scan_loops.wrapping_rem(100 as libc::c_int as libc::c_ulonglong)
20356 == 0 as libc::c_int as libc::c_ulonglong
20357 {
20358 usleep(config.interval as __useconds_t);
20359 }
20360 freeReplyObject(reply as *mut libc::c_void);
20361 if !(force_cancel_loop == 0 as libc::c_int
20362 && it != 0 as libc::c_int as libc::c_ulonglong)
20363 {
20364 break;
20365 }
20366 }
20367 if !types.is_null() {
20368 zfree(types as *mut libc::c_void);
20369 }
20370 if !sizes.is_null() {
20371 zfree(sizes as *mut libc::c_void);
20372 }
20373 printf(b"\n-------- summary -------\n\n\0" as *const u8 as *const libc::c_char);
20374 if force_cancel_loop != 0 {
20375 printf(b"[%05.2f%%] \0" as *const u8 as *const libc::c_char, pct);
20376 }
20377 printf(
20378 b"Sampled %llu keys in the keyspace!\n\0" as *const u8 as *const libc::c_char,
20379 sampled,
20380 );
20381 printf(
20382 b"Total key length in bytes is %llu (avg len %.2f)\n\n\0" as *const u8
20383 as *const libc::c_char,
20384 totlen,
20385 if totlen != 0 {
20386 totlen as libc::c_double / sampled as libc::c_double
20387 } else {
20388 0 as libc::c_int as libc::c_double
20389 },
20390 );
20391 di = dictGetIterator(types_dict);
20392 loop {
20393 de = dictNext(di);
20394 if de.is_null() {
20395 break;
20396 }
20397 let mut type_1: *mut typeinfo = (*de).v.val as *mut typeinfo;
20398 if !((*type_1).biggest_key).is_null() {
20399 printf(
20400 b"Biggest %6s found '%s' has %llu %s\n\0" as *const u8
20401 as *const libc::c_char,
20402 (*type_1).name,
20403 (*type_1).biggest_key,
20404 (*type_1).biggest,
20405 if memkeys == 0 {
20406 (*type_1).sizeunit as *const libc::c_char
20407 } else {
20408 b"bytes\0" as *const u8 as *const libc::c_char
20409 },
20410 );
20411 }
20412 }
20413 dictReleaseIterator(di);
20414 printf(b"\n\0" as *const u8 as *const libc::c_char);
20415 di = dictGetIterator(types_dict);
20416 loop {
20417 de = dictNext(di);
20418 if de.is_null() {
20419 break;
20420 }
20421 let mut type_2: *mut typeinfo = (*de).v.val as *mut typeinfo;
20422 printf(
20423 b"%llu %ss with %llu %s (%05.2f%% of keys, avg size %.2f)\n\0" as *const u8
20424 as *const libc::c_char,
20425 (*type_2).count,
20426 (*type_2).name,
20427 (*type_2).totalsize,
20428 if memkeys == 0 {
20429 (*type_2).sizeunit as *const libc::c_char
20430 } else {
20431 b"bytes\0" as *const u8 as *const libc::c_char
20432 },
20433 if sampled != 0 {
20434 100 as libc::c_int as libc::c_double * (*type_2).count as libc::c_double
20435 / sampled as libc::c_double
20436 } else {
20437 0 as libc::c_int as libc::c_double
20438 },
20439 if (*type_2).count != 0 {
20440 (*type_2).totalsize as libc::c_double / (*type_2).count as libc::c_double
20441 } else {
20442 0 as libc::c_int as libc::c_double
20443 },
20444 );
20445 }
20446 dictReleaseIterator(di);
20447 dictRelease(types_dict);
20448 exit(0 as libc::c_int);
20449}
20450unsafe extern "C" fn getKeyFreqs(
20451 mut keys: *mut redisReply,
20452 mut freqs: *mut libc::c_ulonglong,
20453) {
20454 let mut reply: *mut redisReply = 0 as *mut redisReply;
20455 let mut i: libc::c_uint = 0;
20456 i = 0 as libc::c_int as libc::c_uint;
20457 while (i as libc::c_ulong) < (*keys).elements {
20458 let mut argv: [*const libc::c_char; 3] = [
20459 b"OBJECT\0" as *const u8 as *const libc::c_char,
20460 b"FREQ\0" as *const u8 as *const libc::c_char,
20461 (**((*keys).element).offset(i as isize)).str_0 as *const libc::c_char,
20462 ];
20463 let mut lens: [size_t; 3] = [
20464 6 as libc::c_int as size_t,
20465 4 as libc::c_int as size_t,
20466 (**((*keys).element).offset(i as isize)).len,
20467 ];
20468 redisAppendCommandArgv(
20469 context,
20470 3 as libc::c_int,
20471 argv.as_mut_ptr(),
20472 lens.as_mut_ptr(),
20473 );
20474 i = i.wrapping_add(1);
20475 }
20476 i = 0 as libc::c_int as libc::c_uint;
20477 while (i as libc::c_ulong) < (*keys).elements {
20478 if redisGetReply(
20479 context,
20480 &mut reply as *mut *mut redisReply as *mut *mut libc::c_void,
20481 ) != 0 as libc::c_int
20482 {
20483 let mut keyname: hisds = hi_sdscatrepr(
20484 hi_sdsempty(),
20485 (**((*keys).element).offset(i as isize)).str_0,
20486 (**((*keys).element).offset(i as isize)).len,
20487 );
20488 fprintf(
20489 stderr,
20490 b"Error getting freq for key '%s' (%d: %s)\n\0" as *const u8
20491 as *const libc::c_char,
20492 keyname,
20493 (*context).err,
20494 ((*context).errstr).as_mut_ptr(),
20495 );
20496 hi_sdsfree(keyname);
20497 exit(1 as libc::c_int);
20498 } else {
20499 if (*reply).type_0 != 3 as libc::c_int {
20500 if (*reply).type_0 == 6 as libc::c_int {
20501 fprintf(
20502 stderr,
20503 b"Error: %s\n\0" as *const u8 as *const libc::c_char,
20504 (*reply).str_0,
20505 );
20506 exit(1 as libc::c_int);
20507 } else {
20508 let mut keyname_0: hisds = hi_sdscatrepr(
20509 hi_sdsempty(),
20510 (**((*keys).element).offset(i as isize)).str_0,
20511 (**((*keys).element).offset(i as isize)).len,
20512 );
20513 fprintf(
20514 stderr,
20515 b"Warning: OBJECT freq on '%s' failed (may have been deleted)\n\0"
20516 as *const u8 as *const libc::c_char,
20517 keyname_0,
20518 );
20519 hi_sdsfree(keyname_0);
20520 *freqs.offset(i as isize) = 0 as libc::c_int as libc::c_ulonglong;
20521 }
20522 } else {
20523 *freqs.offset(i as isize) = (*reply).integer as libc::c_ulonglong;
20524 }
20525 }
20526 freeReplyObject(reply as *mut libc::c_void);
20527 i = i.wrapping_add(1);
20528 }
20529}
20530unsafe extern "C" fn findHotKeys() {
20531 let mut keys: *mut redisReply = 0 as *mut redisReply;
20532 let mut reply: *mut redisReply = 0 as *mut redisReply;
20533 let mut counters: [libc::c_ulonglong; 16] = [
20534 0 as libc::c_int as libc::c_ulonglong,
20535 0,
20536 0,
20537 0,
20538 0,
20539 0,
20540 0,
20541 0,
20542 0,
20543 0,
20544 0,
20545 0,
20546 0,
20547 0,
20548 0,
20549 0,
20550 ];
20551 let mut hotkeys: [hisds; 16] = [
20552 0 as hisds,
20553 0 as *mut libc::c_char,
20554 0 as *mut libc::c_char,
20555 0 as *mut libc::c_char,
20556 0 as *mut libc::c_char,
20557 0 as *mut libc::c_char,
20558 0 as *mut libc::c_char,
20559 0 as *mut libc::c_char,
20560 0 as *mut libc::c_char,
20561 0 as *mut libc::c_char,
20562 0 as *mut libc::c_char,
20563 0 as *mut libc::c_char,
20564 0 as *mut libc::c_char,
20565 0 as *mut libc::c_char,
20566 0 as *mut libc::c_char,
20567 0 as *mut libc::c_char,
20568 ];
20569 let mut sampled: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20570 let mut total_keys: libc::c_ulonglong = 0;
20571 let mut freqs: *mut libc::c_ulonglong = 0 as *mut libc::c_ulonglong;
20572 let mut it: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20573 let mut scan_loops: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20574 let mut arrsize: libc::c_uint = 0 as libc::c_int as libc::c_uint;
20575 let mut i: libc::c_uint = 0;
20576 let mut k: libc::c_uint = 0;
20577 let mut pct: libc::c_double = 0.;
20578 signal(
20579 2 as libc::c_int,
20580 Some(longStatLoopModeStop as unsafe extern "C" fn(libc::c_int) -> ()),
20581 );
20582 total_keys = getDbSize() as libc::c_ulonglong;
20583 printf(
20584 b"\n# Scanning the entire keyspace to find hot keys as well as\n\0" as *const u8
20585 as *const libc::c_char,
20586 );
20587 printf(
20588 b"# average sizes per key type. You can use -i 0.1 to sleep 0.1 sec\n\0"
20589 as *const u8 as *const libc::c_char,
20590 );
20591 printf(
20592 b"# per 100 SCAN commands (not usually needed).\n\n\0" as *const u8
20593 as *const libc::c_char,
20594 );
20595 loop {
20596 pct = 100 as libc::c_int as libc::c_double * sampled as libc::c_double
20597 / total_keys as libc::c_double;
20598 reply = sendScan(&mut it);
20599 scan_loops = scan_loops.wrapping_add(1);
20600 keys = *((*reply).element).offset(1 as libc::c_int as isize);
20601 if (*keys).elements > arrsize as libc::c_ulong {
20602 freqs = zrealloc(
20603 freqs as *mut libc::c_void,
20604 (core::mem::size_of::<libc::c_ulonglong>() as libc::c_ulong)
20605 .wrapping_mul((*keys).elements),
20606 ) as *mut libc::c_ulonglong;
20607 if freqs.is_null() {
20608 fprintf(
20609 stderr,
20610 b"Failed to allocate storage for keys!\n\0" as *const u8
20611 as *const libc::c_char,
20612 );
20613 exit(1 as libc::c_int);
20614 }
20615 arrsize = (*keys).elements as libc::c_uint;
20616 }
20617 getKeyFreqs(keys, freqs);
20618 i = 0 as libc::c_int as libc::c_uint;
20619 while (i as libc::c_ulong) < (*keys).elements {
20620 sampled = sampled.wrapping_add(1);
20621 if sampled.wrapping_rem(1000000 as libc::c_int as libc::c_ulonglong)
20622 == 0 as libc::c_int as libc::c_ulonglong
20623 {
20624 printf(
20625 b"[%05.2f%%] Sampled %llu keys so far\n\0" as *const u8
20626 as *const libc::c_char,
20627 pct,
20628 sampled,
20629 );
20630 }
20631 k = 0 as libc::c_int as libc::c_uint;
20632 while k < 16 as libc::c_int as libc::c_uint
20633 && *freqs.offset(i as isize) > counters[k as usize]
20634 {
20635 k = k.wrapping_add(1);
20636 }
20637 if !(k == 0 as libc::c_int as libc::c_uint) {
20638 k = k.wrapping_sub(1);
20639 if k == 0 as libc::c_int as libc::c_uint
20640 || counters[k as usize] == 0 as libc::c_int as libc::c_ulonglong
20641 {
20642 hi_sdsfree(hotkeys[k as usize]);
20643 } else {
20644 hi_sdsfree(hotkeys[0 as libc::c_int as usize]);
20645 memmove(
20646 counters.as_mut_ptr() as *mut libc::c_void,
20647 counters.as_mut_ptr().offset(1 as libc::c_int as isize)
20648 as *const libc::c_void,
20649 (core::mem::size_of::<libc::c_ulonglong>() as libc::c_ulong)
20650 .wrapping_mul(k as libc::c_ulong),
20651 );
20652 memmove(
20653 hotkeys.as_mut_ptr() as *mut libc::c_void,
20654 hotkeys.as_mut_ptr().offset(1 as libc::c_int as isize)
20655 as *const libc::c_void,
20656 (core::mem::size_of::<hisds>() as libc::c_ulong)
20657 .wrapping_mul(k as libc::c_ulong),
20658 );
20659 }
20660 counters[k as usize] = *freqs.offset(i as isize);
20661 hotkeys[k
20662 as usize] = hi_sdscatrepr(
20663 hi_sdsempty(),
20664 (**((*keys).element).offset(i as isize)).str_0,
20665 (**((*keys).element).offset(i as isize)).len,
20666 );
20667 printf(
20668 b"[%05.2f%%] Hot key '%s' found so far with counter %llu\n\0"
20669 as *const u8 as *const libc::c_char,
20670 pct,
20671 hotkeys[k as usize],
20672 *freqs.offset(i as isize),
20673 );
20674 }
20675 i = i.wrapping_add(1);
20676 }
20677 if config.interval != 0
20678 && scan_loops.wrapping_rem(100 as libc::c_int as libc::c_ulonglong)
20679 == 0 as libc::c_int as libc::c_ulonglong
20680 {
20681 usleep(config.interval as __useconds_t);
20682 }
20683 freeReplyObject(reply as *mut libc::c_void);
20684 if !(force_cancel_loop == 0 as libc::c_int
20685 && it != 0 as libc::c_int as libc::c_ulonglong)
20686 {
20687 break;
20688 }
20689 }
20690 if !freqs.is_null() {
20691 zfree(freqs as *mut libc::c_void);
20692 }
20693 printf(b"\n-------- summary -------\n\n\0" as *const u8 as *const libc::c_char);
20694 if force_cancel_loop != 0 {
20695 printf(b"[%05.2f%%] \0" as *const u8 as *const libc::c_char, pct);
20696 }
20697 printf(
20698 b"Sampled %llu keys in the keyspace!\n\0" as *const u8 as *const libc::c_char,
20699 sampled,
20700 );
20701 i = 1 as libc::c_int as libc::c_uint;
20702 while i <= 16 as libc::c_int as libc::c_uint {
20703 k = (16 as libc::c_int as libc::c_uint).wrapping_sub(i);
20704 if counters[k as usize] > 0 as libc::c_int as libc::c_ulonglong {
20705 printf(
20706 b"hot key found with counter: %llu\tkeyname: %s\n\0" as *const u8
20707 as *const libc::c_char,
20708 counters[k as usize],
20709 hotkeys[k as usize],
20710 );
20711 hi_sdsfree(hotkeys[k as usize]);
20712 }
20713 i = i.wrapping_add(1);
20714 }
20715 exit(0 as libc::c_int);
20716}
20717unsafe extern "C" fn getInfoField(
20718 mut info: *mut libc::c_char,
20719 mut field: *mut libc::c_char,
20720) -> *mut libc::c_char {
20721 let mut p: *mut libc::c_char = strstr(info, field);
20722 let mut n1: *mut libc::c_char = 0 as *mut libc::c_char;
20723 let mut n2: *mut libc::c_char = 0 as *mut libc::c_char;
20724 let mut result: *mut libc::c_char = 0 as *mut libc::c_char;
20725 if p.is_null() {
20726 return 0 as *mut libc::c_char;
20727 }
20728 p = p
20729 .offset(
20730 (strlen(field)).wrapping_add(1 as libc::c_int as libc::c_ulong) as isize,
20731 );
20732 n1 = strchr(p, '\r' as i32);
20733 n2 = strchr(p, ',' as i32);
20734 if !n2.is_null() && n2 < n1 {
20735 n1 = n2;
20736 }
20737 result = zmalloc(
20738 (core::mem::size_of::<libc::c_char>() as libc::c_ulong)
20739 .wrapping_mul(n1.offset_from(p) as libc::c_long as libc::c_ulong)
20740 .wrapping_add(1 as libc::c_int as libc::c_ulong),
20741 ) as *mut libc::c_char;
20742 memcpy(
20743 result as *mut libc::c_void,
20744 p as *const libc::c_void,
20745 n1.offset_from(p) as libc::c_long as libc::c_ulong,
20746 );
20747 *result
20748 .offset(
20749 n1.offset_from(p) as libc::c_long as isize,
20750 ) = '\0' as i32 as libc::c_char;
20751 return result;
20752}
20753unsafe extern "C" fn getLongInfoField(
20754 mut info: *mut libc::c_char,
20755 mut field: *mut libc::c_char,
20756) -> libc::c_long {
20757 let mut value: *mut libc::c_char = getInfoField(info, field);
20758 let mut l: libc::c_long = 0;
20759 if value.is_null() {
20760 return -(9223372036854775807 as libc::c_long) - 1 as libc::c_long;
20761 }
20762 l = strtol(value, 0 as *mut *mut libc::c_char, 10 as libc::c_int);
20763 zfree(value as *mut libc::c_void);
20764 return l;
20765}
20766#[no_mangle]
20767pub unsafe extern "C" fn bytesToHuman(
20768 mut s: *mut libc::c_char,
20769 mut n: libc::c_longlong,
20770) {
20771 let mut d: libc::c_double = 0.;
20772 if n < 0 as libc::c_int as libc::c_longlong {
20773 *s = '-' as i32 as libc::c_char;
20774 s = s.offset(1);
20775 n = -n;
20776 }
20777 if n < 1024 as libc::c_int as libc::c_longlong {
20778 sprintf(s, b"%lldB\0" as *const u8 as *const libc::c_char, n);
20779 return;
20780 } else {
20781 if n < (1024 as libc::c_int * 1024 as libc::c_int) as libc::c_longlong {
20782 d = n as libc::c_double / 1024 as libc::c_int as libc::c_double;
20783 sprintf(s, b"%.2fK\0" as *const u8 as *const libc::c_char, d);
20784 } else if n
20785 < 1024 as libc::c_longlong * 1024 as libc::c_int as libc::c_longlong
20786 * 1024 as libc::c_int as libc::c_longlong
20787 {
20788 d = n as libc::c_double
20789 / (1024 as libc::c_int * 1024 as libc::c_int) as libc::c_double;
20790 sprintf(s, b"%.2fM\0" as *const u8 as *const libc::c_char, d);
20791 } else if n
20792 < 1024 as libc::c_longlong * 1024 as libc::c_int as libc::c_longlong
20793 * 1024 as libc::c_int as libc::c_longlong
20794 * 1024 as libc::c_int as libc::c_longlong
20795 {
20796 d = n as libc::c_double
20797 / (1024 as libc::c_longlong * 1024 as libc::c_int as libc::c_longlong
20798 * 1024 as libc::c_int as libc::c_longlong) as libc::c_double;
20799 sprintf(s, b"%.2fG\0" as *const u8 as *const libc::c_char, d);
20800 }
20801 };
20802}
20803unsafe extern "C" fn statMode() {
20804 let mut reply: *mut redisReply = 0 as *mut redisReply;
20805 let mut aux: libc::c_long = 0;
20806 let mut requests: libc::c_long = 0 as libc::c_int as libc::c_long;
20807 let mut i: libc::c_int = 0 as libc::c_int;
20808 loop {
20809 let mut buf: [libc::c_char; 64] = [0; 64];
20810 let mut j: libc::c_int = 0;
20811 reply = reconnectingRedisCommand(
20812 context,
20813 b"INFO\0" as *const u8 as *const libc::c_char,
20814 );
20815 if reply.is_null() {
20816 fprintf(stderr, b"\nI/O error\n\0" as *const u8 as *const libc::c_char);
20817 exit(1 as libc::c_int);
20818 } else {
20819 if (*reply).type_0 == 6 as libc::c_int {
20820 fprintf(
20821 stderr,
20822 b"ERROR: %s\n\0" as *const u8 as *const libc::c_char,
20823 (*reply).str_0,
20824 );
20825 exit(1 as libc::c_int);
20826 }
20827 }
20828 let fresh77 = i;
20829 i = i + 1;
20830 if fresh77 % 20 as libc::c_int == 0 as libc::c_int {
20831 printf(
20832 b"------- data ------ --------------------- load -------------------- - child -\nkeys mem clients blocked requests connections \n\0"
20833 as *const u8 as *const libc::c_char,
20834 );
20835 }
20836 aux = 0 as libc::c_int as libc::c_long;
20837 j = 0 as libc::c_int;
20838 while j < 20 as libc::c_int {
20839 let mut k: libc::c_long = 0;
20840 sprintf(
20841 buf.as_mut_ptr(),
20842 b"db%d:keys\0" as *const u8 as *const libc::c_char,
20843 j,
20844 );
20845 k = getLongInfoField((*reply).str_0, buf.as_mut_ptr());
20846 if !(k == -(9223372036854775807 as libc::c_long) - 1 as libc::c_long) {
20847 aux += k;
20848 }
20849 j += 1;
20850 }
20851 sprintf(buf.as_mut_ptr(), b"%ld\0" as *const u8 as *const libc::c_char, aux);
20852 printf(b"%-11s\0" as *const u8 as *const libc::c_char, buf.as_mut_ptr());
20853 aux = getLongInfoField(
20854 (*reply).str_0,
20855 b"used_memory\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20856 );
20857 bytesToHuman(buf.as_mut_ptr(), aux as libc::c_longlong);
20858 printf(b"%-8s\0" as *const u8 as *const libc::c_char, buf.as_mut_ptr());
20859 aux = getLongInfoField(
20860 (*reply).str_0,
20861 b"connected_clients\0" as *const u8 as *const libc::c_char
20862 as *mut libc::c_char,
20863 );
20864 sprintf(buf.as_mut_ptr(), b"%ld\0" as *const u8 as *const libc::c_char, aux);
20865 printf(b" %-8s\0" as *const u8 as *const libc::c_char, buf.as_mut_ptr());
20866 aux = getLongInfoField(
20867 (*reply).str_0,
20868 b"blocked_clients\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20869 );
20870 sprintf(buf.as_mut_ptr(), b"%ld\0" as *const u8 as *const libc::c_char, aux);
20871 printf(b"%-8s\0" as *const u8 as *const libc::c_char, buf.as_mut_ptr());
20872 aux = getLongInfoField(
20873 (*reply).str_0,
20874 b"total_commands_processed\0" as *const u8 as *const libc::c_char
20875 as *mut libc::c_char,
20876 );
20877 sprintf(
20878 buf.as_mut_ptr(),
20879 b"%ld (+%ld)\0" as *const u8 as *const libc::c_char,
20880 aux,
20881 if requests == 0 as libc::c_int as libc::c_long {
20882 0 as libc::c_int as libc::c_long
20883 } else {
20884 aux - requests
20885 },
20886 );
20887 printf(b"%-19s\0" as *const u8 as *const libc::c_char, buf.as_mut_ptr());
20888 requests = aux;
20889 aux = getLongInfoField(
20890 (*reply).str_0,
20891 b"total_connections_received\0" as *const u8 as *const libc::c_char
20892 as *mut libc::c_char,
20893 );
20894 sprintf(buf.as_mut_ptr(), b"%ld\0" as *const u8 as *const libc::c_char, aux);
20895 printf(b" %-12s\0" as *const u8 as *const libc::c_char, buf.as_mut_ptr());
20896 aux = getLongInfoField(
20897 (*reply).str_0,
20898 b"bgsave_in_progress\0" as *const u8 as *const libc::c_char
20899 as *mut libc::c_char,
20900 );
20901 aux
20902 |= getLongInfoField(
20903 (*reply).str_0,
20904 b"aof_rewrite_in_progress\0" as *const u8 as *const libc::c_char
20905 as *mut libc::c_char,
20906 ) << 1 as libc::c_int;
20907 aux
20908 |= getLongInfoField(
20909 (*reply).str_0,
20910 b"loading\0" as *const u8 as *const libc::c_char as *mut libc::c_char,
20911 ) << 2 as libc::c_int;
20912 match aux {
20913 1 => {
20914 printf(b"SAVE\0" as *const u8 as *const libc::c_char);
20915 }
20916 2 => {
20917 printf(b"AOF\0" as *const u8 as *const libc::c_char);
20918 }
20919 3 => {
20920 printf(b"SAVE+AOF\0" as *const u8 as *const libc::c_char);
20921 }
20922 4 => {
20923 printf(b"LOAD\0" as *const u8 as *const libc::c_char);
20924 }
20925 0 | _ => {}
20926 }
20927 printf(b"\n\0" as *const u8 as *const libc::c_char);
20928 freeReplyObject(reply as *mut libc::c_void);
20929 usleep(config.interval as __useconds_t);
20930 };
20931}
20932unsafe extern "C" fn scanMode() {
20933 let mut reply: *mut redisReply = 0 as *mut redisReply;
20934 let mut cur: libc::c_ulonglong = 0 as libc::c_int as libc::c_ulonglong;
20935 signal(
20936 2 as libc::c_int,
20937 Some(longStatLoopModeStop as unsafe extern "C" fn(libc::c_int) -> ()),
20938 );
20939 loop {
20940 reply = sendScan(&mut cur);
20941 let mut j: libc::c_uint = 0 as libc::c_int as libc::c_uint;
20942 while (j as libc::c_ulong)
20943 < (**((*reply).element).offset(1 as libc::c_int as isize)).elements
20944 {
20945 if config.output == 0 as libc::c_int {
20946 let mut out: hisds = hi_sdscatrepr(
20947 hi_sdsempty(),
20948 (**((**((*reply).element).offset(1 as libc::c_int as isize)).element)
20949 .offset(j as isize))
20950 .str_0,
20951 (**((**((*reply).element).offset(1 as libc::c_int as isize)).element)
20952 .offset(j as isize))
20953 .len,
20954 );
20955 printf(b"%s\n\0" as *const u8 as *const libc::c_char, out);
20956 hi_sdsfree(out);
20957 } else {
20958 printf(
20959 b"%s\n\0" as *const u8 as *const libc::c_char,
20960 (**((**((*reply).element).offset(1 as libc::c_int as isize)).element)
20961 .offset(j as isize))
20962 .str_0,
20963 );
20964 }
20965 j = j.wrapping_add(1);
20966 }
20967 freeReplyObject(reply as *mut libc::c_void);
20968 if config.interval != 0 {
20969 usleep(config.interval as __useconds_t);
20970 }
20971 if !(force_cancel_loop == 0 as libc::c_int
20972 && cur != 0 as libc::c_int as libc::c_ulonglong)
20973 {
20974 break;
20975 }
20976 }
20977 exit(0 as libc::c_int);
20978}
20979#[no_mangle]
20980pub unsafe extern "C" fn powerLawRand(
20981 mut min: libc::c_longlong,
20982 mut max: libc::c_longlong,
20983 mut alpha: libc::c_double,
20984) -> libc::c_longlong {
20985 let mut pl: libc::c_double = 0.;
20986 let mut r: libc::c_double = 0.;
20987 max += 1 as libc::c_int as libc::c_longlong;
20988 r = rand() as libc::c_double / 2147483647 as libc::c_int as libc::c_double;
20989 pl = pow(
20990 (pow(max as libc::c_double, alpha + 1 as libc::c_int as libc::c_double)
20991 - pow(min as libc::c_double, alpha + 1 as libc::c_int as libc::c_double)) * r
20992 + pow(min as libc::c_double, alpha + 1 as libc::c_int as libc::c_double),
20993 1.0f64 / (alpha + 1 as libc::c_int as libc::c_double),
20994 );
20995 return max - 1 as libc::c_int as libc::c_longlong - pl as libc::c_longlong + min;
20996}
20997#[no_mangle]
20998pub unsafe extern "C" fn LRUTestGenKey(mut buf: *mut libc::c_char, mut buflen: size_t) {
20999 snprintf(
21000 buf,
21001 buflen,
21002 b"lru:%lld\0" as *const u8 as *const libc::c_char,
21003 powerLawRand(
21004 1 as libc::c_int as libc::c_longlong,
21005 config.lru_test_sample_size,
21006 6.2f64,
21007 ),
21008 );
21009}
21010unsafe extern "C" fn LRUTestMode() {
21011 let mut reply: *mut redisReply = 0 as *mut redisReply;
21012 let mut key: [libc::c_char; 128] = [0; 128];
21013 let mut start_cycle: libc::c_longlong = 0;
21014 let mut j: libc::c_int = 0;
21015 srand((time(0 as *mut time_t) ^ getpid() as libc::c_long) as libc::c_uint);
21016 loop {
21017 start_cycle = mstime();
21018 let mut hits: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
21019 let mut misses: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
21020 while mstime() - start_cycle < 1000 as libc::c_int as libc::c_longlong {
21021 j = 0 as libc::c_int;
21022 while j < 250 as libc::c_int {
21023 let mut val: [libc::c_char; 6] = [0; 6];
21024 val[5 as libc::c_int as usize] = '\0' as i32 as libc::c_char;
21025 let mut i: libc::c_int = 0 as libc::c_int;
21026 while i < 5 as libc::c_int {
21027 val[i
21028 as usize] = ('A' as i32 + rand() % ('z' as i32 - 'A' as i32))
21029 as libc::c_char;
21030 i += 1;
21031 }
21032 LRUTestGenKey(
21033 key.as_mut_ptr(),
21034 core::mem::size_of::<[libc::c_char; 128]>() as libc::c_ulong,
21035 );
21036 redisAppendCommand(
21037 context,
21038 b"SET %s %s\0" as *const u8 as *const libc::c_char,
21039 key.as_mut_ptr(),
21040 val.as_mut_ptr(),
21041 );
21042 j += 1;
21043 }
21044 j = 0 as libc::c_int;
21045 while j < 250 as libc::c_int {
21046 redisGetReply(
21047 context,
21048 &mut reply as *mut *mut redisReply as *mut *mut libc::c_void,
21049 );
21050 j += 1;
21051 }
21052 j = 0 as libc::c_int;
21053 while j < 250 as libc::c_int {
21054 LRUTestGenKey(
21055 key.as_mut_ptr(),
21056 core::mem::size_of::<[libc::c_char; 128]>() as libc::c_ulong,
21057 );
21058 redisAppendCommand(
21059 context,
21060 b"GET %s\0" as *const u8 as *const libc::c_char,
21061 key.as_mut_ptr(),
21062 );
21063 j += 1;
21064 }
21065 j = 0 as libc::c_int;
21066 while j < 250 as libc::c_int {
21067 if redisGetReply(
21068 context,
21069 &mut reply as *mut *mut redisReply as *mut *mut libc::c_void,
21070 ) == 0 as libc::c_int
21071 {
21072 match (*reply).type_0 {
21073 6 => {
21074 fprintf(
21075 stderr,
21076 b"%s\n\0" as *const u8 as *const libc::c_char,
21077 (*reply).str_0,
21078 );
21079 }
21080 4 => {
21081 misses += 1;
21082 }
21083 _ => {
21084 hits += 1;
21085 }
21086 }
21087 }
21088 j += 1;
21089 }
21090 if (*context).err != 0 {
21091 fprintf(
21092 stderr,
21093 b"I/O error during LRU test\n\0" as *const u8 as *const libc::c_char,
21094 );
21095 exit(1 as libc::c_int);
21096 }
21097 }
21098 printf(
21099 b"%lld Gets/sec | Hits: %lld (%.2f%%) | Misses: %lld (%.2f%%)\n\0"
21100 as *const u8 as *const libc::c_char,
21101 hits + misses,
21102 hits,
21103 hits as libc::c_double / (hits + misses) as libc::c_double
21104 * 100 as libc::c_int as libc::c_double,
21105 misses,
21106 misses as libc::c_double / (hits + misses) as libc::c_double
21107 * 100 as libc::c_int as libc::c_double,
21108 );
21109 };
21110}
21111#[no_mangle]
21112pub unsafe extern "C" fn compute_something_fast() -> libc::c_ulong {
21113 let mut s: [libc::c_uchar; 256] = [0; 256];
21114 let mut i: libc::c_uchar = 0;
21115 let mut j: libc::c_uchar = 0;
21116 let mut t: libc::c_uchar = 0;
21117 let mut count: libc::c_int = 1000 as libc::c_int;
21118 let mut k: libc::c_int = 0;
21119 let mut output: libc::c_ulong = 0 as libc::c_int as libc::c_ulong;
21120 k = 0 as libc::c_int;
21121 while k < 256 as libc::c_int {
21122 s[k as usize] = k as libc::c_uchar;
21123 k += 1;
21124 }
21125 i = 0 as libc::c_int as libc::c_uchar;
21126 j = 0 as libc::c_int as libc::c_uchar;
21127 loop {
21128 let fresh78 = count;
21129 count = count - 1;
21130 if !(fresh78 != 0) {
21131 break;
21132 }
21133 i = i.wrapping_add(1);
21134 j = (j as libc::c_int + s[i as usize] as libc::c_int) as libc::c_uchar;
21135 t = s[i as usize];
21136 s[i as usize] = s[j as usize];
21137 s[j as usize] = t;
21138 output = output
21139 .wrapping_add(
21140 s[(s[i as usize] as libc::c_int + s[j as usize] as libc::c_int
21141 & 255 as libc::c_int) as usize] as libc::c_ulong,
21142 );
21143 }
21144 return output;
21145}
21146unsafe extern "C" fn sigIntHandler(mut s: libc::c_int) {
21147 if config.monitor_mode != 0 || config.pubsub_mode != 0 {
21148 close((*context).fd);
21149 (*context).fd = -(1 as libc::c_int);
21150 config.blocking_state_aborted = 1 as libc::c_int;
21151 } else {
21152 exit(1 as libc::c_int);
21153 };
21154}
21155unsafe extern "C" fn intrinsicLatencyMode() {
21156 let mut test_end: libc::c_longlong = 0;
21157 let mut run_time: libc::c_longlong = 0;
21158 let mut max_latency: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
21159 let mut runs: libc::c_longlong = 0 as libc::c_int as libc::c_longlong;
21160 run_time = config.intrinsic_latency_duration as libc::c_longlong
21161 * 1000000 as libc::c_int as libc::c_longlong;
21162 test_end = ustime() + run_time;
21163 signal(
21164 2 as libc::c_int,
21165 Some(longStatLoopModeStop as unsafe extern "C" fn(libc::c_int) -> ()),
21166 );
21167 loop {
21168 let mut start: libc::c_longlong = 0;
21169 let mut end: libc::c_longlong = 0;
21170 let mut latency: libc::c_longlong = 0;
21171 start = ustime();
21172 compute_something_fast();
21173 end = ustime();
21174 latency = end - start;
21175 runs += 1;
21176 if latency <= 0 as libc::c_int as libc::c_longlong {
21177 continue;
21178 }
21179 if latency > max_latency {
21180 max_latency = latency;
21181 printf(
21182 b"Max latency so far: %lld microseconds.\n\0" as *const u8
21183 as *const libc::c_char,
21184 max_latency,
21185 );
21186 }
21187 let mut avg_us: libc::c_double = run_time as libc::c_double
21188 / runs as libc::c_double;
21189 let mut avg_ns: libc::c_double = avg_us * 1e3f64;
21190 if force_cancel_loop != 0 || end > test_end {
21191 printf(
21192 b"\n%lld total runs (avg latency: %.4f microseconds / %.2f nanoseconds per run).\n\0"
21193 as *const u8 as *const libc::c_char,
21194 runs,
21195 avg_us,
21196 avg_ns,
21197 );
21198 printf(
21199 b"Worst run took %.0fx longer than the average latency.\n\0" as *const u8
21200 as *const libc::c_char,
21201 max_latency as libc::c_double / avg_us,
21202 );
21203 exit(0 as libc::c_int);
21204 }
21205 };
21206}
21207unsafe extern "C" fn askPassword(mut msg: *const libc::c_char) -> hisds {
21208 linenoiseMaskModeEnable();
21209 let mut auth: hisds = linenoise(msg);
21210 linenoiseMaskModeDisable();
21211 return auth;
21212}
21213unsafe fn main_0(
21214 mut argc: libc::c_int,
21215 mut argv: *mut *mut libc::c_char,
21216) -> libc::c_int {
21217 let mut firstarg: libc::c_int = 0;
21218 let mut tv: timeval = timeval { tv_sec: 0, tv_usec: 0 };
21219 memset(
21220 &mut config.sslconfig as *mut cliSSLconfig as *mut libc::c_void,
21221 0 as libc::c_int,
21222 core::mem::size_of::<cliSSLconfig>() as libc::c_ulong,
21223 );
21224 config
21225 .conn_info
21226 .hostip = hi_sdsnew(b"127.0.0.1\0" as *const u8 as *const libc::c_char);
21227 config.conn_info.hostport = 6379 as libc::c_int;
21228 config.hostsocket = 0 as *mut libc::c_char;
21229 config.repeat = 1 as libc::c_int as libc::c_long;
21230 config.interval = 0 as libc::c_int as libc::c_long;
21231 config.dbnum = 0 as libc::c_int;
21232 config.conn_info.input_dbnum = 0 as libc::c_int;
21233 config.interactive = 0 as libc::c_int;
21234 config.shutdown = 0 as libc::c_int;
21235 config.monitor_mode = 0 as libc::c_int;
21236 config.pubsub_mode = 0 as libc::c_int;
21237 config.blocking_state_aborted = 0 as libc::c_int;
21238 config.latency_mode = 0 as libc::c_int;
21239 config.latency_dist_mode = 0 as libc::c_int;
21240 config.latency_history = 0 as libc::c_int;
21241 config.lru_test_mode = 0 as libc::c_int;
21242 config.lru_test_sample_size = 0 as libc::c_int as libc::c_longlong;
21243 config.cluster_mode = 0 as libc::c_int;
21244 config.cluster_send_asking = 0 as libc::c_int;
21245 config.slave_mode = 0 as libc::c_int;
21246 config.getrdb_mode = 0 as libc::c_int;
21247 config.get_functions_rdb_mode = 0 as libc::c_int;
21248 config.stat_mode = 0 as libc::c_int;
21249 config.scan_mode = 0 as libc::c_int;
21250 config.intrinsic_latency_mode = 0 as libc::c_int;
21251 config.pattern = 0 as hisds;
21252 config.rdb_filename = 0 as *mut libc::c_char;
21253 config.pipe_mode = 0 as libc::c_int;
21254 config.pipe_timeout = 30 as libc::c_int;
21255 config.bigkeys = 0 as libc::c_int;
21256 config.hotkeys = 0 as libc::c_int;
21257 config.stdin_lastarg = 0 as libc::c_int;
21258 config.stdin_tag_arg = 0 as libc::c_int;
21259 config.stdin_tag_name = 0 as *mut libc::c_char;
21260 config.conn_info.auth = 0 as *mut libc::c_char;
21261 config.askpass = 0 as libc::c_int;
21262 config.conn_info.user = 0 as *mut libc::c_char;
21263 config.eval = 0 as *mut libc::c_char;
21264 config.eval_ldb = 0 as libc::c_int;
21265 config.eval_ldb_end = 0 as libc::c_int;
21266 config.eval_ldb_sync = 0 as libc::c_int;
21267 config.enable_ldb_on_eval = 0 as libc::c_int;
21268 config.last_cmd_type = -(1 as libc::c_int);
21269 config.verbose = 0 as libc::c_int;
21270 config.set_errcode = 0 as libc::c_int;
21271 config.no_auth_warning = 0 as libc::c_int;
21272 config.in_multi = 0 as libc::c_int;
21273 config.cluster_manager_command.name = 0 as *mut libc::c_char;
21274 config.cluster_manager_command.argc = 0 as libc::c_int;
21275 config.cluster_manager_command.argv = 0 as *mut *mut libc::c_char;
21276 config.cluster_manager_command.stdin_arg = 0 as hisds;
21277 config.cluster_manager_command.flags = 0 as libc::c_int;
21278 config.cluster_manager_command.replicas = 0 as libc::c_int;
21279 config.cluster_manager_command.from = 0 as *mut libc::c_char;
21280 config.cluster_manager_command.to = 0 as *mut libc::c_char;
21281 config.cluster_manager_command.from_user = 0 as *mut libc::c_char;
21282 config.cluster_manager_command.from_pass = 0 as *mut libc::c_char;
21283 config.cluster_manager_command.from_askpass = 0 as libc::c_int;
21284 config.cluster_manager_command.weight = 0 as *mut *mut libc::c_char;
21285 config.cluster_manager_command.weight_argc = 0 as libc::c_int;
21286 config.cluster_manager_command.slots = 0 as libc::c_int;
21287 config.cluster_manager_command.timeout = 60000 as libc::c_int;
21288 config.cluster_manager_command.pipeline = 10 as libc::c_int;
21289 config.cluster_manager_command.threshold = 2 as libc::c_int as libc::c_float;
21290 config.cluster_manager_command.backup_dir = 0 as *mut libc::c_char;
21291 pref.hints = 1 as libc::c_int;
21292 spectrum_palette = spectrum_palette_color.as_mut_ptr();
21293 spectrum_palette_size = spectrum_palette_color_size;
21294 if isatty(fileno(stdout)) == 0
21295 && (getenv(b"FAKETTY\0" as *const u8 as *const libc::c_char)).is_null()
21296 {
21297 config.output = 1 as libc::c_int;
21298 config.push_output = 0 as libc::c_int;
21299 } else {
21300 config.output = 0 as libc::c_int;
21301 config.push_output = 1 as libc::c_int;
21302 }
21303 config.mb_delim = hi_sdsnew(b"\n\0" as *const u8 as *const libc::c_char);
21304 config.cmd_delim = hi_sdsnew(b"\n\0" as *const u8 as *const libc::c_char);
21305 firstarg = parseOptions(argc, argv);
21306 argc -= firstarg;
21307 argv = argv.offset(firstarg as isize);
21308 parseEnv();
21309 if config.askpass != 0 {
21310 config
21311 .conn_info
21312 .auth = askPassword(
21313 b"Please input password: \0" as *const u8 as *const libc::c_char,
21314 );
21315 }
21316 if config.cluster_manager_command.from_askpass != 0 {
21317 config
21318 .cluster_manager_command
21319 .from_pass = askPassword(
21320 b"Please input import source node password: \0" as *const u8
21321 as *const libc::c_char,
21322 );
21323 }
21324 gettimeofday(&mut tv, 0 as *mut libc::c_void);
21325 init_genrand64(
21326 (tv.tv_sec as libc::c_longlong * 1000000 as libc::c_int as libc::c_longlong
21327 + tv.tv_usec as libc::c_longlong ^ getpid() as libc::c_longlong)
21328 as libc::c_ulonglong,
21329 );
21330 if !(config.cluster_manager_command.name).is_null() {
21331 let mut proc_0: Option::<clusterManagerCommandProc> = validateClusterManagerCommand();
21332 if proc_0.is_none() {
21333 exit(1 as libc::c_int);
21334 }
21335 clusterManagerMode(proc_0);
21336 }
21337 if config.latency_mode != 0 {
21338 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21339 exit(1 as libc::c_int);
21340 }
21341 latencyMode();
21342 }
21343 if config.latency_dist_mode != 0 {
21344 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21345 exit(1 as libc::c_int);
21346 }
21347 latencyDistMode();
21348 }
21349 if config.slave_mode != 0 {
21350 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21351 exit(1 as libc::c_int);
21352 }
21353 sendCapa();
21354 sendReplconf(
21355 b"rdb-filter-only\0" as *const u8 as *const libc::c_char,
21356 b"\0" as *const u8 as *const libc::c_char,
21357 );
21358 slaveMode();
21359 }
21360 if config.getrdb_mode != 0 || config.get_functions_rdb_mode != 0 {
21361 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21362 exit(1 as libc::c_int);
21363 }
21364 sendCapa();
21365 sendRdbOnly();
21366 if config.get_functions_rdb_mode != 0
21367 && sendReplconf(
21368 b"rdb-filter-only\0" as *const u8 as *const libc::c_char,
21369 b"functions\0" as *const u8 as *const libc::c_char,
21370 ) == 0
21371 {
21372 fprintf(
21373 stderr,
21374 b"Failed requesting functions only RDB from server, aborting\n\0"
21375 as *const u8 as *const libc::c_char,
21376 );
21377 exit(1 as libc::c_int);
21378 }
21379 getRDB(0 as *mut clusterManagerNode);
21380 }
21381 if config.pipe_mode != 0 {
21382 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21383 exit(1 as libc::c_int);
21384 }
21385 pipeMode();
21386 }
21387 if config.bigkeys != 0 {
21388 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21389 exit(1 as libc::c_int);
21390 }
21391 findBigKeys(0 as libc::c_int, 0 as libc::c_int as libc::c_uint);
21392 }
21393 if config.memkeys != 0 {
21394 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21395 exit(1 as libc::c_int);
21396 }
21397 findBigKeys(1 as libc::c_int, config.memkeys_samples);
21398 }
21399 if config.hotkeys != 0 {
21400 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21401 exit(1 as libc::c_int);
21402 }
21403 findHotKeys();
21404 }
21405 if config.stat_mode != 0 {
21406 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21407 exit(1 as libc::c_int);
21408 }
21409 if config.interval == 0 as libc::c_int as libc::c_long {
21410 config.interval = 1000000 as libc::c_int as libc::c_long;
21411 }
21412 statMode();
21413 }
21414 if config.scan_mode != 0 {
21415 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21416 exit(1 as libc::c_int);
21417 }
21418 scanMode();
21419 }
21420 if config.lru_test_mode != 0 {
21421 if cliConnect(0 as libc::c_int) == -(1 as libc::c_int) {
21422 exit(1 as libc::c_int);
21423 }
21424 LRUTestMode();
21425 }
21426 if config.intrinsic_latency_mode != 0 {
21427 intrinsicLatencyMode();
21428 }
21429 if argc == 0 as libc::c_int && (config.eval).is_null() {
21430 signal(
21431 13 as libc::c_int,
21432 core::mem::transmute::<
21433 libc::intptr_t,
21434 __sighandler_t,
21435 >(1 as libc::c_int as libc::intptr_t),
21436 );
21437 signal(
21438 2 as libc::c_int,
21439 Some(sigIntHandler as unsafe extern "C" fn(libc::c_int) -> ()),
21440 );
21441 cliConnect(0 as libc::c_int);
21442 repl();
21443 }
21444 if !(config.eval).is_null() {
21445 if cliConnect(0 as libc::c_int) != 0 as libc::c_int {
21446 exit(1 as libc::c_int);
21447 }
21448 return evalMode(argc, argv);
21449 } else {
21450 cliConnect((1 as libc::c_int) << 1 as libc::c_int);
21451 return noninteractive(argc, argv);
21452 };
21453}
21454pub fn main() {
21455 let mut args: Vec::<*mut libc::c_char> = Vec::new();
21456 for arg in ::std::env::args() {
21457 args.push(
21458 (::std::ffi::CString::new(arg))
21459 .expect("Failed to convert argument into CString.")
21460 .into_raw(),
21461 );
21462 }
21463 args.push(core::ptr::null_mut());
21464 unsafe {
21465 ::std::process::exit(
21466 main_0(
21467 (args.len() - 1) as libc::c_int,
21468 args.as_mut_ptr() as *mut *mut libc::c_char,
21469 ) as i32,
21470 )
21471 }
21472}