/** * Add an error response to the queue of the server * * @param connection The client connection which will receive the response * * @param http_error_code The http error code to send * * @return MHD return value, MHD_NO if the response failed to be created, * return code of MHD_queue_response otherwise */ static int send_error( struct MHD_Connection *connection, int http_error_code ) { int ret; struct MHD_Response *response; switch( http_error_code ) { case MHD_HTTP_NOT_FOUND : response = MHD_create_response_from_data( strlen("Not Found"), (void *) "Not Found", MHD_NO, MHD_NO ); break; case MHD_HTTP_BAD_REQUEST : response = MHD_create_response_from_data( strlen("Bad Request"), (void *) "Bad Request", MHD_NO, MHD_NO ); break; case MHD_HTTP_INTERNAL_SERVER_ERROR : response = MHD_create_response_from_data( strlen("Internal Server Error"), (void *) "Internal Server Error", MHD_NO, MHD_NO ); break; default : response = MHD_create_response_from_data( strlen("Unknown error"), (void *) "Unknown error", MHD_NO, MHD_NO ); break; } if( !response ) return MHD_NO; ret = MHD_queue_response ( connection, http_error_code, response ); MHD_destroy_response( response ); return ret; }
/* **************************************************************************** * * restReply - */ void restReply(ConnectionInfo* ciP, std::string answer) { MHD_Response* response; ++replyIx; LM_T(LmtServiceOutPayload, ("Response %d: responding with %d bytes, Status Code %d", replyIx, answer.length(), ciP->httpStatusCode)); LM_T(LmtServiceOutPayload, ("Response payload: '%s'", answer.c_str())); if (answer == "") response = MHD_create_response_from_data(answer.length(), (void*) answer.c_str(), MHD_NO, MHD_NO); else response = MHD_create_response_from_data(answer.length(), (void*) answer.c_str(), MHD_YES, MHD_YES); if (!response) LM_RVE(("MHD_create_response_from_buffer FAILED")); if (ciP->httpHeader.size() != 0) { for (unsigned int hIx = 0; hIx < ciP->httpHeader.size(); ++hIx) MHD_add_response_header(response, ciP->httpHeader[hIx].c_str(), ciP->httpHeaderValue[hIx].c_str()); } if (answer != "") { if (ciP->outFormat == XML) MHD_add_response_header(response, "Content-Type", "application/xml"); else if (ciP->outFormat == JSON) MHD_add_response_header(response, "Content-Type", "application/json"); } MHD_queue_response(ciP->connection, ciP->httpStatusCode, response); MHD_destroy_response(response); }
static int ahc_echo (void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **unused) { struct MHD_Response *response; char *username; const char *password = "******"; const char *realm = "*****@*****.**"; int ret; username = MHD_digest_auth_get_username(connection); if ( (username == NULL) || (0 != strcmp (username, "testuser")) ) { response = MHD_create_response_from_data(strlen (DENIED), DENIED, MHD_NO, MHD_NO); ret = MHD_queue_auth_fail_response(connection, realm, OPAQUE, response, MHD_NO); MHD_destroy_response(response); return ret; } ret = MHD_digest_auth_check(connection, realm, username, password, 300); free(username); if ( (ret == MHD_INVALID_NONCE) || (ret == MHD_NO) ) { response = MHD_create_response_from_data(strlen (DENIED), DENIED, MHD_NO, MHD_NO); if (NULL == response) return MHD_NO; ret = MHD_queue_auth_fail_response(connection, realm, OPAQUE, response, (ret == MHD_INVALID_NONCE) ? MHD_YES : MHD_NO); MHD_destroy_response(response); return ret; } response = MHD_create_response_from_data(strlen(PAGE), PAGE, MHD_NO, MHD_NO); ret = MHD_queue_response(connection, MHD_HTTP_OK, response); MHD_destroy_response(response); return ret; }
static int handle_request(void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **con_cls) { int ret; struct MHD_Response *response = NULL; struct brubeck_server *brubeck = cls; if (!strcmp(method, "GET")) { if (!strcmp(url, "/ping")) { char *jsonr; json_t *pong = json_pack("{s:s, s:i, s:s}", "version", "brubeck " GIT_SHA, "pid", (int)getpid(), "status", "OK"); jsonr = json_dumps(pong, JSON_PRESERVE_ORDER); response = MHD_create_response_from_data(strlen(jsonr), jsonr, 1, 0); json_decref(pong); } else if (!strcmp(url, "/stats")) response = send_stats(brubeck); else if (starts_with(url, "/metric/")) response = send_metric(brubeck, url); } else if (!strcmp(method, "POST")) { if (starts_with(url, "/expire/")) response = expire_metric(brubeck, url); } if (!response) { static const char *NOT_FOUND = "404 not found"; response = MHD_create_response_from_data( strlen(NOT_FOUND), (void *)NOT_FOUND, 0, 0); MHD_add_response_header(response, "Connection", "close"); ret = MHD_queue_response(connection, 404, response); } else { MHD_add_response_header(response, "Connection", "close"); MHD_add_response_header(response, "Content-Type", "application/json"); ret = MHD_queue_response(connection, 200, response); } MHD_destroy_response(response); return ret; }
inline int sendMethodNotAllowedResponse(struct MHD_Connection* connection, bool allowGet) { struct MHD_Response* response; int ret; #ifdef MICROHTTPD_DEPRECATED response = MHD_create_response_from_data( strlen(XML_MWS_METHOD_NOT_ALLOWED), (void*)XML_MWS_METHOD_NOT_ALLOWED, false, false); #else // MICROHTTPD_DEPRECATED response = MHD_create_response_from_buffer( strlen(XML_MWS_METHOD_NOT_ALLOWED), (void*)XML_MWS_METHOD_NOT_ALLOWED, MHD_RESPMEM_PERSISTENT); #endif // MICROHTTPD_DEPRECATED MHD_add_response_header(response, "Content-Type", "text/xml"); MHD_add_response_header(response, "Allow", allowGet ? "GET, POST, OPTIONS" : "POST, OPTIONS"); MHD_add_response_header(response, "Access-Control-Allow-Origin", "*"); MHD_add_response_header(response, "Allow", allowGet ? "GET, POST, OPTIONS" : "POST, OPTIONS"); MHD_add_response_header(response, "Access-Control-Allow-Headers", "CONTENT-TYPE"); MHD_add_response_header(response, "Access-Control-Max-Age", "1728000"); ret = MHD_queue_response(connection, MHD_HTTP_METHOD_NOT_ALLOWED, response); MHD_destroy_response(response); return ret; }
static int see_other(MHD_Connection* connection, const std::string& new_location) { MHD_Response* response = MHD_create_response_from_data(0, 0, MHD_NO, MHD_NO); MHD_add_response_header(response, MHD_HTTP_HEADER_LOCATION, new_location.c_str()); MHD_queue_response(connection, MHD_HTTP_SEE_OTHER, response); MHD_destroy_response(response); return MHD_YES; }
static int connection_handler (void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t * upload_data_size, void **ptr) { static int i; if (*ptr == NULL) { *ptr = &i; return MHD_YES; } if (*upload_data_size != 0) { (*upload_data_size) = 0; return MHD_YES; } struct MHD_Response *response = MHD_create_response_from_data (strlen ("Response"), "Response", 0, 0); int ret = MHD_queue_response (connection, MHD_HTTP_OK, response); MHD_destroy_response (response); return ret; }
int send_response(struct http_response *resp) { struct MHD_Response *response; struct http_header *hdr; char *origin; int ret; response = MHD_create_response_from_data(resp->ndata, (void *)resp->data, MHD_NO, MHD_YES); assert(response); for (hdr = resp->headers; hdr; hdr = hdr->next) MHD_add_response_header(response, hdr->key, hdr->value); MHD_add_response_header(response, "Access-Control-Allow-Headers", "Authorization, Origin"); MHD_add_response_header(response, "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS"); origin = http_get_header(resp->connection, "Origin"); MHD_add_response_header(response, "Access-Control-Allow-Origin", origin ? origin : "*"); free(origin); ret = MHD_queue_response(resp->connection, resp->status, response); MHD_destroy_response(response); return (ret); }
/** * HTTP access handler call back */ int http_ahc (void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *upload_data, const char *version, size_t *upload_data_size, void **ptr) { static int aptr; struct MHD_Response *response; int ret; if (0 != strcmp (method, MHD_HTTP_METHOD_GET)) return MHD_NO; /* unexpected method */ if (&aptr != *ptr) { /* do never respond on first call */ *ptr = &aptr; return MHD_YES; } *ptr = NULL; /* reset when done */ response = MHD_create_response_from_data (strlen (test_data), (void *) test_data, MHD_NO, MHD_NO); ret = MHD_queue_response (connection, MHD_HTTP_OK, response); MHD_destroy_response (response); return ret; }
inline int sendOptionsResponse(struct MHD_Connection* connection) { struct MHD_Response* response; int ret; #ifdef MICROHTTPD_DEPRECATED response = MHD_create_response_from_data(strlen(EMPTY_RESPONSE), (void*) EMPTY_RESPONSE, false, false); #else // MICROHTTPD_DEPRECATED response = MHD_create_response_from_buffer(strlen(EMPTY_RESPONSE), (void*) EMPTY_RESPONSE, MHD_RESPMEM_PERSISTENT); #endif // MICROHTTPD_DEPRECATED MHD_add_response_header(response, "Content-Type", "text/plain"); MHD_add_response_header(response, "Access-Control-Allow-Origin", "*"); MHD_add_response_header(response, "Access-Control-Allow-Methods", "POST, OPTIONS"); MHD_add_response_header(response, "Access-Control-Allow-Headers", "CONTENT-TYPE"); MHD_add_response_header(response, "Access-Control-Max-Age", "1728000"); ret = MHD_queue_response(connection, MHD_HTTP_OK, response); MHD_destroy_response(response); return ret; }
inline int sendXmlGenericResponse(struct MHD_Connection* connection, const char* xmlGenericResponse, int statusCode) { struct MHD_Response* response; int ret; #ifdef MICROHTTPD_DEPRECATED response = MHD_create_response_from_data(strlen(xmlGenericResponse), (void*) xmlGenericResponse, /* must_free = */ 0, /* must_copy = */ 0); #else // MICROHTTPD_DEPRECATED response = MHD_create_response_from_buffer(strlen(xmlGenericResponse), (void*) xmlGenericResponse, MHD_RESPMEM_PERSISTENT); #endif // MICROHTTPD_DEPRECATED MHD_add_response_header(response, "Content-Type", "text/xml"); ret = MHD_queue_response(connection, statusCode, response); MHD_destroy_response(response); return ret; }
static struct MHD_Response * send_metric(struct brubeck_server *server, const char *url) { static const char *metric_types[] = { "gauge", "meter", "counter", "histogram", "timer", "internal" }; static const char *expire_status[] = { "disabled", "inactive", "active" }; struct brubeck_metric *metric = safe_lookup_metric( server, url + strlen("/metric/")); if (metric) { json_t *mj = json_pack("{s:s, s:s, s:i, s:s}", "key", metric->key, "type", metric_types[metric->type], #if METRIC_SHARD_SPECIFIER "shard", (int)metric->shard, #else "shard", 0, #endif "expire", expire_status[metric->expire] ); char *jsonr = json_dumps(mj, JSON_INDENT(4) | JSON_PRESERVE_ORDER); json_decref(mj); return MHD_create_response_from_data( strlen(jsonr), jsonr, 1, 0); } return NULL; }
int CWebServer::AskForAuthentication(struct MHD_Connection *connection) { struct MHD_Response *response = MHD_create_response_from_data(0, NULL, MHD_NO, MHD_NO); if (!response) { CLog::Log(LOGERROR, "CWebServer: unable to create HTTP Unauthorized response"); return MHD_NO; } int ret = AddHeader(response, MHD_HTTP_HEADER_WWW_AUTHENTICATE, "Basic realm=XBMC"); ret |= AddHeader(response, MHD_HTTP_HEADER_CONNECTION, "close"); if (!ret) { CLog::Log(LOGERROR, "CWebServer: unable to prepare HTTP Unauthorized response"); MHD_destroy_response(response); return MHD_NO; } #ifdef WEBSERVER_DEBUG std::multimap<std::string, std::string> headerValues; GetRequestHeaderValues(connection, MHD_RESPONSE_HEADER_KIND, headerValues); CLog::Log(LOGDEBUG, "webserver [OUT] HTTP %d", MHD_HTTP_UNAUTHORIZED); for (std::multimap<std::string, std::string>::const_iterator header = headerValues.begin(); header != headerValues.end(); ++header) CLog::Log(LOGDEBUG, "webserver [OUT] %s: %s", header->first.c_str(), header->second.c_str()); #endif ret = MHD_queue_response(connection, MHD_HTTP_UNAUTHORIZED, response); MHD_destroy_response(response); return ret; }
int list_all_nodes(struct MHD_Connection *connection, struct system_data *sysdata, int uri_num) { struct MHD_Response *response; int i, ret; DEBUG("\n"); strcpy (pagebuff, "{\n"); strcat (pagebuff, " \"node\" : [\n"); for (i=0; i < NUM_NODES; i++) { ret = print_node_json(pagebuff, &sysdata->nodes[i]); sprintf(&pagebuff[strlen(pagebuff)], "%c\n", i==NUM_NODES-1?' ':','); if (ret) return present_error(connection, "Error generating node #: %d\n", i+1); } strcat (pagebuff, " ]\n}\n"); response = MHD_create_response_from_data (strlen(pagebuff), (void *) pagebuff, MHD_NO, MHD_NO); ret = MHD_queue_response (connection, MHD_HTTP_OK, response); MHD_destroy_response (response); return ret; }
int HttpServer::HandleRequest(void *cls, struct MHD_Connection* connection, const char* url, const char* method, const char* version, const char* upload_data, size_t* upload_data_size, void** ptr) { Dispatcher& dispatch = *static_cast<Dispatcher*>(cls); static int dummy; struct MHD_Response * response; int ret; if (&dummy != *ptr) { /* The first time only the headers are valid, do not respond in the first round... */ *ptr = &dummy; return MHD_YES; } *ptr = NULL; /* clear context pointer */ std::string post_body; if (*upload_data_size > 0) { post_body = std::string(upload_data, *upload_data_size); } std::string page = dispatch(method, url, post_body); response = MHD_create_response_from_data(page.length(), (void*) page.c_str(), MHD_NO, MHD_YES); ret = MHD_queue_response(connection, MHD_HTTP_OK, response); MHD_destroy_response(response); return ret; }
int CWebServer::CreateErrorResponse(struct MHD_Connection *connection, int responseType, HTTPMethod method, struct MHD_Response *&response) { size_t payloadSize = 0; void *payload = NULL; if (method != HEAD) { switch (responseType) { case MHD_HTTP_NOT_FOUND: payloadSize = strlen(PAGE_FILE_NOT_FOUND); payload = (void *)PAGE_FILE_NOT_FOUND; break; case MHD_HTTP_NOT_IMPLEMENTED: payloadSize = strlen(NOT_SUPPORTED); payload = (void *)NOT_SUPPORTED; break; } } response = MHD_create_response_from_data(payloadSize, payload, MHD_NO, MHD_NO); if (response == NULL) { CLog::Log(LOGERROR, "CWebServer: failed to create a HTTP %d error response", responseType); return MHD_NO; } return MHD_YES; }
// wraps the given string in a html page and sends it as response with the given status code static void sendMessage(MHD_Connection *connection, unsigned int status, std::string message) { std::string page = "<html><body><p>"+message+"</p></body></html>"; struct MHD_Response* resp = MHD_create_response_from_data(page.size(), (void*)page.data(), 0, 1); MHD_add_response_header(resp, "Content-Type", "text/html"); secure_queue_response(connection, status, resp); MHD_destroy_response(resp); }
/** * Create a response object. The response object can be extended with * header information and then be used any number of times. * * @param size size of the data portion of the response * @param buffer size bytes containing the response's data portion * @param mode flags for buffer management * @return NULL on error (i.e. invalid arguments, out of memory) * @ingroup response */ struct MHD_Response * MHD_create_response_from_buffer (size_t size, void *buffer, enum MHD_ResponseMemoryMode mode) { return MHD_create_response_from_data (size, buffer, mode == MHD_RESPMEM_MUST_FREE, mode == MHD_RESPMEM_MUST_COPY); }
/* * web_send_file * Read files and send them out */ int web_send_file (struct MHD_Connection *conn, const char *filename, const int code, const bool unl) { struct stat buf; FILE *fp; struct MHD_Response *response; const char *p; const char *ct = NULL; int ret; if ((p = strchr(filename, '.')) != NULL) { p++; if (strcmp(p, "xml") == 0) ct = "text/xml"; else if (strcmp(p, "js") == 0) ct = "text/javascript"; } if (stat(filename, &buf) == -1 || ((fp = fopen(filename, "r")) == NULL)) { if (strcmp(p, "xml") == 0) response = MHD_create_response_from_data(0, (void *)"", MHD_NO, MHD_NO); else { int len = strlen(FNF) + strlen(filename) - 1; // len(%s) + 1 for \0 char *s = (char *)malloc(len); if (s == NULL) { fprintf(stderr, "Out of memory FNF\n"); exit(1); } snprintf(s, len, FNF, filename); response = MHD_create_response_from_data(len, (void *)s, MHD_YES, MHD_NO); // free } } else response = MHD_create_response_from_callback(buf.st_size, 32 * 1024, &web_read_file, fp, &web_close_file); if (response == NULL) return MHD_YES; if (ct != NULL) MHD_add_response_header(response, "Content-type", ct); ret = MHD_queue_response(conn, code, response); MHD_destroy_response(response); if (unl) unlink(filename); return ret; }
int send_response(struct MHD_Connection* conn, const char* body, int status_code) { struct MHD_Response* response; if (body) { response = MHD_create_response_from_data(strlen(body), (void*)body, MHD_NO, MHD_YES); } else { response = MHD_create_response_from_data(0, NULL, MHD_NO, MHD_YES); } if (!response) { return MHD_NO; } int ret = MHD_queue_response(conn, status_code, response); MHD_destroy_response(response); return ret; }
int answer_to_connection (void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **con_cls) { TDB_CONTEXT *db = (TDB_CONTEXT*) cls; const char *page; struct MHD_Response *response; int ret; // We assume that nginx won't pass us / itself. if (strcmp(url, "/")==0) { printf("\nSetup nginx properly!"); return MHD_NO; } TDB_DATA key, data; key.dptr = strdup(url); key.dsize = strlen(url); response = MHD_create_response_from_data (strlen(page), (void*) page, MHD_YES, MHD_NO); if (strcmp(method, "GET")==0) { TDB_DATA data; data = tdb_fetch (db, key); if (data.dptr) { MHD_add_response_header (response, "Location", data.dptr); ret = MHD_queue_response (connection, MHD_HTTP_MOVED_PERMANENTLY, response); } else { ret = MHD_queue_response (connection, 404, response); } } else if (strcmp(method, "POST")==0) { printf ("%s -> %s", url, upload_data); data.dptr = strdup(upload_data); data.dsize = strlen(upload_data); tdb_store(db, key, data, TDB_REPLACE); ret = MHD_queue_response (connection, MHD_HTTP_OK, response); } free(data.dptr); free(key.dptr); MHD_destroy_response(response); return ret; }
int CWebServer::CreateMemoryDownloadResponse(struct MHD_Connection *connection, const void *data, size_t size, bool free, bool copy, struct MHD_Response *&response) { response = MHD_create_response_from_data(size, const_cast<void*>(data), free ? MHD_YES : MHD_NO, copy ? MHD_YES : MHD_NO); if (response == NULL) { CLog::Log(LOGERROR, "CWebServer: failed to create a HTTP download response"); return MHD_NO; } return MHD_YES; }
int CWebServer::CreateRedirect(struct MHD_Connection *connection, const std::string &strURL, struct MHD_Response *&response) { response = MHD_create_response_from_data(0, NULL, MHD_NO, MHD_NO); if (response == NULL) { CLog::Log(LOGERROR, "CWebServer: failed to create HTTP redirect response to %s", strURL.c_str()); return MHD_NO; } AddHeader(response, MHD_HTTP_HEADER_LOCATION, strURL); return MHD_YES; }
int send_reponse (struct MHD_Connection *connection, const char *page, int status_code) { MDW_LOG_DEBUG("send_reponse"); struct MHD_Response *response = MHD_create_response_from_data(strlen (page), (void *) page, 0 /*must_free*/, 0 /*must_copy*/); if (!response) return MHD_NO; int ret = MHD_queue_response (connection, status_code, response); MHD_destroy_response (response); return ret; }
static struct MHD_Response * expire_metric(struct brubeck_server *server, const char *url) { struct brubeck_metric *metric = safe_lookup_metric( server, url + strlen("/expire/")); if (metric) { metric->expire = BRUBECK_EXPIRE_DISABLED; return MHD_create_response_from_data( 0, "", 0, 0); } return NULL; }
// add security related headers and send the response on the given connection // the reference counter is not touched // this function is a wrapper around MHD_queue_response // MHD_queue_response should be replaced with this function static void secure_queue_response(MHD_Connection *connection, unsigned int status_code, struct MHD_Response* response) { // TODO: protect againts handling untrusted content to the browser // see: // http://www.dotnetnoob.com/2012/09/security-through-http-response-headers.html // http://www.w3.org/TR/CSP2/ // https://code.google.com/p/doctype-mirror/wiki/ArticleContentSniffing // check content type // don't server when no type or no whitelisted type is given // TODO sending invalid mime types is as bad as not sending them TODO /* std::vector<std::string> allowed_types; allowed_types.push_back("text/html"); allowed_types.push_back("application/json"); allowed_types.push_back("image/png"); */ const char* type = MHD_get_response_header(response, "Content-Type"); if(type == 0 /*|| std::find(allowed_types.begin(), allowed_types.end(), std::string(type)) == allowed_types.end()*/) { std::string page; if(type == 0) page = "<html><body><p>Fatal Error: no content type was set on this response. This is a bug.</p></body></html>"; else page = "<html><body><p>Fatal Error: this content type is not allowed. This is a bug.<br/> Content-Type: "+std::string(type)+"</p></body></html>"; struct MHD_Response* resp = MHD_create_response_from_data(page.size(), (void*)page.data(), 0, 1); MHD_add_response_header(resp, "Content-Type", "text/html"); MHD_queue_response(connection, MHD_HTTP_INTERNAL_SERVER_ERROR, resp); MHD_destroy_response(resp); } // tell Internet Explorer to not do content sniffing MHD_add_response_header(response, "X-Content-Type-Options", "nosniff"); // Content security policy header, its a new technology and not implemented everywhere // get own host name as the browser sees it std::string host; MHD_get_connection_values(connection, MHD_HEADER_KIND, _extract_host_header_it_cb, (void*)&host); std::string csp; csp += "default-src 'none';"; csp += "script-src '"+host+STATIC_FILES_ENTRY_PATH+"';"; csp += "font-src '"+host+STATIC_FILES_ENTRY_PATH+"';"; csp += "img-src 'self';"; // allow images from all paths on this server csp += "media-src 'self';"; // allow media files from all paths on this server MHD_add_response_header(response, "X-Content-Security-Policy", csp.c_str()); MHD_queue_response(connection, status_code, response); }
int test_http_server_timeout_handler(void * cls, struct MHD_Connection * connection, const char * url, const char * method, const char * version, const char * upload_data, size_t * upload_data_size, void ** ptr) { test_http_server * handle = cls; struct MHD_Response * response; int ret; int * c_count; if (*ptr == NULL) { handle->log = apr_hash_make(handle->pool); /* The first time only the headers are valid, do not respond in the first round... */ *ptr = cls; //just to flag its not null.... int * c_count = apr_palloc(handle->pool, sizeof(int)); *c_count = 0; *ptr = c_count; return MHD_YES; } c_count = *ptr; if(*c_count == 0) { //log the request.... apr_hash_set(handle->log, apr_pstrdup(handle->pool, "METHOD"), APR_HASH_KEY_STRING, apr_pstrdup(handle->pool, method)); apr_hash_set(handle->log, apr_pstrdup(handle->pool, "URL"), APR_HASH_KEY_STRING, apr_pstrdup(handle->pool, url)); apr_hash_set(handle->log, apr_pstrdup(handle->pool, "VERSION"), APR_HASH_KEY_STRING, apr_pstrdup(handle->pool, version)); apr_hash_set(handle->log, apr_pstrdup(handle->pool, "DATA_LENGTH"), APR_HASH_KEY_STRING, apr_pmemdup (handle->pool, upload_data_size, sizeof(size_t))); apr_hash_set(handle->log, apr_pstrdup(handle->pool, "DATA"), APR_HASH_KEY_STRING, apr_pmemdup (handle->pool, upload_data, *upload_data_size)); } *c_count = *c_count+1; if(*upload_data_size == 0) { //cause a timeout... apr_sleep(handle->sleep_duration); response = MHD_create_response_from_data(strlen(handle->response), (void*) handle->response, MHD_NO, MHD_NO); ret = MHD_queue_response(connection, handle->response_code, response); MHD_destroy_response(response); return ret; } else { *upload_data_size = 0; //we processed everything? return MHD_YES; } }
int scan_therms(struct MHD_Connection *connection, struct system_data *sysdata, int uri_num) { const char *page = "<html><body>Scan therms</body></html>"; struct MHD_Response *response; int ret; DEBUG("\n"); response = MHD_create_response_from_data (strlen(page), (void *) page, MHD_NO, MHD_NO); ret = MHD_queue_response (connection, MHD_HTTP_OK, response); MHD_destroy_response (response); return ret; }
int unsupported_handler(struct MHD_Connection *connection) { const char *page = "<html><body>Unsupported request</body></html>"; struct MHD_Response *response; int ret; DEBUG("\n"); response = MHD_create_response_from_data (strlen(page), (void *) page, MHD_NO, MHD_NO); ret = MHD_queue_response (connection, MHD_HTTP_NOT_FOUND, response); MHD_destroy_response (response); return ret; }
/* * web_send_data * Send internal HTML string */ static int web_send_data (struct MHD_Connection *connection, const char *data, const int code, bool free, bool copy, const char *ct) { struct MHD_Response *response; int ret; response = MHD_create_response_from_data(strlen(data), (void *)data, free ? MHD_YES : MHD_NO, copy ? MHD_YES : MHD_NO); if (response == NULL) return MHD_NO; if (ct != NULL) MHD_add_response_header(response, "Content-type", ct); ret = MHD_queue_response(connection, code, response); MHD_destroy_response(response); return ret; }