bool WMLPageState::processAccessControlData(const String& domain, const String& path)
{
if (m_hasAccessControlData)
return false;
m_hasAccessControlData = true;
KURL previousURL, currentURL;
if (!tryAccessHistoryURLs(m_page, previousURL, currentURL))
return true;
// Spec: The path attribute defaults to the value "/"
m_accessPath = path.isEmpty() ? "/" : path;
// Spec: The domain attribute defaults to the current decks domain.
String previousHost = hostFromURL(previousURL);
m_accessDomain = domain.isEmpty() ? previousHost : normalizedHostName(domain);
// Spec: To simplify the development of applications that may not know the absolute path to the
// current deck, the path attribute accepts relative URIs. The user agent converts the relative
// path to an absolute path and then performs prefix matching against the PATH attribute.
Document* document = m_page->mainFrame() ? m_page->mainFrame()->document() : 0;
if (document && previousHost == m_accessDomain && !m_accessPath.startsWith("/")) {
String currentPath = currentURL.path();
size_t index = currentPath.reverseFind('/');
if (index != WTF::notFound)
m_accessPath = document->completeURL(currentPath.left(index + 1) + m_accessPath).path();
}
return true;
}
bool WMLPageState::canAccessDeck() const
{
if (!m_hasAccessControlData)
return true;
KURL previousURL, currentURL;
if (!tryAccessHistoryURLs(m_page, previousURL, currentURL))
return true;
if (equalIgnoringFragmentIdentifier(previousURL, currentURL))
return true;
return hostIsAllowedToAccess(hostFromURL(previousURL)) && pathIsAllowedToAccess(previousURL.path());
}
HTTPResponse *HTTPClient::httpPostFile(std::string URL, std::string file) {
ssize_t fileSize = Utils::fileSize(file.c_str());
if (fileSize == -1) return NULL;
FILE *fp = fopen(file.c_str(), "r");
if (fp == NULL) {
// Woops!
return NULL;
}
uint8_t *buf = (uint8_t *) malloc(fileSize);
memset(buf, 0, (size_t) fileSize);
fread(buf, fileSize, 1, fp);
fclose(fp);
HTTPResponse *resp = new HTTPResponse();
Tcp client;
char serverName[100];
unsigned short serverPort = 80;
size_t pathOffset = hostFromURL(URL.c_str(), serverName, &serverPort);
if (client.connectTo(std::string(serverName), serverPort)) {
Log::d("Connect to server OK");
char linebuf[1024];
snprintf(linebuf, 1024, "POST %s HTTP/1.1", URL.c_str() + pathOffset);
client.println(linebuf);
if (serverPort != 80) {
snprintf(linebuf, 1024, "Host: %s:%i", serverName, serverPort);
} else {
snprintf(linebuf, 1024, "Host: %s", serverName);
}
client.println(linebuf);
client.println("Content-Type: application/octet-stream");
client.println("Connection: close");
std::string contentLength = "Content-Length: " + Utils::toString((int) fileSize);
client.println(contentLength.c_str());
client.println("");
client.send(buf, fileSize);
Log::d("HTTP Request to %s sent", URL.c_str());
// Request sent, wait for reply
unsigned long reqTime = Utils::millis();
while (!client.available() && (Utils::millis() - reqTime < HTTP_RESPONSE_TIMEOUT_VALUE)) {
#ifndef NOWATCHDOG
Watchdog::heartBeat();
#endif
}
if (client.available()) {
char rBuffer[300 + 1];
memset(rBuffer, 0, 300 + 1);
int s = getLine(client, (uint8_t *) rBuffer, 300);
Log::d("buffer response[%i]: %s", s, rBuffer);
if (strncmp(rBuffer, "HTTP/1.", 7) == 0) {
resp->error = HTTP_OK;
resp->responseCode = getResponseCode(rBuffer);
// Read headers
do {
s = getLine(client, (uint8_t *) rBuffer, 300);
if (s > 0 && strlen(rBuffer) != 0) {
char *dppos = strchr(rBuffer, ':');
*dppos = 0;
if (*(dppos + 1) == ' ') {
dppos++;
}
dppos++;
resp->headers[std::string(rBuffer)] = std::string(dppos);
}
} while (s > 0 && strlen(rBuffer) != 0);
resp->body = NULL;
if (resp->headers.count("Content-Length") == 1) {
size_t bodySize = (size_t) atol(resp->headers["Content-Length"].c_str());
resp->body = (uint8_t *) malloc(bodySize + 1);
memset(resp->body, 0, bodySize + 1);
client.readall(resp->body, bodySize);
}
} else {
Log::e("HTTP malformed reply");
resp->error = HTTP_MALFORMED_REPLY;
}
} else {
Log::e("HTTP request timeout");
resp->error = HTTP_REQUEST_TIMEOUT;
}
} else {
Log::e("HTTP connection timeout");
resp->error = HTTP_CONNECTION_TIMEOUT;
}
free(buf);
Log::d("Stopping tcp client");
client.stop();
// TODO: better handling?
while (client.connected()) {
client.stop();
}
return resp;
}
HTTPResponse *HTTPClient::httpRequest(HTTPMethod method, std::string URL,
std::map<std::string, std::string> postValues) {
HTTPResponse *resp = new HTTPResponse();
Tcp client;
char serverName[100];
unsigned short serverPort = 80;
size_t pathOffset = hostFromURL(URL.c_str(), serverName, &serverPort);
if (client.connectTo(std::string(serverName), serverPort)) {
Log::d("Connect to server OK");
char linebuf[1024];
snprintf(linebuf, 1024, "%s %s HTTP/1.1", (method == HTTP_GET ? "GET" : "POST"), URL.c_str() + pathOffset);
client.println(linebuf);
if (serverPort != 80) {
snprintf(linebuf, 1024, "Host: %s:%i", serverName, serverPort);
} else {
snprintf(linebuf, 1024, "Host: %s", serverName);
}
client.println(linebuf);
client.println("Connection: close");
if (method == HTTP_POST && postValues.empty()) {
client.println("Content-Length: 0");
client.println("");
} else if (method == HTTP_POST && !postValues.empty()) {
std::string reqBody;
for (std::map<std::string, std::string>::iterator i = postValues.begin(); i != postValues.end(); ++i) {
reqBody.append(i->first);
reqBody.append("=");
reqBody.append(i->second);
reqBody.append("&");
}
reqBody = Utils::trim(reqBody, '&');
client.println("Content-Type: application/x-www-form-urlencoded");
unsigned long contentLength = reqBody.size();
snprintf(linebuf, 1024, "Content-Length: %lu", contentLength);
client.println(linebuf);
client.println("");
client.print(reqBody.c_str());
Log::d("HTTP Post: %s", reqBody.c_str());
}
Log::d("HTTP Request to %s sent", URL.c_str());
// Request sent, wait for reply
unsigned long reqTime = Utils::millis();
while (!client.available() && (Utils::millis() - reqTime < HTTP_RESPONSE_TIMEOUT_VALUE)) { ; }
if (client.available()) {
char rBuffer[300 + 1];
memset(rBuffer, 0, 300 + 1);
int s = getLine(client, (uint8_t *) rBuffer, 300);
Log::d("buffer response[%i]: %s", s, rBuffer);
if (strncmp(rBuffer, "HTTP/1.", 7) == 0) {
resp->error = HTTP_OK;
resp->responseCode = getResponseCode(rBuffer);
// Read headers
do {
s = getLine(client, (uint8_t *) rBuffer, 300);
if (s > 0 && strlen(rBuffer) != 0) {
char *dppos = strchr(rBuffer, ':');
*dppos = 0;
if (*(dppos + 1) == ' ') {
dppos++;
}
dppos++;
resp->headers[std::string(rBuffer)] = std::string(dppos);
}
} while (s > 0 && strlen(rBuffer) != 0);
resp->body = NULL;
if (resp->headers.count("Content-Length") == 1) {
size_t bodySize = (size_t) atol(resp->headers["Content-Length"].c_str());
resp->body = (uint8_t *) malloc(bodySize + 1);
memset(resp->body, 0, bodySize + 1);
client.readall(resp->body, bodySize);
}
} else {
Log::e("HTTP malformed reply");
resp->error = HTTP_MALFORMED_REPLY;
}
} else {
Log::e("HTTP request timeout");
resp->error = HTTP_REQUEST_TIMEOUT;
}
} else {
Log::e("HTTP connection timeout");
resp->error = HTTP_CONNECTION_TIMEOUT;
}
Log::d("Stopping tcp client");
client.stop();
// TODO: better handling?
while (client.connected()) {
client.stop();
}
return resp;
}
