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

/*************************************************************函数名 makeSig**输入:   **          method 请求方法 "get" or "post"            url_path   openapi名称            params    请求参数            secret      密钥**输出:  **              **返回:  签名**描述: 生成签名**            **************************************************************/ string CSnsSigCheck::makeSig(string& method, string& url_path, map<string, string>& params, string& secret) {    string source;    transform(method.begin(),method.end(), method.begin(),::toupper);    source.append(method);    source.append("&");    source.append(url_encode(url_path));    source.append("&");    source.append(url_encode(join_params(params)));    char* p_sig = oauth_sign_hmac_sha1_raw(        source.c_str(),        source.size(),         secret.c_str(),        secret.size());        if (p_sig == NULL)        {            return "";        }        string sig = p_sig;;        delete [] p_sig;        p_sig = NULL;        return sig;}

int url_geturlpath(void* id, char* url, size_t len){	int i;	char buffer[MAX_PATH];	url_t* uri = (url_t*)id;	if(uri->path)	{		assert('/'==uri->path[0]);		strcpy(url, uri->path);	}	else	{		strcpy(url, "/");	}	for(i=0; i<uri->count; i++)	{		strcat(url, 0==i ? "?" : "&");		url_encode(uri->params[i].name, -1, buffer, sizeof(buffer));		strcat(url, buffer);		strcat(url, "=");		url_encode(uri->params[i].value, -1, buffer, sizeof(buffer));		strcat(url, buffer);	}	return 0;}

/** * Map rank request command */qboolean G_API_mapRank(char *result, gentity_t *ent, char *mapName, char *optUserName, char *optMapName, char *optRunName, char *optPhysicsName, char *authToken) {	char net_port[8]                = { 0 };	char cphysics[8]                = { 0 };	char encodedMapName[255]        = { 0 };	char encodedOptUserName[255]    = { 0 };	char encodedOptMapName[255]     = { 0 };	char encodedOptRunName[255]     = { 0 };	char encodedOptPhysicsName[255] = { 0 };	sprintf(net_port, "%d", trap_Cvar_VariableIntegerValue("net_port"));	sprintf(cphysics, "%d", physics.integer);	if (!check_string(optUserName) || !check_string(optMapName) || !check_string(optRunName) || !check_string(optPhysicsName)) {		return qfalse;	}	if (url_encode(mapName, encodedMapName) == qfalse ||	    url_encode(optUserName, encodedOptUserName) == qfalse ||	    url_encode(optMapName, encodedOptMapName) == qfalse ||	    url_encode(optRunName, encodedOptRunName) == qfalse ||	    url_encode(optPhysicsName, encodedOptPhysicsName) == qfalse) {		return qfalse;	}	// Check authtoken emptiness	if (authToken[0] == '/0') {		Q_strncpyz(authToken, "undefined", MAX_QPATH);	}	return G_AsyncAPICall("r", result, ent, 8, encodedOptUserName, encodedOptMapName, encodedOptRunName, encodedOptPhysicsName, encodedMapName, authToken, cphysics, net_port);}

/** * Checkpoints request command */qboolean G_API_getPlayerCheckpoints(char *result, gentity_t *ent, char *userName, char *mapName, char *runName, int runNum, char *authToken) {	char net_port[8]             = { 0 };	char bufferRunNum[8]         = { 0 };	char encodedMapName[255]     = { 0 };	char encodedOptUserName[255] = { 0 };	char encodedRunName[255]     = { 0 };	char cphysics[8]             = { 0 };	sprintf(net_port, "%d", trap_Cvar_VariableIntegerValue("net_port"));	sprintf(bufferRunNum, "%d", runNum);	sprintf(cphysics, "%d", physics.integer);	if (url_encode(mapName, encodedMapName) == qfalse ||	    url_encode(userName, encodedOptUserName) == qfalse ||	    url_encode(runName, encodedRunName) == qfalse) {		return qfalse;	}	// Check authtoken emptiness	if (authToken[0] == '/0') {		Q_strncpyz(authToken, "undefined", MAX_QPATH);	}	return G_AsyncAPICall("e", result, ent, 7, encodedMapName, encodedOptUserName, encodedRunName, bufferRunNum, authToken, cphysics, net_port);}

static sds signature(sds consumerSecret, sds accessTokenSecret, METHOD method, sds url, Parameters *params) {  sds query      = join_parameters(params, "&");  sds encodedCS  = url_encode(consumerSecret);  sds encodedATS = url_encode(accessTokenSecret);  sds key = sdscatprintf(sdsempty(), "%s&%s", encodedCS, encodedATS);  sds method_str;  if (method == POST) {    method_str = sdsnew("POST");  } else {    method_str = sdsnew("GET");  }  sds encodedURL    = url_encode(url);  sds encodedQuery  = url_encode(query);  sds base = sdscatprintf(sdsempty(), "%s&%s&%s", method_str, encodedURL, encodedQuery);  sds res  = hmac_sha1(key, base);  sds buf  = sdsgrowzero(sdsempty(), 256);  k64_encode (res, buf);  sdsfree(query);  sdsfree(encodedCS);  sdsfree(encodedATS);  sdsfree(key);  sdsfree(method_str);  sdsfree(encodedURL);  sdsfree(encodedQuery);  sdsfree(base);  sdsfree(res);  return sdsnewlen(buf, strlen(buf));}

INT64_T chirp_client_thirdput(struct chirp_client * c, const char *path, const char *hostname, const char *newpath, time_t stoptime){	char safepath[CHIRP_LINE_MAX];	char safenewpath[CHIRP_LINE_MAX];	url_encode(path, safepath, sizeof(safepath));	url_encode(newpath, safenewpath, sizeof(safenewpath));	return simple_command(c, stoptime, "thirdput %s %s %s/n", safepath, hostname, safenewpath);}

INT64_T chirp_client_link(struct chirp_client * c, const char *oldpath, const char *newpath, time_t stoptime){	char safeoldpath[CHIRP_LINE_MAX];	char safenewpath[CHIRP_LINE_MAX];	url_encode(oldpath, safeoldpath, sizeof(safeoldpath));	url_encode(newpath, safenewpath, sizeof(safenewpath));	return simple_command(c, stoptime, "link %s %s/n", safeoldpath, safenewpath);}

void    Network::transmitMsg(const QString& login,                             const QString& location,                             const QString& message){  QByteArray msg("user_cmd msg ");  msg.append("*:" + login);  msg.append("@*");  msg.append(url_encode(location.toStdString().c_str()));  msg.append("*");  msg.append(" msg ");  msg.append(url_encode(message.toStdString().c_str()));  msg.append('/n');  sendMessage(msg);}

static int append_values (var_str * q,const char * name, const db_val_t* v,		int n, int * started ){	int i;	if( v != NULL)	{		if( *started )			CHECK(append_const(q,"&"),0,error);		CHECK(append_const(q,(char*)name),0,error);		CHECK(append_const(q,"="),0,error);		for(i=0;i<n;i++)		{			CHECK(append_str(q,url_encode(value_to_string(&v[i]))),0,error);			if( i < n-1)				CHECK(append_const(q,val_delim_s),0,error);		}		*started = 1;	}	return 0;error:	return -1;}

static void xine_open_and_play(char * file){  int tmp;  if(file == NULL){    return;  }  char * tmp3 = malloc(((sizeof(char) * strlen(file) * 3)) + 1);  char * tmp2 = malloc(((sizeof(char) * strlen(file) * 3)) + 7);  if(file[0] == '/'){    url_encode(file, tmp3);    sprintf(tmp2, "file:/%s", tmp3);  }else{    sprintf(tmp2, "%s", file);  }  xine_close ( stream );  log_debug(tmp2);  free(tmp3);  if(!xine_open ( stream, tmp2)){    return;  }  free(tmp2);  if(!xine_play ( stream, 0, 0 )){    return;  }  int count = 0;  while ( !xine_get_pos_length ( stream, &tmp, &tmp, &length ) ) // The header file states: "probably because it's not known yet... try again later"  {	sleepTS.tv_sec = 0;	sleepTS.tv_nsec = 10000000;	nanosleep(&sleepTS,NULL); //Just try until you get some usefull info	count++;	if(count>5) break;    //log_debug("Sleeping");  }}

	std::string& CNetWriter::generatePostData()	{		s_strPostData = s_strUrl;		s_strPostData += "?d=";		//md5		//s_strUserData += "&pv2=1";		std::string strtemp = s_strUserData;				strtemp += s_md5Key;		md5 alg;		alg.Update((unsigned char*)strtemp.c_str(), strtemp.size());		alg.Finalize();		char * pMd5 = PrintMD5(alg.Digest());		std::string strSign;		if (pMd5)		{			strSign = pMd5;			free(pMd5);		}		std::string str = s_strUserData + "&sign=";		str += strSign.c_str(); 		char * pOut = new char[str.size() *3 + 1]; 		memset(pOut, 0, sizeof(char) * (str.size() *3 + 1)); 		url_encode((unsigned char*)str.c_str(), str.size(), pOut, str.size() *3); 		s_strPostData += pOut; 		delete []pOut;		return s_strPostData;	}

void _addreinfo_http(int solution_id) {	char reinfo[(1 << 16)], *rend;	char * reinfo_encode;	FILE *fp = fopen("error.out", "r");	rend = reinfo;	while (fgets(rend, 1024, fp)) {		rend += strlen(rend);		if (rend - reinfo > 40000)			break;	}	fclose(fp);	reinfo_encode=url_encode(reinfo);	FILE * re=fopen("re.post","w");	fprintf(re,"addreinfo=1&sid=%d&reinfo=%s",solution_id,reinfo_encode);	fclose(re);	free(reinfo_encode);	const char  * cmd=" wget --post-file=/"re.post/" --load-cookies=cookie --save-cookies=cookie --keep-session-cookies -q -O - /"%s/admin/problem_judge.php/"";	FILE * fjobs=read_cmd_output(cmd,http_baseurl);	//fscanf(fjobs,"%d",&ret);	pclose(fjobs);}

/** * Get config command */qboolean G_API_getConfig(void) {	char *buf                = NULL;	char net_port[8]         = { 0 };	char cphysics[8]         = { 0 };	char encodedMapName[255] = { 0 };	buf = malloc(LARGE_RESPONSE_MAX_SIZE * sizeof (char));	if (!buf) {		LDE("%s/n", "failed to allocate memory");		return qfalse;	}	sprintf(net_port, "%d", trap_Cvar_VariableIntegerValue("net_port"));	sprintf(cphysics, "%d", physics.integer);	if (url_encode(level.rawmapname, encodedMapName) == qfalse) {		free(buf);		return qfalse;	}	return G_SyncAPICall("o", buf, NULL, 4, encodedMapName, GAME_VERSION_DATED, cphysics, net_port);}

void maep_geonames_place_request(const gchar *request,                                 MaepGeonamesRequestCallback cb, gpointer obj) {  request_cb_t *context;  /* gconf_set_string("search_text", phrase); */  gchar *locale, lang[3] = { 0,0,0 };  locale = setlocale (LC_MESSAGES, NULL);  g_utf8_strncpy (lang, locale, 2);  /* build search request */  char *encoded_phrase = url_encode(request);  char *url = g_strdup_printf(	      GEONAMES "search?q=%s&maxRows=%u&lang=%s"	      "&isNameRequired=1&featureClass=P&username=" PACKAGE,	      encoded_phrase, MAX_RESULT, lang);  g_free(encoded_phrase);  /* request search results asynchronously */  g_message("start asynchronous place download (%s).", url);  context = g_malloc0(sizeof(request_cb_t));  context->cb = cb;  context->obj = obj;  net_io_download_async(url, geonames_request_cb, context);  g_free(url);}

static int append_ops(var_str * q,const char * name, const db_op_t* op,		int n, int * started ){	int i;	if( op != NULL)	{		if( *started )			CHECK(append_const(q,"&"),0,error);		CHECK(append_const(q,(char*)name),0,error);		CHECK(append_const(q,"="),0,error);		for(i=0;i<n;i++)		{			str tmp;			tmp.s = (char*)op[i];			tmp.len = strlen(tmp.s);			CHECK(append_str(q,url_encode(tmp)),0,error);			if( i < n-1)				CHECK(append_const(q,val_delim_s),0,error);		}		*started = 1;	}	return 0;error:	return -1;}

void maep_nominatim_address_request(const gchar *request,                                    MaepGeonamesRequestCallback cb, gpointer obj) {  request_cb_t *context;  /* gconf_set_string("search_text", phrase); */  gchar *locale, lang[3] = { 0,0,0 };  locale = setlocale (LC_MESSAGES, NULL);  g_utf8_strncpy (lang, locale, 2);  /* build search request */  char *encoded_phrase = url_encode(request);  char *url = g_strdup_printf(	      NOMINATIM "search?q=%s&format=xml&addressdetails=1", encoded_phrase);  g_free(encoded_phrase);  /* request search results asynchronously */  g_message("start asynchronous nominatim download (%s).", url);  context = g_malloc0(sizeof(request_cb_t));  context->cb = cb;  context->obj = obj;  net_io_download_async(url, geonames_request_cb, context);  g_free(url);}

static void cgi_write_cookies_recursive(FILE * f, prefix_tree_t * tree){	if(tree)	{		if(tree->data)		{			char * encode = url_encode(tree->data);			fprintf(f, " %s/n", encode);			free(encode);		}		else		{			int i;						for(i = 0; i < CHAR_RANGE; i++)			{				if(tree->table[i])				{					fputc((char)CHAR_MIN+i, f);					cgi_write_cookies_recursive(f, tree->table[i]);				}			}		}	}}

 client::response &request(const std::string &url,                           const T &body,                           const common::header_map &hdr=common::header_map(),                           unsigned max_redirection=std::numeric_limits<unsigned>::max()) {     if(prepare(url)) {         the_request_.method=http_method::POST;         // Default content type for HTML Forms         the_request_.set_content_type("application/x-www-form-urlencoded");         // Write URL encoded body into body stream         url_encode(body, std::ostreambuf_iterator<char>(the_request_.body_stream()));         if (!hdr.empty()) the_request_.headers.insert(hdr.begin(), hdr.end());         the_client_->send_request(the_request_, the_response_);         auto i=the_response_.headers.find("location");         if (max_redirection>0) {             if (static_cast<uint16_t>(the_response_.status_code) / 100 == 3                 && i != the_response_.headers.end()) {                 // 3xx redirect with "Location" header                 if (the_response_.status_code==http_status_code::TEMPORARY_REDIRECT) {                     // 307 needs to resend request with original method                     return request(i->second, body, hdr, max_redirection-1);                 } else {                     // Other 3xx uses "POST-Redirection-GET"                     return request(i->second, hdr, max_redirection-1);                 }             }         }     }     return the_response_; }

INT64_T chirp_client_getfile_buffer(struct chirp_client * c, const char *path, char **buffer, time_t stoptime){	INT64_T length;	INT64_T result;	char safepath[CHIRP_LINE_MAX];	url_encode(path, safepath, sizeof(safepath));	*buffer = 0;	length = simple_command(c, stoptime, "getfile %s/n", safepath);	if(length <= 0)		return length;	*buffer = malloc(length + 1);	if(!*buffer) {		c->broken = 1;		errno = ENOMEM;		return -1;	}	result = link_read(c->link, *buffer, length, stoptime);	if(result < 0) {		free(*buffer);		c->broken = 1;		return -1;	}	(*buffer)[length] = 0;	return result;}

INT64_T chirp_client_getlongdir(struct chirp_client * c, const char *path, chirp_longdir_t callback, void *arg, time_t stoptime){	char name[CHIRP_LINE_MAX];	struct chirp_stat info;	int result;	char safepath[CHIRP_LINE_MAX];	url_encode(path, safepath, sizeof(safepath));	result = simple_command(c, stoptime, "getlongdir %s/n", safepath);	if(result < 0)		return result;	while(link_readline(c->link, name, sizeof(name), stoptime)) {		if(!name[0])			return 0;		if(get_stat_result(c, &info, stoptime) >= 0) {			callback(name, &info, arg);		} else {			break;		}	}	c->broken = 1;	errno = ECONNRESET;	return -1;}

INT64_T chirp_client_openacl(struct chirp_client * c, const char *path, time_t stoptime){	char safepath[CHIRP_LINE_MAX];	url_encode(path, safepath, sizeof(safepath));	return simple_command(c, stoptime, "getacl %s/n", safepath);}

INT64_T chirp_client_audit(struct chirp_client * c, const char *path, struct chirp_audit ** list, time_t stoptime){	INT64_T result;	struct chirp_audit *entry;	int i, actual;	char line[CHIRP_LINE_MAX];	char safepath[CHIRP_LINE_MAX];	url_encode(path, safepath, sizeof(safepath));	result = simple_command(c, stoptime, "audit %s/n", safepath);	if(result <= 0)		return result;	*list = malloc(sizeof(struct chirp_audit) * result);	entry = *list;	for(i = 0; i < result; i++) {		actual = link_readline(c->link, line, sizeof(line), stoptime);		if(actual <= 0) {			free(*list);			result = -1;			errno = ECONNRESET;			break;		} else {			sscanf(line, "%s %" SCNd64 " %" SCNd64 " %" SCNd64 , entry->name, &entry->nfiles, &entry->ndirs, &entry->nbytes);		}		entry++;	}	return result;}

void send_stacktrace_by_curl(const char* rawStacktrace) {    const char *fileNameToSave = getenv("RANDOMTEST_FILE");    const char *url = getenv("RANDOMTEST_URL");    const char *version = getenv("RANDOMTEST_VERSION");    char encodedStacktrace[BUFSIZE];    if (fileNameToSave) {        FILE* f = fopen(fileNameToSave, "at");        fprintf(f, "%s", rawStacktrace);        fclose(f);    }    else {        fprintf(stderr, "%s", rawStacktrace);    }    /* no URL or empty value -> no reporting */    if (!url || url[0] == '/0') {        // fprintf(stderr, "WARN: RANDOMTEST_URL not set, crash reports skipped/n");        return;    }    char* buf_ptr = url_encode("stacktrace=", rawStacktrace, encodedStacktrace, encodedStacktrace + BUFSIZE);    *buf_ptr++ = '&';    if (version) {        buf_ptr = url_encode("version=", version, buf_ptr, encodedStacktrace + BUFSIZE);    }    CURL* handle = curl_easy_init();    curl_easy_setopt(handle, CURLOPT_URL, url);    curl_easy_setopt(handle, CURLOPT_POST, 1);    curl_easy_setopt(handle, CURLOPT_POSTFIELDS, encodedStacktrace);    /* Fix HTTP 417 error code */    struct curl_slist *list = NULL;    list = curl_slist_append(list, "Expect:");    curl_easy_setopt(handle, CURLOPT_HTTPHEADER, list);    CURLcode code = curl_easy_perform(handle);    if (code != 0) {        fprintf(stderr, "RTN: ERROR: %s call failed with error %d/n", url, code);        return;    }    curl_easy_cleanup(handle);}

void EmailService::getEmailConfigurations(App42CallBack* pTarget, SEL_App42CallFuncND pSelector){    App42EmailResponse *response = new App42EmailResponse::App42EmailResponse(pTarget,pSelector);        try    {        Util::throwExceptionIfTargetIsNull(pTarget, "Callback's Target");        Util::throwExceptionIfCallBackIsNull(pSelector, "Callback");    }    catch (App42Exception *e)    {        std::string ex = e->what();        response->httpErrorCode = e->getHttpErrorCode();        response->appErrorCode  = e->getAppErrorCode();        response->errorDetails  = ex;        response->isSuccess = false;        if (pTarget && pSelector)        {            (pTarget->*pSelector)((App42CallBack *)pTarget, response);        }        delete e;        e = NULL;        return;    }        string timestamp = Util::getTimeStamp();    /**     * Creating SignParams and signature     */    map<string, string> signParams;    populateSignParams(signParams);    string signature = Util::signMap(secretKey, signParams);        /**     * Creating URL     */    string resource = "email";	resource.append("/configuration");	string baseUrl = getBaseUrl(resource);    baseUrl.append("?");    string encodedUrl = url_encode(baseUrl);    // Util::app42Trace("/n baseUrl = %s",baseUrl.c_str());    // Util::app42Trace("/n createUserbody = %s",createUserbody.c_str());        /**     * Creating Headers     */    std::vector<std::string> headers;    map<string, string> metaHeaders;    populateMetaHeaderParams(metaHeaders);    Util::BuildHeaders(metaHeaders, headers);    Util::BuildHeaders(apiKey, timestamp, VERSION, signature, headers);        /**     * Initiating Http call     */    Util::executeGet(encodedUrl, headers, response, httpresponse_selector(App42UserResponse::onComplete));    }

voidmake_url(char *urlbuffer, struct ftpinfo *f, const char *dir){	char ftp_user_encoded[STRSIZE];	char ftp_dir_encoded[STRSIZE];	char *cp;	const char *dir2;	/*	 * f->pass is quite likely to contain unsafe characters	 * that need to be encoded in the URL (for example,	 * "@", ":" and "/" need quoting).  Let's be	 * paranoid and also encode f->user and f->dir.  (For	 * example, f->dir could easily contain '~', which is	 * unsafe by a strict reading of RFC 1738).	 */	if (strcmp("ftp", f->user) == 0 && f->pass[0] == 0) {		ftp_user_encoded[0] = 0;	} else {		cp = url_encode(ftp_user_encoded, f->user,			ftp_user_encoded + sizeof ftp_user_encoded - 1,			RFC1738_SAFE_LESS_SHELL, 0);		*cp++ = ':';		cp = url_encode(cp, f->pass,			ftp_user_encoded + sizeof ftp_user_encoded - 1,			NULL, 0);		*cp++ = '@';		*cp = 0;	}	cp = url_encode(ftp_dir_encoded, f->dir,			ftp_dir_encoded + sizeof ftp_dir_encoded - 1,			RFC1738_SAFE_LESS_SHELL_PLUS_SLASH, 1);	if (cp != ftp_dir_encoded && cp[-1] != '/')		*cp++ = '/';	dir2 = dir;	while (*dir2 == '/')		++dir2;	url_encode(cp, dir2,			ftp_dir_encoded + sizeof ftp_dir_encoded,			RFC1738_SAFE_LESS_SHELL_PLUS_SLASH, 0);	snprintf(urlbuffer, STRSIZE, "%s://%s%s/%s", f->xfer_type,	    ftp_user_encoded, f->host, ftp_dir_encoded);}

INT64_T chirp_client_lremovexattr(struct chirp_client *c, const char *path, const char *name, time_t stoptime){	char safepath[CHIRP_LINE_MAX];	url_encode(path, safepath, sizeof(safepath));	INT64_T result = simple_command(c, stoptime, "lremovexattr %s %s/n", safepath, name);	if (result == -1 && errno == EINVAL) errno = ENOATTR;	return result;}

sp_link *sp_link_create_from_search(sp_search *search){  char *uri_encoded = url_encode(search->query);  char *uri = ALLOC_STR(strlen("spotify:search:") + strlen(uri_encoded));  sprintf(uri, "spotify:search:%s", uri_encoded);  return sp_link_create_from_string(uri);}

/** * Record send command */qboolean G_API_sendRecord(char *result, gentity_t *ent, char *mapName, char *runName,                          char *authToken, char *data, char *etrunVersion) {	char net_port[8]         = { 0 };	char cphysics[8]         = { 0 };	char encodedMapName[255] = { 0 };	char encodedRunName[255] = { 0 };	sprintf(net_port, "%d", trap_Cvar_VariableIntegerValue("net_port"));	sprintf(cphysics, "%d", physics.integer);	if (url_encode(mapName, encodedMapName) == qfalse ||	    url_encode(runName, encodedRunName) == qfalse) {		return qfalse;	}	return G_AsyncAPICall("d", result, ent, 7, encodedMapName, encodedRunName, authToken, data, etrunVersion, cphysics, net_port);}

	lfl_string as_loadvars::create_request(const lfl_string& method, const lfl_string& uri, bool send_data)	{		lfl_string information;		//create information in the form of name=value (urlencoded)		string_hash<lfl_string>::iterator it = m_values.begin();		for(bool first = true; it != m_values.end(); ++it)		{			lfl_string name, value;			name = it->first;			value = it->second;			url_encode( &name );			url_encode( &value );			information += string_printf("%s%s=%s", first? "":"&",name.c_str(), value.c_str() );			first = false;		}		if( method == "POST")		{			lfl_string request = string_printf( "POST %s HTTP/1.1/r/n", uri.c_str() );			m_headers.set("Content-Length", string_printf( "%i", information.size()));			request += create_header();			request += "/r/n";			request += information;			return request;		}		else if(method == "GET")		{			lfl_string request = string_printf( "GET %s?%s HTTP/1.1/r/n", uri.c_str(), information.c_str() );			request += create_header();			request += "/r/n";			return request;		}		else		{			assert(0 && "unsupported");		}		return "";	}

void GameService::GetAllGamesCount(App42CallBack* pTarget, SEL_App42CallFuncND pSelector){    App42GameResponse *response = new App42GameResponse(pTarget,pSelector);        try    {        Util::throwExceptionIfTargetIsNull(pTarget, "Callback's Target");        Util::throwExceptionIfCallBackIsNull(pSelector, "Callback");    }    catch (App42Exception *e)    {        std::string ex = e->what();        response->httpErrorCode = e->getHttpErrorCode();        response->appErrorCode  = e->getAppErrorCode();        response->errorDetails  = ex;        response->isSuccess = false;        if (pTarget && pSelector)        {            (pTarget->*pSelector)((App42CallBack *)pTarget, response);        }        delete e;        e = NULL;        return;    }        string timestamp = Util::getTimeStamp();        /**     * Creating SignParams and signature     */    map<string, string> signParams;	Util::BuildGetSigningMap(apiKey, timestamp, VERSION, signParams);	string signature = Util::signMap(secretKey, signParams);        /**     * Creating URL     */    string resource = "game/";    resource.append("count");	string url = getBaseUrl(resource);    url.append("?");    string encodedUrl = url_encode(url);    /**     * Creating Headers     */    std::vector<std::string> headers;    map<string, string> metaHeaders;    populateMetaHeaderParams(metaHeaders);    Util::BuildHeaders(metaHeaders, headers);    Util::BuildHeaders(apiKey, timestamp, VERSION, signature, headers);        /**     * Initiating Http call     */    Util::executeGet(encodedUrl,headers, response, app42response_selector(App42GameResponse::onComplete));    }