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

static inline ListCell *parseQS(char *path) {    ListCell *qs = NULL;    char *copy = bsNew(path);    char *segment, *key, *value;    bool s = true;    for (;;) {        if (s) {segment = strtok(copy, "="); s = false;}        else   {segment = strtok(NULL, "=");}        if (segment == NULL) break;        if (*(segment + strlen(segment) + 1) == '&') continue;        key     = segment;        segment = strtok(NULL, "&/0");        if (segment == NULL) break;        key   = urldecode(key);        value = urldecode(segment);        qs    = listCons(kvNew(key, value), sizeof(KV), qs);        bsDel(key);        bsDel(value);    }    bsDel(copy);    return qs;}

static int http_parse_arguments(struct http_request *r, NMEM nmem,                                const char *args){    const char *p2 = args;    while (*p2)    {        struct http_argument *a;        const char *equal = strchr(p2, '=');        const char *eoa = strchr(p2, '&');        if (!equal)        {            yaz_log(YLOG_WARN, "Expected '=' in argument");            return -1;        }        if (!eoa)            eoa = equal + strlen(equal); // last argument        else if (equal > eoa)        {            yaz_log(YLOG_WARN, "Missing '&' in argument");            return -1;        }        a = nmem_malloc(nmem, sizeof(struct http_argument));        a->name = nmem_strdupn(nmem, p2, equal - p2);        a->value = nmem_strdupn(nmem, equal+1, eoa - equal - 1);        urldecode(a->name, a->name);        urldecode(a->value, a->value);        a->next = r->arguments;        r->arguments = a;        p2 = eoa;        while (*p2 == '&')            p2++;    }    return 0;}

static void insert(nvlist_t *vars, struct qstr *name, struct qstr *val){	urldecode(name->buf, name->idx, name->buf);	urldecode(val->buf, val->idx, val->buf);	/* now, {name,val}->buf are null-terminated strings */	nvl_set_str(vars, name->buf, val->buf);}

/* 处理模块 */void httpcws_handler(struct evhttp_request *req, void *arg){	        struct evbuffer *buf;        buf = evbuffer_new();				/* 分析URL参数 */		struct evkeyvalq httpcws_http_query;		evhttp_parse_query(evhttp_request_uri(req), &httpcws_http_query);				/* 接收POST表单信息 */		const char *tcsql_input_postbuffer = (const char*) EVBUFFER_DATA(req->input_buffer);						/* 接收GET表单参数 */		const char *httpcws_input_words = evhttp_find_header (&httpcws_http_query, "w");		const char *httpcws_output_tmp = NULL;		char *httpcws_output_words = "/0";		if (tcsql_input_postbuffer != NULL) {			char *tcsql_input_postbuffer_tmp = (char *) malloc(EVBUFFER_LENGTH(req->input_buffer)+1);			memset (tcsql_input_postbuffer_tmp, '/0', EVBUFFER_LENGTH(req->input_buffer)+1);			strncpy(tcsql_input_postbuffer_tmp, tcsql_input_postbuffer, EVBUFFER_LENGTH(req->input_buffer));			char *decode_uri = urldecode(tcsql_input_postbuffer_tmp);			free(tcsql_input_postbuffer_tmp);			httpcws_output_tmp = ICTCLAS_ParagraphProcess(decode_uri, 0);			free(decode_uri);			httpcws_output_words = strdup(httpcws_output_tmp);			trim (httpcws_output_words);		} else if (httpcws_input_words != NULL) {			char *httpcws_input_words_tmp = strdup(httpcws_input_words);			char *decode_uri = urldecode(httpcws_input_words_tmp);			free(httpcws_input_words_tmp);			httpcws_output_tmp = ICTCLAS_ParagraphProcess(decode_uri, 0);			free(decode_uri);			httpcws_output_words = strdup(httpcws_output_tmp);			trim (httpcws_output_words);		} else {			httpcws_output_words = strdup("");		}				/* 输出内容给客户端 */		evhttp_add_header(req->output_headers, "Server", "HTTPCWS/1.0.0");		evhttp_add_header(req->output_headers, "Content-Type", "text/plain; charset=GB2312");		evhttp_add_header(req->output_headers, "Connection", "close");		evbuffer_add_printf(buf, "%s", httpcws_output_words);        evhttp_send_reply(req, HTTP_OK, "OK", buf);				free(httpcws_output_words);		evhttp_clear_headers(&httpcws_http_query);		evbuffer_free(buf);	}

static struct lh_kv_elem* parse_url_params(char *sparams) {    if (!sparams)        return NULL;    struct lh_kv_elem *param = NULL;    char *key = sparams;    while (1) {        char *eq_mark = strchr(key, '=');        if (eq_mark == NULL)            break;        char *value = eq_mark + 1;        struct lh_kv_elem *newparam = malloc(sizeof(struct lh_kv_elem));        newparam->next = param;        newparam->key = key;        newparam->value = value;        param = newparam;                char *and_mark = strchr(value, '&');        *eq_mark = 0;        //urldecode(key);        if (and_mark)            *and_mark = 0;        urldecode(value);        if (and_mark == NULL)            break;        key = and_mark + 1;    }    return param;}

static intpkg_string(struct pkg *pkg, ucl_object_t *obj, int attr){	int ret = EPKG_OK;	const char *str;	str = ucl_object_tostring_forced(obj);	switch (attr)	{	case PKG_LICENSE_LOGIC:		if (!strcmp(str, "single"))			pkg_set(pkg, PKG_LICENSE_LOGIC, (int64_t) LICENSE_SINGLE);		else if (!strcmp(str, "or") ||		         !strcmp(str, "dual"))			pkg_set(pkg, PKG_LICENSE_LOGIC, (int64_t)LICENSE_OR);		else if (!strcmp(str, "and") ||		         !strcmp(str, "multi"))			pkg_set(pkg, PKG_LICENSE_LOGIC, (int64_t)LICENSE_AND);		else {			pkg_emit_error("Unknown license logic: %s", str);			ret = EPKG_FATAL;		}		break;	default:		if (attr == PKG_DESC)			ret = urldecode(str, &pkg->fields[attr]);		else			ret = pkg_set(pkg, attr, str);		break;	}	return (ret);}

		/// Parse some data. The enum return value is good when a complete request has		/// been parsed, bad if the data is invalid, indeterminate when more data is		/// required. The InputIterator return value indicates how much of the input		/// has been consumed.		result_type parse(boost::asio::streambuf& buf)		{			int c = EOF;			while ((c = buf.sbumpc()) != EOF)			{				result_type result = consume(c);				if (result == good || result == bad)				{					std::string url = urldecode(url_);					std::string::size_type qmak_pos = url.find("?");					if (qmak_pos == std::string::npos)					{						path_ = url;					}					else					{						path_ = url.substr(0, qmak_pos);						std::string quert_str = url.substr(qmak_pos + 1, url.size());						query_ = query_parser(quert_str);					}					return result;				}			}			return indeterminate;		}

int extract_query_string(struct form_t *form, const char *query_string){    int count = 0;    if (!query_string){        return count;    }    query_string = urldecode(query_string);    while (query_string && *query_string){        const char *name;        const char *value;        char *eq = strchr(query_string, '=');        if (eq){            name = strndup(query_string, (size_t)(eq - query_string));            query_string = eq + 1;            char *amp = strchr(query_string, '&');            if (amp){                value = strndup(query_string, (size_t)(amp - query_string));                query_string = amp + 1;            } else {                value = strdup(query_string);                query_string = strchr(query_string, '/0');            }        } else {            name = strdup(query_string);            value = NULL;            query_string = strchr(query_string, '/0');        }        if (strlen(name) > 0){            add_var_to_form(form, name, value);            count++;        }    }    return count;}

static int parse_request(struct fd_state *state) {    assert(state && state->read_buf);	//printf("%s", state->read_buf);    char *path = strchr(state->read_buf, '/');    if (path == NULL)        return -1;        char *scookies = strstr(path, "Cookie: ");    if (scookies)        scookies += 8;    char *space = strchr(path, ' ');    if (space) {        *space = 0;    }    char *question = strchr(path, '?');    if (question)        *question = 0;    urldecode(path);        char *sparams = NULL;    if (question)        sparams = question + 1;        int iscalled = call_callback(state, path, sparams, scookies);    if (iscalled) {        return 0;    }    const char *dot = strrchr(path, '.');    if (dot) {  //file        const char *ext = dot + 1;        const char *mime = "text/plain";        if (strcmp(ext, "html") == 0 || strcmp(ext, "htm") == 0) {            mime = "text/html";        } else if (strcmp(ext, "css") == 0) {            mime = "text/css";        } else if (strcmp(ext, "js") == 0) {            mime = "text/javascript";        } else if (strcmp(ext, "png") == 0) {            mime = "image/png";        } else if (strcmp(ext, "jpeg") == 0 || strcmp(ext, "jpg") == 0 || strcmp(ext, "jpe") == 0 ) {            mime = "image/jpeg";        } else if (strcmp(ext, "gif") == 0) {            mime = "image/gif";        }        char abspath[1024];        strncpy(abspath, _root_dir, sizeof(abspath));        strncat(abspath, path, sizeof(abspath)-strlen(path));        state->pf = fopen(abspath, "r");        if (state->pf) {            fseek(state->pf, 0, SEEK_END);            write_response_header(state, mime, ftell(state->pf), "");            rewind(state->pf);        } else {            write_response_error(state);        }    } else { //func        write_response_error(state);    }    return 0;}

int http_parse_query(char *url, KeyValuePair *params, const int max_count){	KeyValuePair *pCurrent;	KeyValuePair *pEnd;	char *pParamStart;	char *p;	char *pStrEnd;	int value_len;	pParamStart = strchr(url, '?');	if (pParamStart == NULL)	{		return 0;	}	*pParamStart = '/0';	pEnd = params + max_count;	pCurrent = params;	p = pParamStart + 1;	while (p != NULL && *p != '/0')	{		if (pCurrent >= pEnd)		{			return pCurrent - params;		}		pCurrent->key = p;		pStrEnd = strchr(p, '&');		if (pStrEnd == NULL)		{			p = NULL;		}		else		{			*pStrEnd = '/0';			p = pStrEnd + 1;		}		pStrEnd = strchr(pCurrent->key, '=');		if (pStrEnd == NULL)		{			continue;		}		*pStrEnd = '/0';		pCurrent->value = pStrEnd + 1;		if (*pCurrent->key == '/0')		{			continue;		}		urldecode(pCurrent->value, strlen(pCurrent->value), /			pCurrent->value, &value_len);		pCurrent++;	}	return pCurrent - params;}

int llspaux::lua_urldecode(lua_State* L){    size_t len=0;    const char* p=lua_tolstring(L,1,&len);    return urldecode(L,p,len);}

    void test_urldecode()    {        std::string ia("");        urldecode(ia);        assert_equal(ia, "");        std::string ib("abc def");        urldecode(ib);        assert_equal(ib, "abc def");        std::string ic("+%20");        urldecode(ic);        assert_equal(ic, "  ");        std::string id("%41+string+ending+in+%");        urldecode(id);        assert_equal(id, "A string ending in %");    }

static intset_path(PyObject *env, char *buf, int len){    int c, c1, slen;    char *s0, *t;    PyObject *obj;    t = s0 = buf;    while(len > 0){        c = *buf++;        if(c == '%' && len > 2){            c = *buf++;            c1 = c;            c = *buf++;            c = hex2int(c1) * 16 + hex2int(c);            len -= 2;        }else if(c == '?'){            //stop            if(set_query(env, buf, len) == -1){                //Error                return -1;            }            break;        }else if(c == '#'){            //stop             //ignore fragment            break;        }        *t++ = c;        len--;    }    //*t = 0;    slen = t - s0;    slen = urldecode(s0, slen);    obj = PyBytes_FromStringAndSize(s0, slen);    /* DEBUG("path:%.*s", (int)slen, PyBytes_AS_STRING(obj)); */    if(likely(obj != NULL)){#ifdef PY3        //TODO CHECK ERROR         char *c2 = PyBytes_AS_STRING(obj);        PyObject *v = PyUnicode_DecodeUTF8(c2, strlen(c2), NULL);        PyDict_SetItem(env, path_info_key, v);        Py_DECREF(v);#else        PyDict_SetItem(env, path_info_key, obj);#endif        Py_DECREF(obj);        return slen;    }else{        return -1;    }}

int llspaux::args(lua_State* L,const char* p,size_t len){    lua_newtable(L);        size_t offset1=0,length1=0;    size_t offset2=0,length2=0;    size_t i;    for(i=0;i<len;++i)    {    	if(p[i]=='=')	{	    length1=i-offset1;	    offset2=i+1;	}else if(p[i]=='&')	{	    length2=i-offset2;	    	    if(length1 && length2)	    {	    		lua_pushlstring(L,p+offset1,length1);		urldecode(L,p+offset2,length2);		lua_rawset(L,-3);	    }	    	    offset1=i+1;	    length1=offset2=length2=0;	}    }    length2=i-offset2;    if(length1 && length2)    {	    	lua_pushlstring(L,p+offset1,length1);	urldecode(L,p+offset2,length2);	lua_rawset(L,-3);    }    return 1;}

static int L_urldecode( lua_State* L ) {    const char* param;    char* data;    PARAM_STRING( param );    data = strdup( param );    urldecode( data );    RETURN_STRING( data );    free( data );    return 1;}

static int parse_query(char* query, int ql, char* params[], char* values[]) {  int count=0;  int i,pi,vi;  for(i=0;i<ql;i++) {    pi=i;    for(;i<ql;i++) {      if (query[i]=='=') { query[i]=0; break; }    }    i++;    if (i>=ql) return -1;    vi=i;    for(;i<ql;i++) {      if (query[i]=='&') { query[i]=0; break; }    }    if (count>=MAXPARAMS) return -1;    params[count]=urldecode(query+pi,query+pi);    values[count]=urldecode(query+vi,query+vi);    count++;  }  return count;}

int CompileWork::GetTextAreaValue(){	string textareaname = Config::GetInstance()->GetValue("TEXTAREANAME");	if(textareaname.empty())		textareaname = TEXTAREANAME;	textAreaValue = requestHttp->GetQueryParamValue(TEXTAREANAME);	if(textAreaValue == RT_INFO[RT_ERR])	{		return RT_ERR;	}	textAreaValue = urldecode(textAreaValue);	return RT_OK;}

int main ( int argc, char **argv ) {	assert(argc > 1 );	char in[BUF_SIZE];	char out[BUF_SIZE];	sprintf(in, "%s", argv[1]);	printf("in: %s/n", in);	urldecode(in, out);	printf("out: %s/n", out);	return 0;}

int winargs(int argc, char **argv, char *buffer){    if (argc == 2)    {        if (!(strlen(argv[1]) < MaxBuffer - 1))            return 0;        if (strstr(argv[1], "garglk:///"))            return urldecode(buffer, MaxBuffer, argv[1]+10);        strcpy(buffer, argv[1]);    }    return (argc == 2);}

static intpkg_set_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_document_t *doc, int attr){	int ret = EPKG_OK;	while (val->data.scalar.length > 0 &&			val->data.scalar.value[val->data.scalar.length - 1] == '/n') {		val->data.scalar.value[val->data.scalar.length - 1] = '/0';		val->data.scalar.length--;	}	ret = urldecode(val->data.scalar.value, &pkg->fields[attr]);	return (ret);}

/* Parse url parameters and save them to params array. The pch pointer is increased to the position where parsing stopped. */void parseParams(struct uriparams *params, char *pch){	char *pch2;	// parsemode = 1 means parsing next param, parsemode = -1 parsing next	//value; pch2 points to the beginning of the currently parsed string, pch is the current position	int32_t parsemode = 1;	pch2 = pch;	while(pch[0] != '/0')	{		if((parsemode == 1 && pch[0] == '=') || (parsemode == -1 && pch[0] == '&'))		{			pch[0] = '/0';			urldecode(pch2);			if(parsemode == 1)			{				if(params->paramcount >= MAXGETPARAMS) { break; }				++params->paramcount;				params->params[params->paramcount - 1] = pch2;			}			else			{				params->values[params->paramcount - 1] = pch2;			}			parsemode = -parsemode;			pch2 = pch + 1;		}		++pch;	}	/* last value wasn't processed in the loop yet... */	if(parsemode == -1 && params->paramcount <= MAXGETPARAMS)	{		urldecode(pch2);		params->values[params->paramcount - 1] = pch2;	}}

static intset_path(PyObject *env, char *buf, int len){    int c, c1, slen;    char *s0, *t;    PyObject *obj;    t = s0 = buf;    while(len > 0){        c = *buf++;        if(c == '%' && len > 2){            c = *buf++;            c1 = c;            c = *buf++;            c = hex2int(c1) * 16 + hex2int(c);            len -= 2;        }else if(c == '?'){            //stop            if(set_query(env, buf, len) == -1){                //Error                return -1;            }            break;        }else if(c == '#'){            //stop             //ignore fragment            break;        }        *t++ = c;        len--;    }    //*t = 0;    slen = t - s0;    slen = urldecode(s0, slen);#ifdef PY3    obj = PyUnicode_DecodeLatin1(s0, slen, "strict");#else    obj = PyBytes_FromStringAndSize(s0, slen);#endif    if (likely(obj != NULL)) {        PyDict_SetItem(env, path_info_key, obj);        Py_DECREF(obj);        return slen;    } else {        return -1;    }}

static intpkg_set_files_from_object(struct pkg *pkg, ucl_object_t *obj){	ucl_object_t *cur;	ucl_object_iter_t it = NULL;	const char *sum = NULL;	const char *uname = NULL;	const char *gname = NULL;	void *set = NULL;	mode_t perm = 0;	struct sbuf *fname = NULL;	const char *key, *okey;	okey = ucl_object_key(obj);	if (okey == NULL)		return (EPKG_FATAL);	urldecode(okey, &fname);	while ((cur = ucl_iterate_object(obj, &it, true))) {		key = ucl_object_key(cur);		if (key == NULL)			continue;		if (!strcasecmp(key, "uname") && cur->type == UCL_STRING)			uname = ucl_object_tostring(cur);		else if (!strcasecmp(key, "gname") && cur->type == UCL_STRING)			gname = ucl_object_tostring(cur);		else if (!strcasecmp(key, "sum") && cur->type == UCL_STRING &&		    strlen(ucl_object_tostring(cur)) == 64)			sum = ucl_object_tostring(cur);		else if (!strcasecmp(key, "perm") &&		    (cur->type == UCL_STRING || cur->type == UCL_INT)) {			if ((set = setmode(ucl_object_tostring_forced(cur))) == NULL)				pkg_emit_error("Not a valid mode: %s",				    ucl_object_tostring(cur));			else				perm = getmode(set, 0);		} else {			pkg_emit_error("Skipping unknown key for file(%s): %s",			    sbuf_data(fname), ucl_object_tostring(cur));		}	}	pkg_addfile_attr(pkg, sbuf_data(fname), sum, uname, gname, perm, false);	sbuf_delete(fname);	return (EPKG_OK);}

void	Client::setPathFromUri(Transaction&  trans){  std::string uri = trans.getRequest().getUri();  std::string res;  if (uri.substr(0, 7) == "http://")    {      size_t slash_pos = uri.find("/", 8);      if (slash_pos == std::string::npos)	res = "/";      else	res = uri.substr(slash_pos);    }  else    res = uri;  res = urldecode(res);  std::string final;  std::string port = inttostr(trans.getClientEndPoint().getPort());  std::string host = trans.getRequest().getHeaders()["HOST"];  final = Conf::Inst().get("documentroot", "/var/www", port, host);

int main(int argc, char **argv){    char data[4096];    ssize_t bytes;        decoder_state state;    state.state = ST_SYM;    while ((bytes = read(0, data, sizeof(data))) > 0)    {        bytes = urldecode(&state, data, bytes);        if (bytes > 0)        {            write(1, data, bytes);        }        else        {            return 1;        }    }    return 0;}

static intpkg_set_dirs_from_object(struct pkg *pkg, ucl_object_t *obj){	ucl_object_t *cur;	ucl_object_iter_t it = NULL;	const char *uname = NULL;	const char *gname = NULL;	void *set;	mode_t perm = 0;	bool try = false;	struct sbuf *dirname = NULL;	const char *key, *okey;	okey = ucl_object_key(obj);	if (okey == NULL)		return (EPKG_FATAL);	urldecode(okey, &dirname);	while ((cur = ucl_iterate_object(obj, &it, true))) {		key = ucl_object_key(cur);		if (key == NULL)			continue;		if (!strcasecmp(key, "uname") && cur->type == UCL_STRING)			uname = ucl_object_tostring(cur);		else if (!strcasecmp(key, "gname") && cur->type == UCL_STRING)			gname = ucl_object_tostring(cur);		else if (!strcasecmp(key, "perm") &&		    (cur->type == UCL_STRING || cur->type == UCL_INT)) {			if ((set = setmode(ucl_object_tostring_forced(cur))) == NULL)				pkg_emit_error("Not a valid mode: %s",				    ucl_object_tostring(cur));			else				perm = getmode(set, 0);		} else if (!strcasecmp(key, "try") && cur->type == UCL_BOOLEAN) {				try = ucl_object_toint(cur);		} else {			pkg_emit_error("Skipping unknown key for dir(%s): %s",			    sbuf_data(dirname), key);		}	}

int main(int argc,char*argv[]) {	char *data = NULL;	int len,nel;	char *q,*value,*name;	char cmd[80];        char username[80][80] ;	printf("%s%c%c/n","Content-Type:text/html;charset=utf-8",13,10);	printf("<TITLE>Uploading</TITLE>/n");	data = getenv("QUERY_STRING");	printf("%s",data);	urldecode(data);	printf("%s",data);	q = data;	nel = 0;	len = strlen(data);	int i = 0;	if (data == NULL)		printf("<p>Error!Error in passing data from form to script.");	else {	while(strsep(&q,"&"))			nel++;		for(q=data;q<(data+len);){			value=name=q;			for(q+=strlen(q);q<(data+len)&&!*q;q++);			name=strsep(&value,"=");			printf("%s/n",name);			printf("%s/n",value);			printf("<br/>");			sprintf(cmd,"sh upload.sh %s",value);			printf("%s",cmd);	//		system("ls");				system(cmd);		}	}	return 0; }

		result_type parse(InputIterator begin, InputIterator end)		{			while (begin != end)			{				result_type result = consume(*begin++);				if (result == good || result == bad)				{					std::string url = urldecode(url_);					std::string::size_type qmak_pos = url.find("?");					if (qmak_pos == std::string::npos)					{						path_ = url;					}					else					{						path_ = url.substr(0, qmak_pos);						std::string quert_str = url.substr(qmak_pos + 1, url.size());						query_ = query_parser(quert_str);					}					return result;				}			}			return indeterminate;		}

void EtherShield::ES_urldecode(char *urlbuf) {	urldecode(urlbuf);}

//.........这里部分代码省略.........        if (signaled)        {            stop();        }        // check whether client has connected        if (connected())        {            // check for request            if (request(&message, &length))            {                // extract message's request-line                // http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html                const char* haystack = message;                const char* needle = strstr(haystack, "/r/n");                if (needle == NULL)                {                    error(500);                    continue;                }                char line[needle - haystack + 2 + 1];                strncpy(line, haystack, needle - haystack + 2);                line[needle - haystack + 2] = '/0';                // log request-line                printf("%s", line);                // parse request-line                char abs_path[LimitRequestLine + 1];                char query[LimitRequestLine + 1];                if (parse(line, abs_path, query))                {                    // URL-decode absolute-path                    char* p = urldecode(abs_path);                    if (p == NULL)                    {                        error(500);                        continue;                    }                    // resolve absolute-path to local path                    path = malloc(strlen(root) + strlen(p) + 1);                    if (path == NULL)                    {                        error(500);                        continue;                    }                    strcpy(path, root);                    strcat(path, p);                    free(p);                    // ensure path exists                    if (access(path, F_OK) == -1)                    {                        error(404);                        continue;                    }                    // if path to directory                    struct stat sb;                    if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode))                    {                        // redirect from absolute-path to absolute-path/                        if (abs_path[strlen(abs_path) - 1] != '/')                        {                            char uri[strlen(abs_path) + 1 + 1];