/*
Open handler for a new request
*/
static void openPhp(HttpQueue *q)
{
HttpRx *rx;
rx = q->conn->rx;
/*
PHP will buffer all input. i.e. does not stream. The normal Limits still apply.
*/
q->max = q->pair->max = MAXINT;
mprLog(5, "Open php handler");
httpTrimExtraPath(q->conn);
if (rx->flags & (HTTP_OPTIONS | HTTP_TRACE)) {
httpHandleOptionsTrace(q->conn, "DELETE,GET,HEAD,POST,PUT");
} else if (rx->flags & (HTTP_GET | HTTP_HEAD | HTTP_POST | HTTP_PUT)) {
httpMapFile(q->conn, rx->route);
if (!q->stage->stageData) {
if (initializePhp(q->conn->http) < 0) {
httpError(q->conn, HTTP_CODE_INTERNAL_SERVER_ERROR, "PHP initialization failed");
}
q->stage->stageData = mprAlloc(1);
}
q->queueData = mprAllocObj(MaPhp, NULL);
} else {
httpError(q->conn, HTTP_CODE_BAD_METHOD, "Method not supported by file handler: %s", rx->method);
}
}
void httpServerListen(JsVar *server, int port) {
SOCKET sckt = (SOCKET)(jsvGetIntegerAndUnLock(jsvObjectGetChild(server, HTTP_NAME_SOCKET, 0))-1);
int nret;
sockaddr_in serverInfo;
memset(&serverInfo, 0, sizeof(serverInfo));
serverInfo.sin_family = AF_INET;
//serverInfo.sin_addr.s_addr = htonl(INADDR_LOOPBACK); // allow only LOCAL clients to connect
serverInfo.sin_addr.s_addr = INADDR_ANY; // allow anyone to connect
serverInfo.sin_port = htons((unsigned short)port); // port
nret = bind(sckt, (struct sockaddr*)&serverInfo, sizeof(serverInfo));
if (nret == SOCKET_ERROR) {
httpError("socket bind failed");
closesocket(sckt);
return;
}
// Make the socket listen
nret = listen(sckt, 10); // 10 connections (but this ignored on CC30000)
if (nret == SOCKET_ERROR) {
httpError("socket listen failed");
closesocket(sckt);
return;
}
}
/*
Parse the CGI output first line
*/
static bool parseFirstCgiResponse(Cgi *cgi, HttpPacket *packet)
{
MprBuf *buf;
char *protocol, *status, *msg;
buf = packet->content;
protocol = getCgiToken(buf, " ");
if (protocol == 0 || protocol[0] == '\0') {
httpError(cgi->conn, HTTP_CODE_BAD_GATEWAY, "Bad CGI HTTP protocol response");
return 0;
}
if (strncmp(protocol, "HTTP/1.", 7) != 0) {
httpError(cgi->conn, HTTP_CODE_BAD_GATEWAY, "Unsupported CGI protocol");
return 0;
}
status = getCgiToken(buf, " ");
if (status == 0 || *status == '\0') {
httpError(cgi->conn, HTTP_CODE_BAD_GATEWAY, "Bad CGI header response");
return 0;
}
msg = getCgiToken(buf, "\n");
mprNop(msg);
mprDebug("http cgi", 4, "CGI response status: %s %s %s", protocol, status, msg);
return 1;
}
static int issueRequest(HttpConn *conn, cchar *url, MprList *files)
{
HttpRx *rx;
HttpUri *target, *location;
char *redirect;
cchar *msg, *sep;
int count, redirectCount, rc;
httpSetRetries(conn, app->retries);
httpSetTimeout(conn, app->timeout, app->timeout);
for (redirectCount = count = 0; count <= conn->retries && redirectCount < 16 && !mprShouldAbortRequests(conn); count++) {
if (prepRequest(conn, files, count) < 0) {
return MPR_ERR_CANT_OPEN;
}
if (sendRequest(conn, app->method, url, files) < 0) {
return MPR_ERR_CANT_WRITE;
}
if ((rc = httpWait(conn, HTTP_STATE_PARSED, conn->limits->requestTimeout)) == 0) {
if (httpNeedRetry(conn, &redirect)) {
if (redirect) {
location = httpCreateUri(redirect, 0);
target = httpJoinUri(conn->tx->parsedUri, 1, &location);
url = httpUriToString(target, HTTP_COMPLETE_URI);
count = 0;
}
/* Count redirects and auth retries */
redirectCount++;
count--;
} else {
break;
}
} else if (!conn->error) {
if (rc == MPR_ERR_TIMEOUT) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT,
"Inactive request timed out, exceeded request timeout %d", app->timeout);
} else {
httpError(conn, HTTP_ABORT | HTTP_CODE_COMMS_ERROR, "Connection I/O error");
}
}
if ((rx = conn->rx) != 0) {
if (rx->status == HTTP_CODE_REQUEST_TOO_LARGE || rx->status == HTTP_CODE_REQUEST_URL_TOO_LARGE ||
(rx->status == HTTP_CODE_UNAUTHORIZED && conn->authUser == 0)) {
/* No point retrying */
break;
}
}
mprLog(MPR_DEBUG, "retry %d of %d for: %s %s", count, conn->retries, app->method, url);
}
// MOB - comment out errorMsg as auth errors were returning errors here.
if (conn->error /* || conn->errorMsg */) {
msg = (conn->errorMsg) ? conn->errorMsg : "";
sep = (msg && *msg) ? "\n" : "";
mprError("http: failed \"%s\" request for %s after %d attempt(s).%s%s", app->method, url, count, sep, msg);
return MPR_ERR_CANT_CONNECT;
}
return 0;
}
/*
Start the request (and complete it)
*/
static void startDir(HttpQueue *q)
{
HttpConn *conn;
HttpTx *tx;
HttpRx *rx;
MprList *list;
MprDirEntry *dp;
HttpDir *dir;
cchar *path;
uint nameSize;
int next;
conn = q->conn;
rx = conn->rx;
tx = conn->tx;
if ((dir = conn->reqData) == 0) {
httpError(conn, HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot get directory listing");
return;
}
assert(tx->filename);
if (!(rx->flags & (HTTP_GET | HTTP_HEAD))) {
httpError(conn, HTTP_CODE_BAD_METHOD, "Bad method");
return;
}
httpSetContentType(conn, "text/html");
httpSetHeaderString(conn, "Cache-Control", "no-cache");
httpSetHeaderString(conn, "Last-Modified", conn->http->currentDate);
parseQuery(conn);
if ((list = mprGetPathFiles(tx->filename, MPR_PATH_RELATIVE)) == 0) {
httpWrite(q, "<h2>Cannot get file list</h2>\r\n");
outputFooter(q);
return;
}
if (dir->pattern) {
filterDirList(conn, list);
}
sortList(conn, list);
/*
Get max filename size
*/
nameSize = 0;
for (next = 0; (dp = mprGetNextItem(list, &next)) != 0; ) {
nameSize = max((int) strlen(dp->name), nameSize);
}
nameSize = max(nameSize, 22);
path = rx->route->prefix ? sjoin(rx->route->prefix, rx->pathInfo, NULL) : rx->pathInfo;
outputHeader(q, path, nameSize);
for (next = 0; (dp = mprGetNextItem(list, &next)) != 0; ) {
outputLine(q, dp, tx->filename, nameSize);
}
outputFooter(q);
httpFinalize(conn);
}
/*
Populate a packet with file data. Return the number of bytes read or a negative error code. Will not return with
a short read.
*/
static ssize readFileData(HttpQueue *q, HttpPacket *packet, MprOff pos, ssize size)
{
HttpConn *conn;
HttpTx *tx;
ssize nbytes;
// int btint = 0;
conn = q->conn;
tx = conn->tx;
if (packet->content == 0 && (packet->content = mprCreateBuf(size, -1)) == 0) {
return MPR_ERR_MEMORY;
}
assure(size <= mprGetBufSpace(packet->content));
mprLog(7, "readFileData size %d, pos %Ld", size, pos);
if (pos >= 0) {
mprSeekFile(tx->file, SEEK_SET, pos);
}
if ((nbytes = mprReadFile(tx->file, mprGetBufStart(packet->content), size)) != size) {
/*
As we may have sent some data already to the client, the only thing we can do is abort and hope the client
notices the short data.
*/
httpError(conn, HTTP_CODE_SERVICE_UNAVAILABLE, "Can't read file %s", tx->filename);
return MPR_ERR_CANT_READ;
}
mprAdjustBufEnd(packet->content, nbytes);
packet->esize -= nbytes;
assure(packet->esize == 0);
return nbytes;
}
void PhoneReg::startCodeRequest()
{
qDebug() << QString("reg/req/%1/start").arg(method);
request = new WARequest(userAgent, "code", this);
request->addParam("cc", cc);
request->addParam("in", number);
//request->addParam("reason", "next-method");
request->addParam("reason", "self-send-jailbroken");
request->addParam("method", method);
request->addParam("mcc", mcc);
request->addParam("mnc", mnc);
QString locale = QLocale::system().name();
QString lg = locale.split("_").first();
QString lc = locale.split("_").length() > 1 ? locale.split("_").last() : "";
request->addParam("lg", lc.isEmpty() ? "en" : lg);
request->addParam("lc", lc.isEmpty() ? "US" : lc);
request->addParam("token", Utilities::getTokenAndroid(number));
request->addParam("id", id);
connect(request,SIGNAL(finished(QVariantMap)),
this,SLOT(onCodeRequestDone(QVariantMap)));
connect(request,SIGNAL(sslError()),
this,SLOT(sslError()));
connect(request,SIGNAL(httpError(QString)),
this,SLOT(errorHandler(QString)));
request->getRequest();
}
int httpConnect(HttpConn *conn, cchar *method, cchar *url, struct MprSsl *ssl)
{
mprAssert(conn);
mprAssert(method && *method);
mprAssert(url && *url);
if (conn->endpoint) {
httpError(conn, HTTP_CODE_BAD_GATEWAY, "Can't call connect in a server");
return MPR_ERR_BAD_STATE;
}
mprLog(4, "Http: client request: %s %s", method, url);
if (conn->tx == 0 || conn->state != HTTP_STATE_BEGIN) {
/* WARNING: this will erase headers */
httpPrepClientConn(conn, 0);
}
mprAssert(conn->state == HTTP_STATE_BEGIN);
httpSetState(conn, HTTP_STATE_CONNECTED);
conn->setCredentials = 0;
conn->tx->method = supper(method);
#if BIT_DEBUG
conn->startTime = conn->http->now;
conn->startTicks = mprGetTicks();
#endif
if (openConnection(conn, url, ssl) == 0) {
return MPR_ERR_CANT_OPEN;
}
httpCreateTxPipeline(conn, conn->http->clientRoute);
if (setClientHeaders(conn) < 0) {
return MPR_ERR_CANT_INITIALIZE;
}
return 0;
}
static int runCommand(HttpConn *conn, cchar *command, cchar *csource, cchar *module)
{
EspReq *req;
EspRoute *eroute;
MprCmd *cmd;
MprKey *var;
MprList *elist;
cchar **env;
char *err, *out;
req = conn->data;
eroute = req->route->eroute;
cmd = mprCreateCmd(conn->dispatcher);
if ((req->commandLine = espExpandCommand(eroute, command, csource, module)) == 0) {
httpError(conn, HTTP_CODE_INTERNAL_SERVER_ERROR, "Missing EspCompile directive for %s", csource);
return MPR_ERR_CANT_READ;
}
mprLog(4, "ESP command: %s\n", req->commandLine);
if (eroute->env) {
elist = mprCreateList(0, 0);
for (ITERATE_KEYS(eroute->env, var)) {
mprAddItem(elist, sfmt("%s=%s", var->key, var->data));
}
mprAddNullItem(elist);
env = (cchar**) &elist->items[0];
} else {
static void openQueues(HttpConn *conn)
{
HttpTx *tx;
HttpQueue *q, *qhead;
int i;
tx = conn->tx;
for (i = 0; i < HTTP_MAX_QUEUE; i++) {
qhead = tx->queue[i];
for (q = qhead->nextQ; q != qhead; q = q->nextQ) {
if (q->open && !(q->flags & (HTTP_QUEUE_OPEN_TRIED))) {
if (q->pair == 0 || !(q->pair->flags & HTTP_QUEUE_OPEN_TRIED)) {
openQueue(q, tx->chunkSize);
if (q->open) {
q->flags |= HTTP_QUEUE_OPEN_TRIED;
if (q->stage->open(q) == 0) {
q->flags |= HTTP_QUEUE_OPENED;
} else {
if (!conn->error) {
httpError(conn, HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot open stage %s", q->stage->name);
}
}
}
}
}
}
}
}
void MediaUpload::finished(MultiPartUploader *uploader, QVariantMap dictionary)
{
disconnect(uploader, 0, 0, 0);
uploader->deleteLater();
if (dictionary.contains("url"))
{
msg.media_mime_type = dictionary.value("mimetype").toString();
msg.media_name = dictionary.value("name").toString();
msg.media_size = dictionary.value("size").toLongLong();
msg.media_url = dictionary.value("url").toString();
msg.media_duration_seconds = dictionary.value("duration").toInt();
msg.status = FMessage::Uploaded;
Utilities::logData("Upload finished: " + msg.media_name + " size: " +
QString::number(msg.media_size));
Utilities::logData("Url: " + msg.media_url);
emit sendMessage(this, msg);
}
else if (dictionary.contains("error"))
{
Utilities::logData("Upload failed: " + dictionary.value("error").toString());
emit httpError(this);
}
}
static void readyError(HttpQueue *q)
{
if (!q->conn->error) {
httpError(q->conn, HTTP_CODE_SERVICE_UNAVAILABLE, "The requested resource is not available");
}
httpFinalize(q->conn);
}
/*
Action to run in response to the "test/output" URI
*/
static void output_action()
{
Output *output;
/*
Don't automatically finalize (complete) the request when this routine returns. This keeps the connection open.
*/
dontAutoFinalize();
/*
Define the event notifier. We're interested in WRITABLE events
*/
setNotifier(output_callback);
/*
Open a file for output. Could use open/write, but we use the MPR equivalents for cross-platform I/O.
*/
output = mprAllocObj(Output, manageOutput);
if ((output->file = mprOpenFile(OUTPUT_FILE, O_RDONLY, 0)) == 0) {
httpError(getConn(), HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot open huge.txt");
return;
}
mprGetPathInfo(OUTPUT_FILE, &output->info);
/*
Save a reference to our output state
*/
setData(output);
}
/*
Initialize the upload filter for a new request
*/
static int openUpload(HttpQueue *q)
{
HttpConn *conn;
HttpRx *rx;
Upload *up;
cchar *uploadDir;
char *boundary;
conn = q->conn;
rx = conn->rx;
if ((up = mprAllocObj(Upload, manageUpload)) == 0) {
return MPR_ERR_MEMORY;
}
q->queueData = up;
up->contentState = HTTP_UPLOAD_BOUNDARY;
rx->autoDelete = rx->route->autoDelete;
rx->renameUploads = rx->route->renameUploads;
uploadDir = getUploadDir(rx->route);
httpSetParam(conn, "UPLOAD_DIR", uploadDir);
if ((boundary = strstr(rx->mimeType, "boundary=")) != 0) {
boundary += 9;
up->boundary = sjoin("--", boundary, NULL);
up->boundaryLen = strlen(up->boundary);
}
if (up->boundaryLen == 0 || *up->boundary == '\0') {
httpError(conn, HTTP_CODE_BAD_REQUEST, "Bad boundary");
return MPR_ERR_BAD_ARGS;
}
return 0;
}
PUBLIC int httpConnect(HttpConn *conn, cchar *method, cchar *uri, struct MprSsl *ssl)
{
assert(conn);
assert(method && *method);
assert(uri && *uri);
if (httpServerConn(conn)) {
httpError(conn, HTTP_CODE_BAD_GATEWAY, "Cannot call connect in a server");
return MPR_ERR_BAD_STATE;
}
if (conn->tx == 0 || conn->state != HTTP_STATE_BEGIN) {
/* WARNING: this will erase headers */
httpPrepClientConn(conn, 0);
}
assert(conn->state == HTTP_STATE_BEGIN);
conn->tx->parsedUri = httpCreateUri(uri, HTTP_COMPLETE_URI_PATH);
if (openConnection(conn, ssl) == 0) {
return MPR_ERR_CANT_OPEN;
}
conn->authRequested = 0;
conn->tx->method = supper(method);
conn->startMark = mprGetHiResTicks();
/*
The receive pipeline is created when parsing the response in parseIncoming()
*/
httpCreateTxPipeline(conn, conn->http->clientRoute);
httpSetState(conn, HTTP_STATE_CONNECTED);
setDefaultHeaders(conn);
return 0;
}
void httpMatchHost(HttpConn *conn)
{
MprSocket *listenSock;
HttpEndpoint *endpoint;
HttpHost *host;
Http *http;
http = conn->http;
listenSock = conn->sock->listenSock;
if ((endpoint = httpLookupEndpoint(http, listenSock->ip, listenSock->port)) == 0) {
mprError("No listening endpoint for request from %s:%d", listenSock->ip, listenSock->port);
mprCloseSocket(conn->sock, 0);
return;
}
if (httpHasNamedVirtualHosts(endpoint)) {
host = httpLookupHostOnEndpoint(endpoint, conn->rx->hostHeader);
} else {
host = mprGetFirstItem(endpoint->hosts);
}
if (host == 0) {
httpSetConnHost(conn, 0);
httpError(conn, HTTP_CODE_NOT_FOUND, "No host to serve request. Searching for %s", conn->rx->hostHeader);
conn->host = mprGetFirstItem(endpoint->hosts);
return;
}
if (conn->rx->traceLevel >= 0) {
mprLog(conn->rx->traceLevel, "Select host: \"%s\"", host->name);
}
conn->host = host;
}
/*
Initialize the send connector for a request
*/
PUBLIC int httpSendOpen(HttpQueue *q)
{
HttpConn *conn;
HttpTx *tx;
conn = q->conn;
tx = conn->tx;
if (tx->connector != conn->http->sendConnector) {
httpAssignQueue(q, tx->connector, HTTP_QUEUE_TX);
tx->connector->open(q);
return 0;
}
if (!(tx->flags & HTTP_TX_NO_BODY)) {
assert(tx->fileInfo.valid);
if (tx->fileInfo.size > conn->limits->txBodySize &&
conn->limits->txBodySize < HTTP_UNLIMITED) {
httpLimitError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TOO_LARGE,
"Http transmission aborted. File size exceeds max body of %lld bytes", conn->limits->txBodySize);
return MPR_ERR_CANT_OPEN;
}
tx->file = mprOpenFile(tx->filename, O_RDONLY | O_BINARY, 0);
if (tx->file == 0) {
httpError(conn, HTTP_CODE_NOT_FOUND, "Cannot open document: %s, err %d", tx->filename, mprGetError());
}
}
return 0;
}
static int openQueue(HttpQueue *q, ssize chunkSize)
{
Http *http;
HttpConn *conn;
HttpStage *stage;
MprModule *module;
stage = q->stage;
conn = q->conn;
http = q->conn->http;
if (chunkSize > 0) {
q->packetSize = min(q->packetSize, chunkSize);
}
if (stage->flags & HTTP_STAGE_UNLOADED && stage->module) {
module = stage->module;
module = mprCreateModule(module->name, module->path, module->entry, http);
if (mprLoadModule(module) < 0) {
httpError(conn, HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot load module %s", module->name);
return MPR_ERR_CANT_READ;
}
stage->module = module;
}
if (stage->module) {
stage->module->lastActivity = http->now;
}
return 0;
}
PUBLIC void httpNetError(HttpNet *net, cchar *fmt, ...)
{
va_list args;
HttpStream *stream;
cchar *msg;
int next;
if (net == 0 || fmt == 0) {
return;
}
va_start(args, fmt);
if (!net->error) {
net->error = 1;
net->errorMsg = msg = sfmtv(fmt, args);
#if ME_HTTP_HTTP2
if (net->protocol >= 2 && !net->eof) {
httpSendGoAway(net, HTTP2_INTERNAL_ERROR, "%s", msg);
}
#endif
if (httpIsServer(net)) {
for (ITERATE_ITEMS(net->streams, stream, next)) {
httpError(stream, HTTP_ABORT | HTTP_CODE_COMMS_ERROR, "%s", msg);
}
// TODO httpMonitorNetEvent(net, HTTP_COUNTER_BAD_REQUEST_ERRORS, 1);
}
}
static int doRequest(HttpConn *conn, cchar *url, MprList *files)
{
MprTime mark, remaining;
HttpLimits *limits;
mprAssert(url && *url);
limits = conn->limits;
mprLog(MPR_DEBUG, "fetch: %s %s", app->method, url);
mark = mprGetTime();
if (issueRequest(conn, url, files) < 0) {
return MPR_ERR_CANT_CONNECT;
}
remaining = limits->requestTimeout;
while (!conn->error && conn->state < HTTP_STATE_COMPLETE && remaining > 0) {
remaining = mprGetRemainingTime(mark, limits->requestTimeout);
httpWait(conn, 0, remaining);
readBody(conn);
}
if (conn->state < HTTP_STATE_COMPLETE && !conn->error) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT,
"Inactive request timed out, exceeded request timeout %d", app->timeout);
} else {
readBody(conn);
}
reportResponse(conn, url, mprGetTime() - mark);
httpDestroyRx(conn->rx);
httpDestroyTx(conn->tx);
return 0;
}
void
processCall2(const registry * const registryP,
FILE * const callFileP,
unsigned int const callSize,
bool const sendCookie,
string const& authCookie,
FILE * const respFileP) {
if (callSize > xmlrpc_limit_get(XMLRPC_XML_SIZE_LIMIT_ID))
throw(xmlrpc_c::fault(string("XML-RPC call is too large"),
fault::CODE_LIMIT_EXCEEDED));
else {
string const callXml(getHttpBody(callFileP, callSize));
string responseXml;
try {
registryP->processCall(callXml, &responseXml);
} catch (exception const& e) {
throw(httpError(500, e.what()));
}
writeNormalHttpResp(respFileP, sendCookie, authCookie, responseXml);
}
}
/*
Accept incoming body data from the client destined for the CGI gateway. This is typically POST or PUT data.
Note: For POST "form" requests, this will be called before the command is actually started.
*/
static void browserToCgiData(HttpQueue *q, HttpPacket *packet)
{
HttpConn *conn;
Cgi *cgi;
assert(q);
assert(packet);
if ((cgi = q->queueData) == 0) {
return;
}
conn = q->conn;
assert(q == conn->readq);
if (httpGetPacketLength(packet) == 0) {
/* End of input */
if (conn->rx->remainingContent > 0) {
/* Short incoming body data. Just kill the CGI process */
if (cgi->cmd) {
mprDestroyCmd(cgi->cmd);
}
httpError(conn, HTTP_CODE_BAD_REQUEST, "Client supplied insufficient body data");
}
}
httpPutForService(cgi->writeq, packet, HTTP_SCHEDULE_QUEUE);
}
/*
Open the handler for a new request
*/
static int openCgi(HttpQueue *q)
{
HttpConn *conn;
Cgi *cgi;
int nproc;
conn = q->conn;
if ((nproc = (int) httpMonitorEvent(conn, HTTP_COUNTER_ACTIVE_PROCESSES, 1)) >= conn->limits->processMax) {
httpTrace(conn, "cgi.limit.error", "error",
"msg=\"Too many concurrent processes\", activeProcesses=%d, maxProcesses=%d",
nproc, conn->limits->processMax);
httpError(conn, HTTP_CODE_SERVICE_UNAVAILABLE, "Server overloaded");
httpMonitorEvent(q->conn, HTTP_COUNTER_ACTIVE_PROCESSES, -1);
return MPR_ERR_CANT_OPEN;
}
if ((cgi = mprAllocObj(Cgi, manageCgi)) == 0) {
/* Normal mem handler recovery */
return MPR_ERR_MEMORY;
}
httpTrimExtraPath(conn);
httpMapFile(conn);
httpCreateCGIParams(conn);
q->queueData = q->pair->queueData = cgi;
cgi->conn = conn;
cgi->readq = httpCreateQueue(conn, conn->http->cgiConnector, HTTP_QUEUE_RX, 0);
cgi->writeq = httpCreateQueue(conn, conn->http->cgiConnector, HTTP_QUEUE_TX, 0);
cgi->readq->pair = cgi->writeq;
cgi->writeq->pair = cgi->readq;
cgi->writeq->queueData = cgi->readq->queueData = cgi;
return 0;
}
static void myaction(HttpConn *conn)
{
HttpQueue *q;
q = conn->writeq;
/*
Set the HTTP response status
*/
httpSetStatus(conn, 200);
/*
Add desired headers. "Set" will overwrite, add will create if not already defined.
*/
httpAddHeaderString(conn, "Content-Type", "text/plain");
httpSetHeaderString(conn, "Cache-Control", "no-cache");
httpWrite(q, "<html><title>simpleAction</title><body>\r\n");
httpWrite(q, "<p>Name: %s</p>\n", httpGetParam(conn, "name", "-"));
httpWrite(q, "<p>Address: %s</p>\n", httpGetParam(conn, "address", "-"));
httpWrite(q, "</body></html>\r\n");
/*
Call finalize output and close the request.
Delay closing if you want to do asynchronous output and close later.
*/
httpFinalize(conn);
#if POSSIBLE
/*
Useful things to do in actions
*/
httpRedirect(conn, 302, "/other-uri");
httpError(conn, 409, "My message : %d", 5);
#endif
}
void PhoneReg::startCodeRequest()
{
qDebug() << QString("reg/req/%1/start").arg(method);
request = new WARequest(this, "code");
request->addParam("cc", cc);
request->addParam("in", number);
if (method == "voice") {
request->addParam("reason", "next-method");
}
//request->addParam("reason", "self-send-jailbroken");
request->addParam("method", method);
request->addParam("sim_mcc", mcc);
//request->addParam("sim_mcc", "214");
request->addParam("sim_mnc", mnc);
//request->addParam("sim_mnc", "007");
request->addParam("lg", lg.isEmpty() ? "en" : lg);
request->addParam("lc", lc.isEmpty() ? "zz" : lc);
request->addParam("token", Utilities::getTokenAndroid(number));
request->addParam("id", id);
connect(request,SIGNAL(finished(QVariantMap)),
this,SLOT(onCodeRequestDone(QVariantMap)));
connect(request,SIGNAL(sslError()),
this,SLOT(sslError()));
connect(request,SIGNAL(httpError(QString)),
this,SLOT(errorHandler(QString)));
request->getRequest();
}
static void readyError(HttpQueue *q)
{
if (!q->stream->error) {
httpError(q->stream, HTTP_CODE_NOT_FOUND, "The requested resource is not available");
}
httpFinalize(q->stream);
httpScheduleQueue(q);
}
/*
Web form-based authentication callback for the "form" auth protocol.
Asks the user to login via a web page.
*/
static void formLogin(HttpConn *conn)
{
if (conn->rx->route->auth && conn->rx->route->auth->loginPage) {
httpRedirect(conn, HTTP_CODE_MOVED_TEMPORARILY, conn->rx->route->auth->loginPage);
} else {
httpError(conn, HTTP_CODE_UNAUTHORIZED, "Access Denied. Login required");
}
}
void QNetworkAccessHttpBackend::postRequest()
{
bool loadedFromCache = false;
QHttpNetworkRequest httpRequest;
switch (operation()) {
case QNetworkAccessManager::GetOperation:
httpRequest.setOperation(QHttpNetworkRequest::Get);
validateCache(httpRequest, loadedFromCache);
break;
case QNetworkAccessManager::HeadOperation:
httpRequest.setOperation(QHttpNetworkRequest::Head);
validateCache(httpRequest, loadedFromCache);
break;
case QNetworkAccessManager::PostOperation:
invalidateCache();
httpRequest.setOperation(QHttpNetworkRequest::Post);
uploadDevice = new QNetworkAccessHttpBackendIODevice(this);
break;
case QNetworkAccessManager::PutOperation:
invalidateCache();
httpRequest.setOperation(QHttpNetworkRequest::Put);
uploadDevice = new QNetworkAccessHttpBackendIODevice(this);
break;
default:
break; // can't happen
}
httpRequest.setData(uploadDevice);
httpRequest.setUrl(url());
QList<QByteArray> headers = request().rawHeaderList();
foreach (const QByteArray &header, headers)
httpRequest.setHeaderField(header, request().rawHeader(header));
if (loadedFromCache) {
QNetworkAccessBackend::finished();
return; // no need to send the request! :)
}
httpReply = http->sendRequest(httpRequest);
httpReply->setParent(this);
#ifndef QT_NO_OPENSSL
if (pendingSslConfiguration)
httpReply->setSslConfiguration(*pendingSslConfiguration);
if (pendingIgnoreSslErrors)
httpReply->ignoreSslErrors();
#endif
connect(httpReply, SIGNAL(readyRead()), SLOT(replyReadyRead()));
connect(httpReply, SIGNAL(finished()), SLOT(replyFinished()));
connect(httpReply, SIGNAL(finishedWithError(QNetworkReply::NetworkError,QString)),
SLOT(httpError(QNetworkReply::NetworkError,QString)));
connect(httpReply, SIGNAL(headerChanged()), SLOT(replyHeaderChanged()));
}
void httpServerResponseWriteHead(JsVar *httpServerResponseVar, int statusCode, JsVar *headers) {
if (!jsvIsUndefined(headers) && !jsvIsObject(headers)) {
httpError("Headers sent to writeHead should be an object");
return;
}
jsvUnLock(jsvObjectSetChild(httpServerResponseVar, HTTP_NAME_CODE, jsvNewFromInteger(statusCode)));
JsVar *sendHeaders = jsvObjectGetChild(httpServerResponseVar, HTTP_NAME_HEADERS, 0);
if (sendHeaders) {
if (!jsvIsUndefined(headers)) {
jsvObjectSetChild(httpServerResponseVar, HTTP_NAME_HEADERS, headers);
}
jsvUnLock(sendHeaders);
} else {
// headers are set to 0 when they are sent
httpError("Headers have already been sent");
}
}
/*
The incoming callback is invoked to receive body data
*/
static void incomingFile(HttpQueue *q, HttpPacket *packet)
{
HttpConn *conn;
HttpTx *tx;
HttpRx *rx;
HttpRange *range;
MprBuf *buf;
MprFile *file;
ssize len;
conn = q->conn;
tx = conn->tx;
rx = conn->rx;
file = (MprFile*) q->queueData;
if (file == 0) {
/* Not a PUT so just ignore the incoming data. */
return;
}
if (httpGetPacketLength(packet) == 0) {
/* End of input */
if (file) {
mprCloseFile(file);
}
q->queueData = 0;
if (!tx->etag) {
/* Set the etag for caching in the client */
mprGetPathInfo(tx->filename, &tx->fileInfo);
tx->etag = sfmt("\"%llx-%llx-%llx\"", tx->fileInfo.inode, tx->fileInfo.size, tx->fileInfo.mtime);
}
return;
}
buf = packet->content;
len = mprGetBufLength(buf);
assert(len > 0);
range = rx->inputRange;
if (range && mprSeekFile(file, SEEK_SET, range->start) != range->start) {
httpError(conn, HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot seek to range start to %lld", range->start);
} else if (mprWriteFile(file, mprGetBufStart(buf), len) != len) {
httpError(conn, HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot PUT to %s", tx->filename);
}
}
