src/script/lua_api/l_http.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "lua_api/l_internal.h"
  21 #include "common/c_converter.h"
  22 #include "common/c_content.h"
  23 #include "lua_api/l_http.h"
  24 #include "httpfetch.h"
  25 #include "settings.h"
  26 #include "debug.h"
  27 #include "log.h"
  28
  29 #include <algorithm>
  30 #include <iomanip>
  31 #include <cctype>
  32
  33 #define HTTP_API(name) \
  34         lua_pushstring(L, #name); \
  35         lua_pushcfunction(L, l_http_##name); \
  36         lua_settable(L, -3);
  37
  38 #if USE_CURL
  39 void ModApiHttp::read_http_fetch_request(lua_State *L, HTTPFetchRequest &req)
  40 {
  41         luaL_checktype(L, 1, LUA_TTABLE);
  42
  43         req.caller = httpfetch_caller_alloc_secure();
  44         getstringfield(L, 1, "url", req.url);
  45         lua_getfield(L, 1, "user_agent");
  46         if (lua_isstring(L, -1))
  47                 req.useragent = getstringfield_default(L, 1, "user_agent", "");
  48         lua_pop(L, 1);
  49         req.multipart = getboolfield_default(L, 1, "multipart", false);
  50         req.timeout = getintfield_default(L, 1, "timeout", 3) * 1000;
  51
  52         // post_data: if table, post form data, otherwise raw data
  53         lua_getfield(L, 1, "post_data");
  54         if (lua_istable(L, 2)) {
  55                 lua_pushnil(L);
  56                 while (lua_next(L, 2) != 0)
  57                 {
  58                         req.post_fields[luaL_checkstring(L, -2)] = luaL_checkstring(L, -1);
  59                         lua_pop(L, 1);
  60                 }
  61         } else if (lua_isstring(L, 2)) {
  62                 req.post_data = lua_tostring(L, 2);
  63         }
  64         lua_pop(L, 1);
  65
  66         lua_getfield(L, 1, "extra_headers");
  67         if (lua_istable(L, 2)) {
  68                 lua_pushnil(L);
  69                 while (lua_next(L, 2) != 0)
  70                 {
  71                         const char *header = luaL_checkstring(L, -1);
  72                         req.extra_headers.emplace_back(header);
  73                         lua_pop(L, 1);
  74                 }
  75         }
  76         lua_pop(L, 1);
  77 }
  78
  79 void ModApiHttp::push_http_fetch_result(lua_State *L, HTTPFetchResult &res, bool completed)
  80 {
  81         lua_newtable(L);
  82         setboolfield(L, -1, "succeeded", res.succeeded);
  83         setboolfield(L, -1, "timeout", res.timeout);
  84         setboolfield(L, -1, "completed", completed);
  85         setintfield(L, -1, "code", res.response_code);
  86         setstringfield(L, -1, "data", res.data.c_str());
  87 }
  88
  89 // http_api.fetch_async(HTTPRequest definition)
  90 int ModApiHttp::l_http_fetch_async(lua_State *L)
  91 {
  92         NO_MAP_LOCK_REQUIRED;
  93
  94         HTTPFetchRequest req;
  95         read_http_fetch_request(L, req);
  96
  97         actionstream << "Mod performs HTTP request with URL " << req.url << std::endl;
  98         httpfetch_async(req);
  99
 100         // Convert handle to hex string since lua can't handle 64-bit integers
 101         std::stringstream handle_conversion_stream;
 102         handle_conversion_stream << std::hex << req.caller;
 103         std::string caller_handle(handle_conversion_stream.str());
 104
 105         lua_pushstring(L, caller_handle.c_str());
 106         return 1;
 107 }
 108
 109 // http_api.fetch_async_get(handle)
 110 int ModApiHttp::l_http_fetch_async_get(lua_State *L)
 111 {
 112         NO_MAP_LOCK_REQUIRED;
 113
 114         std::string handle_str = luaL_checkstring(L, 1);
 115
 116         // Convert hex string back to 64-bit handle
 117         u64 handle;
 118         std::stringstream handle_conversion_stream;
 119         handle_conversion_stream << std::hex << handle_str;
 120         handle_conversion_stream >> handle;
 121
 122         HTTPFetchResult res;
 123         bool completed = httpfetch_async_get(handle, res);
 124
 125         push_http_fetch_result(L, res, completed);
 126
 127         return 1;
 128 }
 129
 130 int ModApiHttp::l_request_http_api(lua_State *L)
 131 {
 132         NO_MAP_LOCK_REQUIRED;
 133
 134         // We have to make sure that this function is being called directly by
 135         // a mod, otherwise a malicious mod could override this function and
 136         // steal its return value.
 137         lua_Debug info;
 138
 139         // Make sure there's only one item below this function on the stack...
 140         if (lua_getstack(L, 2, &info)) {
 141                 return 0;
 142         }
 143         FATAL_ERROR_IF(!lua_getstack(L, 1, &info), "lua_getstack() failed");
 144         FATAL_ERROR_IF(!lua_getinfo(L, "S", &info), "lua_getinfo() failed");
 145
 146         // ...and that that item is the main file scope.
 147         if (strcmp(info.what, "main") != 0) {
 148                 return 0;
 149         }
 150
 151         // Mod must be listed in secure.http_mods or secure.trusted_mods
 152         lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
 153         if (!lua_isstring(L, -1)) {
 154                 return 0;
 155         }
 156
 157         const char *mod_name = lua_tostring(L, -1);
 158         std::string http_mods = g_settings->get("secure.http_mods");
 159         http_mods.erase(std::remove(http_mods.begin(), http_mods.end(), ' '), http_mods.end());
 160         std::vector<std::string> mod_list_http = str_split(http_mods, ',');
 161
 162         std::string trusted_mods = g_settings->get("secure.trusted_mods");
 163         trusted_mods.erase(std::remove(trusted_mods.begin(), trusted_mods.end(), ' '), trusted_mods.end());
 164         std::vector<std::string> mod_list_trusted = str_split(trusted_mods, ',');
 165
 166         mod_list_http.insert(mod_list_http.end(), mod_list_trusted.begin(), mod_list_trusted.end());
 167         if (std::find(mod_list_http.begin(), mod_list_http.end(), mod_name) == mod_list_http.end()) {
 168                 lua_pushnil(L);
 169                 return 1;
 170         }
 171
 172         lua_getglobal(L, "core");
 173         lua_getfield(L, -1, "http_add_fetch");
 174
 175         lua_newtable(L);
 176         HTTP_API(fetch_async);
 177         HTTP_API(fetch_async_get);
 178
 179         // Stack now looks like this:
 180         // <core.http_add_fetch> <table with fetch_async, fetch_async_get>
 181         // Now call core.http_add_fetch to append .fetch(request, callback) to table
 182         lua_call(L, 1, 1);
 183
 184         return 1;
 185 }
 186 #endif
 187
 188 void ModApiHttp::Initialize(lua_State *L, int top)
 189 {
 190 #if USE_CURL
 191         API_FCT(request_http_api);
 192 #endif
 193 }