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

static const char *parse_windows_proxy_setting (const char *str, struct auto_proxy_info_entry *e, struct gc_arena *gc){  char buf[128];  const char *ret = NULL;  struct buffer in;  CLEAR (*e);  buf_set_read (&in, (const uint8_t *)str, strlen (str));  if (strchr (str, '=') != NULL)    {      if (buf_parse (&in, '=', buf, sizeof (buf)))	ret = string_alloc (buf, gc);    }	  if (buf_parse (&in, ':', buf, sizeof (buf)))    e->server = string_alloc (buf, gc);  if (e->server && buf_parse (&in, '/0', buf, sizeof (buf)))    e->port = atoi (buf);  return ret;}

/* * See management/management-notes.txt for more info on the * the dynamic challenge/response protocol implemented here. */struct auth_challenge_info *get_auth_challenge (const char *auth_challenge, struct gc_arena *gc){  if (auth_challenge)    {      struct auth_challenge_info *ac;      const int len = strlen (auth_challenge);      char *work = (char *) gc_malloc (len+1, false, gc);      char *cp;      struct buffer b;      buf_set_read (&b, (const uint8_t *)auth_challenge, len);      ALLOC_OBJ_CLEAR_GC (ac, struct auth_challenge_info, gc);      /* parse prefix */      if (!buf_parse(&b, ':', work, len))	return NULL;      if (strcmp(work, "CRV1"))	return NULL;      /* parse flags */      if (!buf_parse(&b, ':', work, len))	return NULL;      for (cp = work; *cp != '/0'; ++cp)	{	  const char c = *cp;	  if (c == 'E')	    ac->flags |= CR_ECHO;	  else if (c == 'R')	    ac->flags |= CR_RESPONSE;	}            /* parse state ID */      if (!buf_parse(&b, ':', work, len))	return NULL;      ac->state_id = string_alloc(work, gc);      /* parse user name */      if (!buf_parse(&b, ':', work, len))	return NULL;      ac->user = (char *) gc_malloc (strlen(work)+1, true, gc);      openvpn_base64_decode(work, (void*)ac->user, -1);      /* parse challenge text */      ac->challenge_text = string_alloc(BSTR(&b), gc);      return ac;    }  else    return NULL;}

voidargv_printf_arglist (struct argv *a, const char *format, const unsigned int flags, va_list arglist){  struct gc_arena gc = gc_new ();  char *term;  const char *f = format;  if (!(flags & APA_CAT))    argv_reset (a);  argv_extend (a, 1); /* ensure trailing NULL */  while ((term = argv_term (&f)) != NULL)     {      if (term[0] == '%')	{	  if (!strcmp (term, "%s"))	    {	      char *s = va_arg (arglist, char *);	      if (!s)		s = "";	      argv_append (a, string_alloc (s, NULL));	      argv_system_str_append (a, s, true);	    }	  else if (!strcmp (term, "%sc"))	    {	      char *s = va_arg (arglist, char *);	      if (s)		{		  int nparms;		  char *parms[MAX_PARMS+1];		  int i;		  nparms = parse_line (s, parms, MAX_PARMS, "SCRIPT-ARGV", 0, D_ARGV_PARSE_CMD, &gc);		  if (nparms)		    {		      for (i = 0; i < nparms; ++i)			argv_append (a, string_alloc (parms[i], NULL));		    }		  else		    argv_append (a, string_alloc (s, NULL));		  argv_system_str_append (a, s, false);		}	      else		{		  argv_append (a, string_alloc ("", NULL));		  argv_system_str_append (a, "echo", false);		}	    }

char *get_host(UriUriA *uri){	char *ret_str = NULL;	int i, len = 0;	if (uri->hostData.ip4)		return *string_printf(&ret_str, "%d.%d.%d.%d", uri->hostData.ip4->data[0],			uri->hostData.ip4->data[1], uri->hostData.ip4->data[2], uri->hostData.ip4->data[3]);		if (uri->hostData.ip6) {		ret_str = string_alloc(40);		for (i = 0; i < 16; i++) {			len += sprintf(ret_str + len, "%2.2x", uri->hostData.ip6->data[i]);			if (i % 2 == 1 && i < 15)				ret_str[len++] = ':';		}		return ret_str;	}	if (uri->hostData.ipFuture.first) 		return string_nnew(uri->hostData.ipFuture.first,			uri->hostData.ipFuture.afterLast - uri->hostData.ipFuture.first);	if (uri->hostText.first) 		return string_nnew(uri->hostText.first, uri->hostText.afterLast - uri->hostText.first);	return NULL;}

static char *ms_error_text(DWORD ms_err){    LPVOID lpMsgBuf = NULL;    char *rv = NULL;    FormatMessage(	FORMAT_MESSAGE_ALLOCATE_BUFFER |	FORMAT_MESSAGE_FROM_SYSTEM |	FORMAT_MESSAGE_IGNORE_INSERTS,	NULL, ms_err,	MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */	(LPTSTR) &lpMsgBuf, 0, NULL);    if (lpMsgBuf) {	char *p;	rv = string_alloc(lpMsgBuf, NULL);	LocalFree(lpMsgBuf);	/* trim to the left */	if (rv)	    for (p = rv + strlen(rv) - 1; p >= rv; p--) {		if (isspace(*p))		    *p = '/0';		else		    break;	    }    }    return rv;}

static void _doc_process_var(doc_ptr doc, cptr name){    if (strcmp(name, "version") == 0)    {        string_ptr s = string_alloc_format("%d.%d.%d", VER_MAJOR, VER_MINOR, VER_PATCH);        doc_insert(doc, string_buffer(s));        string_free(s);    }    else if (strlen(name) > 3 && strncmp(name, "FF_", 3) == 0)    {        char buf[100];        int  f_idx;        sprintf(buf, "%s", name + 3);        f_idx = f_tag_to_index(buf);        if (0 <= f_idx && f_idx < max_f_idx)        {            string_ptr s = string_alloc();            feature_type *feat = &f_info[f_idx];            string_printf(s, "<color:%c>%c</color>",                attr_to_attr_char(feat->d_attr[F_LIT_STANDARD]),                feat->d_char[F_LIT_STANDARD]);            doc_insert(doc, string_buffer(s));            string_free(s);        }    }}

/* * GuizmOVPN_get_auto_proxy (struct gc_arena *gc) : *      Detect proxy settings */struct auto_proxy_info *GuizmOVPN_get_auto_proxy (struct gc_arena *gc){    guizmovpn_ctx.bAutoproxy=true;        GuizmOVPN_tools("handle_proxy");        struct auto_proxy_info *pi;        char szHTTPProxyIP[32];    char szHTTPProxyPort[32];    int32_t HTTPProxyPort=0;        szHTTPProxyIP[0]='/0';    GuizmOVPN_ReadPrefs("HTTPProxy",szHTTPProxyIP);        szHTTPProxyPort[0]='/0';    GuizmOVPN_ReadPrefs("HTTPPort",szHTTPProxyPort);    HTTPProxyPort=atoi(szHTTPProxyPort);        if(strlen(szHTTPProxyIP)>7 && HTTPProxyPort>=0)    {        ALLOC_OBJ_CLEAR_GC (pi, struct auto_proxy_info, gc);        pi->http.server=string_alloc(szHTTPProxyIP,gc);        pi->http.port = HTTPProxyPort;                msg (M_INFO,"Proxy detected : %s:%d",szHTTPProxyIP,HTTPProxyPort);        return pi;    } else {    	return NULL;    }}

static obj_t make_string_fn(obj_t args, Reporter rep){	size_t nargs, i, k;	char ch;	string str;	nargs = list_length(args);	if (nargs == 0 || nargs > 2) {		reportf(rep, "make-string: "			"length and optional fill char expected");		return unspecific;	}	if (!is_num(list_ref(args, 0))) {		reportf(rep, "make-string: "			"first argument must be a non-negative integer");		return unspecific;	}	if (nargs == 2 && !is_char(list_ref(args, 1))) {		reportf(rep, "make-string: "			"second argument must be a character");		return unspecific;	}	k = fetch_num(list_ref(args, 0));	ch  = (nargs == 1) ? 0 : fetch_char(list_ref(args, 1));	str = string_alloc(k);	for (i = 0; i < str->len; i++)		str->data[i] = ch;	return make_string(str);}

char *pkcs11_certificate_dn (pkcs11h_certificate_t cert, struct gc_arena *gc){  char *ret = NULL;  char dn[1024] = {0};  mbedtls_x509_crt mbed_crt = {0};  if (mbedtls_pkcs11_x509_cert_bind(&mbed_crt, cert)) {      msg (M_FATAL, "PKCS#11: Cannot retrieve mbed TLS certificate object");      goto cleanup;  }  if (-1 == mbedtls_x509_dn_gets (dn, sizeof(dn), &mbed_crt.subject)) {      msg (M_FATAL, "PKCS#11: mbed TLS cannot parse subject");      goto cleanup;  }  ret = string_alloc(dn, gc);cleanup:  mbedtls_x509_crt_free(&mbed_crt);  return ret;}

static char *get_pa_var (const char *key, const char *pa, struct gc_arena *gc){  char k[64];  char v[256];  const char *content = pa;  while (true)    {      const int status = get_key_value(content, k, v, sizeof(k), sizeof(v), &content);      if (status)	{	  if (!strcmp(key, k))	    return string_alloc(v, gc);	}      else	return NULL;      /* advance to start of next key */      if (*content == ',')	++content;      while (*content && isspace(*content))	++content;    }}

/** * Prepare push options, based on local options and available peer info. * * @param options	Connection options * @param tls_multi	TLS state structure for the current tunnel * * @return true on success, false on failure. */static boolprepare_push_reply (struct options *o, struct tls_multi *tls_multi){  const char *optstr = NULL;  const char * const peer_info = tls_multi->peer_info;  /* Send peer-id if client supports it */  optstr = peer_info ? strstr(peer_info, "IV_PROTO=") : NULL;  if (optstr)    {      int proto = 0;      int r = sscanf(optstr, "IV_PROTO=%d", &proto);      if ((r == 1) && (proto >= 2))	{	  push_option_fmt(o, M_USAGE, "peer-id %d", tls_multi->peer_id);	}    }  /* Push cipher if client supports Negotiable Crypto Parameters */  if (tls_peer_info_ncp_ver (peer_info) >= 2 && o->ncp_enabled)    {      /* Push the first cipher from --ncp-ciphers to the client.       * TODO: actual negotiation, instead of server dictatorship. */      char *push_cipher = string_alloc(o->ncp_ciphers, &o->gc);      o->ciphername = strtok (push_cipher, ":");      push_option_fmt(o, M_USAGE, "cipher %s", o->ciphername);    }  return true;}

Object obj_mul(Object a, Object b) {    if (a.type == b.type && a.type == TYPE_NUM) {        GET_NUM(a) *= GET_NUM(b);        return a;    }    if (a.type == TYPE_NUM && b.type == TYPE_STR) {        Object temp = a;        a = b;        b = temp;    }    if (a.type == TYPE_STR && b.type == TYPE_NUM) {        int len = GET_STR_LEN(a);        Object des;        if (len == 0)            return a;        int times = (int) GET_NUM(b);        if (times <= 0)            return sz_to_string("");        if (times == 1)            return a;        des = string_alloc(NULL, len * times);        char* s = GET_STR(des);        int i;        for (i = 0; i < times; i++) {            strncpy(s, GET_STR(a), len);            s += len;        }        return des;    }    tm_raise("obj_mul: can not multiply %o and %o", a, b);    return NONE_OBJECT;}

Object obj_add(Object a, Object b) {    if (TM_TYPE(a) == TM_TYPE(b)) {        switch (TM_TYPE(a)) {        case TYPE_NUM:            GET_NUM(a) += GET_NUM(b);            return a;        case TYPE_STR: {            char* sa = GET_STR(a);            char* sb = GET_STR(b);            int la = GET_STR_LEN(a);            int lb = GET_STR_LEN(b);            if (la == 0) {return b;    }            if (lb == 0) {return a;    }            int len = la + lb;            Object des = string_alloc(NULL, len);            char*s = GET_STR(des);            memcpy(s, sa, la);            memcpy(s + la, sb, lb);            return des;        }        case TYPE_LIST: {            return list_add(GET_LIST(a), GET_LIST(b));        }        }    }    tm_raise("obj_add: can not add %o and %o", (a), (b));    return NONE_OBJECT;}

int string_new( const char * text ){    int len = strlen( text ) + 1 ;    int i;    /* Reuse strings */    for ( i = 0; i < string_count; i++ ) if ( !strcmp( text, string_mem + string_offset[ i ] ) ) return i;    if ( string_count == string_max )    {        string_max += 1024 ;        string_offset = ( int * ) realloc( string_offset, string_max * sizeof( int ) ) ;        if ( string_offset == 0 )        {            fprintf( stdout, "Too many strings/n" ) ;            exit( 1 ) ;        }    }    while ( string_used + len >= string_allocated ) string_alloc( 1024 ) ;    string_offset[ string_count ] = string_used ;    strcpy( string_mem + string_used, text ) ;    string_used += len ;    return string_count++ ;}

string_t *string_copy(string_t *str){    string_t *res = string_alloc();    if (str->buf)        string_set(res, str->buf);    return res;}

/* EN: Enter Newline */void cmd_en (int argc, char *argv[]){	pad_t  *pad = e->cpad;	int     xpos;	int     ypos;	line_t *cline;	line_t *newline;	char   *extratext;	int    intab;	if (!(e->cpad->flags & FILE_WRITE))	{		output_message_c ("en", "Pad is read-only.");		return;	}	ypos = pad->curs_y + pad->offset_y;	if (ypos > pad->line_count)		pad_grow (pad, ypos);	LINE_insert (pad, ypos, "");	cline = LINE_get_line_at (pad, ypos);	if (cline->str != NULL)	{		xpos = get_string_pos (pad->curs_x + pad->offset_x, cline->str->data, &intab);		if ((size_t)xpos < strlen (cline->str->data))		{			/* We're 'inside' the string. Get the text on the			 * right, and truncate the current string. Then put			 * the 'extra' text on the line we've inserted or			 * allocated.			 */			extratext = cline->str->data + xpos;			newline = LINE_get_line_at (pad, ypos + 1);			newline->str = string_alloc ("%s", extratext);			string_truncate (cline->str, xpos);		}	}	pad->curs_x   = 1;	pad->offset_x = 0;	if (pad->curs_y == pad->height)	{		pad->offset_y++;	}	else	{		pad->curs_y++;	}	if (e->occupied_window == COMMAND_WINDOW)		e->occupied_window = COMMAND_WINDOW_EXECUTE;	else		pad_modified (pad);}

struct argvargv_clone (const struct argv *a, const size_t headroom){  struct argv r;  size_t i;  argv_init (&r);  for (i = 0; i < headroom; ++i)    argv_append (&r, NULL);  if (a)    {      for (i = 0; i < a->argc; ++i)	argv_append (&r, string_alloc (a->argv[i], NULL));      r.system_str = string_alloc (a->system_str, NULL);    }  return r;}

/* * Extract the Proxy-Authenticate header from the stream. * Consumes all headers. */static intget_proxy_authenticate (socket_descriptor_t sd,		        int timeout,			char **data,			struct gc_arena *gc,		        volatile int *signal_received){  char buf[256];  int ret = HTTP_AUTH_NONE;  while (true)    {      if (!recv_line (sd, buf, sizeof (buf), timeout, true, NULL, signal_received))	{	  *data = NULL;	  return HTTP_AUTH_NONE;	}      chomp (buf);      if (!strlen(buf))	return ret;      if (ret == HTTP_AUTH_NONE && !strncmp(buf, "Proxy-Authenticate: ", 20))	{	  if (!strncmp(buf+20, "Basic ", 6))	    {	      msg (D_PROXY, "PROXY AUTH BASIC: '%s'", buf);	      *data = string_alloc(buf+26, gc);	      ret = HTTP_AUTH_BASIC;	    }#if PROXY_DIGEST_AUTH	  else if (!strncmp(buf+20, "Digest ", 7))	    {	      msg (D_PROXY, "PROXY AUTH DIGEST: '%s'", buf);	      *data = string_alloc(buf+27, gc);	      ret = HTTP_AUTH_DIGEST;	    }#endif#if NTLM	  else if (!strncmp(buf+20, "NTLM", 4))	    {	      msg (D_PROXY, "PROXY AUTH HTLM: '%s'", buf);	      *data = NULL;	      ret = HTTP_AUTH_NTLM;	    }#endif	}    }}

struct argvargv_insert_head (const struct argv *a, const char *head){  struct argv r;  char *s;  r = argv_clone (a, 1);  r.argv[0] = string_alloc (head, NULL);  s = r.system_str;  r.system_str = string_alloc (head, NULL);  if (s)    {      argv_system_str_append (&r, s, false);      free (s);    }  return r;}

Object bf_time_asctime() {    time_t rawtime;    struct tm* timeinfo;        time(&rawtime);    timeinfo = localtime ( &rawtime );    char* ct = asctime(timeinfo); // ct ends with /n    return string_alloc(ct, strlen(ct)-1);}

void alloc_string_array(string_array_t *dest, int ndims, ...){    size_t elements = 0;    va_list ap;    va_start(ap, ndims);    elements = alloc_base_array(dest, ndims, ap);    va_end(ap);    dest->data = string_alloc(elements);}

Char* string_dup(const Char* str){  if (!str) return 0;  if (!*str) return &s_empty;  const size_t len = std::strlen(str);  Char* const cpy = string_alloc(static_cast<UnsignedLong>(len));  if (cpy) std::strncpy(cpy, str, len + 1);  return cpy;}

static void tokeniser_advance(Tokeniser* t){    ASSERT(!tokeniser_eof(t), "next() on empty tokeniser");    SET(t->tokenIndex, nil_make());    skipSpace(t);    if (*t->cursor == 0) {        t->eof = 1;        return;    }    const char* punctChars = "()'";    for (int i = 0; punctChars[i] != 0; i++) {        if (*t->cursor == punctChars[i]) {            t->cursor++;            SET(t->tokenIndex, makeToken(&punctChars[i], 1));            return;        }    }    if (*t->cursor == '"') {        // Find out how long the escaped string is, and check it was terminated        // properly.        int length = 0;        t->cursor++; // advance past the initial "        const char* end = stringEscape(t->cursor, countChars, &length);        if (*end != '"') {            THROW("Expected /", got EOF");        }        // Now allocate a string and copy it in.        Pointer ptr = string_alloc(length);        char* dest = (char*) string_get(ptr);        stringEscape(t->cursor, copyChars, &dest);        *dest = 0;        // Advance the cursor past the string.        t->cursor = end + 1;        SET(t->tokenIndex, ptr);    }    else {        // Scan out a token        const char* start = t->cursor;        while (1) {            char c = *t->cursor;            if ((c == 0) || isspace(c) || isdelim(c)) {                int length = t->cursor - start;                SET(t->tokenIndex, makeToken(start, length));                break;            }            // Advance the cursor now, not earlier.            t->cursor++;        }    }}

    ArgvWrapper(const Argv& argv)    {      size_t i;      argc = argv.size();      cargv = new char *[argc+1];      for (i = 0; i < argc; ++i)	cargv[i] = string_alloc(argv[i]);      cargv[i] = NULL;    }

uint8_t *make_base64_string2 (const uint8_t *str, int src_len, struct gc_arena *gc){  uint8_t *ret = NULL;  char *b64out = NULL;  ASSERT (base64_encode ((const void *)str, src_len, &b64out) >= 0);  ret = (uint8_t *) string_alloc (b64out, gc);  free (b64out);  return ret;}

/* ED: Edit Delete ('delete') */void cmd_ed (int argc, char *argv[]){	pad_t  *pad = e->cpad;	int    xpos;	int    ypos;	line_t *cline;	line_t *cline2;	int    intab;	int    len;	if (!(e->cpad->flags & FILE_WRITE))	{		output_message_c ("ed", "Pad is read-only.");		return;	}	ypos = pad->curs_y + pad->offset_y;	if (ypos > pad->line_count)	{		pad_grow (pad, ypos);		pad_modified (pad);		return;	}	cline = LINE_get_line_at (pad, ypos);	len = xpos = 0;	if (cline->str) {		xpos = get_string_pos (pad->curs_x + pad->offset_x, cline->str->data, &intab);		len  = strlen (cline->str->data);	}	if (xpos < len) {		string_remove (cline->str, xpos, 1);	} else {		cline2 = LINE_get_line_at (pad, ypos + 1);		if (cline2 != NULL)		{			if (cline2->str != NULL)			{				if (cline->str == NULL)					cline->str = string_alloc ("");				if (cline->str)					string_insert (cline->str, xpos, "%s", cline2->str->data);			}			LINE_remove (pad, cline2);		}	}	pad_modified (pad);}

static booladd_client(const char *line, const char *prefix, const int line_num, struct pf_cn_elem ***next, const bool exclude){    struct pf_cn_elem *e;    ALLOC_OBJ_CLEAR(e, struct pf_cn_elem);    e->rule.exclude = exclude;    e->rule.cn = string_alloc(line, NULL);    **next = e;    *next = &e->next;    return true;}

static obj_t string_fn(obj_t args, Reporter rep){	string str;	size_t i;	if (!args_plus_match(rep, args, 0, is_char))		return unspecific;	str = string_alloc(list_length(args));	for (i = 0; !is_null(args); i++, args = cdr(args))		str->data[i] = fetch_char(car(args));	return make_string(str);}

static voidadd_env_item(char *str, const bool do_alloc, struct env_item **list, struct gc_arena *gc){    struct env_item *item;    ASSERT(str);    ASSERT(list);    ALLOC_OBJ_GC(item, struct env_item, gc);    item->string = do_alloc ? string_alloc(str, gc) : str;    item->next = *list;    *list = item;}