FreeRDP
Loading...
Searching...
No Matches
utils/http.c
1
20#include <freerdp/config.h>
21#include <freerdp/utils/http.h>
22
23#include <winpr/assert.h>
24#include <winpr/string.h>
25
26#include <openssl/bio.h>
27#include <openssl/ssl.h>
28#include <openssl/err.h>
29
30#include <freerdp/log.h>
31#define TAG FREERDP_TAG("utils.http")
32
33static const char get_header_fmt[] = "GET %s HTTP/1.1\r\n"
34 "Host: %s\r\n"
35 "\r\n";
36
37static const char post_header_fmt[] = "POST %s HTTP/1.1\r\n"
38 "Host: %s\r\n"
39 "Content-Type: application/x-www-form-urlencoded\r\n"
40 "Content-Length: %lu\r\n"
41 "\r\n";
42
43#define log_errors(log, msg) log_errors_(log, msg, __FILE__, __func__, __LINE__)
44static void log_errors_(wLog* log, const char* msg, const char* file, const char* fkt, size_t line)
45{
46 const DWORD level = WLOG_ERROR;
47 unsigned long ec = 0;
48
49 if (!WLog_IsLevelActive(log, level))
50 return;
51
52 BOOL error_logged = FALSE;
53 while ((ec = ERR_get_error()))
54 {
55 error_logged = TRUE;
56 WLog_PrintTextMessage(log, level, line, file, fkt, "%s: %s", msg,
57 ERR_error_string(ec, NULL));
58 }
59 if (!error_logged)
60 WLog_PrintTextMessage(log, level, line, file, fkt, "%s (no details available)", msg);
61}
62
63static int get_line(BIO* bio, char* buffer, size_t size)
64{
65#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
66 if (size <= 1)
67 return -1;
68
69 size_t pos = 0;
70 do
71 {
72 int rc = BIO_read(bio, &buffer[pos], 1);
73 if (rc <= 0)
74 return rc;
75 char cur = buffer[pos];
76 pos += rc;
77 if ((cur == '\n') || (pos >= size - 1))
78 {
79 buffer[pos] = '\0';
80 return (int)pos;
81 }
82 } while (1);
83#else
84 if (size > INT32_MAX)
85 return -1;
86 return BIO_get_line(bio, buffer, (int)size);
87#endif
88}
89
90BOOL freerdp_http_request(const char* url, const char* body, long* status_code, BYTE** response,
91 size_t* response_length)
92{
93 BOOL ret = FALSE;
94 char* hostname = NULL;
95 const char* path = NULL;
96 char* headers = NULL;
97 size_t size = 0;
98 int status = 0;
99 char buffer[1024] = { 0 };
100 BIO* bio = NULL;
101 SSL_CTX* ssl_ctx = NULL;
102 SSL* ssl = NULL;
103
104 WINPR_ASSERT(status_code);
105 WINPR_ASSERT(response);
106 WINPR_ASSERT(response_length);
107
108 wLog* log = WLog_Get(TAG);
109 WINPR_ASSERT(log);
110
111 *response = NULL;
112
113 if (!url || strnlen(url, 8) < 8 || strncmp(url, "https://", 8) != 0 ||
114 !(path = strchr(url + 8, '/')))
115 {
116 WLog_Print(log, WLOG_ERROR, "invalid url provided");
117 goto out;
118 }
119
120 {
121 const size_t len = WINPR_ASSERTING_INT_CAST(size_t, path - (url + 8));
122 hostname = strndup(&url[8], len);
123 }
124 if (!hostname)
125 return FALSE;
126
127 {
128 size_t blen = 0;
129 if (body)
130 {
131 blen = strlen(body);
132 if (winpr_asprintf(&headers, &size, post_header_fmt, path, hostname, blen) < 0)
133 {
134 free(hostname);
135 return FALSE;
136 }
137 }
138 else
139 {
140 if (winpr_asprintf(&headers, &size, get_header_fmt, path, hostname) < 0)
141 {
142 free(hostname);
143 return FALSE;
144 }
145 }
146
147 ssl_ctx = SSL_CTX_new(TLS_client_method());
148
149 if (!ssl_ctx)
150 {
151 log_errors(log, "could not set up ssl context");
152 goto out;
153 }
154
155 if (!SSL_CTX_set_default_verify_paths(ssl_ctx))
156 {
157 log_errors(log, "could not set ssl context verify paths");
158 goto out;
159 }
160
161 SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
162
163 bio = BIO_new_ssl_connect(ssl_ctx);
164 if (!bio)
165 {
166 log_errors(log, "could not set up connection");
167 goto out;
168 }
169
170 if (BIO_set_conn_port(bio, "https") <= 0)
171 {
172 log_errors(log, "could not set port");
173 goto out;
174 }
175
176 if (!BIO_set_conn_hostname(bio, hostname))
177 {
178 log_errors(log, "could not set hostname");
179 goto out;
180 }
181
182 BIO_get_ssl(bio, &ssl);
183 if (!ssl)
184 {
185 log_errors(log, "could not get ssl");
186 goto out;
187 }
188
189 if (!SSL_set_tlsext_host_name(ssl, hostname))
190 {
191 log_errors(log, "could not set sni hostname");
192 goto out;
193 }
194
195 WLog_Print(log, WLOG_DEBUG, "headers:\n%s", headers);
196 ERR_clear_error();
197
198 {
199 const size_t hlen = strnlen(headers, size);
200 if (hlen > INT32_MAX)
201 goto out;
202
203 if (BIO_write(bio, headers, (int)hlen) < 0)
204 {
205 log_errors(log, "could not write headers");
206 goto out;
207 }
208
209 if (body)
210 {
211 WLog_Print(log, WLOG_DEBUG, "body:\n%s", body);
212
213 if (blen > INT_MAX)
214 {
215 WLog_Print(log, WLOG_ERROR, "body too long!");
216 goto out;
217 }
218
219 ERR_clear_error();
220 if (BIO_write(bio, body, (int)blen) < 0)
221 {
222 log_errors(log, "could not write body");
223 goto out;
224 }
225 }
226 }
227 }
228
229 status = get_line(bio, buffer, sizeof(buffer));
230 if (status <= 0)
231 {
232 log_errors(log, "could not read response");
233 goto out;
234 }
235
236 const char header[9] = { 'H', 'T', 'T', 'P', '/', '1', '.', '1', ' ' };
237 if ((status < (INT64)sizeof(header)) || (strncmp(header, buffer, sizeof(header)) != 0))
238 {
239 WLog_Print(log, WLOG_ERROR, "invalid HTTP status header");
240 goto out;
241 }
242
243 errno = 0;
244 *status_code = strtol(&buffer[sizeof(header)], NULL, 0);
245 if (errno != 0)
246 {
247 char ebuffer[256] = { 0 };
248 WLog_Print(log, WLOG_ERROR, "invalid HTTP status line: %s [%d]",
249 winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
250 goto out;
251 }
252
253 do
254 {
255 status = get_line(bio, buffer, sizeof(buffer));
256 if (status <= 0)
257 {
258 log_errors(log, "could not read response");
259 goto out;
260 }
261
262 char* val = NULL;
263 char* name = strtok_s(buffer, ":", &val);
264 if (name && (_stricmp(name, "content-length") == 0))
265 {
266 errno = 0;
267 *response_length = strtoul(val, NULL, 10);
268 if (errno)
269 {
270 char ebuffer[256] = { 0 };
271 WLog_Print(log, WLOG_ERROR, "could not parse content length (%s): %s [%d]", val,
272 winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
273 goto out;
274 }
275 }
276 } while (strcmp(buffer, "\r\n") != 0);
277
278 if (*response_length > 0)
279 {
280 if (*response_length > INT_MAX)
281 {
282 WLog_Print(log, WLOG_ERROR, "response too long!");
283 goto out;
284 }
285
286 *response = calloc(1, *response_length + 1);
287 if (!*response)
288 goto out;
289
290 BYTE* p = *response;
291 size_t left = *response_length;
292 while (left > 0)
293 {
294 const int rd = (left < INT32_MAX) ? (int)left : INT32_MAX;
295 status = BIO_read(bio, p, rd);
296 if (status <= 0)
297 {
298 log_errors(log, "could not read response");
299 goto out;
300 }
301 p += status;
302 if ((size_t)status > left)
303 break;
304 left -= (size_t)status;
305 }
306 }
307
308 WLog_Print(log, WLOG_DEBUG, "response[%" PRIuz "]:\n%s", *response_length,
309 (const char*)(*response));
310 ret = TRUE;
311
312out:
313 if (!ret)
314 {
315 free(*response);
316 *response = NULL;
317 *response_length = 0;
318 }
319 free(hostname);
320 free(headers);
321 BIO_free_all(bio);
322 SSL_CTX_free(ssl_ctx);
323 return ret;
324}
325
326const char* freerdp_http_status_string(long status)
327{
328 switch (status)
329 {
330 case HTTP_STATUS_CONTINUE:
331 return "HTTP_STATUS_CONTINUE";
332 case HTTP_STATUS_SWITCH_PROTOCOLS:
333 return "HTTP_STATUS_SWITCH_PROTOCOLS";
334 case HTTP_STATUS_OK:
335 return "HTTP_STATUS_OK";
336 case HTTP_STATUS_CREATED:
337 return "HTTP_STATUS_CREATED";
338 case HTTP_STATUS_ACCEPTED:
339 return "HTTP_STATUS_ACCEPTED";
340 case HTTP_STATUS_PARTIAL:
341 return "HTTP_STATUS_PARTIAL";
342 case HTTP_STATUS_NO_CONTENT:
343 return "HTTP_STATUS_NO_CONTENT";
344 case HTTP_STATUS_RESET_CONTENT:
345 return "HTTP_STATUS_RESET_CONTENT";
346 case HTTP_STATUS_PARTIAL_CONTENT:
347 return "HTTP_STATUS_PARTIAL_CONTENT";
348 case HTTP_STATUS_WEBDAV_MULTI_STATUS:
349 return "HTTP_STATUS_WEBDAV_MULTI_STATUS";
350 case HTTP_STATUS_AMBIGUOUS:
351 return "HTTP_STATUS_AMBIGUOUS";
352 case HTTP_STATUS_MOVED:
353 return "HTTP_STATUS_MOVED";
354 case HTTP_STATUS_REDIRECT:
355 return "HTTP_STATUS_REDIRECT";
356 case HTTP_STATUS_REDIRECT_METHOD:
357 return "HTTP_STATUS_REDIRECT_METHOD";
358 case HTTP_STATUS_NOT_MODIFIED:
359 return "HTTP_STATUS_NOT_MODIFIED";
360 case HTTP_STATUS_USE_PROXY:
361 return "HTTP_STATUS_USE_PROXY";
362 case HTTP_STATUS_REDIRECT_KEEP_VERB:
363 return "HTTP_STATUS_REDIRECT_KEEP_VERB";
364 case HTTP_STATUS_BAD_REQUEST:
365 return "HTTP_STATUS_BAD_REQUEST";
366 case HTTP_STATUS_DENIED:
367 return "HTTP_STATUS_DENIED";
368 case HTTP_STATUS_PAYMENT_REQ:
369 return "HTTP_STATUS_PAYMENT_REQ";
370 case HTTP_STATUS_FORBIDDEN:
371 return "HTTP_STATUS_FORBIDDEN";
372 case HTTP_STATUS_NOT_FOUND:
373 return "HTTP_STATUS_NOT_FOUND";
374 case HTTP_STATUS_BAD_METHOD:
375 return "HTTP_STATUS_BAD_METHOD";
376 case HTTP_STATUS_NONE_ACCEPTABLE:
377 return "HTTP_STATUS_NONE_ACCEPTABLE";
378 case HTTP_STATUS_PROXY_AUTH_REQ:
379 return "HTTP_STATUS_PROXY_AUTH_REQ";
380 case HTTP_STATUS_REQUEST_TIMEOUT:
381 return "HTTP_STATUS_REQUEST_TIMEOUT";
382 case HTTP_STATUS_CONFLICT:
383 return "HTTP_STATUS_CONFLICT";
384 case HTTP_STATUS_GONE:
385 return "HTTP_STATUS_GONE";
386 case HTTP_STATUS_LENGTH_REQUIRED:
387 return "HTTP_STATUS_LENGTH_REQUIRED";
388 case HTTP_STATUS_PRECOND_FAILED:
389 return "HTTP_STATUS_PRECOND_FAILED";
390 case HTTP_STATUS_REQUEST_TOO_LARGE:
391 return "HTTP_STATUS_REQUEST_TOO_LARGE";
392 case HTTP_STATUS_URI_TOO_LONG:
393 return "HTTP_STATUS_URI_TOO_LONG";
394 case HTTP_STATUS_UNSUPPORTED_MEDIA:
395 return "HTTP_STATUS_UNSUPPORTED_MEDIA";
396 case HTTP_STATUS_RETRY_WITH:
397 return "HTTP_STATUS_RETRY_WITH";
398 case HTTP_STATUS_SERVER_ERROR:
399 return "HTTP_STATUS_SERVER_ERROR";
400 case HTTP_STATUS_NOT_SUPPORTED:
401 return "HTTP_STATUS_NOT_SUPPORTED";
402 case HTTP_STATUS_BAD_GATEWAY:
403 return "HTTP_STATUS_BAD_GATEWAY";
404 case HTTP_STATUS_SERVICE_UNAVAIL:
405 return "HTTP_STATUS_SERVICE_UNAVAIL";
406 case HTTP_STATUS_GATEWAY_TIMEOUT:
407 return "HTTP_STATUS_GATEWAY_TIMEOUT";
408 case HTTP_STATUS_VERSION_NOT_SUP:
409 return "HTTP_STATUS_VERSION_NOT_SUP";
410 default:
411 return "HTTP_STATUS_UNKNOWN";
412 }
413}
414
415const char* freerdp_http_status_string_format(long status, char* buffer, size_t size)
416{
417 const char* code = freerdp_http_status_string(status);
418 (void)_snprintf(buffer, size, "%s [%ld]", code, status);
419 return buffer;
420}