forked from mheily/rooms
-
Notifications
You must be signed in to change notification settings - Fork 0
/
HttpBuffer.cc.UNUSED
109 lines (85 loc) · 2.96 KB
/
HttpBuffer.cc.UNUSED
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/*
* Copyright (C) 2016 Mark Heily <[email protected]>
* Copyright (C) 1998 - 2015, Daniel Stenberg, <[email protected]>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at https://curl.haxx.se/docs/copyright.html.
*
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
* copies of the Software, and permit persons to whom the Software is
* furnished to do so, under the terms of the COPYING file.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
***************************************************************************/
#include <stdexcept>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <curl/curl.h>
#include "logger.h"
#include "HttpBuffer.h"
// Limit the maximum size of a buffer
const size_t memory_max = 32000000;
static size_t
WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp)
{
size_t realsize = size * nmemb;
struct MemoryStruct *mem = (struct MemoryStruct *)userp;
if (mem->size > memory_max || size > memory_max) {
throw std::runtime_error("document too large");
}
mem->memory = (char*)realloc(mem->memory, mem->size + realsize + 1);
if(mem->memory == NULL) {
log_error("not enough memory (realloc returned NULL)");
return 0;
}
memcpy(&(mem->memory[mem->size]), contents, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
return realsize;
}
void HttpBuffer::get(const char *uri)
{
CURL *curl_handle;
CURLcode res;
if (response.size > 0) {
throw std::logic_error("unsupported reuse of an object");
}
#ifdef _REENTRANT
#error Not threadsafe; manipulates global state
#else
curl_global_init(CURL_GLOBAL_ALL);
#endif
/* init the curl session */
curl_handle = curl_easy_init();
/* specify URL to get */
curl_easy_setopt(curl_handle, CURLOPT_URL, uri);
/* send all data to this function */
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'response' struct to the callback function */
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&response);
/* some servers don't like requests that are made without a user-agent
field, so we provide one */
curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
/* get it! */
res = curl_easy_perform(curl_handle);
/* check for errors */
if(res != CURLE_OK) {
log_error("curl_easy_perform() failed: %s", curl_easy_strerror(res));
throw std::runtime_error("curl request failed");
}
/* cleanup curl stuff */
curl_easy_cleanup(curl_handle);
/* we're done with libcurl, so clean it up */
curl_global_cleanup();
}
HttpBuffer::HttpBuffer() {
response.memory = (char*)malloc(1); /* will be grown as needed by the realloc above */
response.size = 0; /* no data at this point */
}
HttpBuffer::~HttpBuffer() {
free(response.memory);
}