/**
* URL encodes the input string.
* @param QString input
* @returns QString
* @author John M. Harris, Jr.
*/
QString HttpService::UrlEncode(QString input){
CURL* curl;
curl = curl_easy_init();
if(curl){
char* encoded = curl_easy_escape(curl, input.toStdString().c_str(), 0);
size_t thingLen = strlen(encoded) + 1;
char* newGuy = new char[thingLen];
strcpy(newGuy, encoded);
//newGuy[thingLen] = '\0';
curl_free(encoded);
curl_easy_cleanup(curl);
return QString(newGuy);
}
return "";
}
int test(char *URL)
{
unsigned char a[] = {0x2f, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x91, 0xa2, 0xb3, 0xc4, 0xd5, 0xe6, 0xf7};
CURLcode res;
CURL *curl;
int asize;
char *str = NULL;
(void)URL;
res = curl_global_init_mem(CURL_GLOBAL_ALL,
custom_malloc,
custom_free,
custom_realloc,
custom_strdup,
custom_calloc);
if (res != CURLE_OK) {
fprintf(stderr, "curl_global_init_mem() failed\n");
return TEST_ERR_MAJOR_BAD;
}
if ((curl = curl_easy_init()) == NULL) {
fprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
test_setopt(curl, CURLOPT_USERAGENT, "test509"); /* uses strdup() */
asize = (int)sizeof(a);
str = curl_easy_escape(curl, (char *)a, asize); /* uses realloc() */
test_cleanup:
if(str)
curl_free(str);
curl_easy_cleanup(curl);
curl_global_cleanup();
return (int)res;
}
bool
http_post(const char *url, http_response_t *resp, int pairs, ...)
{
CURL *curl;
CURLcode res;
int i, len=0;
char *k[pairs], *v[pairs], *vv[pairs];
va_list params;
va_start(params, pairs);
for (i=0; i<pairs; i++) {
k[i] = va_arg(params, char *);
v[i] = va_arg(params, char *);
vv[i]= curl_easy_escape(curl, v[i], 0);
tlog(DEBUG, "http post: %s = %s(%s)", k[i], v[i], vv[i]);
len += 4+strlen(k[i])+strlen(vv[i]);
}
va_end(params);
char data[len];
memset(data, 0, len);
for (i=0; i<pairs; i++) {
strcat(data, "&");
strcat(data, k[i]);
strcat(data, "=");
strcat(data, vv[i]);
curl_free(vv[i]);
}
tlog(DEBUG, "http post: data = %s", data);
curl = curl_easy_init();
if (curl != NULL) {
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_memory_cb);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)resp);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
return res==CURLE_OK;
}
return false;
}
void CPushPlayerInfoHttpCMD::EscapeUrl(CHAR szUrl[], UINT16 wLen)
{
UINT8 abyDigest[16] = {0};
string strInput = m_strfields;
strInput.append(CENTER_SIGN);
SDMD5(abyDigest, (UINT8*)strInput.c_str(), strInput.length());
CHAR szTemp[32] = {0};
CHAR szHexDigest[256] = {0};
for (UINT8 byIdx = 0; byIdx < 16; byIdx++)
{
sprintf(szTemp, "%02x", (UINT8)abyDigest[byIdx]);
strcat(szHexDigest, szTemp);
}
char *szEscapeHex = curl_easy_escape(m_pEasyHandle, szHexDigest, 0);;
SDSnprintf(szUrl, wLen, "%s?_sig=%s", m_strUrl.c_str(), szEscapeHex);
curl_free(szEscapeHex);
}
/* Extracts the name portion of the URL.
* Returns a pointer to a heap-allocated string or NULL if
* no name part, at location indicated by first argument.
*/
CURLcode get_url_file_name(char **filename, const char *url)
{
const char *pc;
*filename = NULL;
/* Find and get the remote file name */
pc = strstr(url, "://");
if(pc)
pc += 3;
else
pc = url;
pc = strrchr(pc, '/');
if(pc) {
/* duplicate the string beyond the slash */
pc++;
if(*pc) {
*filename = strdup(pc);
if(!*filename)
return CURLE_OUT_OF_MEMORY;
}
}
/* in case we built debug enabled, we allow an environment variable
* named CURL_TESTDIR to prefix the given file name to put it into a
* specific directory
*/
#ifdef DEBUGBUILD
{
char *tdir = curlx_getenv("CURL_TESTDIR");
if(tdir) {
char buffer[512]; /* suitably large */
snprintf(buffer, sizeof(buffer), "%s/%s", tdir, *filename);
Curl_safefree(*filename);
*filename = strdup(buffer); /* clone the buffer */
curl_free(tdir);
}
}
#endif
return CURLE_OK;
}
char *
http_client_uri_escape(const char *src)
{
#if GLIB_CHECK_VERSION(2,16,0)
/* if GLib is recent enough, prefer that over CURL
functions */
return g_uri_escape_string(src, NULL, false);
#else
/* curl_escape() is deprecated, but for some reason,
curl_easy_escape() wants to have a CURL object, which we
don't have right now */
char *tmp = curl_escape(src, 0);
/* call g_strdup(), because the caller expects a pointer which
can be freed with g_free() */
char *dest = g_strdup(tmp == NULL ? src : tmp);
curl_free(tmp);
return dest;
#endif
}
static const char *make_url(const request_rec *r, const crowd_config *config, CURL *curl_easy, const char *user,
const char *format) {
char *url;
if (user == NULL) {
url = apr_psprintf(r->pool, format, config->crowd_url);
} else {
char *encoded_user = log_ralloc(r, curl_easy_escape(curl_easy, user, 0));
if (encoded_user == NULL) {
return NULL;
}
url = apr_psprintf(r->pool, format, config->crowd_url, encoded_user);
curl_free(encoded_user);
}
log_ralloc(r, url);
if (url == NULL) {
return NULL;
}
return url;
}
PCS_API char *pcs_http_build_post_data_v(PcsHttp handle, va_list args)
{
struct pcs_http *http = (struct pcs_http *)handle;
char *name, *val,
*escapval, *res = NULL, *p;
int ressz;
while((name = va_arg(args, char *)) != NULL) {
val = va_arg(args, char *);
if (name[0] == '\0') continue;
escapval = curl_easy_escape(http->curl, val, 0);
if (!res) {
ressz = strlen(name) + strlen(escapval) + 1;
res = (char *)pcs_malloc(ressz + 1);
if (!res) {
return NULL;
}
strcpy(res, name);
strcat(res, "=");
strcat(res, escapval);
}
else {
ressz += strlen(name) + strlen(escapval) + 2;
p = (char *)pcs_malloc(ressz + 1);
if (!p) {
pcs_free(res);
return NULL;
}
strcpy(p, res);
pcs_free(res);
res = p;
strcat(res, "&");
strcat(res, name);
strcat(res, "=");
strcat(res, escapval);
}
curl_free((void *)escapval);
}
return res;
}
bool LLWLParamManager::removeParamSet(const std::string& name, bool delete_from_disk)
{
// remove from param list
std::map<std::string, LLWLParamSet>::iterator mIt = mParamList.find(name);
if(mIt != mParamList.end())
{
mParamList.erase(mIt);
}
F32 key;
// remove all references
bool stat = true;
do
{
// get it
stat = mDay.getKey(name, key);
if(stat == false)
{
break;
}
// and remove
stat = mDay.removeKey(key);
} while(stat == true);
if(delete_from_disk)
{
std::string path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/skies", ""));
// use full curl escaped name
char * curl_str = curl_escape(name.c_str(), name.size());
std::string escaped_name(curl_str);
curl_free(curl_str);
curl_str = NULL;
gDirUtilp->deleteFilesInDir(path_name, escaped_name + ".xml");
}
return true;
}
bool
http_escape(const char *in, char *out)
{
char *res = NULL;
CURL *curl;
bool ret = false;
curl = curl_easy_init();
if (curl != NULL) {
res = curl_easy_escape(curl, in, 0);
if (res != NULL) {
memcpy(out, res, strlen(res)+1);
ret = true;
curl_free(res);
}
curl_easy_cleanup(curl);
return ret;
}
return false;
}
/* exported interface documented in utils/url.h */
nserror url_unescape(const char *str, int length, char **result)
{
char *curlstr;
char *retstr;
curlstr = curl_unescape(str, length);
if (curlstr == NULL) {
return NSERROR_NOMEM;
}
retstr = strdup(curlstr);
curl_free(curlstr);
if (retstr == NULL) {
return NSERROR_NOMEM;
}
*result = retstr;
return NSERROR_OK;
}
void LLWLDayCycle::saveDayCycle(const std::string & fileName)
{
// bugfix for SL-46920: preventing filenames that break stuff.
char * curl_str = curl_escape(fileName.c_str(), fileName.size());
std::string escaped_filename(curl_str);
curl_free(curl_str);
curl_str = NULL;
escaped_filename += ".xml";
std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/days", escaped_filename));
llinfos << "Saving Day Cycle preset from " << pathName << llendl;
llofstream day_cycle_xml;
day_cycle_xml.open(pathName.c_str());
// That failed, try loading from the users area instead.
if(!day_cycle_xml)
{
pathName=gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight/days", escaped_filename);
llinfos << "Saving User Day Cycle preset from " << pathName << llendl;
day_cycle_xml.open(pathName.c_str());
}
LLSD day_data(LLSD::emptyArray());
for(std::map<F32, std::string>::const_iterator mIt = mTimeMap.begin();
mIt != mTimeMap.end();
++mIt)
{
LLSD key(LLSD::emptyArray());
key.append(mIt->first);
key.append(mIt->second);
day_data.append(key);
}
LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
formatter->format(day_data, day_cycle_xml, LLSDFormatter::OPTIONS_PRETTY);
day_cycle_xml.close();
}
int
curl_url_encoding(CURL *curl, char *input, char *output, size_t size)
{
ol_log_func ();
char *escp;
int flag = 0;
if(curl == NULL) {
curl = curl_easy_init();
flag = 1;
}
/*
* convert to GBK, this should be done before this function called
*
char buf[BUFSZ];
iconv_t icv;
if(charset != NULL)
icv = iconv_open("GBK", charset);
else
icv = iconv_open("GBK", "UTF-8");
convert_icv(&icv, input, strlen(input), buf, BUFSZ);
iconv_close(icv);
*/
escp = curl_easy_escape(curl, input, 0);
if(escp == NULL) {
ol_errorf ("curl_easy_escape error.\n");
return -1;
}
if(strlen(escp) > size) {
errno = E2BIG; /* identify that buffer storing the result is too small */
return -1;
}
strcpy(output, escp);
curl_free(escp);
if(flag == 1)
curl_easy_cleanup(curl);
return 0;
}
int viprinet_status_connect(viprinet_status_t *status)
{
char *password_encoded;
char uri[MAX_URI_LEN];
int rc;
pthread_attr_t ptattr;
if (status == NULL) {
return -1;
}
if (status->close != -1) {
return -1;
}
password_encoded = curl_easy_escape(status->curl, status->password, 0);
snprintf(uri, MAX_URI_LEN,
"http://%s/exec?module=interfacestats&action=data&group=ModuleSlots&nick=root&pass=%s",
status->hostname,
password_encoded);
curl_free(password_encoded);
status->close = 0;
curl_easy_setopt(status->curl, CURLOPT_URL, uri);
curl_easy_setopt(status->curl, CURLOPT_NOPROGRESS, 0);
curl_easy_setopt(status->curl, CURLOPT_PROGRESSDATA, status);
curl_easy_setopt(status->curl, CURLOPT_PROGRESSFUNCTION, &progress_callback);
curl_easy_setopt(status->curl, CURLOPT_WRITEFUNCTION, &write_callback);
curl_easy_setopt(status->curl, CURLOPT_WRITEDATA, status);
pthread_attr_init(&ptattr);
pthread_attr_setdetachstate(&ptattr, PTHREAD_CREATE_JOINABLE);
rc = pthread_create(status->thread, &ptattr, &perform, (void *)status);
pthread_attr_destroy(&ptattr);
if (rc) {
return -2;
}
return 0;
}
void wswcurl_urlencode( const char *src, char *dst, size_t size )
{
char *curl_esc;
assert( src );
assert( dst );
if( !src || !dst ) {
return;
}
// libcurl needs a curl pointer to be passed to a function that
// should clearly be "static", how inconvenient...
if( !curldummy ) {
curldummy = curl_easy_init();
}
curl_esc = curl_easy_escape( curldummy, src, 0 );
Q_strncpyz( dst, curl_esc, size );
curl_free( curl_esc );
}
std::string Authorization::sort_params(std::map<std::string ,std::string> ¶ms)
{
stringstream qs;
CURL *curl = curl_easy_init();
char *value;
for (std::map<std::string,std::string>::iterator it=params.begin(); it!=params.end(); ++it)
{
//Some parse and safety check left refer auth_handler.py
// utf encoding on values left
//url encoding
value = curl_easy_escape(curl,it->second.c_str(),0);
qs<<it->first<<"="<<value<<"&";
}
string qs_ = qs.str();
qs_[qs_.length()-1]='\0'; //removing last &
curl_free(value);
return qs_;
}
// out should be enough to hold result
bool
http_unescape(const char *in, char *out)
{
int len = -1;
char *res = NULL;
CURL *curl;
bool ret = false;
curl = curl_easy_init();
if (curl != NULL) {
res = curl_easy_unescape(curl, in, 0, &len);
if (res != NULL && len > 0) {
memcpy(out, res, len+1);
ret = true;
}
if (res != NULL) curl_free(res);
curl_easy_cleanup(curl);
return ret;
}
return false;
}
static int url_encoding(lua_State* l)
{
struct webclient* webclient = (struct webclient*)luaL_checkudata(l, 1, LUA_WEB_CLIENT_MT);
if (!webclient)
return luaL_argerror(l, 1, "parameter self invalid");
if (!webclient->encoding_curl)
webclient->encoding_curl = curl_easy_init();
size_t length = 0;
const char* str = lua_tolstring(l, 2, &length);
char* ret = curl_easy_escape(webclient->encoding_curl, str, (int)length);
if (!ret) {
lua_pushlstring(l, str, length);
return 1;
}
lua_pushstring(l, ret);
curl_free(ret);
return 1;
}
/* 下载单个文件 */
void BaiduPCS_Download(BaiduPCS *api, const char *remote_file, FILE *local_fp) {
//{{{
if (remote_file == NULL || local_fp == NULL) return;
HttpClient *client = api->client;
char *url_buffer = api->util_buffer0;
const char *token = api->token;
const char *error = NULL;
char *remote_path_encode = NULL;
BaiduPCS_ResetError(api);
remote_path_encode = curl_easy_escape(client->curl, remote_file, 0);
sprintf(url_buffer, "https://d.pcs.baidu.com/rest/2.0/pcs/file?"
"access_token=%s"
"&method=download"
"&path=%s", token, remote_path_encode);
curl_free(remote_path_encode);
remote_path_encode = NULL;
#ifdef DEBUG
fprintf(stderr, "request %s\n", url_buffer);
#endif
HttpClient_Init(client);
HttpClient_SetFailRetry(client, 0, 0);
curl_easy_setopt(client->curl, CURLOPT_WRITEFUNCTION, _BaiduPCS_Download_WriteData);
curl_easy_setopt(client->curl, CURLOPT_WRITEDATA, local_fp);
/* 跟随重定向 */
curl_easy_setopt(client->curl, CURLOPT_FOLLOWLOCATION, 1);
/* 下载木有超时 */
curl_easy_setopt(client->curl, CURLOPT_TIMEOUT, 0);
HttpClient_Get(client, url_buffer);
error = HttpClient_GetError(client);
if (error != NULL) {
BaiduPCS_ThrowError(api, "http request failed: %s", error);
}
}
static void *
uim_curl_url_escape_internal(void *url_)
{
uim_lisp escaped_url_;
const char *unescaped_url = REFER_C_STR((uim_lisp)url_);
char *escaped_url;
CURL *curl;
curl = curl_easy_init();
if(curl == NULL)
return uim_scm_f();
escaped_url = curl_easy_escape(curl, unescaped_url, strlen(unescaped_url));
escaped_url_ = (escaped_url != NULL) ? MAKE_STR(escaped_url) : uim_scm_f();
curl_free(escaped_url);
curl_easy_cleanup(curl);
curl_global_cleanup();
return (void *)escaped_url_;
}
void format_query(char *query_str, char *result) {
char *escaped;
CURL *curl = curl_easy_init();
char *token = strtok(query_str, ",;?!-_ \n\r");
while (token != NULL) {
escaped = curl_easy_escape(curl, token, strlen(token));
strcpy(result + strlen(result), escaped);
strcpy(result + strlen(result), "+");
token = strtok(NULL, ",.:;?!-_ ");
curl_free(escaped);
}
result[strlen(result) - 1] = '\0';
curl_easy_cleanup(curl);
}
int AsyncHttpRequest::getMethodSend(const char *data,char *recv,const char *url)
{
std::string request(url);
CURL* easy_handle=curl_easy_init();
char *encodedURL = curl_easy_escape(easy_handle,data, strlen(data));
request.append(encodedURL);
//struct curl_slist *header=NULL;
//header= curl_slist_append(header,request.c_str());
if(m_pInstance->enableDebug)
curl_easy_setopt(easy_handle, CURLOPT_VERBOSE,1L);/*open comment when debug mode.*/
CallbackData *cba = (CallbackData*)malloc(sizeof(CallbackData));
cba->buffer = (char*)malloc(100000);
cba->position = 0;
curl_easy_setopt(easy_handle,CURLOPT_URL,request.c_str());
//curl_easy_setopt(easy_handle,CURLOPT_HTTPHEADER,header);
curl_easy_setopt(easy_handle,CURLOPT_HTTP_TRANSFER_DECODING,1);
curl_easy_setopt(easy_handle,CURLOPT_WRITEFUNCTION,postWriteData);//receive callback function
curl_easy_setopt(easy_handle,CURLOPT_WRITEDATA,cba);
CURLcode code=curl_easy_perform(easy_handle);//
memcpy(recv,cba->buffer,cba->position);
free(cba->buffer);
free(cba);
//curl_slist_free_all(header);
curl_easy_cleanup(easy_handle);
curl_free(encodedURL);
return code;
}
void AnalyticsManager::logEventToServer(const char* serverURL, const char* eventCategory, const char* eventType, const char* eventLabel, int eventValue)
{
CURL* curl = curl_easy_init();
CURLcode res;
// construct the postfields using much string math
char postfields[512] = "";
sprintf_s(postfields, 512, "v=%d&tid=%s&an=%s&cid=%s&t=%s&ec=%s&ea=%s&debug=%d", 1, TRACKING_ID, TRACKING_APP_NAME, clientID, "event", eventCategory, eventType, isDebugMode);
if ( eventLabel[0] != 0 )
{
char* tempEncode = curl_easy_escape(curl, eventLabel, strlen(eventLabel));
strcat_s(postfields, 512, "&el=");
strcat_s(postfields, 512, tempEncode);
curl_free(tempEncode);
}
if ( eventValue != -1 )
{
char tempEncode[128] = "";
_itoa_s(eventValue, tempEncode, 64, 10);
strcat_s(postfields, 512, "&ev=");
strcat_s(postfields, 512, tempEncode);
}
// post the data using curl
if ( curl )
{
// post to Google Analytics first
curl_easy_setopt(curl, CURLOPT_URL, serverURL);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields);
res = curl_easy_perform(curl);
if (res != CURLE_OK)
{
al_trace("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
}
curl_easy_cleanup(curl);
}
}
void SmsGateway::sendSms(std::string &id, std::string &value)
{
if (type_m == Clickatell)
{
#ifdef HAVE_LIBCURL
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if(curl)
{
char *escaped_value = curl_escape(value.c_str(), value.length());
std::stringstream msg;
msg << "http://api.clickatell.com/http/sendmsg?user="******"&password="******"&api_id=" << data_m;
if (!from_m.empty())
msg << "&from=" << from_m;
msg << "&to=" << id << "&text=" << escaped_value;
std::string url = msg.str();
curl_free(escaped_value);
// curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
res = curl_easy_perform(curl);
logger_m.infoStream() << "curl_easy_perform returned: " << res << endlog;
if (res != 0)
logger_m.infoStream() << "msg=" << curl_easy_strerror(res) << endlog;
curl_easy_cleanup(curl);
}
else
logger_m.errorStream() << "Unable to execute SendSmsAction. Curl not available" << endlog;
#endif
}
else
logger_m.errorStream() << "Unable to send SMS, gateway not set." << endlog;
}
static int get_url(void)
{
int i;
CURLUcode rc;
int error = 0;
for(i = 0; get_url_list[i].in && !error; i++) {
char *url = NULL;
CURLU *urlp = curl_url();
if(!urlp) {
error++;
break;
}
rc = curl_url_set(urlp, CURLUPART_URL, get_url_list[i].in,
get_url_list[i].urlflags);
if(!rc) {
rc = curl_url_get(urlp, CURLUPART_URL, &url, get_url_list[i].getflags);
if(rc) {
fprintf(stderr, "%s:%d returned %d\n",
__FILE__, __LINE__, (int)rc);
error++;
}
else {
if(checkurl(url, get_url_list[i].out)) {
error++;
}
}
}
else if(rc != get_url_list[i].ucode) {
fprintf(stderr, "Get URL\nin: %s\nreturned %d (expected %d)\n",
get_url_list[i].in, (int)rc, get_url_list[i].ucode);
error++;
}
curl_free(url);
curl_url_cleanup(urlp);
}
return error;
}
char *url_to_path(const char *url)
{
char *tmps, *unesc;
CURL *curl;
tmps = strstr(url, "///localhost/") + 13;
if(tmps < url) tmps = strstr(url,"///") + 3;
if(tmps >= url)
{
if(curl = curl_easy_init())
{
unesc = curl_easy_unescape(curl,tmps,0,NULL);
tmps = strdup(unesc);
curl_free(unesc);
curl_easy_cleanup(curl);
return tmps;
}
}
return strdup((char *)url);
}
void CPushPlayerInfoHttpCMD::EscapeFields()
{
CNGString strTemp;
char *szEscape = NULL;
m_strfields.append("playerid=");
strTemp = m_stPlayerInfo.dwPlayerID;
szEscape = curl_easy_escape(m_pEasyHandle, strTemp.c_str(), 0);
m_strfields.append(szEscape);
curl_free(szEscape);
m_strfields.append("&level=");
strTemp = m_stPlayerInfo.wLevel;
szEscape = curl_easy_escape(m_pEasyHandle, strTemp.c_str(), 0);
m_strfields.append(szEscape);
curl_free(szEscape);
m_strfields.append("&careerid=");
strTemp = m_stPlayerInfo.wCoachHeroID;
szEscape = curl_easy_escape(m_pEasyHandle, strTemp.c_str(), 0);
m_strfields.append(szEscape);
curl_free(szEscape);
m_strfields.append("&viplevel=");
strTemp = m_stPlayerInfo.byVipLv;
szEscape = curl_easy_escape(m_pEasyHandle, strTemp.c_str(), 0);
m_strfields.append(szEscape);
curl_free(szEscape);
m_strfields.append("&_ch=");
strTemp = m_stPlayerInfo.byAuthType;
szEscape = curl_easy_escape(m_pEasyHandle, strTemp.c_str(), 0);
m_strfields.append(szEscape);
curl_free(szEscape);
m_strfields.append("&name=");
szEscape = curl_easy_escape(m_pEasyHandle, m_stPlayerInfo.strNickName.c_str(), 0);
if(NULL == szEscape)
{
SYS_CRITICAL( _SDT( "[%s: %d]: curl_easy_escape playerid[%u] nickname [%s] failed"), MSG_MARK,
m_stPlayerInfo.dwPlayerID, m_stPlayerInfo.strNickName.c_str());
}
m_strfields.append(szEscape);
curl_free(szEscape);
}
// "inworldz://simname/x/y/z" -> "simname/x/y/z"
// (actually .*//foo -> foo)
// static
void LLURLSimString::setString(const std::string& sim_string)
{
sInstance.mSimString.clear();
sInstance.mSimName.clear();
sInstance.mParseState = NOT_PARSED;
if (sim_string == sLocationStringHome)
{
gSavedSettings.setBOOL("LoginLastLocation", FALSE);
}
else if (sim_string == sLocationStringLast)
{
gSavedSettings.setBOOL("LoginLastLocation", TRUE);
}
else
{
char* curlstr = curl_unescape(sim_string.c_str(), sim_string.size());
std::string tstring = std::string(curlstr);
curl_free(curlstr);
std::string::size_type idx = tstring.find("//");
idx = (idx == std::string::npos) ? 0 : idx+2;
sInstance.mSimString = tstring.substr(idx);
}
}
void AppWindow::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& selection_data, guint info, guint time)
{
// this is totally ridiculous, but so be it!
// we erase the protocol in front of the filename
// using std::string because Glib::ustring throws a conversion error for some reason
std::string string_filename = selection_data.get_data_as_string();
string_filename.erase(0, string_filename.find(':')+3);
//convert to char* and unescape
char * temp_filename = curl_unescape( string_filename.c_str(), 0);
string_filename = temp_filename;
// curl requires this to be freed
curl_free( temp_filename );
//let's remove any \n and \r that are typical of URI's
if ( string_filename.find('\n') != Glib::ustring::npos )
string_filename.erase( string_filename.find('\n'), 1 );
if ( string_filename.find('\r') != Glib::ustring::npos )
string_filename.erase( string_filename.find('\r'), 1 );
open_new_file( string_filename );
context->drag_finish(false, false, time);
}
/* Send a GET request to write *data (after url encoding) to *url
* Sends request to influx host defined in conn. Returns resulting CURLcode.
*/
CURLcode sendGet(influxConn *conn, char *url, char *data){
CURL *curl = conn->curl;
CURLcode resultCode;
if(curl){
if(data){ //urlencode data
char *encoded_data = curl_easy_escape(curl, data, strlen(data));
url = realloc(url, sizeof(char *) * ((int) strlen(url) + strlen(encoded_data) + 1) );
if(url){
strncat(url, encoded_data, strlen(encoded_data));
curl_free(encoded_data);
}
}
if(influx_debug){printf("[q: %s]\n", url);}
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, conn);
resultCode = curl_easy_perform(curl);
}
free(url);
return resultCode;
}
