int ev_handler(struct mg_connection *conn, enum mg_event ev) { switch (ev) { case MG_AUTH: return MG_TRUE; case MG_REQUEST: { //mg_printf_data(conn, "Hello! Requested URI is [%s]", conn->uri); info("Requested URI:REQ is [%s]:[%s]", conn->uri, conn->request_method); mg_send_header(conn, "Content-Type", "application/json"); json_t* jobj_req = NULL; json_error_t jerror; if (cmpuri(conn->request_method,"POST")){ jobj_req = json_loadb(conn->content, conn->content_len, 0, &jerror); if (!jobj_req){ mg_printf_data(conn,"json error on line %d: %s\n", jerror.line, jerror.text); mg_send_status(conn, 400); info("error parsing json POST, json error on line %d: %s\n", jerror.line, jerror.text); return MG_TRUE; } } json_t* jobj_resp = json_object(); int status = 404; //allow handler to choose response status status = root_handler(conn, jobj_req, jobj_resp); //free request if (jobj_req){ json_decref(jobj_req); jobj_req = NULL; } //dump response char * jstr = json_dumps(jobj_resp, 0); json_decref(jobj_resp); jobj_resp = NULL; if (status == 404){ char* errmsg = "{\"error\":\"No handler for URI found.\"}"; mg_send_data(conn, errmsg, strlen(errmsg)); mg_send_status(conn, 404); } else { mg_send_data(conn, jstr, strlen(jstr)); mg_send_status(conn, status); } free(jstr); return MG_TRUE; } default: return MG_FALSE; } }
void apollo::upload_item_image( hades::connection& conn, mg_connection *mg_conn, const int item_id, atlas::http::uri_callback_type callback_success, atlas::http::uri_callback_type callback_failure ) { upload_file( conn, mg_conn, "attachment_title", "attachment_data", [&conn, mg_conn, callback_success, item_id](attachment a) { insert_attachment(a, conn); image_of iof; iof.get_int<attr::attachment_id>() = a.info.get_int<attr::attachment_id>(); iof.get_int<attr::item_id>() = item_id; iof.insert(conn); // Send details of the attachment. auto r = atlas::http::json_response(a.info); mg_send_status(mg_conn, 200); mg_send_header(mg_conn, "Content-type", "text/json"); mg_send_data(mg_conn, r.data.c_str(), r.data.length()); callback_success(); }, callback_failure ); }
atlas::http::uri_type atlas::http::detail::make_async(uri_function_type f) { return [f]( mg_connection *conn, uri_parameters_type match, uri_callback_type success, uri_callback_type failure ) { try { response r = f(match); mg_send_status(conn, r.status_code); for(std::pair<std::string, std::string> header : r.headers) mg_send_header(conn, header.first.c_str(), header.second.c_str()); mg_send_data(conn, r.data.c_str(), r.data.length()); success(); } catch(const http::exception& e) { log::error("atlas::http::detail::make_async") << "exception returned to client: " << e.what(); error(e.code(), e.what(), conn, success, failure); } catch(const std::exception& e) { log::error("atlas::http::detail::make_async") << "exception not returned to client: " << e.what(); // There was an exception while processing the request; we don't // want to provide further information to the client. error(500, "unknown error", conn, success, failure); } }; }
void ouroboros_server::handle_group_rest(const rest_request& aRequest) { //get reference to named thing group<var_field> *pgroup = mStore.get(normalize_group(aRequest.getGroups())); std::string sjson; mg_connection *conn = aRequest.getConnection(); if (pgroup) { switch (aRequest.getHttpRequestType()) { case GET: //Send JSON describing named item sjson = pgroup->getJSON(); break; default: sjson = detail::bad_JSON(conn); } } else { sjson = detail::bad_JSON(conn); } mg_send_data(conn, sjson.c_str(), sjson.length()); }
static void send_index_page(struct mg_connection *conn) { const char *data; int data_len; char var_name[100], file_name[100]; mg_printf_data(conn, "%s", "<html><body>Upload example." "<form method=\"POST\" action=\"/handle_post_request\" " " enctype=\"multipart/form-data\">" "<input type=\"file\" name=\"file\" /> <br/>" "<input type=\"submit\" value=\"Upload\" />" "</form>"); if (mg_parse_multipart(conn->content, conn->content_len, var_name, sizeof(var_name), file_name, sizeof(file_name), &data, &data_len) > 0) { mg_printf_data(conn, "%s", "Uploaded file:<pre>"); mg_send_data(conn, data, data_len); mg_printf_data(conn, "%s", "/pre>"); } mg_printf_data(conn, "%s", "</body></html>"); }
static int handle_health(struct mg_connection *conn) { send_headers(conn); char health[4] = {(char)0xF0, (char)0x9F, (char)0x91, (char)0xBB}; mg_send_data(conn, health, 4); return MG_TRUE; }
void ouroboros_server::handle_callback_rest(const rest_request& aRequest) { //get reference to named thing std::string resource = normalize_group(aRequest.getGroups()) + '/' + aRequest.getFields(); var_field *named = mStore.get(normalize_group(aRequest.getGroups()), aRequest.getFields()); std::string response; mg_connection *conn = aRequest.getConnection(); if (named) { switch (aRequest.getHttpRequestType()) { case POST: { std::string data(conn->content, conn->content_len); JSON json(data); std::string response_url = json.get("callback"); //create callback //Due to a limitation of C++03, use a semi-global map //to track response URLs mResponseUrls[named] = response_url; std::string callback_id = register_callback(aRequest.getGroups(), aRequest.getFields(), establish_connection); std::stringstream ss; ss << "{ \"id\" : \"" << callback_id << "\" }"; mg_send_status(conn, 201); response = ss.str(); } break; //TODO DELETE is not supported by the underlying mechanism /*case DELETE: { //Send JSON describing named item std::string data(conn->content, conn->content_len); JSON json(data); std::string id = json.get("id"); unregister_callback(id); response = detail::good_JSON(); }*/ break; default: response = detail::bad_JSON(conn); } } else { response = detail::bad_JSON(conn); } mg_send_data(conn, response.c_str(), response.length()); }
void Response::Send(struct mg_connection* conn) const { mg_send_status(conn, status_code_); if (!headers_.empty()) { HeaderMap::const_iterator itr = headers_.begin(); HeaderMap::const_iterator end = headers_.end(); for (; itr != end; ++itr) { mg_send_header(conn, (itr->first).c_str(), (itr->second).c_str()); } } if (data_.empty()) { mg_send_data(conn, 0, 0); } else { mg_send_data(conn, data_.c_str(), data_.length()); } }
static int httpserver_ev_handler(struct mg_connection *conn, enum mg_event ev) { if (ev == MG_REQUEST) { //mg_send_header(conn, "Content-Type", "text/plain"); //mg_printf_data(conn, "This is a reply from server instance # %s", (char *)conn->server_param); if (PaymentVerifyModule.OnChargeFromSWServer(conn)) { mg_send_data(conn, "0", 1); } else { mg_send_data(conn, "1", 1); } return MG_TRUE; } else if (ev == MG_AUTH) { return MG_TRUE; } else { return MG_FALSE; } }
static void lsp(struct mg_connection *conn, const char *p, int len, lua_State *L) { int i, j, pos = 0; for (i = 0; i < len; i++) { if (p[i] == '<' && p[i + 1] == '?') { for (j = i + 1; j < len ; j++) { if (p[j] == '?' && p[j + 1] == '>') { if (i-pos!=0) mg_send_data(conn, p + pos, i - pos); if (luaL_loadbuffer(L, p + (i + 2), j - (i + 2), "") == 0) { lua_pcall(L, 0, LUA_MULTRET, 0); } pos = j + 2; i = pos - 1; break; } } } } if (i > pos) { mg_send_data(conn, p + pos, i - pos); } }
static void effects_get(struct mg_connection* conn) { int len; settings_load(); len = effects_json(work_buf, sizeof(work_buf)); mg_send_header(conn, CONTENT_TYPE, CONTENT_TYPE_JSON); mg_send_status(conn, 200); mg_send_data(conn, work_buf, len); }
static void settings_post(struct mg_connection* conn) { int rc; int len; char buf[256]; settings_load(); len = mg_get_var(conn, BRIGHTNESS, buf, sizeof(buf)); if (len > 0) { settings.brightness = strtol(buf, NULL, 10); } len = mg_get_var(conn, MANUAL_TICK, buf, sizeof(buf)); if (len > 0) { settings.manual_tick = strtol(buf, NULL, 10); } len = mg_get_var(conn, IDLE_INTERVAL, buf, sizeof(buf)); if (len > 0) { settings.idle_interval = strtol(buf, NULL, 10); } len = mg_get_var(conn, MANUAL_TOGGLE, buf, sizeof(buf)); if (len > 0) { settings.manual_toggle = strtol(buf, NULL, 10); } len = mg_get_var(conn, SCREEN_SAVER_TOGGLE, buf, sizeof(buf)); if (len > 0) { settings.screen_saver_toggle = strtol(buf, NULL, 10); } len = mg_get_var(conn, ALPHA, buf, sizeof(buf)); if (len > 0) { settings.alpha = strtol(buf, NULL, 10); } rc = settings_save(); if (rc) { mg_printf_data(conn, "Could not save " SETTINGS_FILE); mg_send_status(conn, 500); return; } len = settings_json(work_buf, sizeof(work_buf)); mg_send_header(conn, CONTENT_TYPE, CONTENT_TYPE_JSON); mg_send_status(conn, 200); mg_send_data(conn, work_buf, len); }
static int event_handler(struct mg_connection *conn) { mg_send_data(conn, "test success", strlen("test success")); std::cout << conn->uri << std::endl; std::string strUri = conn->uri; strUri.erase(0, strUri.find("/callPython/") + sizeof("/callPython/") - 1); std::cout << strUri.c_str() << std::endl; std::string strCmd = "python "; strCmd += strUri; system(strCmd.c_str()); return 0; }
static int index_html(struct mg_connection *conn) { size_t index_size; const char *index_html = find_embedded_file("websocket.html", &index_size); if (conn->is_websocket) { // This handler is called for each incoming websocket frame, one or more // times for connection lifetime. // Echo websocket data back to the client. mg_websocket_write(conn, 1, conn->content, conn->content_len); return conn->content_len == 4 && !memcmp(conn->content, "exit", 4) ? MG_CLIENT_CLOSE : MG_CLIENT_CONTINUE; } else { mg_send_header(conn, "Content-Type", "text/html"); mg_send_data(conn, index_html, index_size); return MG_REQUEST_PROCESSED; } }
atlas::http::uri_type atlas::http::detail::make_async_with_conn(conn_uri_function_type f) { return [f]( mg_connection *conn, uri_parameters_type match, uri_callback_type success, uri_callback_type failure ) { response r = f(conn, match); mg_send_status(conn, r.status_code); for(std::pair<std::string, std::string> header : r.headers) mg_send_header(conn, header.first.c_str(), header.second.c_str()); mg_send_data(conn, r.data.c_str(), r.data.length()); success(); }; }
int webserver_request_handler(struct mg_connection* conn, enum mg_event ev) { if (ev == MG_REQUEST) { /* check ajax json requests * else just send the file to the client */ if (strstr(conn->uri, AJAX_HEADER) == conn->uri) { char param1[64]; char param2[64]; const char* cmd = conn->uri + strlen(AJAX_HEADER); /* read POST data for parameters */ mg_get_var(conn, "p1", param1, sizeof(param1)); mg_get_var(conn, "p2", param2, sizeof(param2)); webserver_runajax(conn, cmd, param1, param2); } else { /* set default 'index.html' for urls with no file references */ char path[DH_PATH_MAX]; strcpy(path, WEB_ROOTDIR); strcat(path, conn->uri); if (util_pathisdir(path)) { if (path[strlen(path)-1] != '/') strcat(path, "/index.html"); else strcat(path, "index.html"); } /* send back the file to the client */ file_t f = fio_openmem(mem_heap(), path, FALSE, MID_PRF); if (f != NULL) { size_t size; void* data = fio_detachmem(f, &size, NULL); mg_send_data(conn, data, (uint)size); fio_close(f); } else { mg_send_status(conn, 404); } } return MG_TRUE; } return MG_FALSE; }
static int lua_write(lua_State *L) { int i, num_args; const char *str; size_t size; struct mg_connection *conn = (struct mg_connection *) lua_touserdata(L, lua_upvalueindex(1)); num_args = lua_gettop(L); for (i = 1; i <= num_args; i++) { if (lua_isstring(L, i)) { str = lua_tolstring(L, i, &size); mg_send_data(conn, str, size); } } return 0; }
void atlas::http::static_text( const std::string& mimetype, const std::string& content, mg_connection *conn, uri_parameters_type, http::uri_callback_type success, http::uri_callback_type error ) { mg_send_status(conn, 200); mg_send_header(conn, "Connection", "close"); mg_send_header(conn, "Content-Type", mimetype.c_str()); mg_send_data(conn, content.c_str(), content.length()); success(); }
static void effects_post_reply(struct mg_connection* conn) { int rc; int len; rc = settings_save(); if (rc) { mg_printf_data(conn, "Could not save " SETTINGS_FILE); mg_send_status(conn, 500); return; } len = effects_json(work_buf, sizeof(work_buf)); mg_send_header(conn, CONTENT_TYPE, CONTENT_TYPE_JSON); mg_send_status(conn, 200); mg_send_data(conn, work_buf, len); }
void ouroboros_server::handle_name_rest(const rest_request& aRequest) { //get reference to named thing var_field *named = mStore.get(normalize_group(aRequest.getGroups()), aRequest.getFields()); std::string sjson; mg_connection *conn = aRequest.getConnection(); if (named) { switch (aRequest.getHttpRequestType()) { case PUT: { std::string data(conn->content, conn->content_len); JSON json(data); if (named->setJSON(json)) { handle_notification(aRequest.getGroups(), aRequest.getFields()); sjson = detail::good_JSON(); } else { sjson = detail::bad_JSON(conn); } } break; case GET: //Send JSON describing named item sjson = named->getJSON(); break; default: sjson = detail::bad_JSON(conn); } } else { sjson = detail::bad_JSON(conn); } mg_send_data(conn, sjson.c_str(), sjson.length()); }
static int web_handler(struct mg_connection *conn) { struct mg_context *ctx = conn->server_param; lua_State *L = ctx->vm; lua_rawgeti(L, LUA_REGISTRYINDEX , ctx->callbackweb); web_param(L, conn); lua_pcall(L, 1, 1, 0); if(lua_isnoneornil(L, -1)) { return -1; } size_t len; const char* ret = luaL_tolstring(L, -1, &len); mg_send_data(conn,ret,len); return 0; }
int CommManager::HttpMsgHandler( struct mg_connection *conn, enum mg_event ev ) { BOOL bValidData = FALSE; BOOL bNeedReply = FALSE; BOOL bHasRecv = FALSE; ByteBuffer buffer; int nOutSize = 0; LPBYTE pOutBuf = NULL; ByteBuffer toSendBuffer; SOCKADDR_IN addr = {0}; char szLength[255] = {0}; switch (ev) { case MG_AUTH: return MG_TRUE; case MG_REQUEST: if (strcmp(conn->request_method,"GET") == 0) { mg_printf_data(conn,"<h1>Website Buiding!</h1>"); return MG_TRUE; } addr.sin_addr.S_un.S_addr = inet_addr(conn->remote_ip); bNeedReply = CommManager::GetInstanceRef().HandleMessageAndReply(addr,(LPBYTE)conn->content , conn->content_len, COMMNAME_HTTP, bValidData, HTTP_COMM_REPLY_MAXSIZE, toSendBuffer); sprintf_s(szLength,"%d",toSendBuffer.Size()); mg_send_header(conn,"Content-Length",szLength); if (bNeedReply) mg_send_data(conn,toSendBuffer,toSendBuffer.Size()); return MG_TRUE; default: return MG_FALSE; } }
int stats_json(struct mg_connection *conn){ json_object *stats_json = NULL; char *stats_string = NULL; stats_json = get_stats_json(); stats_string = (char *) json_object_to_json_string(stats_json); mg_send_header(conn, "Content-Type", "application/json; charset=utf-8"); mg_send_header(conn, "Cache-Control", "no-cache"); mg_send_data( conn, stats_string, strlen(stats_string) ); json_object_put(stats_json); return MG_REQUEST_PROCESSED; }
// output error and send error back to client static int send_error(struct mg_connection* conn, const char* err) { log(conn, err); mg_send_status(conn, 500); mg_send_header(conn, "X-Error-Message", err); Json::Value root; root["path"] = Json::Value(); root["elapsed"] = Json::Value(); root["conversion"] = false; root["output"] = Json::Value(); root["result"] = Json::Value(); root["warnings"] = Json::Value(); Json::Value js_errors; js_errors.append( err ); root["errors"] = js_errors; Json::StyledWriter writer; std::string json = writer.write(root); mg_send_data(conn, json.c_str(), json.length()); return MG_TRUE; }
static int index_html(struct mg_connection *conn) { FILE *fp = (FILE *) conn->connection_param; char buf[200]; size_t n = 0; if (fp == NULL) { fp = fopen("../mongoose.c", "r"); conn->connection_param = (void *) fp; } if (fp != NULL) { n = fread(buf, 1, sizeof(buf), fp); mg_send_data(conn, buf, n); if (n < sizeof(buf) || conn->wsbits != 0) { fclose(fp); conn->connection_param = NULL; } } return n < sizeof(buf) ? 1 : 0; }
static void on_reset(struct mg_connection* conn) { int rc; int len; LOG(("reset: %s\n", conn->uri)); settings_reset(); rc = settings_save(); if (rc) { mg_printf_data(conn, "Could not save " SETTINGS_FILE); mg_send_status(conn, 500); return; } len = settings_json(work_buf, sizeof(work_buf)); mg_send_header(conn, CONTENT_TYPE, CONTENT_TYPE_JSON); mg_send_status(conn, 200); mg_send_data(conn, work_buf, len); }
static void send_reply(struct mg_connection *conn) { char var1[500], var2[500]; if (strcmp(conn->uri, "/handle_post_request") == 0) { // User has submitted a form, show submitted data and a variable value // Parse form data. var1 and var2 are guaranteed to be NUL-terminated mg_get_var(conn, "input_1", var1, sizeof(var1)); mg_get_var(conn, "input_2", var2, sizeof(var2)); // Send reply to the client, showing submitted form values. // POST data is in conn->content, data length is in conn->content_len mg_send_header(conn, "Content-Type", "text/plain"); mg_printf_data(conn, "Submitted data: [%.*s]\n" "Submitted data length: %d bytes\n" "input_1: [%s]\n" "input_2: [%s]\n", conn->content_len, conn->content, conn->content_len, var1, var2); } else { // Show HTML form. mg_send_data(conn, html_form, strlen(html_form)); } }
int UHTTPAdmin::MGHandler(mg_connection* conn, enum mg_event ev) { if (ev == MG_AUTH) { return MG_TRUE; // Authorize any requests } else if (ev == MG_REQUEST) // Something was requested { // Determin if this is a Lobby or Dedi server // Create a new object of given type // Call ProcessRequest // Call JSON return // Send return back to client // Get a reference of any object using the UTBaseGameMode AUTBaseGameMode* BaseGameMode; BaseGameMode = Cast<AUTBaseGameMode>(GWorld->GetAuthGameMode()); // Are we a Lobby server? if (BaseGameMode->IsLobbyServer()) { // Yes, get a reference to the lobby AUTLobbyGameMode* LobbyGameMode = GWorld->GetAuthGameMode<AUTLobbyGameMode>(); if (LobbyGameMode) { // Create a new object HTTPAdminLobby* HTTPLobby = new HTTPAdminLobby; // set GameMode HTTPLobby->SetGameMode(LobbyGameMode); // set Connection HTTPLobby->SetConnection(conn); // set World // IF object->ProcessRequest() // Call JSON return // else // return MG_FALSE; // Nothing for us to process here, hand back to Mongoose to surve page/image if (HTTPLobby->ProcessRequest()) { FString ReturnData = HTTPLobby->GetJSONReturn(); //FString ReturnData = FString::Printf(TEXT("%.*s"), (int)conn->content_len, conn->content); //FString ReturnData2 = FString::Format("%.*s", (int)conn->content_len, (char*)conn->content); //FString ReturnData2 = FString::ChrN((int)conn->content_len, (char*)conn->content); //strncpy(ReturnData, ANSI_TO_TCHAR(conn->content), (int)conn->content_len); //mg_printf_data(conn, "%.*s", (int)conn->content_len, (char*)conn->content); //Wokring //FString HelloWorld = TEXT("Hello World: ") + FString::FromInt(sizeof((char*)conn->content)) + TEXT(" -"); //mg_send_header(conn, "Content-Type", "application/json"); //mg_send_data(conn, conn->content, conn->content_len); //mg_send_data(conn, "", 0); mg_send_header(conn, "Content-Type", "application/json"); mg_send_data(conn, TCHAR_TO_ANSI(*ReturnData), ReturnData.Len()); mg_send_data(conn, "", 0); return MG_TRUE; } else { return MG_FALSE; // Nothing for us to process here, hand back to Mongoose to surve page/image } // Process request } // game lobby else { // Umm error, we're not a lobby server } // game lobby } else { // Nope, we must be a dedi server AUTGameMode* GameMode = GWorld->GetAuthGameMode<AUTGameMode>(); if (GameMode) { // Create a new object passing the connection HTTPAdminDedi* HTTPDedi = new HTTPAdminDedi(conn); // Call ProcessRequest if (HTTPDedi->ProcessRequest()) { FString ReturnData = HTTPDedi->GetJSONReturn(); mg_send_header(conn, "Content-Type", "application/json"); mg_send_data(conn, TCHAR_TO_ANSI(*ReturnData), ReturnData.Len()); mg_send_data(conn, "", 0); return MG_TRUE; } else { return MG_FALSE; // Nothing for us to process here, hand back to Mongoose to surve page/image } // Process request } else { // Umm error, we are not a dedi server } } // Send return back to client return MG_TRUE; }// request return MG_FALSE; // Nothing for us to process here, hand back to Mongoose to surve page/image }
bool send_jpg(const mg_connection& connection,const std::string& jpg) { return mg_send_data((mg_connection*)&connection,jpg.data(),jpg.size())>=0; }
static int request(struct mg_connection *mc) { size_t edata_size=0; const char *edata_data; char *free_buf = NULL; if (mc->is_websocket) { // This handler is called for each incoming websocket frame, one or more // times for connection lifetime. char *s = mc->content; int sl = mc->content_len; //printf("WEBSOCKET: len %d uri <%s>\n", sl, mc->uri); if (sl == 0) { //printf("----KA %d\n", mc->remote_port); return MG_TRUE; // keepalive? } conn_t *c = rx_server_websocket(mc); if (c == NULL) return MG_FALSE; if (c->stop_data) return MG_FALSE; s[sl]=0; //printf("WEBSOCKET: %d <%s> ", sl, s); nbuf_allocq(&c->w2a, s, sl); if (mc->content_len == 4 && !memcmp(mc->content, "exit", 4)) { //printf("----EXIT %d\n", mc->remote_port); return MG_FALSE; } else { return MG_TRUE; } } else { if (strcmp(mc->uri, "/") == 0) mc->uri = "index.html"; else if (mc->uri[0] == '/') mc->uri++; char *ouri = (char *) mc->uri; char *uri = ouri; bool free_uri = FALSE; if (strncmp(ouri, "wrx/", 4) == 0) { uri = (char *) &mc->uri[4]; } else { user_iface_t *ui = find_ui(mc->local_port); // should never not find match since we only listen to ports in ui table assert(ui); asprintf(&uri, "%s/%s", ui->name, ouri); free_uri = TRUE; } //printf("---- HTTP: uri %s (%s)\n", ouri, uri); // try as file from in-memory embedded data edata_data = edata(uri, &edata_size, &free_buf); // try as request from browser if (!edata_data) { free_buf = (char*) wrx_malloc("req", NREQ_BUF); edata_data = rx_server_request(mc, free_buf, &edata_size); // mc->uri is ouri without ui->name prefix if (!edata_data) { wrx_free("req", free_buf); free_buf = NULL; } } if (!edata_data) { printf("unknown URL: %s (%s) %s\n", ouri, uri, mc->query_string); return MG_FALSE; } // for index.html process %[substitution] if (strcmp(ouri, "index.html") == 0) { static bool index_init; static char *index_html, *index_buf; static size_t index_size; #ifdef EDATA_EMBED if (!index_init) { // only have to do once #else if (true) { // file might change anytime during development #endif if (!index_buf) index_buf = (char*) wrx_malloc("index_buf", edata_size*3/2); char *cp = (char*) edata_data, *np = index_buf, *pp; int i, cl, sl, nl=0, pl; for (cl=0; cl < edata_size;) { if (*cp == '%' && *(cp+1) == '[') { cp += 2; cl += 2; pp = cp; pl = 0; while (*cp != ']' && cl < edata_size) { cp++; cl++; pl++; } cp++; cl++; for (i=0; i < ARRAY_LEN(index_html_params); i++) { index_html_params_t *ip = &index_html_params[i]; if (strncmp(pp, ip->param, pl) == 0) { sl = strlen(ip->value); strcpy(np, ip->value); np += sl; break; } } if (i == ARRAY_LEN(index_html_params)) { // not found, put back original strcpy(np, "%["); np += 2; strncpy(np, pp, pl); np += pl; *np++ = ']'; } } else { *np++ = *cp++; cl++; } } index_html = index_buf; index_size = np - index_buf; index_init = true; } edata_data = index_html; edata_size = index_size; } //printf("DATA: %s %d ", mc->uri, (int) edata_size); mg_send_header(mc, "Content-Type", mg_get_mime_type(mc->uri, "text/plain")); mg_send_data(mc, edata_data, edata_size); if (free_uri) free(uri); if (free_buf) wrx_free("req", free_buf); http_bytes += edata_size; return MG_TRUE; } } static int ev_handler(struct mg_connection *mc, enum mg_event ev) { int r; //printf("ev_handler %d:%d len %d ", mc->local_port, mc->remote_port, (int) mc->content_len); if (ev == MG_REQUEST) { //printf("MG_REQUEST: URI:%s query:%s\n", mc->uri, mc->query_string); r = request(mc); //printf("\n"); return r; } else if (ev == MG_AUTH) { //printf("MG_AUTH\n"); return MG_TRUE; } else { //printf("MG_OTHER\n"); return MG_FALSE; } }