Line data    Source code

       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             : #ifndef HTTPFETCH_HEADER
      21             : #define HTTPFETCH_HEADER
      22             : 
      23             : #include <vector>
      24             : #include "util/string.h"
      25             : #include "config.h"
      26             : 
      27             : // Can be used in place of "caller" in asynchronous transfers to discard result
      28             : // (used as default value of "caller")
      29             : #define HTTPFETCH_DISCARD 0
      30             : #define HTTPFETCH_SYNC 1
      31             : 
      32           5 : struct HTTPFetchRequest
      33             : {
      34             :         std::string url;
      35             : 
      36             :         // Identifies the caller (for asynchronous requests)
      37             :         // Ignored by httpfetch_sync
      38             :         unsigned long caller;
      39             : 
      40             :         // Some number that identifies the request
      41             :         // (when the same caller issues multiple httpfetch_async calls)
      42             :         unsigned long request_id;
      43             : 
      44             :         // Timeout for the whole transfer, in milliseconds
      45             :         long timeout;
      46             : 
      47             :         // Timeout for the connection phase, in milliseconds
      48             :         long connect_timeout;
      49             : 
      50             :         // Indicates if this is multipart/form-data or
      51             :         // application/x-www-form-urlencoded.  POST-only.
      52             :         bool multipart;
      53             : 
      54             :         // POST fields.  Fields are escaped properly.
      55             :         // If this is empty a GET request is done instead.
      56             :         StringMap post_fields;
      57             : 
      58             :         // Raw POST data, overrides post_fields.
      59             :         std::string post_data;
      60             : 
      61             :         // If not empty, should contain entries such as "Accept: text/html"
      62             :         std::vector<std::string> extra_headers;
      63             : 
      64             :         //useragent to use
      65             :         std::string useragent;
      66             : 
      67             :         HTTPFetchRequest();
      68             : };
      69             : 
      70           0 : struct HTTPFetchResult
      71             : {
      72             :         bool succeeded;
      73             :         bool timeout;
      74             :         long response_code;
      75             :         std::string data;
      76             :         // The caller and request_id from the corresponding HTTPFetchRequest.
      77             :         unsigned long caller;
      78             :         unsigned long request_id;
      79             : 
      80           0 :         HTTPFetchResult()
      81           0 :         {
      82           0 :                 succeeded = false;
      83           0 :                 timeout = false;
      84           0 :                 response_code = 0;
      85           0 :                 data = "";
      86           0 :                 caller = HTTPFETCH_DISCARD;
      87           0 :                 request_id = 0;
      88           0 :         }
      89             : 
      90           0 :         HTTPFetchResult(const HTTPFetchRequest &fetch_request)
      91           0 :         {
      92           0 :                 succeeded = false;
      93           0 :                 timeout = false;
      94           0 :                 response_code = 0;
      95           0 :                 data = "";
      96           0 :                 caller = fetch_request.caller;
      97           0 :                 request_id = fetch_request.request_id;
      98           0 :         }
      99             : 
     100             : };
     101             : 
     102             : // Initializes the httpfetch module
     103             : void httpfetch_init(int parallel_limit);
     104             : 
     105             : // Stops the httpfetch thread and cleans up resources
     106             : void httpfetch_cleanup();
     107             : 
     108             : // Starts an asynchronous HTTP fetch request
     109             : void httpfetch_async(const HTTPFetchRequest &fetch_request);
     110             : 
     111             : // If any fetch for the given caller ID is complete, removes it from the
     112             : // result queue, sets the fetch result and returns true. Otherwise returns false.
     113             : bool httpfetch_async_get(unsigned long caller, HTTPFetchResult &fetch_result);
     114             : 
     115             : // Allocates a caller ID for httpfetch_async
     116             : // Not required if you want to set caller = HTTPFETCH_DISCARD
     117             : unsigned long httpfetch_caller_alloc();
     118             : 
     119             : // Frees a caller ID allocated with httpfetch_caller_alloc
     120             : // Note: This can be expensive, because the httpfetch thread is told
     121             : // to stop any ongoing fetches for the given caller.
     122             : void httpfetch_caller_free(unsigned long caller);
     123             : 
     124             : // Performs a synchronous HTTP request. This blocks and therefore should
     125             : // only be used from background threads.
     126             : void httpfetch_sync(const HTTPFetchRequest &fetch_request,
     127             :                 HTTPFetchResult &fetch_result);
     128             : 
     129             : 
     130             : #endif // !HTTPFETCH_HEADER