自学教程：C++ string_init函数代码示例

/* Create a new slowlog entry. * Incrementing the ref count of all the objects retained is up to * this function. */static slowlog_entry *slowlog_create_entry(struct msg *r, long long duration) {    slowlog_entry *se = nc_alloc(sizeof(*se));    uint32_t j, keys_count, keys_count_input;    se->cmdtype = r->type;    keys_count_input = keys_count = r->keys==NULL?0:array_n(r->keys);    if (keys_count_input > SLOWLOG_ENTRY_MAX_KEYS) keys_count_input = SLOWLOG_ENTRY_MAX_KEYS;    se->keys_count = (int)keys_count;    if (keys_count_input > 0) {        se->keys = array_create(keys_count_input, sizeof(struct string));        for (j = 0; j < keys_count_input; j ++) {            struct keypos *kp = array_get(r->keys, j);            struct string *key = array_push(se->keys);            uint32_t key_len = (uint32_t)(kp->end-kp->start);            string_init(key);            if (key_len > SLOWLOG_ENTRY_MAX_STRING) {                int len;                uint8_t buf[SLOWLOG_ENTRY_MAX_STRING+50];                memcpy(buf,kp->start,SLOWLOG_ENTRY_MAX_STRING);                len = nc_scnprintf(buf+SLOWLOG_ENTRY_MAX_STRING,                    50,"... (%lu more bytes)",                    key_len-SLOWLOG_ENTRY_MAX_STRING);                            if (len > 0) {                    string_copy(key,buf,SLOWLOG_ENTRY_MAX_STRING+(uint32_t)len);                } else {                    string_copy(key,kp->start,SLOWLOG_ENTRY_MAX_STRING);                }            } else {                string_copy(key,kp->start,key_len);            }        }    }else {        se->keys = NULL;    }        se->time = time(NULL);    se->duration = duration;    STAILQ_NEXT(se, next) = NULL;        return se;}

/* * input : aname(STR) [asn(STR) masn(STR) email(STR) state(INT)] * return: NORMAL REP_ERR_ALREADYREGIST * reply : NULL */static NEOERR* aic_cmd_appup(struct queue_entry *q, struct cache *cd, mdb_conn *db){    char *aname;    int aid, pid = 0, tune = -1;    STRING str;    string_init(&str);    NEOERR *err;        REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);    REQ_FETCH_PARAM_INT(q->hdfrcv, "tune", tune);    if (tune != -1) {        if (hdf_get_int_value(q->hdfrcv, "tuneop", 0)) {            /* set tune bit */            string_appendf(&str, " tune=tune | %d ", tune);        } else {            /* unset tune bit */            string_appendf(&str, " tune=tune & %d ", ~tune);        }    }    aid = hash_string(aname);    err = aic_cmd_appinfo(q, cd, db);    if (err != STATUS_OK) return nerr_pass(err);    if (!hdf_get_obj(q->hdfsnd, "state"))        return nerr_raise(REP_ERR_NREGIST, "%s %d hasn't regist", aname, aid);    pid = hdf_get_int_value(q->hdfsnd, "pid", 0);    err = mcs_build_upcol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".UpdateCol.appinfo"), &str);    if (err != STATUS_OK) return nerr_pass(err);        MDB_EXEC(db, NULL, "UPDATE appinfo SET %s WHERE aid=%d;", NULL, str.buf, aid);    /* TODO memory leak, if exec() failure */    string_clear(&str);        cache_delf(cd, PREFIX_APPINFO"%d", aid);    if (pid > 0) {        cache_delf(cd, PREFIX_APPOUSER"%d_0", pid);    }    return STATUS_OK;}

PyObject * p_neo_error (NEOERR *err){  STRING str;  string_init (&str);  if (nerr_match(err, NERR_PARSE))  {    nerr_error_string (err, &str);    PyErr_SetString (NeoParseError, str.buf);  }  else  {    nerr_error_traceback (err, &str);    PyErr_SetString (NeoError, str.buf);  }  string_clear (&str);  nerr_ignore(&err);  return NULL;}

static NEOERR* aux_cmd_memoryadd(struct aux_entry *e, QueueEntry *q){	STRING str; string_init(&str);	NEOERR *err;        mdb_conn *db = e->db;    err = mdb_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.memory"), &str);	if (err != STATUS_OK) return nerr_pass(err);        MDB_EXEC(db, NULL, "INSERT INTO memory %s", NULL, str.buf);    string_clear(&str);    m_memory_maxid++;    return STATUS_OK;}

NEOERR* pos_data_mod(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses){	STRING str; string_init(&str);    mdb_conn *db = hash_lookup(dbh, "city");	NEOERR *err;    if (!cgi || !cgi->hdf || !db) return nerr_raise(NERR_ASSERT, "paramter null");    int id = hdf_get_int_value(cgi->hdf, PRE_QUERY".id", 0);        err = mdb_build_upcol(hdf_get_obj(cgi->hdf, PRE_QUERY),                          hdf_get_obj(g_cfg, "Db.UpdateCol.city"), &str);	if (err != STATUS_OK) return nerr_pass(err);    MDB_EXEC(db, NULL, "UPDATE city SET %s WHERE id=%d;", NULL, str.buf, id);        return STATUS_OK;}

NEOERR *ne_net_read_line(NSOCK *sock, char **buf){  NEOERR *err;  STRING str;  UINT8 *nl;  int l;    string_init(&str);  while (1)  {    if (sock->il - sock->ib > 0)    {      nl = memchr(sock->ibuf + sock->ib, '/n', sock->il - sock->ib);      if (nl == NULL)      {	l = sock->il - sock->ib;	err = string_appendn(&str, (char *)(sock->ibuf + sock->ib), l);	sock->ib += l;	if (err) break;      }      else      {	l = nl - (sock->ibuf + sock->ib);	err = string_appendn(&str, (char *)(sock->ibuf + sock->ib), l);	sock->ib += l;	if (err) break;	*buf = str.buf;	return STATUS_OK;      }    }    else    {      err = ne_net_fill(sock);      if (err) break;      if (sock->il == 0) return STATUS_OK;    }  }  string_clear(&str);  return nerr_pass(err);}

static PyObject * p_html_ws_strip (PyObject *self, PyObject *args){  char *s;  NEOERR *err;  PyObject *rv;  int len;  int lvl;  STRING html;  if (!PyArg_ParseTuple(args, "s#i:htmlStrip(str, level)", &s, &len, &lvl))    return NULL;  string_init (&html);  err = string_appendn (&html, s, len);  if (err) return p_neo_error (err);  cgi_html_ws_strip (&html, lvl);  rv = Py_BuildValue ("s", html.buf);  string_clear (&html);  return rv;}

static NEOERR* aux_cmd_mailadd(struct queue_entry *q, struct cache *cd, mdb_conn *db){    STRING str; string_init(&str);    char sum[LEN_MD5], *content;    NEOERR *err;    REQ_GET_PARAM_STR(q->hdfrcv, "content", content);    mutil_md5_str(content, sum);    hdf_set_value(q->hdfrcv, "checksum", sum);    err = mcs_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.email"),                          &str);    if (err != STATUS_OK) return nerr_pass(err);    MDB_EXEC(db, NULL, "INSERT INTO email %s", NULL, str.buf);    string_clear(&str);    return STATUS_OK;}

static BINDING_FUNCTION(binding_toggle_input){    if (input_size == 1) {        input_size = MULTILINE_INPUT_SIZE;        ncurses_input_update(line_index);    } else {        string_t s = string_init((""));        char *p, *tmp;        int i;        for (i = 0; lines[i]; i++) {            char *tmp;            string_append(s, (tmp = wcs_to_normal(lines[i])));            free_utf(tmp);            if (lines[i + 1])                string_append(s, ("/r/n"));        }        tmp = string_free(s, 0);        add_to_history();        input_size = 1;        ncurses_input_update(0);        for (p=tmp; *p && isspace(*p); p++);        if (*p || config_send_white_lines)            command_exec(window_current->target, window_current->session, tmp, 0);        if (!tmp[0] || tmp[0] == '/' || !window_current->target)            ncurses_typing_mod		= 1;        else {            ncurses_typing_win		= NULL;            window_current->out_active	= 1;        }        curs_set(1);        xfree(tmp);    }}

static NEOERR* aic_cmd_appuserup(struct queue_entry *q, struct cache *cd, mdb_conn *db){    STRING str; string_init(&str);    int uid, aid;    NEOERR *err;    REQ_GET_PARAM_INT(q->hdfrcv, "uid", uid);    REQ_GET_PARAM_INT(q->hdfrcv, "aid", aid);    err = mcs_build_upcol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".UpdateCol.userinfo"), &str);    if (err != STATUS_OK) return nerr_pass(err);    MDB_EXEC(db, NULL, "UPDATE userinfo SET %s WHERE uid=%d AND aid=%d;",             NULL, str.buf, uid, aid);    string_clear(&str);    cache_delf(cd, PREFIX_USERLIST"%d", aid);        return STATUS_OK;}

JNIEXPORT jstring JNICALL Java_org_clearsilver_HDF__1dump(    JNIEnv *env, jclass objClass,    jint hdf_obj_ptr) {  HDF *hdf = (HDF *)hdf_obj_ptr;  NEOERR *err;  STRING str;  jstring retval;  string_init(&str);  err = hdf_dump_str(hdf, NULL, 0, &str);  if (err != STATUS_OK) {    // Throw an exception    jNeoErr(env, err);    retval = NULL;  } else {    retval =  (*env)->NewStringUTF(env,str.buf);  }  string_clear(&str);  return retval;}

void add_java_home_to_path(void){	const char *java_home = get_java_home();	struct string *new_path = string_init(32), *buffer;	const char *env;	if (!java_home)		return;	buffer = string_initf("%s/bin", java_home);	if (dir_exists(buffer->buffer))		string_append_path_list(new_path, buffer->buffer);	string_setf(buffer, "%s/jre/bin", java_home);	if (dir_exists(buffer->buffer))		string_append_path_list(new_path, buffer->buffer);	env = getenv("PATH");	string_append_path_list(new_path, env ? env : get_ij_dir());	setenv_or_exit("PATH", new_path->buffer, 1);	string_release(buffer);	string_release(new_path);}

static int icq_offline_message_end(session_t *s, unsigned char *buf, int len, private_data_t **info) {	/*	 * SNAC(15,03)/0042 SRV_END_OF_OFFLINE_MSGS End-of-offline messages reply	 *	 * This is the last SNAC in server response to CLI_OFFLINE_MSGS_REQ SNAC(15,02)/003C.	 * It doesn't contain message - it is only end_of_sequence marker.	 */	debug_function("icq_offline_message_end()/n");	/* SNAC(15,02)/003E CLI_DELETE_OFFLINE_MSGS_REQ Delete offline messages request	 *	 * Client sends this SNAC when wants to delete offline messages from	 * server. But first you should request them from server using	 * SNAC(15,02)/003C. If you doesn't delete messages server will send them	 * again after client request.	 */	string_t pkt = string_init(NULL);	icq_makemetasnac(s, pkt, CLI_DELETE_OFFLINE_MSGS_REQ, 0, NULL, NULL);	icq_send_pkt(s, pkt);	return 0;}

int main(){	string *s = string_init();	string *o;	string *subs;	string *q = string_init_cstring("quit");		string_read_line(s);		while(string_cmp(s, q))	{		string_print(s);				string_reset(s);		string_read_line(s);	}	string_append(s, q);	o = string_cat(s, q);	string_print(s);	string_print(o);	string_append_cstring(o, "hello");	string_append_char(o, 'J');	string_print(o);	subs = string_substring(o, 5, 6);	printf("--/n");	printf("%c/n", string_get(s, 5));	printf("%d/n", string_index(o, 'o'));	string_print(subs);	printf("--/n");	o = string_free(o);	s = string_free(s);	q = string_free(q);	subs = string_free(subs);	return 0;}

static NEOERR* hdf_read_file_internal (HDF *hdf, const char *path,                                       int include_handle){  NEOERR *err;  int lineno = 0;  char fpath[PATH_BUF_SIZE];  char *ibuf = NULL;  const char *ptr = NULL;  HDF *top = hdf->top;  STRING line;  string_init(&line);  if (path == NULL)    return nerr_raise(NERR_ASSERT, "Can't read NULL file");  if (top->fileload)  {    err = top->fileload(top->fileload_ctx, hdf, path, &ibuf);  }  else  {    if (path[0] != '/')    {      err = hdf_search_path (hdf, path, fpath, PATH_BUF_SIZE);      if (err != STATUS_OK) return nerr_pass(err);      path = fpath;    }    err = ne_load_file (path, &ibuf);  }  if (err) return nerr_pass(err);  ptr = ibuf;  err = _hdf_read_string(hdf, &ptr, &line, path, &lineno, include_handle);  free(ibuf);  string_clear(&line);  return nerr_pass(err);}

NEOERR* hdf_read_file (HDF *hdf, const char *path){  NEOERR *err;  int lineno = 0;  char fpath[_POSIX_PATH_MAX];  char *ibuf = NULL;  const char *ptr = NULL;  HDF *top = hdf->top;  STRING line;  string_init(&line);  if (path == NULL)     return nerr_raise(NERR_ASSERT, "Can't read NULL file");  if (top->fileload)  {    err = top->fileload(top->fileload_ctx, hdf, path, &ibuf);  }  else  {    if (path[0] != '/')    {      err = hdf_search_path (hdf, path, fpath);      if (err != STATUS_OK) return nerr_pass(err);      path = fpath;    }    err = ne_load_file (path, &ibuf);  }  if (err) return nerr_pass(err);  ptr = ibuf;  err = _hdf_read_string(hdf, &ptr, &line, path, &lineno, INCLUDE_FILE);  free(ibuf);  string_clear(&line);  return nerr_pass(err);}

void do_cache_get(void) {  struct string key;  string_init(&key);  read_into_string(&key);  struct cache_entry *entry = cache_lookup(&key);  if (entry == NULL) {    write(STDOUT_FILENO, &kNotFound, sizeof(kNotFound));    return;  }  write(STDOUT_FILENO, &kFound, sizeof(kFound));  write_string(entry->value);  --entry->lifetime;  if (entry->lifetime <= 0) {    // The cache entry is now expired.    fprintf(stderr, "Destroying key/n");    string_destroy(entry->key);    fprintf(stderr, "Destroying value/n");    string_destroy(entry->value);  }}

static NEOERR* aux_cmd_impadd(struct queue_entry *q, struct cache *cd, mdb_conn *db){    STRING str; string_init(&str);    NEOERR *err;    char *aname;    int aid;    REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);    aid = hash_string(aname);    hdf_set_int_value(q->hdfrcv, "aid", aid);    err = mcs_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.improve"),                          &str);    if (err != STATUS_OK) return nerr_pass(err);    MDB_EXEC(db, NULL, "INSERT INTO improve %s", NULL, str.buf);    string_clear(&str);    cache_delf(cd, PREFIX_IMP"%d_0", aid);        return STATUS_OK;}

static NEOERR* aux_cmd_memorymod(struct aux_entry *e, QueueEntry *q){	STRING str; string_init(&str);    int id;	NEOERR *err;    mdb_conn *db = e->db;    struct cache *cd = e->cd;    REQ_GET_PARAM_INT(q->hdfrcv, "id", id);        err = mdb_build_upcol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".UpdateCol.memory"), &str);	if (err != STATUS_OK) return nerr_pass(err);    MDB_EXEC(db, NULL, "UPDATE memory SET %s WHERE id=%d;", NULL, str.buf, id);    string_clear(&str);    cache_delf(cd, PREFIX_MEMORY"%d", id);    return STATUS_OK;}

// Throws a runtime exception back to the Java VM appropriate for the type of// error and frees the NEOERR that is passed in.// TODO: throw more specific exceptions for errors like NERR_IO and NERR_NOMEMint jNeoErr(JNIEnv *env, NEOERR *err) {  STRING str;  string_init(&str);  if (nerr_match(err, NERR_PARSE)) {    nerr_error_string(err, &str);    throwRuntimeException(env, str.buf);  } else if (nerr_match(err, NERR_IO)) {    nerr_error_string(err, &str);    throwIOException(env, str.buf);  } else if (nerr_match(err, NERR_NOMEM)) {    nerr_error_string(err, &str);    throwOutOfMemoryError(env, str.buf);  } else {    nerr_error_traceback(err, &str);    throwRuntimeException(env, str.buf);  }  nerr_ignore(&err);  // free err, otherwise it would leak  string_clear(&str);  return 0;}

NEOERR* ltpl_render(CGI *cgi, HASH *tplh, session_t *ses){    STRING str; string_init(&str);    CSPARSE *cs;    HDF *dhdf;    NEOERR *err;    char *render = NULL;    render = ses->render;    cs = (CSPARSE*)hash_lookup(tplh, render);    dhdf = (HDF*)hash_lookupf(tplh, "%s_hdf", render);    if (!cs) return nerr_raise(LERR_MISS_TPL, "render %s not found", render);    if (dhdf) hdf_copy(cgi->hdf, NULL, dhdf);        ltpl_prepare_rend(cgi->hdf, hdf_get_value(cgi->hdf,                                              PRE_RESERVE"."PRE_CFG_LAYOUT,                                              "layout.html"));        if (ses->tm_cache_browser > 0) {        hdf_set_valuef(cgi->hdf, "cgiout.other.cache=Cache-Control: max-age=%lu",                       ses->tm_cache_browser);    }    cs->hdf = cgi->hdf;    err = cs_render(cs, &str, mcs_strcb);    if (err != STATUS_OK) return nerr_pass(err);    err = cgi_output(cgi, &str);    if (err != STATUS_OK) return nerr_pass(err);    cs->hdf = NULL;    string_clear(&str);    return STATUS_OK;}

/* * we don't pass tplh parameter to it, * because walker don't have it. so, tplh stored in the g_datah */NEOERR* ltpl_render2file(CGI *cgi, char *render, char *fname){    STRING str; string_init(&str);    HASH *tplh;    CSPARSE *cs;    HDF *dhdf;    NEOERR *err;    MCS_NOT_NULLC(cgi->hdf, render, fname);        tplh = hash_lookup(g_datah, "runtime_templates");    MCS_NOT_NULLA(tplh);    cs = hash_lookup(tplh, render);    MCS_NOT_NULLA(cs);    dhdf = hash_lookupf(tplh, "%s_hdf", render);    if (dhdf) hdf_copy(cgi->hdf, NULL, dhdf);    ltpl_prepare_rend(cgi->hdf, hdf_get_value(cgi->hdf,                                              PRE_RESERVE"."PRE_CFG_LAYOUT,                                              "layout.html"));    cs->hdf = cgi->hdf;    err = cs_render(cs, &str, mcs_strcb);    if (err != STATUS_OK) return nerr_pass(err);    err = mfile_makesure_dir(fname);    if (err != STATUS_OK) return nerr_pass(err);        err = mcs_str2file(str, fname);    if (err != STATUS_OK) return nerr_pass(err);    string_clear(&str);    return STATUS_OK;}

static voidstats_metric_init(struct stats_metric *stm){    switch (stm->type) {    case STATS_COUNTER:        stm->value.counter = 0LL;        break;    case STATS_GAUGE:        stm->value.counter = 0LL;        break;    case STATS_TIMESTAMP:        stm->value.timestamp = 0LL;        break;    case STATS_STRING:        string_init(&stm->value.str);        break;    default:        NOT_REACHED();    }}

void parse_header(http_connect_t * con) { 	request *in;	buffer *header;	pool_t *p;	char * start, *end;	p = (pool_t *)con->p;	in = con->in;	header = in->header;	start = (char *)(header->ptr);	end = (char *)header->ptr + (header->used - 1);	if(strncasecmp(start,"put", 3) == 0) {		in->http_method = _PUT;		start += 3;	}if(strncasecmp(start,"get", 3) == 0) {		in->http_method = _GET;		start += 3;	}	else if(strncasecmp(start, "post", 4) == 0) {		in->http_method = _POST;		start += 4;	}	start = skip_space(start, end);	in->uri = string_init(p);	in->uri->ptr = start;	start = find_line(start, end);	in->uri->len = start - in->uri->ptr;	start++;	in->content_length = atoi(start);	//test_print_header(in);	return ;}

void lerr_opfinish_json(NEOERR *err, HDF *hdf){    if (err == STATUS_OK) {        hdf_set_value(hdf, PRE_SUCCESS, "1");        return;    }        hdf_remove_tree(hdf, PRE_SUCCESS);        NEOERR *neede = mcs_err_valid(err);    /* set PRE_ERRXXX with the most recently err */    hdf_set_int_value(hdf, PRE_ERRCODE, neede->error);    if (!hdf_get_obj(hdf, PRE_ERRMSG)) {        hdf_set_valuef(hdf, "%s=%s:%d %s",                       PRE_ERRMSG, neede->file, neede->lineno, neede->desc);    }    STRING str; string_init(&str);    nerr_error_traceback(err, &str);    mtc_err("%s", str.buf);    hdf_set_value(hdf, PRE_ERRTRACE, str.buf);    nerr_ignore(&err);    string_clear(&str);}

/** * Inserts an array of unique element into a avl tree. */void _avl_tree_insert_unique_array(_avl_tree_t* pt_avl_tree, const void* cpv_array, size_t t_count){    size_t i = 0;    assert(pt_avl_tree != NULL);    assert(_avl_tree_is_inited(pt_avl_tree));    assert(cpv_array != NULL);    /*     * Copy the elements from src array to dest avl tree.     * The array of c builtin and user define or cstl builtin are different,     * the elements of c builtin array are element itself, but the elements of      * c string, user define or cstl are pointer of element.     */    if (strncmp(_GET_AVL_TREE_TYPE_BASENAME(pt_avl_tree), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {        /*         * We need built a string_t for c string element.         */        string_t* pstr_elem = create_string();        assert(pstr_elem != NULL);        string_init(pstr_elem);        for (i = 0; i < t_count; ++i) {            string_assign_cstr(pstr_elem, *((const char**)cpv_array + i));            _avl_tree_insert_unique(pt_avl_tree, pstr_elem);        }        string_destroy(pstr_elem);    } else if (_GET_AVL_TREE_TYPE_STYLE(pt_avl_tree) == _TYPE_C_BUILTIN) {        for (i = 0; i < t_count; ++i) {            _avl_tree_insert_unique(pt_avl_tree, (unsigned char*)cpv_array + i * _GET_AVL_TREE_TYPE_SIZE(pt_avl_tree));        }    } else {        for (i = 0; i < t_count; ++i) {            _avl_tree_insert_unique(pt_avl_tree, *((void**)cpv_array + i));        }    }}

static char *fstring_reverse(fstring_t *fstr) {	const char *str;	const fstr_attr_t *attr;	string_t asc;	int i;	if (!fstr)		return NULL;	attr = fstr->attr;	str = fstr->str;	if (!attr || !str)		return NULL;	asc = string_init(NULL);	for (i = 0; str[i]; i++) {#define prev	attr[i-1]#define cur	attr[i]		int reset = 0;		if (i) {			if (!(cur & FSTR_BOLD) && (prev & FSTR_BOLD))		reset = 1;			if (!(cur & FSTR_BLINK) && (prev & FSTR_BLINK))		reset = 1;			if (!(cur & FSTR_UNDERLINE) && (prev & FSTR_UNDERLINE))	reset = 1;			if (!(cur & FSTR_REVERSE) && (prev & FSTR_REVERSE))	reset = 1;			if ((cur & FSTR_NORMAL) && !(prev & FSTR_NORMAL))	reset = 1;	/* colors disappear */			if (reset)				string_append(asc, "%n");		} else			reset = 1;	/* attr */		if ((cur & FSTR_BLINK) &&	(reset || !(prev & FSTR_BLINK)))	string_append(asc, "%i");//		if ((cur & FSTR_UNDERLINE) &&	(reset || !(prev & FSTR_UNDERLINE)))	string_append(asc, "%");//		if ((cur & FSTR_REVERSE) &&	(reset || !(prev & FSTR_REVERSE)))	string_append(asc, "%");		if (!(cur & FSTR_NORMAL)) {		/* background color XXX */#define BGCOLOR(x)	-1			if (0 && ((reset || BGCOLOR(cur) != BGCOLOR(prev)))) {				string_append_c(asc, '%');				switch (BGCOLOR(cur)) {					case (0): string_append_c(asc, 'l'); break;					case (1): string_append_c(asc, 's'); break;					case (2): string_append_c(asc, 'h'); break;					case (3): string_append_c(asc, 'z'); break;					case (4): string_append_c(asc, 'e'); break;					case (5): string_append_c(asc, 'q'); break;					case (6): string_append_c(asc, 'd'); break;					case (7): string_append_c(asc, 'x'); break;				}			}#undef BGCOLOR		/* foreground color */#define FGCOLOR(x)	((!(x & FSTR_NORMAL)) ? (x & FSTR_FOREMASK) : -1)			if (((reset || FGCOLOR(cur) != FGCOLOR(prev)) || (i && (prev & FSTR_BOLD) != (cur & FSTR_BOLD)))) {				string_append_c(asc, '%');				switch ((cur & FSTR_FOREMASK)) {					case (0): string_append_c(asc, (cur & FSTR_BOLD) ? 'K' : 'k'); break;					case (1): string_append_c(asc, (cur & FSTR_BOLD) ? 'R' : 'r'); break;					case (2): string_append_c(asc, (cur & FSTR_BOLD) ? 'G' : 'g'); break;					case (3): string_append_c(asc, (cur & FSTR_BOLD) ? 'Y' : 'y'); break;					case (4): string_append_c(asc, (cur & FSTR_BOLD) ? 'B' : 'b'); break;					case (5): string_append_c(asc, (cur & FSTR_BOLD) ? 'M' : 'm'); break; /* | fioletowy	 | %m/%p  | %M/%P | %q	| */					case (6): string_append_c(asc, (cur & FSTR_BOLD) ? 'C' : 'c'); break;					case (7): string_append_c(asc, (cur & FSTR_BOLD) ? 'W' : 'w'); break;				}			}#undef FGCOLOR		} else {	/* no color */			if ((cur & FSTR_BOLD) && (reset || !(prev & FSTR_BOLD)))				string_append(asc, "%T");		}	/* str */		if (str[i] == '%' || str[i] == '//')			string_append_c(asc, '//');		string_append_c(asc, str[i]);	}/* reset, and return. */	string_append(asc, "%n");	return string_free(asc, 0);#undef prev#undef cur}

boolcrypto_aes_decrypt(struct string *ciphertext, struct string *aes_key, struct string *aes_iv, struct string *decrypted){    bool retval = false;    EVP_CIPHER_CTX ctx;    int decryptspace;    int decryptdone;    EVP_CIPHER_CTX_init(&ctx);    if (!EVP_DecryptInit_ex(&ctx, EVP_aes_256_cbc(), NULL,        (unsigned char *)string_get(aes_key),        (unsigned char *)string_get(aes_iv))) {        log_err("crypto_aes_decrypt: init failed/n");        ERR_print_errors_fp(stderr);        goto bail_out;    }    EVP_CIPHER_CTX_set_padding(&ctx, 1);        if (string_length(aes_key) != EVP_CIPHER_CTX_key_length(&ctx)) {        log_err("crypto_aes_decrypt: invalid key size (%" PRIuPTR " vs expected %d)/n",                string_length(aes_key), EVP_CIPHER_CTX_key_length(&ctx));        goto bail_out;    }    if (string_length(aes_iv) != EVP_CIPHER_CTX_iv_length(&ctx)) {        log_err("crypto_aes_decrypt: invalid iv size (%" PRIuPTR " vs expected %d)/n",                string_length(aes_iv), EVP_CIPHER_CTX_iv_length(&ctx));        goto bail_out;    }    decryptspace = string_length(ciphertext) + EVP_MAX_BLOCK_LENGTH;    string_free(decrypted); /* free previous buffer */    string_init(decrypted, decryptspace, 1024);    if (string_size(decrypted) < decryptspace) {        log_err("crypto_aes_decrypt: decrypt buffer malloc error/n");        goto bail_out;    }        if (EVP_DecryptUpdate(&ctx, (unsigned char*)string_get(decrypted),            &decryptdone, (unsigned char*)string_get(ciphertext),            string_length(ciphertext))) {        /* TODO: need cleaner way: */        decrypted->_u._s.length = decryptdone;    } else {        log_err("crypto_aes_decrypt: decrypt failed/n");        ERR_print_errors_fp(stderr);        goto bail_out;    }        if (EVP_DecryptFinal_ex(&ctx,            (unsigned char*)string_get(decrypted)+string_length(decrypted),            &decryptdone)) {        /* TODO: need cleaner way: */        decrypted->_u._s.length += decryptdone;    } else {        log_err("crypto_aes_decrypt: decrypt final failed/n");        ERR_print_errors_fp(stderr);        goto bail_out;    }    retval = true;bail_out:    EVP_CIPHER_CTX_cleanup(&ctx);    return retval;}

/****************************************************************************set a string value, allocing the space for the string, and deallocating any existing space****************************************************************************/BOOL string_set(char **dest,const char *src){  string_free(dest);  return(string_init(dest,src));}

#define CC_eu   0x6575#define CC_fr   0x6672#define CC_hk   0x686b#define CC_tw   0x7477#define CC_io   0x696f#define CC_it   0x6974#define CC_mo   0x6d6f/* 以网络序(大端)定义Generic Code */#define GC_com  0x636f6d00#define GC_net  0x6e657400#define GC_org  0x6f726700#define GC_gov  0x676f7600#define GC_edu  0x65647500#define GC_biz  0x62697a00string_t host_wildcard = string_init("*");/* * 检查host的label，将顶级域名和可能存在的一级generic域名合并成一个label * 输入的label至少有2项，即label_count >= 2. */static inline int cache_host_parse_deep(string_t label[], int label_count){    int i, ret = -1;    uint16_t country_code = 0;    uint32_t generic_code = 0;    char *p_cc, *p_gc;    int need_check = 0, need_merge = 0;    /*     * 首先，处理顶级域名，label[0]，     * XXX: 只有当顶级域名是国家域名时，才可能需要合并label[0]和label[1]。