VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/rest/RTCRestClientApiBase.cpp@ 96563

Last change on this file since 96563 was 96407, checked in by vboxsync, 2 years ago

scm copyright and license note update
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.4 KB
Line 
1/* $Id: RTCRestClientApiBase.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2/** @file
3 * IPRT - C++ REST, RTCRestClientApiBase implementation.
4 */
5
6/*
7 * Copyright (C) 2018-2022 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37
38/*********************************************************************************************************************************
39* Header Files *
40*********************************************************************************************************************************/
41#define LOG_GROUP RTLOGGROUP_REST
42#include <iprt/cpp/restclient.h>
43
44#include <iprt/assert.h>
45#include <iprt/ctype.h>
46#include <iprt/errcore.h>
47#include <iprt/http.h>
48#include <iprt/log.h>
49#include <iprt/uri.h>
50
51
52/**
53 * Default constructor.
54 */
55RTCRestClientApiBase::RTCRestClientApiBase() RT_NOEXCEPT
56 : m_hHttp(NIL_RTHTTP)
57{
58}
59
60
61/**
62 * The destructor.
63 */
64RTCRestClientApiBase::~RTCRestClientApiBase()
65{
66 if (m_hHttp != NIL_RTHTTP)
67 {
68 int rc = RTHttpDestroy(m_hHttp);
69 AssertRC(rc);
70 m_hHttp = NIL_RTHTTP;
71 }
72}
73
74
75int RTCRestClientApiBase::setCAFile(const char *pcszCAFile) RT_NOEXCEPT
76{
77 return m_strCAFile.assignNoThrow(pcszCAFile);
78}
79
80
81int RTCRestClientApiBase::setCAFile(const RTCString &strCAFile) RT_NOEXCEPT
82{
83 return m_strCAFile.assignNoThrow(strCAFile);
84}
85
86
87const char *RTCRestClientApiBase::getServerUrl(void) const RT_NOEXCEPT
88{
89 if (m_strServerUrl.isEmpty())
90 return getDefaultServerUrl();
91 return m_strServerUrl.c_str();
92}
93
94
95int RTCRestClientApiBase::setServerUrl(const char *a_pszUrl) RT_NOEXCEPT
96{
97#ifdef RT_STRICT
98 if (a_pszUrl)
99 {
100 RTURIPARSED Parsed;
101 int rc = RTUriParse(a_pszUrl, &Parsed);
102 AssertRC(rc);
103 }
104#endif
105
106 return m_strServerUrl.assignNoThrow(a_pszUrl);
107}
108
109
110int RTCRestClientApiBase::setServerUrlPart(const char *a_pszServerUrl, size_t a_offDst, size_t a_cchDst,
111 const char *a_pszSrc, size_t a_cchSrc) RT_NOEXCEPT
112{
113 if ( a_cchDst == a_cchSrc
114 && memcmp(&a_pszServerUrl[0], a_pszSrc, a_cchSrc) == 0)
115 return VINF_SUCCESS;
116
117 if (m_strServerUrl.isEmpty())
118 {
119 int rc = m_strServerUrl.assignNoThrow(a_pszServerUrl);
120 AssertRCReturn(rc, rc);
121 }
122 return m_strServerUrl.replaceNoThrow(a_offDst, a_cchDst, a_pszSrc, a_cchSrc);
123}
124
125
126int RTCRestClientApiBase::setServerScheme(const char *a_pszScheme) RT_NOEXCEPT
127{
128 /*
129 * Validate.
130 */
131 AssertReturn(a_pszScheme, VERR_INVALID_POINTER);
132 size_t const cchScheme = strlen(a_pszScheme);
133 AssertReturn(cchScheme > 0, VERR_INVALID_PARAMETER);
134 Assert(cchScheme < 16);
135#ifdef RT_STRICT
136 for (size_t i = 0; i < cchScheme; i++)
137 Assert(RT_C_IS_ALNUM(a_pszScheme[i]));
138#endif
139
140 /*
141 * Parse, compare & replace.
142 */
143 RTURIPARSED Parsed;
144 const char *pszUrl = getServerUrl();
145 int rc = RTUriParse(pszUrl, &Parsed);
146 AssertRCReturn(rc, rc);
147 return setServerUrlPart(pszUrl, 0, Parsed.cchScheme, a_pszScheme, cchScheme);
148}
149
150
151int RTCRestClientApiBase::setServerAuthority(const char *a_pszAuthority) RT_NOEXCEPT
152{
153 /*
154 * Validate.
155 */
156 AssertReturn(a_pszAuthority, VERR_INVALID_POINTER);
157 size_t const cchAuthority = strlen(a_pszAuthority);
158 AssertReturn(cchAuthority > 0, VERR_INVALID_PARAMETER);
159 Assert(memchr(a_pszAuthority, '/', cchAuthority) == NULL);
160 Assert(memchr(a_pszAuthority, '\\', cchAuthority) == NULL);
161 Assert(memchr(a_pszAuthority, '#', cchAuthority) == NULL);
162 Assert(memchr(a_pszAuthority, '?', cchAuthority) == NULL);
163
164 /*
165 * Parse, compare & replace.
166 */
167 RTURIPARSED Parsed;
168 const char *pszUrl = getServerUrl();
169 int rc = RTUriParse(pszUrl, &Parsed);
170 AssertRCReturn(rc, rc);
171 return setServerUrlPart(pszUrl, Parsed.offAuthority, Parsed.cchAuthority, a_pszAuthority, cchAuthority);
172}
173
174
175int RTCRestClientApiBase::setServerBasePath(const char *a_pszBasePath) RT_NOEXCEPT
176{
177 /*
178 * Validate.
179 */
180 AssertReturn(a_pszBasePath, VERR_INVALID_POINTER);
181 size_t const cchBasePath = strlen(a_pszBasePath);
182 AssertReturn(cchBasePath > 0, VERR_INVALID_PARAMETER);
183 Assert(memchr(a_pszBasePath, '?', cchBasePath) == NULL);
184 Assert(memchr(a_pszBasePath, '#', cchBasePath) == NULL);
185
186 /*
187 * Parse, compare & replace.
188 */
189 RTURIPARSED Parsed;
190 const char *pszUrl = getServerUrl();
191 int rc = RTUriParse(pszUrl, &Parsed);
192 AssertRCReturn(rc, rc);
193 return setServerUrlPart(pszUrl, Parsed.offPath, Parsed.cchPath, a_pszBasePath, cchBasePath);
194}
195
196
197int RTCRestClientApiBase::reinitHttpInstance() RT_NOEXCEPT
198{
199 if (m_hHttp != NIL_RTHTTP)
200 return RTHttpReset(m_hHttp, 0 /*fFlags*/);
201
202 int rc = RTHttpCreate(&m_hHttp);
203 if (RT_SUCCESS(rc) && m_strCAFile.isNotEmpty())
204 rc = RTHttpSetCAFile(m_hHttp, m_strCAFile.c_str());
205
206 if (RT_FAILURE(rc) && m_hHttp != NIL_RTHTTP)
207 {
208 RTHttpDestroy(m_hHttp);
209 m_hHttp = NIL_RTHTTP;
210 }
211 return rc;
212}
213
214
215int RTCRestClientApiBase::xmitReady(RTHTTP a_hHttp, RTCString const &a_rStrFullUrl, RTHTTPMETHOD a_enmHttpMethod,
216 RTCString const &a_rStrXmitBody, uint32_t a_fFlags) RT_NOEXCEPT
217{
218 RT_NOREF(a_hHttp, a_rStrFullUrl, a_enmHttpMethod, a_rStrXmitBody, a_fFlags);
219 return VINF_SUCCESS;
220}
221
222
223int RTCRestClientApiBase::doCall(RTCRestClientRequestBase const &a_rRequest, RTHTTPMETHOD a_enmHttpMethod,
224 RTCRestClientResponseBase *a_pResponse, const char *a_pszMethod, uint32_t a_fFlags) RT_NOEXCEPT
225{
226 LogFlow(("doCall: %s %s\n", a_pszMethod, RTHttpMethodToStr(a_enmHttpMethod)));
227
228
229 /*
230 * Reset the response object (allowing reuse of such) and check the request
231 * object for assignment errors.
232 */
233 int rc;
234 RTHTTP hHttp = NIL_RTHTTP;
235
236 a_pResponse->reset();
237 if (!a_rRequest.hasAssignmentErrors())
238 {
239 /*
240 * Initialize the HTTP instance.
241 */
242 rc = reinitHttpInstance();
243 if (RT_SUCCESS(rc))
244 {
245 hHttp = m_hHttp;
246 Assert(hHttp != NIL_RTHTTP);
247
248 /*
249 * Prepare the response side.
250 */
251 rc = a_pResponse->receivePrepare(hHttp);
252 if (RT_SUCCESS(rc))
253 {
254 /*
255 * Prepare the request for the transmission.
256 */
257 RTCString strExtraPath;
258 RTCString strQuery;
259 RTCString strXmitBody;
260 rc = a_rRequest.xmitPrepare(&strExtraPath, &strQuery, hHttp, &strXmitBody);
261 if (RT_SUCCESS(rc))
262 {
263 /*
264 * Construct the full URL.
265 */
266 RTCString strFullUrl;
267 rc = strFullUrl.assignNoThrow(getServerUrl());
268 if (strExtraPath.isNotEmpty())
269 {
270 if (!strExtraPath.startsWith("/") && !strFullUrl.endsWith("/") && RT_SUCCESS(rc))
271 rc = strFullUrl.appendNoThrow('/');
272 if (RT_SUCCESS(rc))
273 rc = strFullUrl.appendNoThrow(strExtraPath);
274 strExtraPath.setNull();
275 }
276 if (strQuery.isNotEmpty())
277 {
278 Assert(strQuery.startsWith("?"));
279 rc = strFullUrl.appendNoThrow(strQuery);
280 strQuery.setNull();
281 }
282 if (RT_SUCCESS(rc))
283 {
284 rc = xmitReady(hHttp, strFullUrl, a_enmHttpMethod, strXmitBody, a_fFlags);
285 if (RT_SUCCESS(rc))
286 {
287 /*
288 * Perform HTTP request.
289 */
290 uint32_t uHttpStatus = 0;
291 size_t cbBody = 0;
292 void *pvBody = NULL;
293 rc = RTHttpPerform(hHttp, strFullUrl.c_str(), a_enmHttpMethod,
294 strXmitBody.c_str(), strXmitBody.length(),
295 &uHttpStatus, NULL /*ppvHdrs*/, NULL /*pcbHdrs*/, &pvBody, &cbBody);
296 if (RT_SUCCESS(rc))
297 {
298 a_rRequest.xmitComplete(uHttpStatus, hHttp);
299
300 /*
301 * Do response processing.
302 */
303 a_pResponse->receiveComplete(uHttpStatus, hHttp);
304 a_pResponse->consumeBody((const char *)pvBody, cbBody);
305 if (pvBody)
306 RTHttpFreeResponse(pvBody);
307 a_pResponse->receiveFinal();
308
309 return a_pResponse->getStatus();
310 }
311 }
312 }
313 }
314 a_rRequest.xmitComplete(rc, hHttp);
315 }
316 }
317 }
318 else
319 rc = VERR_NO_MEMORY;
320
321 a_pResponse->receiveComplete(rc, hHttp);
322 RT_NOREF_PV(a_pszMethod);
323
324 return a_pResponse->getStatus();
325}
326
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette