/***********************************************************
**函数名 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="******"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));
}
void
make_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));
}
