static int request_test_handler(struct mg_connection *conn, void *cbdata) { int i; char chunk_data[32]; const struct mg_request_info *ri; struct mg_context *ctx; void *ud, *cud; ctx = mg_get_context(conn); ud = mg_get_user_data(ctx); ri = mg_get_request_info(conn); ck_assert(ri != NULL); ck_assert(ctx == g_ctx); ck_assert(ud == &g_ctx); mg_set_user_connection_data(conn, (void *)6543); cud = mg_get_user_connection_data(conn); ck_assert_ptr_eq((void *)cud, (void *)6543); ck_assert_ptr_eq((void *)cbdata, (void *)7); strcpy(chunk_data, "123456789A123456789B123456789C"); mg_printf(conn, "HTTP/1.1 200 OK\r\n" "Transfer-Encoding: chunked\r\n" "Content-Type: text/plain\r\n\r\n"); for (i = 1; i <= 10; i++) { mg_printf(conn, "%x\r\n", i); mg_write(conn, chunk_data, (unsigned)i); mg_printf(conn, "\r\n"); } mg_printf(conn, "0\r\n\r\n"); return 1; }
// Satisfies the HTTP request from memory, or returns a 404 error. The // filesystem is never touched. // Ideally we'd use Mongoose's open_file callback override to implement file // serving from memory instead, but that method provides no way to disable // caching or display directory index documents. static void serve_file_from_memory_or_404(struct mg_connection *connection) { const struct mg_request_info *request_info = mg_get_request_info(connection); const char *uri = request_info->uri; // If the root of the server is requested, display the index instead. if (strlen(uri) < 2) { uri = "/index.html"; } // Construct the file's full path relative to the document root. const int max_path = 2048; char file_path[max_path]; size_t path_length = strlen(uri) + strlen(document_root) + 1; const char *file = NULL; size_t file_size = 0; if (path_length < max_path) { snprintf(file_path, path_length, "%s%s", document_root, uri); file = get_file(file_path, &file_size); } if (file) { // We've located the file in memory. Serve it with headers to disable // caching. mg_printf(connection, "HTTP/1.1 200 OK\r\n" "Cache-Control: no-cache\r\n" "Content-Type: %s\r\n" "Content-Length: %lu\r\n" "Connection: close\r\n\r\n", mg_get_builtin_mime_type(file_path), file_size); mg_write(connection, file, file_size); } else { // The file doesn't exist in memory. mg_printf(connection, "HTTP/1.1 404 Not Found\r\n" "Cache-Control: no-cache\r\n" "Content-Type: text/plain; charset=utf-8\r\n" "Content-Length: 25\r\n" "Connection: close\r\n\r\n" "Error 404: File not found"); } }
void TMongCliContext::Respond(const PHttpResp& HttpResp) { const TMem& Body = HttpResp->GetBodyAsMem(); TStr ResponseHeader = HttpResp->GetHdStr(); mg_write(Conn, ResponseHeader.CStr(), ResponseHeader.Len()); mg_write(Conn, Body.GetBf(), Body.Len()); }
bool write_quad_model_as_bmp(struct mg_connection *conn, quad_model* model) { int width = 640; int height = 320; HWND hWND = CreateWindow(_T("BUTTON"), NULL, WS_OVERLAPPEDWINDOW /*| WS_VISIBLE*/ | CS_OWNDC, 0, 0, width, height, NULL, NULL, NULL, NULL); HDC hDC = GetDC(hWND); int pixelForamt = ChoosePixelFormatEx(hDC, false); PIXELFORMATDESCRIPTOR pfd = {0}; BOOL bRet = SetPixelFormat(hDC, pixelForamt, &pfd); HGLRC hRC = wglCreateContext(hDC); bRet = wglMakeCurrent(hDC, hRC); GLenum err = glewInit( ); if( GLEW_OK != err ) return false; if( !GLEW_VERSION_2_1 ) // check that the machine supports the 2.1 API. return false; // // if( !GLEW_ARB_framebuffer_object) // check that the machine supports the 2.1 API. // return false; //if( !GLEW_VERSION_3_1 ) // check that the machine supports the 2.1 API. // return false; // create a texture object GLuint textureId = 0; glGenTextures(1, &textureId); glBindTexture(GL_TEXTURE_2D, textureId); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); // create a renderbuffer object to store depth info GLuint rboId = 0; glGenRenderbuffersEXT(1, &rboId); glBindRenderbufferEXT(GL_RENDERBUFFER, rboId); glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height); glBindRenderbufferEXT(GL_RENDERBUFFER, 0); // create a framebuffer object GLuint fboId = 0; glGenFramebuffersEXT(1, &fboId); glBindFramebufferEXT(GL_FRAMEBUFFER, fboId); // attach the texture to FBO color attachment point glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0); // attach the renderbuffer to depth attachment point glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboId); bool fboUsed = true; // check FBO status GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER); if(status != GL_FRAMEBUFFER_COMPLETE) fboUsed = false; glBindFramebufferEXT(GL_FRAMEBUFFER, fboId); glViewport(0, 0, width, height); glClearColor(1, 1, 0, 1); //glPushAttrib(GL_COLOR_BUFFER_BIT | GL_PIXEL_MODE_BIT); // for GL_DRAW_BUFFER and GL_READ_BUFFER //glDrawBuffer(GL_BACK); //glReadBuffer(GL_BACK); assert(0 == glGetError()); //glClear(GL_FRONT_AND_BACK); assert(0 == glGetError()); glMatrixMode(GL_PROJECTION); glLoadIdentity(); double aspect = width / (double)height; glOrtho(-3, 3, -3/aspect, 3/aspect, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslated(-1.5, 0, 0); //glUseProgram(0); DrawQuad(); glTranslated(1.5, 0, 0); //glPopAttrib(); quad_modelRender qr; qr.Setquad_model(model); char logbuffer[1024] = ""; int loglen = ARRAYSIZE(logbuffer); qr.Initialize(logbuffer, &loglen); assert(0 == glGetError()); qr.Render(); assert(0 == glGetError()); glFinish(); GLenum error = glGetError(); int bits = 24; std::vector<unsigned char> buffer; buffer.resize( width * height * bits / 8 ); glBindTexture(GL_TEXTURE_2D, textureId); glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGetTexImage(GL_TEXTURE_2D, 0, GL_BGR, GL_UNSIGNED_BYTE, &buffer[0]); glBindTexture(GL_TEXTURE_2D, 0); glBindFramebufferEXT(GL_FRAMEBUFFER, 0); wglMakeCurrent(NULL, NULL); wglDeleteContext(hRC); ReleaseDC(hWND, hDC); //CloseWindow(hWND); BITMAPFILEHEADER bfh = {0}; bfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + buffer.size(); bfh.bfType = 0x4D42; bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); BITMAPINFOHEADER bih = {}; bih.biSize = sizeof(BITMAPINFOHEADER); bih.biWidth= width; bih.biHeight= height; bih.biPlanes= 1; bih.biBitCount= bits; // image/bmp mg_write(conn, &bfh, sizeof(bfh)); mg_write(conn, &bih, sizeof(bih)); mg_write(conn, &buffer[0], buffer.size()); }
void MushiRequest::write(char *data){ mg_write(this->conn,data,strlen(data)); }
static int adapt_serve(struct mg_connection* connection) { struct mg_request_info* request = mg_get_request_info(connection); adapt_serving_context* context = (adapt_serving_context*)request->user_data; const char* uri = request->uri; // char buf[1024]; // sprintf(buf, "Requested uri '%s'\n", uri); // OutputDebugStringA(buf); if (strncmp(uri, context->content_prefix, strlen(context->content_prefix)) == 0) { const char* file_name = uri + strlen(context->content_prefix); if (context->callback->packaging_type == ADAPT_PACKAGE_ZIP) { if (*file_name == '\0') { // Special case, query about file structure const char * r = strstr(request->query_string, "r="); if (r && adapt_serve_zip_metadata(request->request_method, connection, context, r+2)) { return 1; } } else if (adapt_serve_zip_entry(connection, context, file_name)) { return 1; } } else if (context->callback->packaging_type == ADAPT_PACKAGE_SINGLE_FILE) { // plain fb2 file, no external resources if (strcmp(file_name, "file.fb2") == 0) { char buf[4096]; size_t p = 0; mg_printf(connection, "HTTP/1.1 200 Success\r\n" "Content-Type: text/xml\r\n" "Content-Length: %ld\r\n" "\r\n", context->callback->content_length); do { size_t len = context->callback->content_length - p; if (len > sizeof buf) { len = sizeof buf; } context->callback->read_bytes(context->callback, buf, p, len); mg_write(connection, buf, len); p += len; } while (p < context->callback->content_length); return 1; } } else if (context->callback->packaging_type == ADAPT_PACKAGE_FILE_SYSTEM) { if (*file_name != '\0') { return 0; } } } else if (strcmp(uri, context->msg_url) == 0) { if (strcmp(request->request_method, "POST") == 0) { int len = 0; char* buf = adapt_read_connection(connection, &len); if (buf) { context->callback->process_message(context->callback, buf, len); free(buf); } } mg_printf(connection, "HTTP/1.1 200 Success\r\n" "Content-Length: 4\r\n" "\r\nOK\r\n"); return 1; } else if (strncmp(uri, context->html_prefix, strlen(context->html_prefix)) == 0) { const char* file_name = uri + strlen(context->html_prefix); if (strcmp(file_name, "driver.xhtml") == 0) { mg_printf(connection, "HTTP/1.1 200 Success\r\n" "Content-Type: application/xhtml+xml\r\n" "Content-Length: %ld\r\n" "\r\n", strlen(adapt_driver)); mg_write(connection, adapt_driver, sizeof adapt_driver); return 1; } else { const struct adapt_resource* resource = adapt_resource_find(file_name); if (resource) { mg_printf(connection, "HTTP/1.1 200 Success\r\n" "Content-Type: %s\r\n" "Content-Length: %d\r\n" "%s" "\r\n", resource->type, resource->size, resource->compressed ? "Content-Encoding: gzip\r\n" : ""); mg_write(connection, resource->data, resource->size); return 1; } } } mg_write(connection, adapt_http_error, strlen(adapt_http_error)); return 1; }
int Response::vprintf(const char *fmt, va_list ap) { char buf[BUFSIZE]; int len = mg_vsnprintf(conn, buf, sizeof(buf), fmt, ap); return mg_write(conn, buf, (size_t)len); }
/* ************************* * GET * Mongoose http will call this function for each request. * May run in separate thread, will be multithreaded. */ void get(struct mg_connection *conn, const struct mg_request_info *ri, void *user_data) { size_t isize; size_t size; FILE *fp; char *data; int res; int SN; int modulus=1; printf("Request: %s\n",ri->query_string); printf("Uri: -->%s<--\n",ri->uri); if ( str_eq(ri->uri, "/status.html") ) { mg_printf(conn, "HTTP/1.1 200 OK\r\n"); mg_printf(conn, "Content-Type: text/html\r\n\r\n"); mg_printf(conn, STATUS_PAGE, SN1_par, SN2_par, SN3_par ); mg_printf(conn, FORM_PAGE); return; } if ( str_eq(ri->uri, "/SET_STATUS") ) { getServerStatus( ri->query_string ); mg_printf(conn, "HTTP/1.1 200 OK\r\n"); mg_printf(conn, "Content-Type: text/html\r\n\r\n"); mg_printf(conn, STATUS_PAGE, SN1_par, SN2_par, SN3_par ); mg_printf(conn, FORM_PAGE); return; } if ( str_eq( ri->uri, "/favicon.ico") ) { data = (char *) malloc( MAXDATASIZE ); struct stat st; stat("favicon.ico", &st); size = st.st_size; fp = fopen("favicon.ico","rb" ); if (fp == NULL) { isize = 0; goto finis; } isize = fread( data, sizeof( char ), size, fp ); fclose( fp ); finis: // printf("Sending data if size %d as image \n", (int)size ); mg_printf(conn, "HTTP/1.1 200 OK\r\n"); mg_printf(conn, "Content-Type: image/png\r\n"); mg_printf(conn, "Content-Length: %d\r\n\r\n",(int)size ); res = mg_write(conn, data, (int)size); return; } if (ri->query_string == NULL) { mg_printf(conn, "HTTP/1.1 400 NO DATA RETURNED\r\n"); mg_printf(conn, "Content-Type: text/plain\r\n\r\n"); mg_printf(conn, "NULL Query. No answer\r\n"); return; } // Else return YES or NO // mg_printf(conn, "HTTP/1.1 200 OK\r\n"); mg_printf(conn, "Content-Type: text/plain\r\n\r\n"); helper_num++; SN = getServerNr(ri->query_string); SN = SN % 3; // if someone does not read the assignment correctly if ( SN == 0 ){ helper1++; if (SN1_par == 0 ) { mg_printf(conn, "NO\r\n"); } else if (SN1_par == 100 ) { mg_printf(conn, "YES\r\n"); } else { modulus = 10; if ( (helper1 % modulus) <= (SN1_par/10) ) { mg_printf(conn, "YES\r\n"); } else { mg_printf(conn, "NO\r\n"); } } }else if ( SN == 1 ) { helper2++; if (SN2_par == 0 ) { mg_printf(conn, "NO\r\n"); } else if (SN2_par == 100 ) { mg_printf(conn, "YES\r\n"); } else { modulus = 10; if ( (helper2 % modulus) <= (SN2_par/10) ) { mg_printf(conn, "YES\r\n"); } else { mg_printf(conn, "NO\r\n"); } } } else { helper3++; if (SN3_par == 0 ) { mg_printf(conn, "NO\r\n"); } else if (SN3_par == 100 ) { mg_printf(conn, "YES\r\n"); } else { modulus = 10; if ( (helper3 % modulus) <= (SN3_par/10) ) { mg_printf(conn, "YES\r\n"); } else { mg_printf(conn, "NO\r\n"); } } } return; }
int HttpConnection::write(core::data const& da) { use<mg_connection> cnt = connection; return mg_write(cnt, da.bytes(), da.length()); }
static void *mongoose_callback(enum mg_event event, struct mg_connection *conn) { const struct mg_request_info *request_info = mg_get_request_info(conn); if (event == MG_INIT0) { verify_document_root(mg_get_conn_option(conn, "document_root")); return (void *)1; } #if defined(_WIN32) if (event == MG_EVENT_LOG && strstr(request_info->log_message, "cannot bind to") && !strcmp(request_info->log_severity, "error")) { if (!error_dialog_shown_previously) { MessageBoxA(NULL, request_info->log_message, "Error", MB_OK); error_dialog_shown_previously = 1; } return 0; } #endif #if USE_BEL2125_TEST_NR_18_EVENT_HANDLER { int contentLength = 0; int dataRead = 0; char postData[BUFFER_SIZE] = { 0 }; const char* contentType = NULL; if (event == MG_NEW_REQUEST) { if (strstr(request_info->uri, "/echo") == request_info->uri) { int ie_hack = 0; // testing an assumption; turns out it doesn't matter whether headers make it into TCP stack before you expect to fetch all input data at once. int ie_hack2 = 0; contentLength = atoi(mg_get_header(conn, "Content-Length")); assert(contentLength <= BUFFER_SIZE); mg_set_response_code(conn, 200); if (ie_hack2) mg_connection_must_close(conn); // the stackoverflow suggested fix: http://stackoverflow.com/questions/3731420/why-does-ie-issue-random-xhr-408-12152-responses-using-jquery-post contentType = mg_get_header(conn, "Content-Type"); if (ie_hack) { //mg_add_response_header(conn, 0, "Connection", mg_suggest_connection_header(conn)); -- not needed any longer mg_add_response_header(conn, 0, "Content-Type", contentType); mg_add_response_header(conn, 0, "Content-Length", "%d", contentLength); mg_write_http_response_head(conn, 0, 0); // let the previous mg_set_response_code() decide for us } dataRead = mg_read(conn, postData, contentLength); if (dataRead > 0) { assert(dataRead == contentLength); if (!ie_hack) { //mg_add_response_header(conn, 0, "Connection", mg_suggest_connection_header(conn)); -- not needed any longer mg_add_response_header(conn, 0, "Content-Type", contentType); mg_add_response_header(conn, 0, "Content-Length", "%d", dataRead); mg_write_http_response_head(conn, 0, 0); // let the previous mg_set_response_code() decide for us } if (mg_write(conn, postData, dataRead) != contentLength) { mg_send_http_error(conn, 580, NULL, "not all data was written to the socket (len: %u)", (unsigned int)contentLength); // internal error in our custom handler or client closed connection prematurely } return (void*)1; } else { mg_send_http_error(conn, 500, NULL, "I/O failure during mg_read() from connection: %s", mg_strerror(ERRNO)); } } } } #endif // USE_BEL2125_TEST_NR_18_EVENT_HANDLER if (event != MG_NEW_REQUEST) { // This callback currently only handles new requests return NULL; } { int file_found; struct mgstat fst; assert(request_info->phys_path); file_found = (0 == mg_stat(request_info->phys_path, &fst) && !fst.is_directory); if (file_found) { return NULL; // let mongoose handle the default of 'file exists'... } #ifdef _WIN32 // Send the systray icon as favicon if (!strcmp("/favicon.ico", request_info->uri)) { HMODULE module; HRSRC icon; DWORD len; void *data; module = GetModuleHandle(NULL); icon = FindResource(module, MAKEINTRESOURCE(IDR_FAVICON), RT_RCDATA); data = LockResource(LoadResource(module, icon)); len = SizeofResource(module, icon); mg_add_response_header(conn, 0, "Content-Type", "image/x-icon"); mg_add_response_header(conn, 0, "Cache-Control", "no-cache"); mg_add_response_header(conn, 0, "Content-Length", "%u", (unsigned int)len); //mg_add_response_header(conn, 0, "Connection", suggest_connection_header(conn)); -- not needed any longer mg_write_http_response_head(conn, 200, NULL); if ((int)len != mg_write(conn, data, len)) { mg_send_http_error(conn, 580, NULL, "not all data was written to the socket (len: %u)", (unsigned int)len); // internal error in our custom handler or client closed connection prematurely } return (void *)1; } #endif } return NULL; }
/** * Mongoose callback. Run in an arbitrary thread (possibly concurrently with other requests). */ static void* MgCallback(mg_event event, struct mg_connection *conn, const struct mg_request_info *request_info) { CProfiler2* profiler = (CProfiler2*)request_info->user_data; ENSURE(profiler); void* handled = (void*)""; // arbitrary non-NULL pointer to indicate successful handling const char* header200 = "HTTP/1.1 200 OK\r\n" "Access-Control-Allow-Origin: *\r\n" // TODO: not great for security "Content-Type: text/plain; charset=utf-8\r\n\r\n"; const char* header404 = "HTTP/1.1 404 Not Found\r\n" "Content-Type: text/plain; charset=utf-8\r\n\r\n" "Unrecognised URI"; const char* header400 = "HTTP/1.1 400 Bad Request\r\n" "Content-Type: text/plain; charset=utf-8\r\n\r\n" "Invalid request"; switch (event) { case MG_NEW_REQUEST: { std::stringstream stream; std::string uri = request_info->uri; if (uri == "/overview") { profiler->ConstructJSONOverview(stream); } else if (uri == "/query") { if (!request_info->query_string) { mg_printf(conn, "%s (no query string)", header400); return handled; } // Identify the requested thread char buf[256]; int len = mg_get_var(request_info->query_string, strlen(request_info->query_string), "thread", buf, ARRAY_SIZE(buf)); if (len < 0) { mg_printf(conn, "%s (no 'thread')", header400); return handled; } std::string thread(buf); const char* err = profiler->ConstructJSONResponse(stream, thread); if (err) { mg_printf(conn, "%s (%s)", header400, err); return handled; } } else { mg_printf(conn, "%s", header404); return handled; } mg_printf(conn, "%s", header200); std::string str = stream.str(); mg_write(conn, str.c_str(), str.length()); return handled; } case MG_HTTP_ERROR: return NULL; case MG_EVENT_LOG: // Called by Mongoose's cry() LOGERROR("Mongoose error: %s", request_info->log_message); return NULL; case MG_INIT_SSL: return NULL; default: debug_warn(L"Invalid Mongoose event type"); return NULL; } };
static int wiringAdmin_callback(struct mg_connection *conn) { int result = 0; // zero means: let civetweb handle it further, any non-zero value means it is handled by us... const struct mg_request_info *request_info = mg_get_request_info(conn); if (request_info->uri != NULL) { wiring_admin_pt admin = request_info->user_data; if (hashMap_size(admin->wiringReceiveServices) == 0) { printf("%s: No wiringReceiveServices available\n", TAG); } if (strcmp("POST", request_info->request_method) == 0) { celixThreadMutex_lock(&admin->exportedWiringEndpointLock); uint64_t datalength = request_info->content_length; char* data = malloc(datalength + 1); mg_read(conn, data, datalength); data[datalength] = '\0'; char *response = NULL; hash_map_iterator_pt iter = hashMapIterator_create(admin->wiringReceiveServices); while (hashMapIterator_hasNext(iter)) { array_list_pt wiringReceiveServiceList = hashMapIterator_nextValue(iter); if (arrayList_size(wiringReceiveServiceList) > 0) { // printf("WIRING_ADMIN: size of wiringReceiveServiceList is %d\n", arrayList_size(wiringReceiveServiceList)); // TODO: we do not support mulitple wiringReceivers? wiring_receive_service_pt wiringReceiveService = (wiring_receive_service_pt) arrayList_get(wiringReceiveServiceList, 0); if (wiringReceiveService->receive(wiringReceiveService->handle, data, &response) != CELIX_SUCCESS) { response = NULL; } break; } else { printf("%s: wiringReceiveServiceList is empty\n", TAG); } } hashMapIterator_destroy(iter); if (response != NULL) { mg_write(conn, data_response_headers, strlen(data_response_headers)); mg_write(conn, response, strlen(response)); free(response); } else { mg_write(conn, no_content_response_headers, strlen(no_content_response_headers)); } result = 1; free(data); } else { printf("%s: Received HTTP Request, but no RSA_Inaetics callback is installed. Discarding request.\n", TAG); } celixThreadMutex_unlock(&admin->exportedWiringEndpointLock); } else { printf("%s: Received URI is NULL\n", TAG); } return result; }
static int mongoose_begin_request_callback(struct mg_connection *connection) { const struct mg_request_info *request_info = mg_get_request_info(connection); uint8_t magic_pattern[pattern_magic_bytes]; if (is_latency_test_request(request_info, magic_pattern)) { // This is an XMLHTTPRequest made by JavaScript to measure latency in a // browser window. magic_pattern has been filled in with a pixel pattern to // look for. report_latency(connection, magic_pattern); return 1; // Mark as processed } else if (strcmp(request_info->uri, "/keepServerAlive") == 0) { __sync_fetch_and_add(&keep_alives, 1); mg_printf(connection, "HTTP/1.1 200 OK\r\n" "Access-Control-Allow-Origin: *\r\n" "Content-Type: application/octet-stream\r\n" "Cache-Control: no-cache\r\n" "Transfer-Encoding: chunked\r\n\r\n"); const int chunk_size = 6; char *chunk0 = "1\r\n0\r\n"; char *chunk1 = "1\r\n1\r\n"; char *chunk = latency_tester_available() ? chunk1 : chunk0; const int warmup_chunks = 2048; for (int i = 0; i < warmup_chunks; i++) { mg_write(connection, chunk, chunk_size); } while(true) { chunk = latency_tester_available() ? chunk1 : chunk0; if (!mg_write(connection, chunk, chunk_size)) break; usleep(1000 * 1000); } __sync_fetch_and_add(&keep_alives, -1); return 1; } else if(strcmp(request_info->uri, "/runControlTest") == 0) { uint8_t *test_pattern = (uint8_t *)malloc(pattern_bytes); memset(test_pattern, 0, pattern_bytes); for (int i = 0; i < pattern_magic_bytes; i++) { test_pattern[i] = rand(); } open_native_reference_window(test_pattern); report_latency(connection, test_pattern); close_native_reference_window(); return 1; } else if (strcmp(request_info->uri, "/oculusLatencyTester") == 0) { const char *result_or_error = "Unknown error"; if (run_hardware_latency_test(&result_or_error)) { debug_log("hardware latency test succeeded"); mg_printf(connection, "HTTP/1.1 200 OK\r\n" "Access-Control-Allow-Origin: *\r\n" "Cache-Control: no-cache\r\n" "Content-Type: text/plain\r\n\r\n" "%s", result_or_error); } else { debug_log("hardware latency test failed"); mg_printf(connection, "HTTP/1.1 500 Internal Server Error\r\n" "Access-Control-Allow-Origin: *\r\n" "Cache-Control: no-cache\r\n" "Content-Type: text/plain\r\n\r\n" "%s", result_or_error); } return 1; } else { #ifdef NDEBUG // In release mode, we embed the test files in the executable and serve // them from memory. This makes the test easier to distribute as it is // a standalone executable file with no other dependencies. serve_file_from_memory_or_404(connection); return 1; #else // In debug mode, we serve the test files directly from the filesystem for // ease of development. Mongoose handles file serving for us. return 0; #endif } }
static int inline mg_write(struct mg_connection* conn, const StringT& string) { return mg_write(conn, string.c_str(), string.size()); }
static void* TransportRESTCallback(enum mg_event event, struct mg_connection* conn) { // Serving a new request if (event == MG_NEW_REQUEST) { // Retrieving information associated to the current connection // The method from mongoose directly return a pointer from within // the mg_connection struct, thus it can not fail. const mg_request_info& reqinfo = *mg_get_request_info(conn); assert(reqinfo.user_data != NULL and "invalid user data"); // retrieving the request method first // and directly aborting if invalid RequestMethod rqmd = StringToRequestMethod(reqinfo.request_method); if (rqmd == rqmdInvalid) return ReturnSimpleHTTPCode404(conn); // server data Server::ServerData* serverdata = (Server::ServerData*) reqinfo.user_data; // Decision Tree // For thread safety reasons, we must keep a smart pointer of the decision tree // until the request is served. DecisionTree::Ptr dectreeptr = serverdata->decisionTree; assert(!(!dectreeptr)); const DecisionTree::UrlDictionary& urls = dectreeptr->requestMethods[rqmd]; // invoking the user's callback according the decision tree DecisionTree::UrlDictionary::const_iterator mi = urls.find(reqinfo.uri); if (mi == urls.end()) { // the url has not been found return ReturnSimpleHTTPCode404(conn); } // alias to the method handler const DecisionTree::MethodHandler& mhandler = mi->second; // Original service instance Service& service = *(serverdata->service); assert(serverdata->service != NULL and "invalid reference to Messaging::Service"); // Message context Messaging::Context context(service); // reading / checking for parameters if (not mhandler.parameters.empty()) { // copying all default parameters context.params = mhandler.parameters; // reading parameters from the url query // ignoring unknown parameters if (reqinfo.query_string and reqinfo.query_string[0] != '\0') { if (not DecodeURLQuery(context.params, reqinfo.query_string)) return ReturnSimpleHTTPCode<400>(conn, context); } } // resetting context context.method = mhandler.name; context.schema = mhandler.schema; context.httpStatus = 200; context.remotePort = (uint)reqinfo.remote_port; // response Marshal::Object response; // Invoke user callback mhandler.invoke(context, response); // sending the response uint statusCode = context.httpStatus; if (statusCode >= 200 and statusCode <= context.httpStatusCode.max2xx) { Clob& body = context.clob; # ifndef NDEBUG response.toJSON(body, true); # else response.toJSON(body, false); // reduce size output # endif Clob& out = context.buffer; out = context.httpStatusCode.header2xx[statusCode - 200]; out += "Content-Type: application/json\r\nContent-Length: "; out += body.size(); out += "\r\n\r\n"; out += body; mg_write(conn, out.c_str(), out.size()); // reducing memory usage for some Memory-hungry apps context.autoshrink(); } else if (statusCode >= 400 and statusCode <= context.httpStatusCode.max4xx) { // reducing memory usage for some Memory-hungry apps context.autoshrink(); // response mg_write(conn, context.httpStatusCode.response4xx[statusCode - 400]); } else { // not handled by default mg_write(conn, context.httpStatusCode.response5xx[500 - 500]); } return (void*)"ok"; } return nullptr; }
static inline void* ReturnSimpleHTTPCode404(struct mg_connection* conn) { static const AnyString msg("HTTP/1.1 404 Not found\r\n\r\nNot found"); mg_write(conn, msg); return (void*)"ok"; // the request has been managed }
void Request::writeResponse(Response *response) { string data = response->getData(); mg_write(connection, data.c_str(), data.size()); }
static int begin_request(struct mg_connection *conn) { const struct mg_request_info *request_info = mg_get_request_info(conn); HTrace(request_info->request_method ? request_info->request_method : "", " ", request_info->uri ? request_info->uri : "", request_info->query_string ? "?" : "", request_info->query_string ? request_info->query_string : ""); if (!strcmp("/favicon.ico",request_info->uri)) { string http = print_string( "HTTP/1.1 200 OK\r\n" "Content-Type: image/x-icon\r\n" "Content-Length: ", sizeof(favicon), "\r\n" "\r\n"); mg_write(conn,http.c_str(),http.length()); mg_write(conn,favicon,sizeof(favicon)); return 1; } string body; if (!strcmp("/log",request_info->uri)) { Logging::getLogMessagesHTML(body); } else if (!strcmp("/glEnable",request_info->uri)) { if (!strcmp("GL_LOG_INFO_REGAL", request_info->query_string)) Logging::enableError = true; else if (!strcmp("GL_LOG_WARNING_REGAL", request_info->query_string)) Logging::enableWarning = true; else if (!strcmp("GL_LOG_ERROR_REGAL", request_info->query_string)) Logging::enableInfo = true; else if (!strcmp("GL_LOG_APP_REGAL", request_info->query_string)) Logging::enableApp = true; else if (!strcmp("GL_LOG_DRIVER_REGAL", request_info->query_string)) Logging::enableDriver = true; else if (!strcmp("GL_LOG_INTERNAL_REGAL",request_info->query_string)) Logging::enableInternal = true; else if (!strcmp("GL_LOG_HTTP_REGAL", request_info->query_string)) Logging::enableHttp = true; else if (!strcmp("REGAL_FRAME_TIME", request_info->query_string)) Logging::frameTime = true; else if (!strcmp("REGAL_MD5_COLOR", request_info->query_string)) Config::frameMd5Color = true; else if (!strcmp("REGAL_MD5_STENCIL", request_info->query_string)) Config::frameMd5Stencil = true; else if (!strcmp("REGAL_MD5_DEPTH", request_info->query_string)) Config::frameMd5Depth = true; else if (!strcmp("REGAL_SAVE_COLOR", request_info->query_string)) Config::frameSaveColor = true; else if (!strcmp("REGAL_SAVE_STENCIL", request_info->query_string)) Config::frameSaveStencil = true; else if (!strcmp("REGAL_SAVE_DEPTH", request_info->query_string)) Config::frameSaveDepth = true; body += print_string("glEnable(", request_info->query_string, ");",br,br); body += print_string("<a href=\"/glDisable?",request_info->query_string,"\">toggle</a>"); } else if (!strcmp("/glDisable",request_info->uri)) { if (!strcmp("GL_LOG_INFO_REGAL", request_info->query_string)) Logging::enableError = false; else if (!strcmp("GL_LOG_WARNING_REGAL", request_info->query_string)) Logging::enableWarning = false; else if (!strcmp("GL_LOG_ERROR_REGAL", request_info->query_string)) Logging::enableInfo = false; else if (!strcmp("GL_LOG_APP_REGAL", request_info->query_string)) Logging::enableApp = false; else if (!strcmp("GL_LOG_DRIVER_REGAL", request_info->query_string)) Logging::enableDriver = false; else if (!strcmp("GL_LOG_INTERNAL_REGAL",request_info->query_string)) Logging::enableInternal = false; else if (!strcmp("GL_LOG_HTTP_REGAL", request_info->query_string)) Logging::enableHttp = false; else if (!strcmp("REGAL_FRAME_TIME", request_info->query_string)) Logging::frameTime = false; else if (!strcmp("REGAL_MD5_COLOR", request_info->query_string)) Config::frameMd5Color = false; else if (!strcmp("REGAL_MD5_STENCIL", request_info->query_string)) Config::frameMd5Stencil = false; else if (!strcmp("REGAL_MD5_DEPTH", request_info->query_string)) Config::frameMd5Depth = false; else if (!strcmp("REGAL_SAVE_COLOR", request_info->query_string)) Config::frameSaveColor = false; else if (!strcmp("REGAL_SAVE_STENCIL", request_info->query_string)) Config::frameSaveStencil = false; else if (!strcmp("REGAL_SAVE_DEPTH", request_info->query_string)) Config::frameSaveDepth = false; body += print_string("glDisable(", request_info->query_string, ");",br,br); body += print_string("<a href=\"/glEnable?",request_info->query_string,"\">toggle</a>"); } else { ::REGAL_NAMESPACE_INTERNAL::Init::getContextListingHTML(body); } string html = print_string( "<html><body>\n", body, "</body></html>\n"); string http = print_string( "HTTP/1.1 200 OK\r\n" "Content-Type: text/html\r\n" "Content-Length: ", html.length(), "\r\n" "\r\n", html); mg_write(conn,http.c_str(),http.length()); return 1; // Mark as handled for civetweb }
void ofxWSRequestHandler::httpResponseData(char *data, int length) { mg_write(conn, (const void *)data, length); }
int ServiceOutputStream::write(std::string data){ return mg_write(_conn, data.c_str(), data.length()); }
static void *callback(enum mg_event event, struct mg_connection *conn) { const struct mg_request_info *request_info = mg_get_request_info(conn); switch (event) { case MG_EVENT_LOG: { HTrace(request_info->ev_data ? static_cast<const char *>(request_info->ev_data) : ""); break; } case MG_NEW_REQUEST: { HTrace(request_info->request_method ? request_info->request_method : "", " ", request_info->uri ? request_info->uri : "", request_info->query_string ? "?" : "", request_info->query_string ? request_info->query_string : ""); if (!strcmp("/favicon.ico",request_info->uri)) { string http = print_string( "HTTP/1.1 200 OK\r\n" "Content-Type: image/x-icon\r\n" "Content-Length: ", sizeof(favicon), "\r\n" "\r\n"); mg_write(conn,http.c_str(),http.length()); mg_write(conn,favicon,sizeof(favicon)); return (void *) true; } string body; if (!strcmp("/log",request_info->uri)) { if (Logging::buffer) for (list<string>::const_iterator i = Logging::buffer->begin(); i!=Logging::buffer->end(); ++i) body += print_string(*i,br); } else if (!strcmp("/glEnable",request_info->uri)) { if (!strcmp("GL_LOG_INFO_REGAL", request_info->query_string)) Logging::enableError = true; else if (!strcmp("GL_LOG_WARNING_REGAL", request_info->query_string)) Logging::enableWarning = true; else if (!strcmp("GL_LOG_ERROR_REGAL", request_info->query_string)) Logging::enableInfo = true; else if (!strcmp("GL_LOG_APP_REGAL", request_info->query_string)) Logging::enableApp = true; else if (!strcmp("GL_LOG_DRIVER_REGAL", request_info->query_string)) Logging::enableDriver = true; else if (!strcmp("GL_LOG_INTERNAL_REGAL",request_info->query_string)) Logging::enableInternal = true; else if (!strcmp("GL_LOG_HTTP_REGAL", request_info->query_string)) Logging::enableHttp = true; else if (!strcmp("REGAL_FRAME_TIME", request_info->query_string)) Logging::frameTime = true; else if (!strcmp("REGAL_MD5_COLOR", request_info->query_string)) Config::frameMd5Color = true; else if (!strcmp("REGAL_MD5_STENCIL", request_info->query_string)) Config::frameMd5Stencil = true; else if (!strcmp("REGAL_MD5_DEPTH", request_info->query_string)) Config::frameMd5Depth = true; else if (!strcmp("REGAL_SAVE_COLOR", request_info->query_string)) Config::frameSaveColor = true; else if (!strcmp("REGAL_SAVE_STENCIL", request_info->query_string)) Config::frameSaveStencil = true; else if (!strcmp("REGAL_SAVE_DEPTH", request_info->query_string)) Config::frameSaveDepth = true; body += print_string("glEnable(", request_info->query_string, ");",br,br); body += print_string("<a href=\"/glDisable?",request_info->query_string,"\">toggle</a>"); } else if (!strcmp("/glDisable",request_info->uri)) { if (!strcmp("GL_LOG_INFO_REGAL", request_info->query_string)) Logging::enableError = false; else if (!strcmp("GL_LOG_WARNING_REGAL", request_info->query_string)) Logging::enableWarning = false; else if (!strcmp("GL_LOG_ERROR_REGAL", request_info->query_string)) Logging::enableInfo = false; else if (!strcmp("GL_LOG_APP_REGAL", request_info->query_string)) Logging::enableApp = false; else if (!strcmp("GL_LOG_DRIVER_REGAL", request_info->query_string)) Logging::enableDriver = false; else if (!strcmp("GL_LOG_INTERNAL_REGAL",request_info->query_string)) Logging::enableInternal = false; else if (!strcmp("GL_LOG_HTTP_REGAL", request_info->query_string)) Logging::enableHttp = false; else if (!strcmp("REGAL_FRAME_TIME", request_info->query_string)) Logging::frameTime = false; else if (!strcmp("REGAL_MD5_COLOR", request_info->query_string)) Config::frameMd5Color = false; else if (!strcmp("REGAL_MD5_STENCIL", request_info->query_string)) Config::frameMd5Stencil = false; else if (!strcmp("REGAL_MD5_DEPTH", request_info->query_string)) Config::frameMd5Depth = false; else if (!strcmp("REGAL_SAVE_COLOR", request_info->query_string)) Config::frameSaveColor = false; else if (!strcmp("REGAL_SAVE_STENCIL", request_info->query_string)) Config::frameSaveStencil = false; else if (!strcmp("REGAL_SAVE_DEPTH", request_info->query_string)) Config::frameSaveDepth = false; body += print_string("glDisable(", request_info->query_string, ");",br,br); body += print_string("<a href=\"/glEnable?",request_info->query_string,"\">toggle</a>"); } else { for (map<Thread::Thread, RegalContext *>::const_iterator i = th2rc.begin(); i!=th2rc.end(); ++i) { RegalContext *ctx = i->second; // Need a per-context read-lock? body += print_string("ctx = ",ctx,br); body += br; if (ctx) { if (ctx->info) { body += print_string("<b>Vendor </b>:",ctx->info->regalVendor,br); body += print_string("<b>Renderer </b>:",ctx->info->regalRenderer,br); body += print_string("<b>Version </b>:",ctx->info->regalVersion,br); body += print_string("<b>Extensions </b>:",ctx->info->regalExtensions,br); body += br; } #if REGAL_EMULATION if (ctx->ppa) { body += print_string("<b>GL_STENCIL_BIT</b><br/>",ctx->ppa->State::Stencil::toString(br),br); body += print_string("<b>GL_DEPTH_BIT</b><br/>", ctx->ppa->State::Depth::toString(br),br); body += print_string("<b>GL_POLYGON_BIT</b><br/>",ctx->ppa->State::Polygon::toString(br),br); body += br; } #endif } } } string html = print_string( "<html><body>\n", body, "</body></html>\n"); string http = print_string( "HTTP/1.1 200 OK\r\n" "Content-Type: text/html\r\n" "Content-Length: ", html.length(), "\r\n" "\r\n", html); mg_write(conn,http.c_str(),http.length()); break; } default: return NULL; } return (void *) true; // Mark as handled for Mongoose }
static int io_mg_write(void *context, const void *buffer, int size) { return mg_write((struct mg_connection *)context, buffer, size); }
void* CDebuggingServer::MgDebuggingServerCallback(mg_event event, struct mg_connection *conn, const struct mg_request_info *request_info) { void* handled = (void*)""; // arbitrary non-NULL pointer to indicate successful handling const char* header200 = "HTTP/1.1 200 OK\r\n" "Access-Control-Allow-Origin: *\r\n" // TODO: not great for security "Content-Type: text/plain; charset=utf-8\r\n\r\n"; const char* header404 = "HTTP/1.1 404 Not Found\r\n" "Content-Type: text/plain; charset=utf-8\r\n\r\n" "Unrecognised URI"; switch (event) { case MG_NEW_REQUEST: { std::stringstream stream; std::string uri = request_info->uri; if (uri == "/GetThreadDebuggerStatus") { GetThreadDebuggerStatus(stream); } else if (uri == "/EnumVfsJSFiles") { EnumVfsJSFiles(stream); } else if (uri == "/GetAllCallstacks") { GetAllCallstacks(stream); } else if (uri == "/Continue") { uint threadDebuggerID; if (!GetWebArgs(conn, request_info, "threadDebuggerID", threadDebuggerID)) return handled; // TODO: handle the return value SetNextDbgCmd(threadDebuggerID, DBG_CMD_CONTINUE); } else if (uri == "/Break") { SetBreakRequestedByUser(true); } else if (uri == "/SetSettingSimultaneousThreadBreak") { std::string strEnabled; bool bEnabled = false; if (!GetWebArgs(conn, request_info, "enabled", strEnabled)) return handled; // TODO: handle the return value if (strEnabled == "true") bEnabled = true; else if (strEnabled == "false") bEnabled = false; else return handled; // TODO: return an error state SetSettingSimultaneousThreadBreak(bEnabled); } else if (uri == "/GetSettingSimultaneousThreadBreak") { stream << "{ \"Enabled\" : " << (GetSettingSimultaneousThreadBreak() ? "true" : "false") << " } "; } else if (uri == "/SetSettingBreakOnException") { std::string strEnabled; bool bEnabled = false; if (!GetWebArgs(conn, request_info, "enabled", strEnabled)) return handled; // TODO: handle the return value if (strEnabled == "true") bEnabled = true; else if (strEnabled == "false") bEnabled = false; else return handled; // TODO: return an error state SetSettingBreakOnException(bEnabled); } else if (uri == "/GetSettingBreakOnException") { stream << "{ \"Enabled\" : " << (GetSettingBreakOnException() ? "true" : "false") << " } "; } else if (uri == "/Step") { uint threadDebuggerID; if (!GetWebArgs(conn, request_info, "threadDebuggerID", threadDebuggerID)) return handled; // TODO: handle the return value SetNextDbgCmd(threadDebuggerID, DBG_CMD_SINGLESTEP); } else if (uri == "/StepInto") { uint threadDebuggerID; if (!GetWebArgs(conn, request_info, "threadDebuggerID", threadDebuggerID)) return handled; // TODO: handle the return value SetNextDbgCmd(threadDebuggerID, DBG_CMD_STEPINTO); } else if (uri == "/StepOut") { uint threadDebuggerID; if (!GetWebArgs(conn, request_info, "threadDebuggerID", threadDebuggerID)) return handled; // TODO: handle the return value SetNextDbgCmd(threadDebuggerID, DBG_CMD_STEPOUT); } else if (uri == "/GetStackFrame") { uint nestingLevel; uint threadDebuggerID; if (!GetWebArgs(conn, request_info, "nestingLevel", nestingLevel) || !GetWebArgs(conn, request_info, "threadDebuggerID", threadDebuggerID)) { return handled; } GetStackFrameData(stream, nestingLevel, threadDebuggerID, STACK_INFO_LOCALS); } else if (uri == "/GetStackFrameThis") { uint nestingLevel; uint threadDebuggerID; if (!GetWebArgs(conn, request_info, "nestingLevel", nestingLevel) || !GetWebArgs(conn, request_info, "threadDebuggerID", threadDebuggerID)) { return handled; } GetStackFrameData(stream, nestingLevel, threadDebuggerID, STACK_INFO_THIS); } else if (uri == "/GetCurrentGlobalObject") { uint threadDebuggerID; if (!GetWebArgs(conn, request_info, "threadDebuggerID", threadDebuggerID)) { return handled; } GetStackFrameData(stream, 0, threadDebuggerID, STACK_INFO_GLOBALOBJECT); } else if (uri == "/ToggleBreakpoint") { std::string filename; uint line; if (!GetWebArgs(conn, request_info, "filename", filename) || !GetWebArgs(conn, request_info, "line", line)) { return handled; } ToggleBreakPoint(filename, line); } else if (uri == "/GetFile") { std::string filename; if (!GetWebArgs(conn, request_info, "filename", filename)) return handled; GetFile(filename, stream); } else { mg_printf(conn, "%s", header404); return handled; } mg_printf(conn, "%s", header200); std::string str = stream.str(); mg_write(conn, str.c_str(), str.length()); return handled; } case MG_HTTP_ERROR: return NULL; case MG_EVENT_LOG: // Called by Mongoose's cry() LOGERROR(L"Mongoose error: %hs", request_info->log_message); return NULL; case MG_INIT_SSL: return NULL; default: debug_warn(L"Invalid Mongoose event type"); return NULL; } };
static void *mongoose_callback(enum mg_event event, struct mg_connection *conn) { const struct mg_request_info *request_info = mg_get_request_info(conn); if (event == MG_INIT0) { verify_document_root(mg_get_conn_option(conn, "document_root")); return (void *)1; } #if defined(_WIN32) if (event == MG_EVENT_LOG && strstr(request_info->log_message, "cannot bind to") && !strcmp(request_info->log_severity, "error")) { if (!error_dialog_shown_previously) { MessageBoxA(NULL, request_info->log_message, "Error", MB_OK); error_dialog_shown_previously = 1; } return 0; } #endif if (event != MG_NEW_REQUEST) { // This callback currently only handles new requests return NULL; } { int file_found; struct mgstat fst; assert(request_info->phys_path); file_found = (0 == mg_stat(request_info->phys_path, &fst) && !fst.is_directory); if (file_found) { return NULL; // let mongoose handle the default of 'file exists'... } #ifdef _WIN32 // Send the systray icon as favicon if (!strcmp("/favicon.ico", request_info->uri)) { HMODULE module; HRSRC icon; DWORD len; void *data; module = GetModuleHandle(NULL); icon = FindResource(module, MAKEINTRESOURCE(IDR_FAVICON), RT_RCDATA); data = LockResource(LoadResource(module, icon)); len = SizeofResource(module, icon); mg_add_response_header(conn, 0, "Content-Type", "image/x-icon"); mg_add_response_header(conn, 0, "Cache-Control", "no-cache"); mg_add_response_header(conn, 0, "Content-Length", "%u", (unsigned int)len); //mg_add_response_header(conn, 0, "Connection", suggest_connection_header(conn)); -- not needed any longer mg_write_http_response_head(conn, 200, NULL); if ((int)len != mg_write(conn, data, len)) { mg_send_http_error(conn, 580, NULL, "not all data was written to the socket (len: %u)", (unsigned int)len); // internal error in our custom handler or client closed connection prematurely } return (void *)1; } #endif } return NULL; }
static void adapt_sink_connection_write(struct adapt_sink* sink, size_t file_offset, const unsigned char* buf, size_t length) { if (length > 0) { mg_write(((struct adapt_sink_connection*)sink)->connection, buf, length); } }
void MushiRequest::write(QString data){ mg_write(this->conn,data.toStdString().c_str(),data.length()); }
void* FileServer::mongooseCallback(enum mg_event event, struct mg_connection *conn, const struct mg_request_info *request_info) { if (event != MG_NEW_REQUEST) { return NULL; } assert(FileServer::s_self != NULL); if (FileServer::s_self == NULL) { return NULL; } std::string id(request_info->uri); bplus::service::Service::log(BP_INFO, "request.url.path = " + id); // drop the leading / id = id.substr(1, id.length() - 1); // if we can find a slash '/', in the url, we'll drop everything after it. size_t slashLoc = id.find('/'); if (slashLoc != std::string::npos) { id = id.substr(0, slashLoc); } bplus::service::Service::log(BP_INFO, "token '" + id + "' extracted from request path: " + request_info->uri); boost::filesystem::path path; { bplus::sync::Lock lck(FileServer::s_self->m_lock); std::map<std::string,boost::filesystem::path>::const_iterator it; it = FileServer::s_self->m_paths.find(id); if (it == FileServer::s_self->m_paths.end()) { bplus::service::Service::log(BP_WARN, "Requested id not found."); mg_printf(conn, "HTTP/1.0 404 Not Found\r\n\r\n"); return conn; } path = it->second; } // read file and output to connection std::ifstream ifs; if (!bp::file::openReadableStream(ifs, path.string(), std::ios::binary)) { bplus::service::Service::log(BP_WARN, "Couldn't open file for reading " + path.string()); mg_printf(conn, "HTTP/1.0 500 Internal Error\r\n\r\n"); return conn; } // get length of file: long len = 0; try { ifs.seekg(0, std::ios::end); len = ifs.tellg(); ifs.seekg(0, std::ios::beg); } catch (...) { len = -1; } if (len < 0) { bplus::service::Service::log(BP_WARN, "Couldn't determine file length: " + path.string()); mg_printf(conn, "HTTP/1.0 500 Internal Error\r\n\r\n"); return conn; } mg_printf(conn, "HTTP/1.0 200 OK\r\n"); mg_printf(conn, "Content-Length: %ld\r\n", len); mg_printf(conn, "Server: FileAccess BrowserPlus service\r\n"); // set mime type header { std::vector<std::string> mts; mts = bp::file::mimeTypes(path); if (mts.size() > 0) { mg_printf(conn, "Content-Type: %s\r\n", mts.begin()->c_str()); } } mg_printf(conn, "\r\n"); char buf[1024 * 32]; while (!ifs.eof()) { size_t rd = 0; ifs.read(buf, sizeof(buf)); rd = ifs.gcount(); if (rd != (size_t) mg_write(conn, buf, rd)) { bplus::service::Service::log(BP_WARN, "partial write detected! client left?"); ifs.close(); return conn; } } bplus::service::Service::log(BP_DEBUG, "Request processed."); return conn; }
void MushiRequest::write(std::string data){ mg_write(this->conn,data.c_str(),data.length()); }
void Response::write(char const * buf, size_t size) { checkHeadersSent(); mg_write(conn, buf, size); }
static int remoteServiceAdmin_callback(struct mg_connection *conn) { int result = 1; // zero means: let civetweb handle it further, any non-zero value means it is handled by us... const struct mg_request_info *request_info = mg_get_request_info(conn); if (request_info->uri != NULL) { remote_service_admin_pt rsa = request_info->user_data; if (strncmp(request_info->uri, "/service/", 9) == 0 && strcmp("POST", request_info->request_method) == 0) { // uri = /services/myservice/call const char *uri = request_info->uri; // rest = myservice/call const char *rest = uri+9; char *interfaceStart = strchr(rest, '/'); int pos = interfaceStart - rest; char service[pos+1]; strncpy(service, rest, pos); service[pos] = '\0'; long serviceId = atol(service); celixThreadMutex_lock(&rsa->exportedServicesLock); //find endpoint export_registration_pt export = NULL; hash_map_iterator_pt iter = hashMapIterator_create(rsa->exportedServices); while (hashMapIterator_hasNext(iter)) { hash_map_entry_pt entry = hashMapIterator_nextEntry(iter); array_list_pt exports = hashMapEntry_getValue(entry); int expIt = 0; for (expIt = 0; expIt < arrayList_size(exports); expIt++) { export_registration_pt check = arrayList_get(exports, expIt); export_reference_pt ref = NULL; exportRegistration_getExportReference(check, &ref); endpoint_description_pt checkEndpoint = NULL; exportReference_getExportedEndpoint(ref, &checkEndpoint); if (serviceId == checkEndpoint->serviceId) { export = check; free(ref); break; } free(ref); } } hashMapIterator_destroy(iter); if (export != NULL) { uint64_t datalength = request_info->content_length; char* data = malloc(datalength + 1); mg_read(conn, data, datalength); data[datalength] = '\0'; char *response = NULL; int responceLength = 0; int rc = exportRegistration_call(export, data, -1, &response, &responceLength); if (rc != CELIX_SUCCESS) { RSA_LOG_ERROR(rsa, "Error trying to invoke remove service, got error %i\n", rc); } if (rc == CELIX_SUCCESS && response != NULL) { mg_write(conn, data_response_headers, strlen(data_response_headers)); mg_write(conn, response, strlen(response)); free(response); } else { mg_write(conn, no_content_response_headers, strlen(no_content_response_headers)); } result = 1; free(data); } else {