All definitions in libucw

enum bconfig\_type {

enum block\_io\_err\_cause {

enum cf\_class {

enum cf\_operation { CF\_OPERATIONS };

enum cf\_type {

enum crc\_mode {

enum daemon\_flags {

enum fb\_flags {

enum fb\_type {

enum fbsock\_err\_flags {

enum log\_file\_flag {

enum log\_levels {

enum ls\_flag {

enum ls\_fmt {

enum main\_hook\_return {

enum rec\_io\_notify\_status {

enum resource\_flags {

enum size\_units {

enum xtype\_fmt {

typedef struct BUF\_T {

struct bh\_heap {

struct bh\_node {

struct cf\_item {

struct cf\_journal\_item;

struct cf\_section {

struct cf\_user\_type {

typedef struct clist {

typedef struct cnode {

typedef struct crc32\_context {

struct daemon\_control\_params {

struct daemon\_params {

struct eltpool {

struct exception {

struct fastbuf {

struct fb\_params {

struct fbpool {

struct fbsock\_params {

struct lizard\_buffer;

struct log\_msg {

struct log\_stream {

struct main\_block\_io {

struct main\_context {

struct main\_file {

struct main\_hook {

struct main\_process {

struct main\_rec\_io {

struct main\_signal {

struct main\_timer {

typedef struct { \... } md5\_context;

struct mempool {

struct mempool\_state {

struct mempool\_stats {

struct opt\_item {

struct opt\_section {

struct res\_class {

struct resource {

struct respool {

typedef struct { \... } sha1\_context;

typedef struct { \... } sha1\_hmac\_context;

typedef struct simp2\_node {

typedef struct simp\_node {

typedef struct slist {

typedef struct snode {

struct table {

struct table\_col\_instance {

struct table\_column {

struct table\_formatter {

struct table\_template {

struct token\_bucket\_filter {

struct trans {

struct ucw\_allocator {

struct unit\_definition {

struct xtype {

typedef uint8\_t byte;

typedef char \*cf\_copier(void \*dest, void \*src);

typedef void cf\_dumper1(struct fastbuf \*fb, void \*ptr);

typedef char \*cf\_hook(void \*ptr);

typedef char \*cf\_parser(uint number, char \*\*pars, void \*ptr);

typedef char \*cf\_parser1(char \*string, void \*ptr);

typedef int16\_t s16;

typedef int32\_t s32;

typedef int64\_t s64;

typedef int8\_t s8;

typedef s64 timestamp\_t;

typedef uint16\_t u16;

typedef uint32\_t u32;

typedef uint64\_t u64;

typedef uint8\_t u8;

typedef s64 ucw\_off\_t;

typedef unsigned int uint;

typedef uint uns;

typedef const char \* (\*xtype\_fmt\_formatter)(u32 fmt, struct mempool \*pool);

typedef const char \* (\*xtype\_fmt\_parser)(const char \*str, u32 \*dest, struct mempool \*pool);

typedef const char \* (\*xtype\_formatter)(void \*src, u32 fmt, struct mempool \*pool);

typedef const char \* (\*xtype\_parser)(const char \*str, void \*dest, struct mempool \*pool);

static void ASORT\_PREFIX(sort)(ASORT\_ARRAY\_ARG uint array\_size ASORT\_EXTRA\_ARGS);

static ASORT\_KEY\_TYPE \*ASORT\_PREFIX(sort)(ASORT\_KEY\_TYPE \*array, uint num\_elts ASORT\_HASH\_ARGS);

static inline uint Cxvalue(byte x);

static void UNUSED GBUF\_PREFIX(done)(BUF\_T \*b);

static inline GBUF\_TYPE \*GBUF\_PREFIX(grow)(BUF\_T \*b, size\_t len);

static inline void GBUF\_PREFIX(init)(BUF\_T \*b);

static void UNUSED GBUF\_PREFIX(set\_size)(BUF\_T \*b, size\_t len);

static void HASH\_PREFIX(cleanup)(TA);

static int HASH\_PREFIX(delete)(TAC HASH\_KEY\_DECL);

static HASH\_NODE\* HASH\_PREFIX(find)(TAC HASH\_KEY\_DECL);

static HASH\_NODE\* HASH\_PREFIX(find\_next)(TAC P(node) \*start);

static void HASH\_PREFIX(init)(TA);

static HASH\_NODE\* HASH\_PREFIX(lookup)(TAC HASH\_KEY\_DECL, int \*new\_item);

static HASH\_NODE \* HASH\_PREFIX(new)(TAC HASH\_KEY\_DECL);

static void HASH\_PREFIX(remove)(TAC HASH\_NODE \*n);

static inline uint adler32(const byte \*buf, uint len);

uint adler32\_update(uint adler, const byte \*ptr, uint len);

uint base224\_decode(byte \*dest, const byte \*src, uint len);

uint base224\_encode(byte \*dest, const byte \*src, uint len);

uint base64\_decode(byte \*dest, const byte \*src, uint len);

uint base64\_encode(byte \*dest, const byte \*src, uint len);

static inline uint bavailr(struct fastbuf \*f);

static inline uint bavailw(struct fastbuf \*f);

char \*bb\_printf(bb\_t \*bb, const char \*fmt, \...);

char \*bb\_printf\_at(bb\_t \*bb, size\_t ofs, const char \*fmt, \...);

char \*bb\_vprintf(bb\_t \*bb, const char \*fmt, va\_list args);

char \*bb\_vprintf\_at(bb\_t \*bb, size\_t ofs, const char \*fmt, va\_list args);

static inline void bbcopy(struct fastbuf \*f, struct fastbuf \*t, uint l);

void bclose(struct fastbuf \*f);

int bconfig(struct fastbuf \*f, uint type, int data);

static inline void bdirect\_read\_commit(struct fastbuf \*f, byte \*pos);

static inline void bdirect\_read\_commit\_modified(struct fastbuf \*f, byte \*pos);

static inline uint bdirect\_read\_prepare(struct fastbuf \*f, byte \*\*buf);

static inline void bdirect\_write\_commit(struct fastbuf \*f, byte \*pos);

static inline uint bdirect\_write\_prepare(struct fastbuf \*f, byte \*\*buf);

static inline int beof(struct fastbuf \*f);

struct fastbuf \*bfdopen(int fd, uint buflen);

struct fastbuf \*bfdopen\_shared(int fd, uint buflen);

ucw\_off\_t bfilesize(struct fastbuf \*f);

void bfilesync(struct fastbuf \*b);

void bfix\_tmp\_file(struct fastbuf \*fb, const char \*name);

void bflush(struct fastbuf \*f);

static inline int bget\_utf16\_be(struct fastbuf \*b);

static inline int bget\_utf16\_le(struct fastbuf \*b);

static inline int bget\_utf8(struct fastbuf \*b);

static inline int bget\_utf8\_32(struct fastbuf \*b);

static inline int bgetc(struct fastbuf \*f);

char \*bgets(struct fastbuf \*f, char \*b, uint l);

char \*bgets0(struct fastbuf \*f, char \*b, uint l);

uint bgets\_bb(struct fastbuf \*f, struct bb\_t \*b, uint limit);

char \*bgets\_mp(struct fastbuf \*f, struct mempool \*mp);

int bgets\_nodie(struct fastbuf \*f, char \*b, uint l);

void \*big\_alloc(u64 len) LIKE\_MALLOC;

void \*big\_alloc\_zero(u64 len) LIKE\_MALLOC;

void big\_free(void \*start, u64 len);

void block\_io\_add(struct main\_block\_io \*bio, int fd);

void block\_io\_del(struct main\_block\_io \*bio);

static inline int block\_io\_is\_active(struct main\_block\_io \*bio);

void block\_io\_read(struct main\_block\_io \*bio, void \*buf, uint len);

void block\_io\_set\_timeout(struct main\_block\_io \*bio, timestamp\_t expires\_delta);

void block\_io\_write(struct main\_block\_io \*bio, void \*buf, uint len);

struct fastbuf \*bopen(const char \*name, uint mode, uint buflen);

static inline struct fastbuf \*bopen\_fd(int fd, struct fb\_params \*params);

struct fastbuf \*bopen\_fd\_name(int fd, struct fb\_params \*params, const char \*name);

struct fastbuf \*bopen\_file(const char \*name, int mode, struct fb\_params \*params);

struct fastbuf \*bopen\_file\_try(const char \*name, int mode, struct fb\_params \*params);

struct fastbuf \*bopen\_limited\_fd(int fd, uint bufsize, uint limit);

struct fastbuf \*bopen\_tmp(uint buflen);

struct fastbuf \*bopen\_tmp\_file(struct fb\_params \*params);

struct fastbuf \*bopen\_try(const char \*name, uint mode, uint buflen);

static inline int bpeekc(struct fastbuf \*f);

int bprintf(struct fastbuf \*b, const char \*msg, \...);

static inline void bput\_utf16\_be(struct fastbuf \*b, uint u);

static inline void bput\_utf16\_le(struct fastbuf \*b, uint u);

static inline void bput\_utf8(struct fastbuf \*b, uint u);

static inline void bput\_utf8\_32(struct fastbuf \*b, uint u);

static inline void bputc(struct fastbuf \*f, uint c);

static inline void bputs(struct fastbuf \*f, const char \*b);

static inline void bputs0(struct fastbuf \*f, const char \*b);

static inline void bputsn(struct fastbuf \*f, const char \*b);

static inline uint bread(struct fastbuf \*f, void \*b, uint l);

static inline uint breadb(struct fastbuf \*f, void \*b, uint l);

void brewind(struct fastbuf \*f);

void bseek(struct fastbuf \*f, ucw\_off\_t pos, int whence);

void bsetpos(struct fastbuf \*f, ucw\_off\_t pos);

static inline int bskip(struct fastbuf \*f, uint len);

static inline ucw\_off\_t btell(struct fastbuf \*f);

void bthrow(struct fastbuf \*f, const char \*id, const char \*fmt, \...) FORMAT\_CHECK(printf,3,4) NONRET;

static inline void bungetc(struct fastbuf \*f);

static inline void bwrite(struct fastbuf \*f, const void \*b, uint l);

int cf\_close\_group(void);

void cf\_declare\_rel\_section(const char \*name, struct cf\_section \*sec, void \*ptr, uint allow\_unknown);

void cf\_declare\_section(const char \*name, struct cf\_section \*sec, uint allow\_unknown);

void cf\_delete\_context(struct cf\_context \*cc);

void cf\_dump\_sections(struct fastbuf \*fb);

char \*cf\_find\_item(const char \*name, struct cf\_item \*item);

struct mempool \*cf\_get\_pool(void);

int cf\_getopt(int argc, char \* const argv[], const char \*short\_opts, const struct option \*long\_opts, int \*long\_index);

void cf\_init\_section(const char \*name, struct cf\_section \*sec, void \*ptr, uint do\_bzero);

void cf\_journal\_block(void \*ptr, uint len);

void cf\_journal\_commit\_transaction(uint new\_pool, struct cf\_journal\_item \*oldj);

struct cf\_journal\_item \*cf\_journal\_new\_transaction(uint new\_pool);

void cf\_journal\_rollback\_transaction(uint new\_pool, struct cf\_journal\_item \*oldj);

int cf\_load(const char \*file);

void \*cf\_malloc(uint size);

void \*cf\_malloc\_zero(uint size);

char \*cf\_modify\_item(struct cf\_item \*item, enum cf\_operation op, int number, char \*\*pars);

struct cf\_context \*cf\_new\_context(void);

void cf\_open\_group(void);

char \*cf\_parse\_double(const char \*str, double \*ptr);

char \*cf\_parse\_int(const char \*str, int \*ptr);

char \*cf\_parse\_ip(const char \*p, u32 \*varp);

char \*cf\_parse\_u64(const char \*str, u64 \*ptr);

char \*cf\_printf(const char \*fmt, \...) FORMAT\_CHECK(printf,1,2);

int cf\_reload(const char \*file);

void cf\_revert(void);

int cf\_set(const char \*string);

void cf\_set\_journalling(int enable);

char \*cf\_strdup(const char \*s);

struct cf\_context \*cf\_switch\_context(struct cf\_context \*cc);

static inline void clist\_add\_head(clist \*l, cnode \*n);

static inline void clist\_add\_tail(clist \*l, cnode \*n);

static inline int clist\_empty(clist \*l);

static inline void \*clist\_head(clist \*l);

static inline void clist\_init(clist \*l);

static inline void clist\_insert\_after(cnode \*what, cnode \*after);

static inline void clist\_insert\_before(cnode \*what, cnode \*before);

static inline void clist\_insert\_list\_after(clist \*what, cnode \*after);

static inline int clist\_is\_linked(cnode \*n);

static inline void clist\_move(clist \*to, clist \*from);

static inline void \*clist\_next(clist \*l, cnode \*n);

static inline void \*clist\_prev(clist \*l, cnode \*n);

static inline void clist\_remove(cnode \*n);

static inline void \*clist\_remove\_head(clist \*l);

static inline void \*clist\_remove\_tail(clist \*l);

static inline uint clist\_size(clist \*l);

static inline void \*clist\_tail(clist \*l);

static inline void clist\_unlink(cnode \*n);

static inline void \*clist\_unlink\_head(clist \*l);

static inline void \*clist\_unlink\_tail(clist \*l);

static inline u32 crc32\_final(crc32\_context \*ctx);

u32 crc32\_hash\_buffer(const byte \*buf, uint len);

void crc32\_init(crc32\_context \*ctx, uint crc\_mode);

static inline void crc32\_update(crc32\_context \*ctx, const byte \*buf, uint len);

enum daemon\_control\_status daemon\_control(struct daemon\_control\_params \*dc);

void daemon\_exit(struct daemon\_params \*dp);

void daemon\_init(struct daemon\_params \*dp);

void daemon\_resolve\_ugid(struct daemon\_params \*dp);

void daemon\_switch\_ugid(struct daemon\_params \*dp);

void die(const char \*, \...) NONRET FORMAT\_CHECK(printf,1,2);

static inline void \*ep\_alloc(struct eltpool \*pool);

void ep\_delete(struct eltpool \*pool);

static inline void ep\_free(struct eltpool \*pool, void \*p);

struct eltpool \*ep\_new(uint elt\_size, uint elts\_per\_chunk);

u64 ep\_total\_size(struct eltpool \*pool);

struct fastbuf \*fb\_tie(struct fastbuf \*b);

struct fastbuf \*fb\_wrap\_hex\_in(struct fastbuf \*f);

struct fastbuf \*fb\_wrap\_hex\_out(struct fastbuf \*f);

static inline void fbatomic\_commit(struct fastbuf \*b);

struct fastbuf \*fbatomic\_open(const char \*name, struct fastbuf \*master, uint bufsize, int record\_len);

static inline uint fbbuf\_count\_written(struct fastbuf \*f);

void fbbuf\_init\_read(struct fastbuf \*f, byte \*buffer, uint size, uint can\_overwrite);

void fbbuf\_init\_write(struct fastbuf \*f, byte \*buffer, uint size);

struct fastbuf \*fbgrow\_create(uint basic\_size);

struct fastbuf \*fbgrow\_create\_mp(struct mempool \*mp, uint basic\_size);

uint fbgrow\_get\_buf(struct fastbuf \*b, byte \*\*buf);

void fbgrow\_reset(struct fastbuf \*b);

void fbgrow\_rewind(struct fastbuf \*b);

struct fastbuf \*fbmem\_clone\_read(struct fastbuf \*f);

struct fastbuf \*fbmem\_create(uint blocksize);

void fbmulti\_append(struct fastbuf \*f, struct fastbuf \*fb);

struct fastbuf \*fbmulti\_create(void);

void fbmulti\_remove(struct fastbuf \*f, struct fastbuf \*fb);

struct fastbuf \*fbnull\_open(uint bufsize);

void fbnull\_start(struct fastbuf \*b, byte \*buf, uint bufsize);

bool fbnull\_test(struct fastbuf \*b);

void \*fbpool\_end(struct fbpool \*fb);

void fbpool\_init(struct fbpool \*fb);

void fbpool\_start(struct fbpool \*fb, struct mempool \*mp, size\_t init\_size);

struct fastbuf \*fbsock\_create(struct fbsock\_params \*par);

void file\_add(struct main\_file \*fi);

void file\_chg(struct main\_file \*fi);

void file\_debug(struct main\_file \*fi);

void file\_del(struct main\_file \*fi);

static inline int file\_is\_active(struct main\_file \*fi);

uint get\_timer(timestamp\_t \*timer);

timestamp\_t get\_timestamp(void);

static inline uint get\_u16(const void \*p);

static inline uint get\_u16\_be(const void \*p);

static inline uint get\_u16\_le(const void \*p);

static inline u32 get\_u32(const void \*p);

static inline u32 get\_u32\_be(const void \*p);

static inline u32 get\_u32\_le(const void \*p);

static inline u64 get\_u40(const void \*p);

static inline u64 get\_u40\_be(const void \*p);

static inline u64 get\_u40\_le(const void \*p);

static inline u64 get\_u64(const void \*p);

static inline u64 get\_u64\_be(const void \*p);

static inline u64 get\_u64\_le(const void \*p);

static inline uint get\_u8(const void \*p);

uint hash\_block(const byte \*buf, uint len) PURE;

uint hash\_block\_aligned(const byte \*buf, uint len) PURE;

static inline uint CONST hash\_pointer(void \*x);

uint hash\_string(const char \*str) PURE;

uint hash\_string\_aligned(const char \*str) PURE;

uint hash\_string\_nocase(const char \*str) PURE;

static inline uint CONST hash\_u32(uint x);

static inline uint CONST hash\_u64(u64 x);

const char \*hex\_to\_mem(byte \*dest, const char \*src, size\_t max\_bytes, uint flags);

void hook\_add(struct main\_hook \*ho);

void hook\_debug(struct main\_hook \*ho);

void hook\_del(struct main\_hook \*ho);

static inline int hook\_is\_active(struct main\_hook \*ho);

void init\_timer(timestamp\_t \*timer);

int isprime(uint x);

struct lizard\_buffer \*lizard\_alloc(void);

int lizard\_compress(const byte \*in, uint in\_len, byte \*out);

int lizard\_decompress(const byte \*in, byte \*out);

byte \*lizard\_decompress\_safe(const byte \*in, struct lizard\_buffer \*buf, uint expected\_length);

void lizard\_free(struct lizard\_buffer \*buf);

void log\_add\_substream(struct log\_stream \*where, struct log\_stream \*what);

char \*log\_check\_configured(const char \*name);

void log\_close\_all(void);

int log\_close\_stream(struct log\_stream \*ls);

void log\_configured(const char \*name);

static inline struct log\_stream \*log\_default\_stream(void);

void log\_drop\_stderr(void);

void log\_file(const char \*name);

int log\_find\_type(const char \*name);

void log\_fork(void);

void log\_init(const char \*argv0);

struct log\_stream \*log\_new\_configured(const char \*name);

struct log\_stream \*log\_new\_fd(int fd, uint flags);

struct log\_stream \*log\_new\_file(const char \*path, uint flags);

struct log\_stream \*log\_new\_stream(size\_t size);

struct log\_stream \*log\_new\_syslog(const char \*facility, int options);

void log\_pass\_filtered(struct log\_stream \*ls, struct log\_msg \*m);

static inline struct log\_stream \*log\_ref\_stream(struct log\_stream \*ls);

int log\_register\_type(const char \*name);

int log\_rm\_substream(struct log\_stream \*where, struct log\_stream \*what);

void log\_set\_default\_stream(struct log\_stream \*ls);

void log\_set\_format(struct log\_stream \*ls, uint mask, uint data);

struct log\_stream \*log\_stream\_by\_flags(uint flags);

int log\_switch(void);

void log\_switch\_disable(void);

void log\_switch\_enable(void);

int log\_syslog\_facility\_exists(const char \*facility);

char \*log\_type\_name(uint flags);

void main\_cleanup(void);

struct main\_context \*main\_current(void);

void main\_debug\_context(struct main\_context \*m);

void main\_delete(struct main\_context \*m);

void main\_destroy(struct main\_context \*m);

static inline timestamp\_t main\_get\_now(void);

void main\_get\_time(void);

void main\_init(void);

void main\_loop(void);

struct main\_context \*main\_new(void);

static inline void main\_shut\_down(void);

void main\_step(void);

struct main\_context \*main\_switch\_context(struct main\_context \*m);

void main\_teardown(void);

byte \*md5\_final(md5\_context \*context);

void md5\_hash\_buffer(byte \*outbuf, const byte \*buffer, uint length);

void md5\_init(md5\_context \*context);

void md5\_transform(u32 buf[4], const u32 in[16]);

void md5\_update(md5\_context \*context, const byte \*buf, uint len);

void mem\_to\_hex(char \*dest, const byte \*src, size\_t bytes, uint flags);

void \*mp\_alloc(struct mempool \*pool, size\_t size);

static inline void \*mp\_alloc\_fast(struct mempool \*pool, size\_t size);

static inline void \*mp\_alloc\_fast\_noalign(struct mempool \*pool, size\_t size);

void \*mp\_alloc\_noalign(struct mempool \*pool, size\_t size);

void \*mp\_alloc\_zero(struct mempool \*pool, size\_t size);

static inline void \*mp\_append\_block(struct mempool \*pool, void \*p, const void \*block, size\_t size);

static inline char \*mp\_append\_char(struct mempool \*pool, char \*p, uint c);

static inline void \*mp\_append\_string(struct mempool \*pool, void \*p, const char \*str);

void \*mp\_append\_utf8\_32(struct mempool \*pool, void \*p, uint c);

static inline size\_t mp\_avail(struct mempool \*pool);

void mp\_delete(struct mempool \*pool);

static inline void \*mp\_end(struct mempool \*pool, void \*end);

static inline char \*mp\_end\_string(struct mempool \*pool, void \*end);

static inline void \*mp\_expand(struct mempool \*pool);

void mp\_flush(struct mempool \*pool);

static inline struct ucw\_allocator \*mp\_get\_allocator(struct mempool \*mp);

static inline void \*mp\_grow(struct mempool \*pool, size\_t size);

void mp\_init(struct mempool \*pool, size\_t chunk\_size);

void \*mp\_memdup(struct mempool \*, const void \*, size\_t) LIKE\_MALLOC;

char \*mp\_multicat(struct mempool \*, \...) LIKE\_MALLOC SENTINEL\_CHECK;

struct mempool \*mp\_new(size\_t chunk\_size);

size\_t mp\_open(struct mempool \*pool, void \*ptr);

static inline size\_t mp\_open\_fast(struct mempool \*pool, void \*ptr);

void mp\_pop(struct mempool \*pool);

char \*mp\_printf(struct mempool \*mp, const char \*fmt, \...) FORMAT\_CHECK(printf,2,3) LIKE\_MALLOC;

char \*mp\_printf\_append(struct mempool \*mp, char \*ptr, const char \*fmt, \...) FORMAT\_CHECK(printf,3,4);

static inline void \*mp\_ptr(struct mempool \*pool);

struct mempool\_state \*mp\_push(struct mempool \*pool);

void \*mp\_realloc(struct mempool \*pool, void \*ptr, size\_t size);

static inline void \*mp\_realloc\_fast(struct mempool \*pool, void \*ptr, size\_t size);

void \*mp\_realloc\_zero(struct mempool \*pool, void \*ptr, size\_t size);

void mp\_restore(struct mempool \*pool, struct mempool\_state \*state);

static inline void mp\_restore\_fast(struct mempool \*pool, struct mempool\_state \*state);

static inline void mp\_save(struct mempool \*pool, struct mempool\_state \*state);

void mp\_shrink(struct mempool \*pool, u64 min\_total\_size);

static inline size\_t mp\_size(struct mempool \*pool, void \*ptr);

static inline void \*mp\_spread(struct mempool \*pool, void \*p, size\_t size);

void \*mp\_start(struct mempool \*pool, size\_t size);

static inline void \*mp\_start\_fast(struct mempool \*pool, size\_t size);

static inline void \*mp\_start\_fast\_noalign(struct mempool \*pool, size\_t size);

void mp\_stats(struct mempool \*pool, struct mempool\_stats \*stats);

char \*mp\_str\_from\_mem(struct mempool \*p, const void \*mem, size\_t len) LIKE\_MALLOC;

static inline char \*LIKE\_MALLOC mp\_strcat(struct mempool \*mp, const char \*x, const char \*y);

char \*mp\_strdup(struct mempool \*, const char \*) LIKE\_MALLOC;

char \*mp\_strjoin(struct mempool \*p, char \*\*a, uint n, uint sep) LIKE\_MALLOC;

u64 mp\_total\_size(struct mempool \*pool);

char \*mp\_vprintf(struct mempool \*mp, const char \*fmt, va\_list args) LIKE\_MALLOC;

char \*mp\_vprintf\_append(struct mempool \*mp, char \*ptr, const char \*fmt, va\_list args);

void msg(uint flags, const char \*fmt, \...) FORMAT\_CHECK(printf,2,3);

uint next\_table\_prime(uint x);

uint nextprime(uint x);

int open\_tmp(char \*name\_buf, int open\_flags, int mode);

void opt\_failure(const char \* mesg, \...) FORMAT\_CHECK(printf,1,2) NONRET;

int opt\_parse(const struct opt\_section \* options, char \*\* argv);

uint prev\_table\_prime(uint x);

void process\_add(struct main\_process \*mp);

void process\_debug(struct main\_process \*pr);

void process\_del(struct main\_process \*mp);

int process\_fork(struct main\_process \*mp);

static inline int process\_is\_active(struct main\_process \*mp);

static inline void put\_u16(void \*p, uint x);

static inline void put\_u16\_be(void \*p, uint x);

static inline void put\_u16\_le(void \*p, uint x);

static inline void put\_u32(void \*p, u32 x);

static inline void put\_u32\_be(void \*p, u32 x);

static inline void put\_u32\_le(void \*p, u32 x);

static inline void put\_u40(void \*p, u64 x);

static inline void put\_u64(void \*p, u64 x);

static inline void put\_u64\_be(void \*p, u64 x);

static inline void put\_u64\_le(void \*p, u64 x);

static inline void put\_u8(void \*p, uint x);

uint random\_max(uint max);

u64 random\_max\_u64(u64 max);

uint random\_u32(void);

u64 random\_u64(void);

void rec\_io\_add(struct main\_rec\_io \*rio, int fd);

void rec\_io\_del(struct main\_rec\_io \*rio);

static inline int rec\_io\_is\_active(struct main\_rec\_io \*rio);

uint rec\_io\_parse\_line(struct main\_rec\_io \*rio);

void rec\_io\_set\_timeout(struct main\_rec\_io \*rio, timestamp\_t expires\_delta);

void rec\_io\_start\_read(struct main\_rec\_io \*rio);

void rec\_io\_stop\_read(struct main\_rec\_io \*rio);

void res\_add(struct resource \*r);

void res\_detach(struct resource \*r);

void res\_drop(struct resource \*r);

void res\_dump(struct resource \*r, uint indent);

struct resource \*res\_eltpool(struct eltpool \*ep);

struct resource \*res\_for\_fd(int fd);

void res\_free(struct resource \*r);

static inline struct resource \*res\_init(struct resource \*r, const struct res\_class \*rc, void \*priv);

void \*res\_malloc(size\_t size, struct resource \*\*ptr) LIKE\_MALLOC;

void \*res\_malloc\_zero(size\_t size, struct resource \*\*ptr) LIKE\_MALLOC;

struct resource \*res\_mempool(struct mempool \*mp);

static inline struct resource \*res\_new(const struct res\_class \*rc, void \*priv);

static inline void res\_permanent(struct resource \*r);

void \*res\_realloc(struct resource \*res, size\_t size);

struct resource \*res\_subpool(struct respool \*rp);

static inline void res\_temporary(struct resource \*r);

void reset\_getopt(void);

void rp\_commit(struct respool \*rp);

static inline struct respool \*rp\_current(void);

void rp\_delete(struct respool \*rp);

void rp\_detach(struct respool \*rp);

void rp\_dump(struct respool \*rp, uint indent);

struct respool \*rp\_new(const char \*name, struct mempool \*mp);

static inline struct respool \*rp\_switch(struct respool \*rp);

byte \*sha1\_final(sha1\_context \*hd);

void sha1\_hash\_buffer(byte \*outbuf, const byte \*buffer, uint length);

void sha1\_hmac(byte \*outbuf, const byte \*key, uint keylen, const byte \*data, uint datalen);

void sha1\_init(sha1\_context \*hd);

void sha1\_update(sha1\_context \*hd, const byte \*inbuf, uint inlen);

int sig\_name\_to\_number(const char \*name);

const char \*sig\_number\_to\_name(int number);

void signal\_add(struct main\_signal \*ms);

void signal\_debug(struct main\_signal \*sg);

void signal\_del(struct main\_signal \*ms);

static inline int signal\_is\_active(struct main\_signal \*ms);

simp2\_node \*simp2\_append(struct mempool \*mp, clist \*l);

simp\_node \*simp\_append(struct mempool \*mp, clist \*l);

static inline void slist\_add\_head(slist \*l, snode \*n);

static inline void slist\_add\_tail(slist \*l, snode \*n);

static inline int slist\_empty(slist \*l);

static inline void \*slist\_head(slist \*l);

static inline void slist\_init(slist \*l);

static inline void slist\_insert\_after(slist \*l, snode \*what, snode \*after);

void slist\_insert\_before(slist \*l, snode \*what, snode \*before);

static inline void \*slist\_next(snode \*n);

void \*slist\_prev(slist \*l, snode \*n);

void slist\_remove(slist \*l, snode \*n);

static inline void slist\_remove\_after(slist \*l, snode \*after);

static inline void \*slist\_remove\_head(slist \*l);

static inline void slist\_remove\_tail(slist \*l);

static inline uint slist\_size(slist \*l);

static inline void \*slist\_tail(slist \*l);

size\_t str\_count\_char(const char \*str, uint chr);

char \*str\_format\_flags(char \*dest, const char \*fmt, uint flags);

int str\_has\_prefix(const char \*str, const char \*prefix);

int str\_has\_suffix(const char \*str, const char \*suffix);

int str\_hier\_prefix(const char \*str, const char \*prefix, uint sep);

int str\_hier\_suffix(const char \*str, const char \*suffix, uint sep);

uint str\_len(const char \*str) PURE;

uint str\_len\_aligned(const char \*str) PURE;

int str\_match\_pattern(const char \*patt, const char \*str);

int str\_match\_pattern\_nocase(const char \*patt, const char \*str);

int str\_sepsplit(char \*str, uint sep, char \*\*rec, uint max);

char \*str\_unesc(char \*dest, const char \*src);

int str\_wordsplit(char \*str, char \*\*rec, uint max);

uint switch\_timer(timestamp\_t \*oldt, timestamp\_t \*newt);

void table\_cleanup(struct table \*tbl);

void table\_col\_fbend(struct table \*tbl);

struct fastbuf \*table\_col\_fbstart(struct table \*tbl, int col);

void table\_col\_generic\_format(struct table \*tbl, int col, void \*value, const struct xtype \*expected\_type);

bool table\_col\_is\_printed(struct table \*tbl, uint col\_def\_idx);

void table\_col\_printf(struct table \*tbl, int col, const char \*fmt, \...) FORMAT\_CHECK(printf, 3, 4);

void table\_end(struct table \*tbl);

void table\_end\_row(struct table \*tbl);

int table\_get\_col\_idx(struct table \*tbl, const char \*col\_name);

const char \*table\_get\_col\_list(struct table \*tbl);

struct table \*table\_init(const struct table\_template \*tbl\_template);

void table\_reset\_row(struct table \*tbl);

const char \*table\_set\_col\_opt(struct table \*tbl, uint col\_inst\_idx, const char \*col\_opt);

void table\_set\_col\_order(struct table \*tbl, const struct table\_col\_instance \*col\_order);

const char \*table\_set\_col\_order\_by\_name(struct table \*tbl, const char \*col\_order);

void table\_set\_formatter(struct table \*tbl, const struct table\_formatter \*fmt);

const char \*table\_set\_gary\_options(struct table \*tbl, char \*\*gary\_table\_opts);

const char \*table\_set\_option(struct table \*tbl, const char \*opt);

const char \*table\_set\_option\_value(struct table \*tbl, const char \*key, const char \*value);

void table\_start(struct table \*tbl, struct fastbuf \*out);

void tbf\_init(struct token\_bucket\_filter \*f);

int tbf\_limit(struct token\_bucket\_filter \*f, timestamp\_t now);

void temp\_file\_name(char \*name\_buf, int \*open\_flags);

void timer\_add(struct main\_timer \*tm, timestamp\_t expires);

void timer\_add\_rel(struct main\_timer \*tm, timestamp\_t expires\_delta);

void timer\_debug(struct main\_timer \*tm);

void timer\_del(struct main\_timer \*tm);

static inline int timer\_is\_active(struct main\_timer \*tm);

void trans\_caught(void);

void trans\_cleanup(void);

void trans\_commit(void);

struct exception \*trans\_current\_exc(void);

void trans\_dump(void);

void trans\_fold(void);

struct trans \*trans\_get\_current(void);

void trans\_init(void);

struct trans \*trans\_open(void);

void trans\_rollback(void);

void trans\_throw(const char \*id, void \*object, const char \*fmt, \...) FORMAT\_CHECK(printf,3,4) NONRET;

void trans\_throw\_exc(struct exception \*x) NONRET;

void trans\_vthrow(const char \*id, void \*object, const char \*fmt, va\_list args) NONRET;

static inline uint unicode\_sanitize\_char(uint u);

static inline void \*utf16\_be\_get(const void \*p, uint \*uu);

static inline void \*utf16\_be\_get\_repl(const void \*p, uint \*uu, uint repl);

static inline void \*utf16\_be\_put(void \*p, uint u);

static inline void \*utf16\_le\_get(const void \*p, uint \*uu);

static inline void \*utf16\_le\_get\_repl(const void \*p, uint \*uu, uint repl);

static inline void \*utf16\_le\_put(void \*p, uint u);

static inline byte \*utf8\_32\_get(const byte \*p, uint \*uu);

static inline byte \*utf8\_32\_get\_repl(const byte \*p, uint \*uu, uint repl);

static inline byte \*utf8\_32\_put(byte \*p, uint u);

static inline uint utf8\_encoding\_len(uint c);

static inline byte \*utf8\_get(const byte \*p, uint \*uu);

static inline byte \*utf8\_get\_repl(const byte \*p, uint \*uu, uint repl);

static inline byte \*utf8\_put(byte \*p, uint u);

static inline uint utf8\_space(uint u);

size\_t utf8\_strlen(const byte \*str);

size\_t utf8\_strnlen(const byte \*str, size\_t n);

static inline const byte \*varint\_get(const byte \*p, u64 \*res);

static inline const byte \*varint\_get32(const byte \*p, u32 \*res);

static inline int varint\_invalid(const byte \*p);

static inline uint varint\_len(const byte hdr);

static inline uint varint\_put(byte \*p, u64 u);

static inline uint varint\_put\_invalid(byte \*p);

static inline uint varint\_space(u64 u);

int vbprintf(struct fastbuf \*b, const char \*msg, va\_list args);

void vdie(const char \*fmt, va\_list args) NONRET;

void vmsg(uint flags, const char \*fmt, va\_list args);

void xfree(void \*);

void \*xmalloc(size\_t) LIKE\_MALLOC;

void \*xmalloc\_zero(size\_t) LIKE\_MALLOC;

void \*xrealloc(void \*, size\_t);

char \*xstrdup(const char \*) LIKE\_MALLOC;

const char \*xtype\_format\_fmt(struct xtype \*xt, u32 fmt, struct mempool \*pool);

const char \*xtype\_parse\_fmt(const struct xtype \*xt, const char \*str, u32 \*dest, struct mempool \*pool);

int xtype\_unit\_parser(const char \*str, const struct unit\_definition \*units);

void daemon\_run(struct daemon\_params \*dp, void (\*body)(struct daemon\_params \*dp));

extern struct cf\_section cf\_2string\_list\_config;

extern char \*cf\_def\_file;

extern char \*cf\_def\_file;

extern char \*cf\_env\_file;

extern char \*cf\_env\_file;

extern struct cf\_section cf\_string\_list\_config;

extern struct cf\_section fbpar\_cf;

extern struct fb\_params fbpar\_def;

extern void (\*log\_die\_hook)(void);

extern int log\_pid;

extern char \*log\_title;

extern const struct table\_formatter table\_fmt\_blockline;

extern const struct table\_formatter table\_fmt\_human\_readable;

extern const struct table\_formatter table\_fmt\_machine\_readable;

extern struct cf\_user\_type timestamp\_type;

extern struct ucw\_allocator ucw\_allocator\_std;

extern struct ucw\_allocator ucw\_allocator\_zeroed;

\#define ABS(x) ((x) < 0 ? -(x) : (x))

\#define ALIGN\_PTR(p, s) ((uintptr\_t)(p) % (s) ? (typeof(p))((uintptr\_t)(p) + (s) - (uintptr\_t)(p) % (s)) : (p))

\#define ALIGN\_TO(s, a) (((s)+a-1)&~(a-1))

\#define ALWAYS\_INLINE inline \_\_attribute\_\_((always\_inline))

\#define ARRAY\_SIZE(a) (sizeof(a)/sizeof(\*(a)))

\#define ARY\_LT\_NUM(ary,i,x) (ary)[i] < (x)

\#define ASSERT(x) ({ if (unlikely(!(x))) assert\_failed(\#x, \_\_FILE\_\_, \_\_LINE\_\_); 1; })

\#define ASSERT\_MSG(cond,str,x\...) ({ if (unlikely(!(cond))) assert\_failed\_msg(\#cond, \_\_FILE\_\_, \_\_LINE\_\_, str,\#\#x); 1; })

\#define ASSERT\_READABLE(ptr) ({ volatile char \*\_\_p = (ptr); \*\_\_p; })

\#define ASSERT\_WRITEABLE(ptr) ({ volatile char \*\_\_p = (ptr); \*\_\_p = \*\_\_p; })

\#define BASE224\_ENC\_LENGTH(x) (((x)\*8+38)/39\*5)

\#define BASE224\_IN\_CHUNK 39

\#define BASE224\_OUT\_CHUNK 40

\#define BASE64\_ENC\_LENGTH(x) (((x)+2)/3 \*4)

\#define BASE64\_IN\_CHUNK 3

\#define BASE64\_OUT\_CHUNK 4

\#define BIN\_SEARCH\_EQ(ary,N,x) ({ int i = BIN\_SEARCH\_FIRST\_GE(ary,N,x); if (i >= (N) || (ary)[i] != (x)) i=-1; i; })

\#define BIN\_SEARCH\_FIRST\_GE(ary,N,x) BIN\_SEARCH\_FIRST\_GE\_CMP(ary,N,x,ARY\_LT\_NUM)

\#define BIN\_SEARCH\_FIRST\_GE\_CMP(ary,N,x,ary\_lt\_x) ({ \

\#define BUF\_T GBUF\_PREFIX(t)

\#define CELL\_ALIGN\_LEFT (1U << 31)

\#define CF\_ANY\_NUM -0x7fffffff

\#define CF\_BITMAP\_INT(n,p) { .cls = CC\_BITMAP, .type = CT\_INT, .name = n, .number = 1, .ptr = CHECK\_PTR\_TYPE(p,u32\*) }

\#define CF\_BITMAP\_LOOKUP(n,p,t) { .cls = CC\_BITMAP, .type = CT\_LOOKUP, .name = n, .number = 1, .ptr = CHECK\_PTR\_TYPE(p,u32\*), .u.lookup = t }

\#define CF\_COMMIT(f) .commit = (cf\_hook\*) f

\#define CF\_COPY(f) .copy = (cf\_copier\*) f

\#define CF\_DOUBLE(n,p) CF\_STATIC(n,p,DOUBLE,double,1)

\#define CF\_DOUBLE\_ARY(n,p,c) CF\_STATIC(n,p,DOUBLE,double,c)

\#define CF\_DOUBLE\_DYN(n,p,c) CF\_DYNAMIC(n,p,DOUBLE,double,c)

\#define CF\_DYNAMIC(n,p,T,t,c) { .cls = CC\_DYNAMIC, .type = CT\_\#\#T, .name = n, .number = c, .ptr = CHECK\_PTR\_TYPE(p,t\*\*) }

\#define CF\_END { .cls = CC\_END }

\#define CF\_INIT(f) .init = (cf\_hook\*) f

\#define CF\_INT(n,p) CF\_STATIC(n,p,INT,int,1)

\#define CF\_INT\_ARY(n,p,c) CF\_STATIC(n,p,INT,int,c)

\#define CF\_INT\_DYN(n,p,c) CF\_DYNAMIC(n,p,INT,int,c)

\#define CF\_IP(n,p) CF\_STATIC(n,p,IP,u32,1)

\#define CF\_IP\_ARY(n,p,c) CF\_STATIC(n,p,IP,u32,c)

\#define CF\_IP\_DYN(n,p,c) CF\_DYNAMIC(n,p,IP,u32,c)

\#define CF\_ITEMS .cfg = ( struct cf\_item[] )

\#define CF\_LIST(n,p,s) { .cls = CC\_LIST, .name = n, .number = 1, .ptr = CHECK\_PTR\_TYPE(p,clist\*), .u.sec = s }

\#define CF\_LONG\_OPTS {"config", 1, 0, \'C\'}, {"set", 1, 0, \'S\'}, CF\_LONG\_OPTS\_DEBUG

\#define CF\_LOOKUP(n,p,t) { .cls = CC\_STATIC, .type = CT\_LOOKUP, .name = n, .number = 1, .ptr = CHECK\_PTR\_TYPE(p,int\*), .u.lookup = t }

\#define CF\_LOOKUP\_ARY(n,p,t,c) { .cls = CC\_STATIC, .type = CT\_LOOKUP, .name = n, .number = c, .ptr = CHECK\_PTR\_TYPE(p,int\*), .u.lookup = t }

\#define CF\_LOOKUP\_DYN(n,p,t,c) { .cls = CC\_DYNAMIC, .type = CT\_LOOKUP, .name = n, .number = c, .ptr = CHECK\_PTR\_TYPE(p,int\*\*), .u.lookup = t }

\#define CF\_NO\_LONG\_OPTS (const struct option []) { CF\_LONG\_OPTS { NULL, 0, 0, 0 } }

\#define CF\_OPERATIONS T(CLOSE) T(SET) T(CLEAR) T(ALL) \

\#define CF\_PARSER(n,p,f,c) { .cls = CC\_PARSER, .name = n, .number = c, .ptr = p, .u.par = (cf\_parser\*) f }

\#define CF\_SECTION(n,p,s) { .cls = CC\_SECTION, .name = n, .number = 1, .ptr = p, .u.sec = s }

\#define CF\_SHORT\_OPTS "C:S:"

\#define CF\_STATIC(n,p,T,t,c) { .cls = CC\_STATIC, .type = CT\_\#\#T, .name = n, .number = c, .ptr = CHECK\_PTR\_TYPE(p,t\*) }

\#define CF\_STRING(n,p) CF\_STATIC(n,p,STRING,char\*,1)

\#define CF\_STRING\_ARY(n,p,c) CF\_STATIC(n,p,STRING,char\*,c)

\#define CF\_STRING\_DYN(n,p,c) CF\_DYNAMIC(n,p,STRING,char\*,c)

\#define CF\_TYPE(s) .size = sizeof(s)

\#define CF\_U64(n,p) CF\_STATIC(n,p,U64,u64,1)

\#define CF\_U64\_ARY(n,p,c) CF\_STATIC(n,p,U64,u64,c)

\#define CF\_U64\_DYN(n,p,c) CF\_DYNAMIC(n,p,U64,u64,c)

\#define CF\_UINT(n,p) CF\_STATIC(n,p,INT,uint,1)

\#define CF\_UINT\_ARY(n,p,c) CF\_STATIC(n,p,INT,uint,c)

\#define CF\_UINT\_DYN(n,p,c) CF\_DYNAMIC(n,p,INT,uint,c)

\#define CF\_USAGE \

\#define CF\_USER(n,p,t) { .cls = CC\_STATIC, .type = CT\_USER, .name = n, .number = 1, .ptr = p, .u.utype = t }

\#define CF\_USER\_ARY(n,p,t,c) { .cls = CC\_STATIC, .type = CT\_USER, .name = n, .number = c, .ptr = p, .u.utype = t }

\#define CF\_USER\_DYN(n,p,t,c) { .cls = CC\_DYNAMIC, .type = CT\_USER, .name = n, .number = c, .ptr = p, .u.utype = t }

\#define CF\_XTYPE(n,p,t) { .cls = CC\_STATIC, .type = CT\_XTYPE, .name = n, .number = 1, .ptr = p, .u.xtype = t }

\#define CF\_XTYPE\_ARY(n,p,t,c) { .cls = CC\_STATIC, .type = CT\_XTYPE, .name = n, .number = c, .ptr = p, .u.xtype = t }

\#define CF\_XTYPE\_DYN(n,p,t,c) { .cls = CC\_DYNAMIC, .type = CT\_XTYPE, .name = n, .number = c, .ptr = p, .u.xtype = t }

\#define CHECK\_PTR\_TYPE(x, type) ((x)-(type)(x) + (type)(x))

\#define CLAMP(x,min,max) ({ typeof(x) \_t=x; (\_t < min) ? min : (\_t > max) ? max : \_t; })

\#define CLIST\_FOR\_EACH(type,n,list) for(type n=(void\*)(list).head.next; (cnode\*)(n) != &(list).head; n=(void\*)((cnode\*)(n))->next)

\#define CLIST\_FOR\_EACH\_BACKWARDS(type,n,list) for(type n=(void\*)(list).head.prev; (cnode\*)(n) != &(list).head; n=(void\*)((cnode\*)(n))->prev)

\#define CLIST\_FOR\_EACH\_DELSAFE(type,n,list,tmp) for(type n=(void\*)(list).head.next; tmp=(void\*)((cnode\*)(n))->next, (cnode\*)(n) != &(list).head; n=(void\*)tmp)

\#define CLIST\_WALK(n,list) for(n=(void\*)(list).head.next; (cnode\*)(n) != &(list).head; n=(void\*)((cnode\*)(n))->next)

\#define CLIST\_WALK\_DELSAFE(n,list,tmp) for(n=(void\*)(list).head.next; tmp=(void\*)((cnode\*)(n))->next, (cnode\*)(n) != &(list).head; n=(void\*)tmp)

\#define COMPARE(x,y) do { if ((x)<(y)) return -1; if ((x)>(y)) return 1; } while(0)

\#define CONST \_\_attribute\_\_((const))

\#define CONSTRUCTOR \_\_attribute\_\_((constructor))

\#define CONSTRUCTOR\_WITH\_PRIORITY(p) \_\_attribute\_\_((constructor(p)))

\#define Calpha(x) Ccat(x, \_C\_ALPHA)

\#define Cblank(x) Ccat(x, \_C\_BLANK)

\#define Cctrl(x) Ccat(x, \_C\_CTRL)

\#define Cdigit(x) Ccat(x, \_C\_DIGIT)

\#define Clocase(x) (ucw\_c\_lower[(byte)(x)])

\#define Clower(x) Ccat(x, \_C\_LOWER)

\#define Cupcase(x) (ucw\_c\_upper[(byte)(x)])

\#define Cupper(x) Ccat(x, \_C\_UPPER)

\#define Cword(x) Ccat(x, \_C\_WORD)

\#define Cxdigit(x) Ccat(x, \_C\_XDIGIT)

\#define DARY\_LEN(a) GARY\_SIZE(a)

\#define DBG(x,y\...) msg(L\_DEBUG, x,\#\#y)

\#define DBG\_SPOT msg(L\_DEBUG, "%s:%d (%s)", \_\_FILE\_\_, \_\_LINE\_\_, \_\_func\_\_)

\#define FORMAT\_CHECK(x,y,z) \_\_attribute\_\_((format(x,y,z)))

\#define GARY\_FIX(ptr) (ptr) = gary\_fix((ptr))

\#define GARY\_FREE(ptr) gary\_free(ptr)

\#define GARY\_INIT(ptr, n) (ptr) = gary\_init(sizeof(\*(ptr)), (n), &ucw\_allocator\_std)

\#define GARY\_INIT\_ALLOC(ptr, n, a) (ptr) = gary\_init(sizeof(\*(ptr)), (n), (a))

\#define GARY\_INIT\_OR\_RESIZE(ptr, n) (ptr) = (ptr) ? gary\_set\_size((ptr), (n)) : gary\_init(sizeof(\*(ptr)), (n), &ucw\_allocator\_std)

\#define GARY\_INIT\_SPACE(ptr, n) do { GARY\_INIT(ptr, n); (GARY\_HDR(ptr))->num\_elts = 0; } while (0)

\#define GARY\_INIT\_SPACE\_ALLOC(ptr, n, a) do { GARY\_INIT\_ALLOC(ptr, n, a); (GARY\_HDR(ptr))->num\_elts = 0; } while (0)

\#define GARY\_INIT\_SPACE\_ZERO(ptr, n) do { GARY\_INIT\_ZERO(ptr, n); (GARY\_HDR(ptr))->num\_elts = 0; } while (0)

\#define GARY\_INIT\_ZERO(ptr, n) (ptr) = gary\_init(sizeof(\*(ptr)), (n), &ucw\_allocator\_zeroed)

\#define GARY\_POP(ptr) GARY\_POP\_MULTI(ptr, 1)

\#define GARY\_POP\_MULTI(ptr, n) GARY\_HDR(ptr)->num\_elts -= (n)

\#define GARY\_PUSH(ptr) GARY\_PUSH\_MULTI(ptr, 1)

\#define GARY\_PUSH\_MULTI(ptr, n) ({ \

\#define GARY\_RESIZE(ptr, n) ((ptr) = gary\_set\_size((ptr), (n)))

\#define GARY\_SIZE(ptr) (GARY\_HDR(ptr)->num\_elts)

\#define GLUE(x,y) x\#\#y

\#define GLUE\_(x,y) x\#\#\_\#\#y

\#define HEAP\_DECREASE(type,heap,num,less,swap,pos,elt) \

\#define HEAP\_DELETE(type,heap,num,less,swap,pos) \

\#define HEAP\_DELETE\_MIN(type,heap,num,less,swap) \

\#define HEAP\_INCREASE(type,heap,num,less,swap,pos,elt) \

\#define HEAP\_INIT(type,heap,num,less,swap) \

\#define HEAP\_INSERT(type,heap,num,less,swap,elt) \

\#define HEAP\_REPLACE(type,heap,num,less,swap,pos,elt) \

\#define HEAP\_REPLACE\_MIN(type,heap,num,less,swap,elt) \

\#define HEAP\_SWAP(heap,a,b,t) (t=heap[a], heap[a]=heap[b], heap[b]=t)

\#define LIKE\_MALLOC \_\_attribute\_\_((malloc))

\#define LIZARD\_MAX\_LEN(LENGTH) ((LENGTH) \* LIZARD\_MAX\_MULTIPLY + LIZARD\_MAX\_ADD)

\#define LIZARD\_NEEDS\_CHARS 8

\#define LSFMT\_DEFAULT (LSFMT\_LEVEL | LSFMT\_TIME | LSFMT\_TITLE | LSFMT\_PID)

\#define LS\_GET\_CTRL(flags) (((flags) & LS\_CTRL\_MASK) >> LS\_CTRL\_POS)

\#define LS\_GET\_LEVEL(flags) (((flags) & LS\_LEVEL\_MASK) >> LS\_LEVEL\_POS)

\#define LS\_GET\_STRNUM(flags) (((flags) & LS\_STRNUM\_MASK) >> LS\_STRNUM\_POS)

\#define LS\_GET\_TYPE(flags) (((flags) & LS\_TYPE\_MASK) >> LS\_TYPE\_POS)

\#define LS\_SET\_CTRL(ctrl) ((ctrl) << LS\_CTRL\_POS)

\#define LS\_SET\_LEVEL(level) ((level) << LS\_LEVEL\_POS)

\#define LS\_SET\_STRNUM(strnum) ((strnum) << LS\_STRNUM\_POS)

\#define LS\_SET\_TYPE(type) ((type) << LS\_TYPE\_POS)

\#define L\_LOGGER\_ERR 0x40000000

\#define L\_SIGHANDLER 0x80000000

\#define MAX(a,b) (((a)>(b))?(a):(b))

\#define MD5\_HEX\_SIZE 33

\#define MD5\_SIZE 16

\#define MIN(a,b) (((a)<(b))?(a):(b))

\#define NONRET \_\_attribute\_\_((noreturn))

\#define NO\_INLINE \_\_attribute\_\_((noinline))

\#define OFFSETOF(s, i) ((uint)offsetof(s, i))

\#define OPT\_BEFORE\_CONFIG 0x800

\#define OPT\_BOOL(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, int \*), .help = desc, .flags = fl, .cls = OPT\_CL\_BOOL, .type = CT\_INT }

\#define OPT\_BREAK(shortopt, longopt, fl) { .letter = shortopt, .name = longopt, .flags = fl, .cls = OPT\_CL\_BREAK }

\#define OPT\_CALL(shortopt, longopt, fn, data, fl, desc) { .letter = shortopt, .name = longopt, .ptr = data, .help = desc, .u.call = fn, .flags = fl, .cls = OPT\_CL\_CALL, .type = CT\_USER }

\#define OPT\_DOUBLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, double \*), .help = desc, .flags = fl, .cls = OPT\_CL\_STATIC, .type = CT\_DOUBLE }

\#define OPT\_DOUBLE\_MULTIPLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, double \*\*), .help = desc, .flags = fl, .cls = OPT\_CL\_MULTIPLE, .type = CT\_DOUBLE }

\#define OPT\_END { .cls = OPT\_CL\_END }

\#define OPT\_HELP(line) { .help = line, .cls = OPT\_CL\_HELP }

\#define OPT\_HELP\_COL 0x1000

\#define OPT\_HELP\_COLUMNS(line) { .help = line, .flags = OPT\_HELP\_COL, .cls = OPT\_CL\_HELP }

\#define OPT\_HELP\_OPTION OPT\_CALL(0, "help", opt\_handle\_help, NULL, OPT\_BEFORE\_CONFIG | OPT\_INTERNAL | OPT\_NO\_VALUE, "\tShow this help")

\#define OPT\_HOOK(fn, data, events) { .cls = OPT\_CL\_HOOK, .u.hook = fn, .flags = events, .ptr = data }

\#define OPT\_HOOK\_AFTER\_VALUE 0x4

\#define OPT\_HOOK\_BEFORE\_ARG 0x1

\#define OPT\_HOOK\_BEFORE\_VALUE 0x2

\#define OPT\_HOOK\_FINAL 0x8

\#define OPT\_INC(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, int \*), .flags = fl, .help = desc, .cls = OPT\_CL\_INC, .type = CT\_INT }

\#define OPT\_INT(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, int \*), .help = desc, .flags = fl, .cls = OPT\_CL\_STATIC, .type = CT\_INT }

\#define OPT\_INT\_MULTIPLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, int \*\*), .help = desc, .flags = fl, .cls = OPT\_CL\_MULTIPLE, .type = CT\_INT }

\#define OPT\_IP(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, u32 \*), .help = desc, .flags = fl, .cls = OPT\_CL\_STATIC, .type = CT\_IP }

\#define OPT\_IP\_MULTIPLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, u32 \*\*), .help = desc, .flags = fl, .cls = OPT\_CL\_MULTIPLE, .type = CT\_IP }

\#define OPT\_ITEMS .opt = ( struct opt\_item[] )

\#define OPT\_LAST\_ARG 0x40

\#define OPT\_MAYBE\_VALUE 0x8

\#define OPT\_MULTIPLE 0x200

\#define OPT\_NEGATIVE 0x10

\#define OPT\_NO\_VALUE 0x4

\#define OPT\_REQUIRED 0x1

\#define OPT\_REQUIRED\_VALUE 0x2

\#define OPT\_SECTION(sec) { .cls = OPT\_CL\_SECTION, .u.section = &sec }

\#define OPT\_SINGLE 0x100

\#define OPT\_STRING(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, char \*\*), .help = desc, .flags = fl, .cls = OPT\_CL\_STATIC, .type = CT\_STRING }

\#define OPT\_STRING\_MULTIPLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, char \*\*\*), .help = desc, .flags = fl, .cls = OPT\_CL\_MULTIPLE, .type = CT\_STRING }

\#define OPT\_SWITCH(shortopt, longopt, target, val, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, int \*), .help = desc, .flags = fl, .cls = OPT\_CL\_SWITCH, .type = CT\_LOOKUP, .u.value = val }

\#define OPT\_U64(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, u64 \*), .help = desc, .flags = fl, .cls = OPT\_CL\_STATIC, .type = CT\_U64 }

\#define OPT\_U64\_MULTIPLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, u64 \*\*), .help = desc, .flags = fl, .cls = OPT\_CL\_MULTIPLE, .type = CT\_U64 }

\#define OPT\_UINT(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, uint \*), .help = desc, .flags = fl, .cls = OPT\_CL\_STATIC, .type = CT\_INT }

\#define OPT\_UINT\_MULTIPLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = CHECK\_PTR\_TYPE(&target, uint \*\*), .help = desc, .flags = fl, .cls = OPT\_CL\_MULTIPLE, .type = CT\_INT }

\#define OPT\_USER(shortopt, longopt, target, ttype, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .u.utype = &ttype, .flags = fl, .help = desc, .cls = OPT\_CL\_STATIC, .type = CT\_USER }

\#define OPT\_USER\_MULTIPLE(shortopt, longopt, target, ttype, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .u.utype = &ttype, .flags = fl, .help = desc, .cls = OPT\_CL\_MULTIPLE, .type = CT\_USER }

\#define OPT\_VALUE\_FLAGS (OPT\_REQUIRED\_VALUE | OPT\_NO\_VALUE | OPT\_MAYBE\_VALUE)

\#define OPT\_XTYPE(shortopt, longopt, target, ttype, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .u.xtype = &ttype, .flags = fl, .help = desc, .cls = OPT\_CL\_STATIC, .type = CT\_XTYPE }

\#define OPT\_XTYPE\_MULTIPLE(shortopt, longopt, target, ttype, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .u.xtype = &ttype, .flags = fl, .help = desc, .cls = OPT\_CL\_MULTIPLE, .type = CT\_XTYPE }

\#define PACKED \_\_attribute\_\_((packed))

\#define PTR\_TO(s, i) &((s\*)0)->i

\#define PURE \_\_attribute\_\_((pure))

\#define REV\_COMPARE(x,y) COMPARE(y,x)

\#define ROL(x, bits) (((x) << (bits)) | ((uint)(x) >> (sizeof(uint)\*8 - (bits))))

\#define ROR(x, bits) (((uint)(x) >> (bits)) | ((x) << (sizeof(uint)\*8 - (bits))))

\#define SENTINEL\_CHECK \_\_attribute\_\_((sentinel))

\#define SHA1\_BLOCK\_SIZE 64

\#define SHA1\_HEX\_SIZE 41

\#define SKIP\_BACK(s, i, p) ((s \*)((char \*)p - OFFSETOF(s, i)))

\#define SLIST\_FOR\_EACH(type,n,list) for(type n=(void\*)(list).head.next; n; n=(void\*)((snode\*)(n))->next)

\#define SLIST\_WALK(n,list) for(n=(void\*)(list).head.next; (n); (n)=(void\*)((snode\*)(n))->next)

\#define SLIST\_WALK\_DELSAFE(n,list,prev) for((prev)=(void\*)&(list).head; (n)=(void\*)((snode\*)prev)->next; (prev)=(((snode\*)(prev))->next==(snode\*)(n) ? (void\*)(n) : (void\*)(prev)))

\#define STRINGIFY(x) \#x

\#define STRINGIFY\_EXPANDED(x) STRINGIFY(x)

\#define TABLE\_COL\_BODY(\_name, \_type) void table\_col\_\#\#\_name(struct table \*tbl, int col, \_type val) {\

\#define TBL\_COL(\_idx) { .idx = \_idx, .fmt = XTYPE\_FMT\_DEFAULT, .next\_column = -1 }

\#define TBL\_FMT\_HUMAN\_READABLE .formatter = &table\_fmt\_human\_readable

\#define UNI\_REPLACEMENT 0xfffc

\#define UNUSED \_\_attribute\_\_((unused))

\#define UTF8\_MAX\_LEN 6

\#define XT\_SIZE\_FMT\_UNIT(\_unit) (\_unit | XT\_SIZE\_FMT\_FIXED\_UNIT)

\#define XT\_TIMESTAMP\_FMT\_DATETIME XTYPE\_FMT\_PRETTY

\#define XT\_TIMESTAMP\_FMT\_EPOCH XTYPE\_FMT\_RAW

\#define bgets\_stk(fb) \

\#define likely(x) \_\_builtin\_expect((x),1)

\#define unlikely(x) \_\_builtin\_expect((x),0)