/* parse a cgi query string returning one key-value pair at a time */
bool qstring_next_pair(const char *qstring, char *buf, char **vbuf, uint32_t buflen) {
static const char *q = NULL;
char *eob;
// set up if not currently working on a qstring
if (q == NULL)
q = qstring;
if (*q == '\0') {
q = NULL; // set internal state (no work in progress)
return false; // signal this query string is fully parsed
}
eob = buf + buflen - 1;
*vbuf = buf; // in case there is no '='
while (*q != '\0') {
if (buf >= eob) // check for buffer overflow
break;
if (*q == '=') {
*buf++ = '\0';
*vbuf = buf;
++q;
} else if (*q == '&') {
++q;
break;
} else {
*buf++ = *q++;
}
}
*buf = '\0'; // terminate value string
url_decode(buf);
if (*vbuf != buf)
url_decode(*vbuf);
return true;
}
static int url_parse_param(const char* param, url_t* uri)
{
const char *pn, *pv;
char buffer[MAX_PATH];
url_param_t *pp;
for(pn = param; param && *param && uri->count < MAX_PARAMS; pn=param+1)
{
param = strchr(pn, '&');
pv = strchr(pn, '=');
if(!pv || pv == pn || (param && pv>param)) // name is null
continue;
memset(buffer, 0, sizeof(buffer));
pp = &uri->params[uri->count++];
url_decode(pn, pv-pn, buffer, sizeof(buffer));
pp->name = strdup(buffer);
++pv;
if(param)
{
url_decode(pv, param-pv, buffer, sizeof(buffer));
}
else
{
url_decode(pv, -1, buffer, sizeof(buffer));
}
pp->value = strdup(buffer);
}
return 0;
}
void http_alarm(char *rx, unsigned int rx_len)
{
unsigned int i, save;
char *time, *item;
ALARMTIME t;
save=0;
time=0; item=0;
for(; rx_len!=0;)
{
if(strncmpi(rx, "time=", 5) == 0)
{ rx += 5; rx_len -= 5; time = rx; i = url_decode(rx, rx, rx_len); rx += i; rx_len -= i; }
else if(strncmpi(rx, "item=", 5) == 0)
{ rx += 5; rx_len -= 5; item = rx; i = url_decode(rx, rx, rx_len); rx += i; rx_len -= i; }
else if(strncmpi(rx, "save=", 5) == 0)
{ rx += 5; rx_len -= 5; save = 1; }
else
{ rx++; rx_len--; }
}
if(save && time && item)
{
if((strlen(time) > 3) || (strlen(item) > 0))
{
i = atoi(item);
alarm_parsetime(time, &t);
alarm_settime(i, &t);
alarm_load();
menu_drawwnd(1);
}
}
return;
}
static void parse_get( value *p, const char *args ) {
char *aand, *aeq, *asep;
value tmp;
while( true ) {
aand = strchr(args,'&');
if( aand == NULL ) {
asep = strchr(args,';');
aand = asep;
} else {
asep = strchr(args,';');
if( asep != NULL && asep < aand )
aand = asep;
}
if( aand != NULL )
*aand = 0;
aeq = strchr(args,'=');
if( aeq != NULL ) {
*aeq = 0;
tmp = alloc_array(3);
val_array_ptr(tmp)[0] = url_decode(args,(int)(aeq-args));
val_array_ptr(tmp)[1] = url_decode(aeq+1,(int)strlen(aeq+1));
val_array_ptr(tmp)[2] = *p;
*p = tmp;
*aeq = '=';
}
if( aand == NULL )
break;
*aand = (aand == asep)?';':'&';
args = aand+1;
}
}
struct url parse_url(char *uri, char *query)
{
struct url url = {0};
char *dir, *name;
unsigned i;
if (!(dir = strtok(uri, "/"))) {
/*
* strtok() never return an empty string. And that's
* what we usually want, because "/players/" will be
* handled the same than "/players".
*
* However, the root route doesn't have a name, hence
* the default page doesn't either. So to allow default
* page for root directory, we make a special case and
* use an empty string.
*/
strcpy(uri, "");
url.dirs[0] = uri;
url.ndirs = 1;
} else {
do {
if (url.ndirs == MAX_DIRS)
error(414, NULL);
url_decode(dir);
url.dirs[url.ndirs] = dir;
url.ndirs++;
} while ((dir = strtok(NULL, "/")));
}
/*
* Load arg 'name' and 'val' in two steps to not mix up strtok()
* instances.
*/
if (query[0] == '\0')
return url;
name = strtok(query, "&");
while (name) {
if (url.nargs == MAX_ARGS)
error(414, NULL);
url.args[url.nargs].name = name;
url.nargs++;
name = strtok(NULL, "&");
}
for (i = 0; i < url.nargs; i++) {
strtok(url.args[i].name, "=");
url.args[i].val = strtok(NULL, "=");
if (url.args[i].val)
url_decode(url.args[i].val);
}
return url;
}
void test_url_decode() {
char buf[20];
url_decode(buf, "/foo%20bar");
info("URL decoded: %s", buf);
assert(strcmp("/foo bar", buf) == 0);
url_decode(buf, "/%E4%B8%AD%E5%9B%BD%E4%BA%BA");
info("URL decoded: %s", buf);
assert(strcmp("/中国人", buf) == 0);
}
GHashTable *http_parse_header (http_request *h, gchar *req) {
GHashTable *head = g_hash_new();
gchar **lines, **items, *key, *val, *p, prefix[50];
guint i;
h->method = NULL;
h->uri = NULL;
h->header = head;
if (req == NULL)
return head;
lines = g_strsplit( req, "\r\n", 0 );
if (lines == NULL || lines[0] == NULL)
return head;
items = g_strsplit( lines[0], " ", 3 );
h->method = g_strdup( items[0] );
h->uri = g_strdup( items[1] );
// if (CONFd("Verbosity") >= 8) g_message( "http_parse_header: method_len: %d, uri_len: %d", strlen(h->method), strlen(h->uri));
if (CONFd("Verbosity") >= 8) g_message( "http_parse_header: Method: %s", h->method );
if (CONFd("Verbosity") >= 8) g_message( "http_parse_header: URI: %s", url_decode(h->uri) );
g_strfreev( items );
for (i = 1; lines[i] != NULL && lines[i][0] != '\0'; i++ ) {
key = lines[i];
val = strchr(key, ':');
if (val != NULL) {
/* Separate the key from the value */
*val = '\0';
/* Normalize key -- lowercase every after 1st char */
for (p = key + 1; *p != '\0'; p++)
*p = tolower(*p);
/* Strip ": " plus leading and trailing space from val */
g_strchomp( val += 2 ); // ": "
//if ( strcmp(key, "Referer" )== 0) {
// if (CONFd("Verbosity") >= 8) g_message("http_parse_header: Referer: %s", url_decode(val) );
//}
//else {
if (CONFd("Verbosity") >= 8) {
g_snprintf(prefix, 50, "http_parse_header: %s: ", key);
syslog_message(prefix, url_decode(val), strlen(url_decode(val)) );
}
g_hash_set( head, key, val );
//}
}
}
g_strfreev( lines );
h->header = head;
return head;
}
/**
* Parses the query string into parameters
*/
static void parse_parameters(multimap_t * const params, char * query_string)
{
if (query_string) {
size_t query_string_len = strlen(query_string);
char * buf = query_string;
char * end_buf = buf + query_string_len;
char * key = NULL;
size_t key_len = 0;
char * value = NULL;
size_t value_len = 0;
while (buf < end_buf) {
char * end = strpbrk(buf, "=&;#");
size_t len = end ? end - buf : end_buf - buf;
char next = end ? *end : 0;
switch (next) {
case '=': {
key = buf;
key_len = len;
}
break;
case '&':
case ';':
case '#':
case '\0': {
if (key) {
value = buf;
value_len = len;
} else {
// key with no value
key = buf;
key_len = len;
value = "";
value_len = 0;
}
char * decoded_key = url_decode(key, key_len);
char * decoded_value = url_decode(value, value_len);
multimap_put(params, decoded_key, decoded_value);
key = NULL;
value = NULL;
}
break;
}
buf += len + 1;
}
}
}
static void http_auth_init(const char *url)
{
char *at, *colon, *cp, *slash, *decoded;
int len;
cp = strstr(url, "://");
if (!cp)
return;
/*
* Ok, the URL looks like "proto://something". Which one?
* "proto://<user>:<pass>@<host>/...",
* "proto://<user>@<host>/...", or just
* "proto://<host>/..."?
*/
cp += 3;
at = strchr(cp, '@');
colon = strchr(cp, ':');
slash = strchrnul(cp, '/');
if (!at || slash <= at)
return; /* No credentials */
if (!colon || at <= colon) {
/* Only username */
len = at - cp;
user_name = xmalloc(len + 1);
memcpy(user_name, cp, len);
user_name[len] = '\0';
decoded = url_decode(user_name);
free(user_name);
user_name = decoded;
user_pass = NULL;
} else {
len = colon - cp;
user_name = xmalloc(len + 1);
memcpy(user_name, cp, len);
user_name[len] = '\0';
decoded = url_decode(user_name);
free(user_name);
user_name = decoded;
len = at - (colon + 1);
user_pass = xmalloc(len + 1);
memcpy(user_pass, colon + 1, len);
user_pass[len] = '\0';
decoded = url_decode(user_pass);
free(user_pass);
user_pass = decoded;
}
}
int parseURL(ExHttp *pHttp)
{
/* we should treat URL carefully to prevent security issues. */
char *ePos = NULL;
char *pBuf = pHttp->curPos;
TRIM_HEAD(&pBuf);
pHttp->url = pBuf;
SKIP(&pBuf, ' ');
TRIMI_LB_TAIL(pBuf);
TRIM_HEAD(&pBuf);
pHttp->protocol = pBuf;
SKIP(&pBuf, '\n');
TRIMI_LB_TAIL(pBuf);
pHttp->curPos = pBuf;
pHttp->queryString = NULL;
if (*(pHttp->method) == 'G') {
/* if URL is empty, take index file as default */
if (*(pHttp->url) == '\0') {
pHttp->url = (char *) IndexFile;
}
else if ((ePos = strchr(pHttp->url, '?')) != NULL) {
*ePos = '\0';
pHttp->queryString = ++ePos;
pHttp->paramEndPos = find_lb_end(pHttp->protocol);
}
}
/* convert URL to UTF-8 encoding */
return url_decode(pHttp->url, pHttp->url, 0);
}
static std::string URLDecode(const std::string& url) {
char* s = url_decode(url.c_str());
std::string result = s;
free(s);
return result;
}
static int
parse_struct_info (unsigned char *where, size_t length, const char *start,
const char *end, P11KitUri *uri)
{
unsigned char *value;
size_t value_length;
int ret;
assert (start <= end);
ret = url_decode (start, end, &value, &value_length);
if (ret < 0)
return ret;
/* Too long, shouldn't match anything */
if (value_length > length) {
free (value);
uri->unrecognized = 1;
return 1;
}
memset (where, ' ', length);
memcpy (where, value, value_length);
free (value);
return 1;
}
static int
parse_string_attribute (const char *name, const char *start, const char *end,
P11KitUri *uri)
{
unsigned char *value;
CK_ATTRIBUTE attr;
size_t length;
int ret;
assert (start <= end);
if (strcmp ("id", name) == 0)
attr.type = CKA_ID;
else if (strcmp ("object", name) == 0)
attr.type = CKA_LABEL;
else
return 0;
ret = url_decode (start, end, &value, &length);
if (ret < 0)
return ret;
attr.pValue = value;
attr.ulValueLen = length;
uri_take_attribute (uri, &attr);
return 1;
}
int main()
{
formu.lu = 1;
tt_nsconnect("ns-server.epita.fr", 4242, "EdzC*nO4", "poulai_f");
/*tt_nsgetinfo("poulai_f");*/
/*tt_nssendmsg("poulai_f", "si ce message apparaît, c'est gut");*/
depart.lu = 0;
depart.login = malloc(9);
depart.msg = malloc(18);
strcat(depart.login, "poulai_f");
strcat(depart.msg, "teste de messageu");
tt_nssendmsg("poulai_f", "tonku");
while (1)
{
tt_nsverif(&formu, &depart);
printf("pwet\n");
if (!formu.lu)
{
printf("\nMessage de %s:\n%s\n", formu.login, url_decode(formu.msg));
formu.lu = 1;
}
sleep(1);
}
return 0;
}
//Code to play a file. Only Gaya will understand this.
void gaya_auto_load(char *url_encoded_file) {
char *file = url_decode(url_encoded_file);
char *name = util_basename(file);
printf("Content-Type: text/html\n\n");
printf("<html><body onloadset=playme bgcolor=black text=white link=white >\n");
//printf("<html><body >\n");
printf("<br><a href=\"/oversight/oversight.cgi\">Oversight</a>\n");
//char *back=get_self_link("","",name);
//printf("<br>%s\n",back);
//FREE(back);
printf("<br><a href=\"/start.cgi\">Home</a>\n");
printf("<hr><a href=\"file://%s\" %s onfocusload name=playme>Play %s</a>\n", // file://
url_encoded_file,vod_attr(file),name);
printf("</body></html>\n");
FREE(file);
FREE(name);
}
bool HttpConnection::onMessageBegin(const BufferRef& method, const BufferRef& uri, int versionMajor, int versionMinor)
{
TRACE("onMessageBegin: '%s', '%s', HTTP/%d.%d", method.str().c_str(), uri.str().c_str(), versionMajor, versionMinor);
request_->method = method;
request_->uri = uri;
url_decode(input_, request_->uri);
std::size_t n = request_->uri.find("?");
if (n != std::string::npos) {
request_->path = request_->uri.ref(0, n);
request_->query = request_->uri.ref(n + 1);
} else {
request_->path = request_->uri;
}
request_->httpVersionMajor = versionMajor;
request_->httpVersionMinor = versionMinor;
if (request_->supportsProtocol(1, 1))
// FIXME? HTTP/1.1 is keeping alive by default. pass "Connection: close" to close explicitely
setShouldKeepAlive(true);
else
setShouldKeepAlive(false);
// limit request uri length
if (request_->uri.size() > worker().server().maxRequestUriSize()) {
request_->status = HttpError::RequestUriTooLong;
request_->finish();
return false;
}
return true;
}
void KConcatFetchObject::init(KHttpRequest *rq)
{
assert(head==NULL);
KConcatPath *cp = new KConcatPath;
cp->path = strdup(rq->url->path);
add(cp);
assert(rq->url->param);
char *buf = strdup(rq->url->param+1);
url_decode(buf,0,NULL,false);
char *param = buf;
while (param) {
char *p = strchr(param,',');
if (p) {
*p = '\0';
p++;
}
if (*param) {
cp = new KConcatPath;
cp->path = strdup(param);
add(cp);
}
param = p;
}
free(buf);
hot = head;
}
char *XDG_GetStringValue(XDG_PARSED_FILE *file, const char *group_name, const char *value_name, DWORD dwFlags)
{
PARSED_GROUP *group;
PARSED_ENTRY *entry;
for (group = file->groups; group; group = group->next)
{
if (!parsed_str_eq(&group->name, group_name))
continue;
for (entry = group->entries; entry; entry = entry->next)
if (entry->name.str != NULL && parsed_str_eq(&entry->name, value_name))
{
int len;
char *ret;
len = dskentry_decode(entry->value.str, entry->value.len, NULL);
ret = SHAlloc(len);
if (ret == NULL) return NULL;
dskentry_decode(entry->value.str, entry->value.len, ret);
if (dwFlags & XDG_URLENCODE)
url_decode(ret, ret);
return ret;
}
}
return NULL;
}
int decode(char * inputStr, hashmap_t * map)
{
char * pch, * tmp, * key, * value;
char *saveptr1, *saveptr2;
/* split input string */
pch = strtok_r (inputStr," ", &saveptr1);
while (pch != NULL)
{
/* url decode the part */
tmp = url_decode(pch);
key = strtok_r (tmp,":", &saveptr2);
value = strtok_r (NULL,":", &saveptr2);
/* put it into hashmap */
if (hashmap_set(map,key,value) < 0)
{
fprintf(stderr,"can't set decode string into hashmap (%s/%s)\n",key,value);
return -1;
}
/* continue */
pch = strtok_r (NULL," ", &saveptr1);
}
return 0;
}
static void cgi_init_cookie()
{
char * buf;
char key[COOKIE_KEY_MAX];
char value[COOKIE_VALUE_MAX];
if((buf = getenv("COOKIE")) != NULL && *buf)
{
FILE * f = fopen(buf, "r");
if(!f)
{
exit(EXIT_FAILURE);
}
has_cookie = 1;
while(!feof(f))
{
fscanf(f, "%511s %8191s", key, value);
char * decoded = url_decode(value);
strcpy(value, decoded);
free(decoded);
prefix_tree_set(COOKIE, key, value);
}
fclose(f);
}
}
const char *http_request_headers(int fd)
{
static char buf[8192]; /* static variables are not on the stack */
int i;
char value[512];
char envvar[512];
/* For lab 2: don't remove this line. */
touch("http_request_headers");
/* Now parse HTTP headers */
for (;;)
{
if (http_read_line(fd, buf, sizeof(buf)) < 0)
return "Socket IO error";
if (buf[0] == '\0') /* end of headers */
break;
/* Parse things like "Cookie: foo bar" */
char *sp = strchr(buf, ' ');
if (!sp)
return "Header parse error (1)";
*sp = '\0';
sp++;
/* Strip off the colon, making sure it's there */
if (strlen(buf) == 0)
return "Header parse error (2)";
char *colon = &buf[strlen(buf) - 1];
if (*colon != ':')
return "Header parse error (3)";
*colon = '\0';
/* Set the header name to uppercase and replace hyphens with underscores */
for (i = 0; i < strlen(buf); i++) {
buf[i] = toupper(buf[i]);
if (buf[i] == '-')
buf[i] = '_';
}
/* Decode URL escape sequences in the value */
url_decode(value, sp);
/* Store header in env. variable for application code */
/* Some special headers don't use the HTTP_ prefix. */
if (strcmp(buf, "CONTENT_TYPE") != 0 &&
strcmp(buf, "CONTENT_LENGTH") != 0) {
sprintf(envvar, "HTTP_%s", buf);
setenv(envvar, value, 1);
} else {
setenv(buf, value, 1);
}
}
return 0;
}
int handle_request(ClientConn client_conn)
{
int error = 0;
do {
std::string request = client_conn.getData();
key_value_t params;
splitStringToMap(request, '&', '=', params);
key_value_t::iterator iter = params.find("name");
if (iter == params.end())
{
log_error("param error: miss 'name'");
error = -1;
break;
}
iter = params.find("age");
if (iter == params.end())
{
log_error("param error: miss 'age'");
error = -1;
break;
}
std::string name = url_decode(params["name"]);
std::string age = url_decode(params["age"]);
MysqlRowSetPtr res = mysqlApi.query("SELECT age FROM es.lovers WHERE name='%s'", name.c_str());
if (res.get() == NULL || !res->next()) {
log_error("User '%s' NOT-FOUND", name.c_str());
error = -1;
break;
}
if (mysqlApi.update("UPDATE es.lovers SET age=%s WHERE name='%s'", age.c_str(), name.c_str()) < 0) {
log_error("update failed.");
error = -2;
break;
}
} while(0);
send_reply(client_conn.getFD(), error ? "FAILED" : "SUCC");
return error;
}
const std::string& LazyDecodedValue::string() const
{
if (decoded_value_.empty())
{
decoded_value_ = url_decode(raw_value_.data(), raw_value_.end());
}
return decoded_value_;
}
/* Receives an HTTP request from socket SOCKFD and decodes it into KVREQ.
* Returns false if there is an error. */
bool kvrequest_receive(kvrequest_t *kvreq, int sockfd) {
bool success = false;
kvreq->type = EMPTY;
http_request_t req;
url_params_t params;
zero_params(¶ms);
success = http_request_receive(&req, sockfd);
if (!success)
goto error;
success = url_decode(¶ms, req.path);
if (!success)
goto error;
switch (req.method) {
case GET: {
kvreq->type = is_empty_str(params.key) ? INDEX : GETREQ;
break;
}
case PUT: {
if (is_empty_str(params.key) || is_empty_str(params.val))
goto error;
kvreq->type = PUTREQ;
break;
}
case DELETE: {
if (is_empty_str(params.key))
goto error;
kvreq->type = DELREQ;
break;
}
case POST: {
if (is_empty_str(params.path))
goto error;
if (!strcmp(params.path, REGISTER_PATH)) {
if (is_empty_str(params.key) || is_empty_str(params.val))
goto error;
kvreq->type = REGISTER;
} else if (!strcmp(params.path, COMMIT_PATH)) {
kvreq->type = COMMIT;
} else if (!strcmp(params.path, ABORT_PATH)) {
kvreq->type = ABORT;
}
break;
}
default:
goto error;
}
strcpy(kvreq->key, params.key);
strcpy(kvreq->val, params.val);
return true;
error:
return false;
}
void http_init(struct httpc *app, struct request **rpp, char *str_uri)
{
int ok;
struct request *request;
struct pl pl_uri;
struct url url;
*rpp = NULL;
pl_uri.p = NULL;
str_dup((char**)&pl_uri.p, str_uri);
pl_uri.l = strlen(str_uri);
ok = url_decode(&url, &pl_uri);
if(ok!=0)
goto err_uri;
request = mem_zalloc(sizeof(*request), destructor);
ok = hash_alloc(&request->hdrht, HDR_HASH_SIZE);
request->err_h = dummy_err;
request->done_h = http_done;
request->post = NULL;
request->form = 0;
request->www_auth.p = NULL;
request->www_auth.l = 0;
request->auth = NULL;
request->retry = 0;
pl_strdup(&request->host, &url.host);
pl_strdup(&request->path, &url.path);
request->secure = !pl_strcmp(&url.scheme, "https");
memcpy(&request->meth, "GET", 4);
request->meth[4] = 0;
if(url.port)
request->port = url.port;
else
request->port = request->secure ? 443 : 80;
DEBUG_INFO("secure: %d port %d\n", request->secure, request->port);
sa_init(&request->dest, AF_INET);
ok = sa_set_str(&request->dest, request->host, request->port);
request->state = ok ? START : RESOLVED;
request->app = app;
*rpp = request;
err_uri:
if(pl_uri.p)
mem_deref((void*)pl_uri.p);
return;
}
int main(int argc, char **argv)
{
struct strbuf buf = STRBUF_INIT, url_sb = STRBUF_INIT,
private_ref_sb = STRBUF_INIT, marksfilename_sb = STRBUF_INIT,
notes_ref_sb = STRBUF_INIT;
static struct remote *remote;
const char *url_in;
git_extract_argv0_path(argv[0]);
setup_git_directory();
if (argc < 2 || argc > 3) {
usage("git-remote-svn <remote-name> [<url>]");
return 1;
}
remote = remote_get(argv[1]);
url_in = (argc == 3) ? argv[2] : remote->url[0];
if (starts_with(url_in, "file://")) {
dump_from_file = 1;
url = url_decode(url_in + sizeof("file://")-1);
} else {
dump_from_file = 0;
end_url_with_slash(&url_sb, url_in);
url = url_sb.buf;
}
strbuf_addf(&private_ref_sb, "refs/svn/%s/master", remote->name);
private_ref = private_ref_sb.buf;
strbuf_addf(¬es_ref_sb, "refs/notes/%s/revs", remote->name);
notes_ref = notes_ref_sb.buf;
strbuf_addf(&marksfilename_sb, "%s/info/fast-import/remote-svn/%s.marks",
get_git_dir(), remote->name);
marksfilename = marksfilename_sb.buf;
while (1) {
if (strbuf_getline(&buf, stdin, '\n') == EOF) {
if (ferror(stdin))
die("Error reading command stream");
else
die("Unexpected end of command stream");
}
if (do_command(&buf))
break;
strbuf_reset(&buf);
}
strbuf_release(&buf);
strbuf_release(&url_sb);
strbuf_release(&private_ref_sb);
strbuf_release(¬es_ref_sb);
strbuf_release(&marksfilename_sb);
return 0;
}
struct curl_httppost *multipartform(const char *url)
{
struct curl_httppost *formpost = NULL;
struct curl_httppost *lastptr = NULL;
char *temp = strrchr(url, '?');
char *begin = url_decode(temp);
char *mid = NULL;
char *name, *value;
char *file, *path;
/* Fill in the filename field */
do
{
mid = strchr(begin, '=');
begin++;
name = strndup(begin, mid-begin);
begin = strchr(begin, '&');
mid++;
if (!begin)
value = strdup(mid);
else value = strndup(mid, begin-mid);
if(strstr(value, "_UPLOAD"))
{
path = strrchr(value, '_');
file = strndup(value, path-value);
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, name,
CURLFORM_FILE, file,
CURLFORM_END);
free(file);
}
else
{
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, name,
CURLFORM_COPYCONTENTS, value,
CURLFORM_END);
}
free(name);
free(value);
}
while (begin);
free(begin);
return formpost;
}
void HttpProtocol::DecodeCookies(Variant &variables, char *data) {
ASSERT(data && *data);
char *strtok_buf = NULL;
char *var = strtok_r(data, ";", &strtok_buf);
while (var) {
char *val = strchr(var, '=');
// Remove leading spaces from cookie names, needed for multi-cookie
// header where ; can be followed by a space */
while (isspace(*var)) {
var++;
}
if (var != val && *var != '\0') {
if (val) { /* have a value */
int len = val - var;
char *name = url_decode(var, len);
String sname(name, len, AttachString);
++val;
len = strlen(val);
char *value = url_decode(val, len);
if (RuntimeOption::EnableMagicQuotesGpc) {
char *slashedvalue = string_addslashes(value, len);
free(value);
value = slashedvalue;
}
String svalue(value, len, AttachString);
register_variable(variables, (char*)sname.data(), svalue, false);
} else {
int len = strlen(var);
char *name = url_decode(var, len);
String sname(name, len, AttachString);
register_variable(variables, (char*)sname.data(), "", false);
}
}
var = strtok_r(NULL, ";", &strtok_buf);
}
}
String StringUtil::UrlDecode(CStrRef input, bool decodePlus /* = true */) {
int len = input.size();
char *ret;
if (decodePlus) {
ret = url_decode(input.data(), len);
} else {
ret = url_raw_decode(input.data(), len);
}
return String(ret, len, AttachString);
}
int main(void)
{
char buf[] = "you%20are%20good%3b%3b";
assert(url_decode(buf, strlen(buf)) == 14);
printf("%s\n", buf);
printf("%d\n", if_get_mtu("en1"));
return 0;
}
