cmCTestCurl.cxx 9.3 KB
Newer Older
1
2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
3
4
5
#include "cmCTestCurl.h"

#include "cmCTest.h"
6
#include "cmSystemTools.h"
7

8
#include "cmConfigure.h"
9
10
11
#include <ostream>
#include <stdio.h>

12
13
14
15
16
17
18
19
20
21
cmCTestCurl::cmCTestCurl(cmCTest* ctest)
{
  this->CTest = ctest;
  this->SetProxyType();
  this->UseHttp10 = false;
  // In windows, this will init the winsock stuff
  ::curl_global_init(CURL_GLOBAL_ALL);
  // default is to verify https
  this->VerifyPeerOff = false;
  this->VerifyHostOff = false;
22
  this->Quiet = false;
23
  this->TimeOutSeconds = 0;
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
  this->Curl = curl_easy_init();
}

cmCTestCurl::~cmCTestCurl()
{
  ::curl_easy_cleanup(this->Curl);
  ::curl_global_cleanup();
}

std::string cmCTestCurl::Escape(std::string const& source)
{
  char* data1 = curl_easy_escape(this->Curl, source.c_str(), 0);
  std::string ret = data1;
  curl_free(data1);
  return ret;
39
40
}

41
namespace {
42
43
size_t curlWriteMemoryCallback(void* ptr, size_t size, size_t nmemb,
                               void* data)
44
45
46
{
  int realsize = (int)(size * nmemb);

47
  std::vector<char>* vec = static_cast<std::vector<char>*>(data);
48
49
50
51
52
  const char* chPtr = static_cast<char*>(ptr);
  vec->insert(vec->end(), chPtr, chPtr + realsize);
  return realsize;
}

53
54
size_t curlDebugCallback(CURL* /*unused*/, curl_infotype /*unused*/,
                         char* chPtr, size_t size, void* data)
55
{
56
  std::vector<char>* vec = static_cast<std::vector<char>*>(data);
57
58
59
60
61
62
63
64
  vec->insert(vec->end(), chPtr, chPtr + size);

  return size;
}
}

void cmCTestCurl::SetCurlOptions(std::vector<std::string> const& args)
{
65
66
67
  for (std::vector<std::string>::const_iterator i = args.begin();
       i != args.end(); ++i) {
    if (*i == "CURLOPT_SSL_VERIFYPEER_OFF") {
68
      this->VerifyPeerOff = true;
69
70
    }
    if (*i == "CURLOPT_SSL_VERIFYHOST_OFF") {
71
72
      this->VerifyHostOff = true;
    }
73
  }
74
75
76
77
}

bool cmCTestCurl::InitCurl()
{
78
  if (!this->Curl) {
79
    return false;
80
81
  }
  if (this->VerifyPeerOff) {
82
    curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYPEER, 0);
83
84
  }
  if (this->VerifyHostOff) {
85
    curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYHOST, 0);
86
  }
87
  if (!this->HTTPProxy.empty()) {
88
89
    curl_easy_setopt(this->Curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
    curl_easy_setopt(this->Curl, CURLOPT_PROXYTYPE, this->HTTPProxyType);
90
    if (!this->HTTPProxyAuth.empty()) {
91
92
93
      curl_easy_setopt(this->Curl, CURLOPT_PROXYUSERPWD,
                       this->HTTPProxyAuth.c_str());
    }
94
95
  }
  if (this->UseHttp10) {
96
    curl_easy_setopt(this->Curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
97
  }
98
99
  // enable HTTP ERROR parsing
  curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
100
101
102
103
104
105
106

  // if there is little to no activity for too long stop submitting
  if (this->TimeOutSeconds) {
    curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_LIMIT, 1);
    curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_TIME, this->TimeOutSeconds);
  }

107
108
109
110
  return true;
}

bool cmCTestCurl::UploadFile(std::string const& local_file,
111
                             std::string const& url, std::string const& fields,
112
113
114
                             std::string& response)
{
  response = "";
115
  if (!this->InitCurl()) {
116
117
    cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
    return false;
118
  }
119
120
  /* enable uploading */
  curl_easy_setopt(this->Curl, CURLOPT_UPLOAD, 1);
121

122
123
124
125
126
  /* HTTP PUT please */
  ::curl_easy_setopt(this->Curl, CURLOPT_PUT, 1);
  ::curl_easy_setopt(this->Curl, CURLOPT_VERBOSE, 1);

  FILE* ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
127
  if (!ftpfile) {
128
129
130
    cmCTestLog(this->CTest, ERROR_MESSAGE,
               "Could not open file for upload: " << local_file << "\n");
    return false;
131
  }
132
133
134
135
136
137
138
139
140
141
142
143
144
  // set the url
  std::string upload_url = url;
  upload_url += "?";
  upload_url += fields;
  ::curl_easy_setopt(this->Curl, CURLOPT_URL, upload_url.c_str());
  // now specify which file to upload
  ::curl_easy_setopt(this->Curl, CURLOPT_INFILE, ftpfile);
  unsigned long filelen = cmSystemTools::FileLength(local_file);
  // and give the size of the upload (optional)
  ::curl_easy_setopt(this->Curl, CURLOPT_INFILESIZE,
                     static_cast<long>(filelen));
  ::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
                     curlWriteMemoryCallback);
145
  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
146
  // Set Content-Type to satisfy fussy modsecurity rules.
147
  struct curl_slist* headers =
Daniel Pfeifer's avatar
Daniel Pfeifer committed
148
    ::curl_slist_append(CM_NULLPTR, "Content-Type: text/xml");
149
150
151
152
153
154
155
156
  // Add any additional headers that the user specified.
  for (std::vector<std::string>::const_iterator h = this->HttpHeaders.begin();
       h != this->HttpHeaders.end(); ++h) {
    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
                       "   Add HTTP Header: \"" << *h << "\"" << std::endl,
                       this->Quiet);
    headers = ::curl_slist_append(headers, h->c_str());
  }
157
  ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers);
158
159
  std::vector<char> responseData;
  std::vector<char> debugData;
160
161
  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void*)&responseData);
  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void*)&debugData);
162
163
164
165
  ::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
  // Now run off and do what you've been told!
  ::curl_easy_perform(this->Curl);
  ::fclose(ftpfile);
166
167
  ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, NULL);
  ::curl_slist_free_all(headers);
168

169
  if (!responseData.empty()) {
170
    response = std::string(responseData.begin(), responseData.end());
171
172
    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
                       "Curl response: [" << response << "]\n", this->Quiet);
173
  }
174
  std::string curlDebug;
175
  if (!debugData.empty()) {
176
    curlDebug = std::string(debugData.begin(), debugData.end());
177
178
    cmCTestOptionalLog(this->CTest, DEBUG,
                       "Curl debug: [" << curlDebug << "]\n", this->Quiet);
179
  }
180
  if (response.empty()) {
181
182
    cmCTestLog(this->CTest, ERROR_MESSAGE, "No response from server.\n"
                 << curlDebug);
183
    return false;
184
  }
185
186
187
188
  return true;
}

bool cmCTestCurl::HttpRequest(std::string const& url,
189
                              std::string const& fields, std::string& response)
190
191
{
  response = "";
192
193
194
195
  cmCTestOptionalLog(this->CTest, DEBUG, "HttpRequest\n"
                       << "url: " << url << "\n"
                       << "fields " << fields << "\n",
                     this->Quiet);
196
  if (!this->InitCurl()) {
197
198
    cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
    return false;
199
  }
200
201
202
203
  curl_easy_setopt(this->Curl, CURLOPT_POST, 1);
  curl_easy_setopt(this->Curl, CURLOPT_POSTFIELDS, fields.c_str());
  ::curl_easy_setopt(this->Curl, CURLOPT_URL, url.c_str());
  ::curl_easy_setopt(this->Curl, CURLOPT_FOLLOWLOCATION, 1);
204
  // set response options
205
206
  ::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
                     curlWriteMemoryCallback);
207
  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
208
209
  std::vector<char> responseData;
  std::vector<char> debugData;
210
211
  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void*)&responseData);
  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void*)&debugData);
212
213
  ::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);

214
215
216
217
218
219
220
221
222
223
224
225
226
227
  // Add headers if any were specified.
  struct curl_slist* headers = CM_NULLPTR;
  if (!this->HttpHeaders.empty()) {
    for (std::vector<std::string>::const_iterator h =
           this->HttpHeaders.begin();
         h != this->HttpHeaders.end(); ++h) {
      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
                         "   Add HTTP Header: \"" << *h << "\"" << std::endl,
                         this->Quiet);
      headers = ::curl_slist_append(headers, h->c_str());
    }
  }

  ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers);
228
  CURLcode res = ::curl_easy_perform(this->Curl);
229
  ::curl_slist_free_all(headers);
230

231
  if (!responseData.empty()) {
232
    response = std::string(responseData.begin(), responseData.end());
233
234
    cmCTestOptionalLog(this->CTest, DEBUG,
                       "Curl response: [" << response << "]\n", this->Quiet);
235
  }
236
  if (!debugData.empty()) {
237
    std::string curlDebug = std::string(debugData.begin(), debugData.end());
238
239
    cmCTestOptionalLog(this->CTest, DEBUG,
                       "Curl debug: [" << curlDebug << "]\n", this->Quiet);
240
  }
241
242
  cmCTestOptionalLog(this->CTest, DEBUG, "Curl res: " << res << "\n",
                     this->Quiet);
243
244
245
246
247
  return (res == 0);
}

void cmCTestCurl::SetProxyType()
{
248
249
250
251
252
253
254
  this->HTTPProxy = "";
  // this is the default
  this->HTTPProxyType = CURLPROXY_HTTP;
  this->HTTPProxyAuth = "";
  if (cmSystemTools::GetEnv("HTTP_PROXY", this->HTTPProxy)) {
    std::string port;
    if (cmSystemTools::GetEnv("HTTP_PROXY_PORT", port)) {
255
      this->HTTPProxy += ":";
256
      this->HTTPProxy += port;
257
    }
258
259
    std::string type;
    if (cmSystemTools::GetEnv("HTTP_PROXY_TYPE", type)) {
260
      // HTTP/SOCKS4/SOCKS5
261
      if (type == "HTTP") {
262
        this->HTTPProxyType = CURLPROXY_HTTP;
263
      } else if (type == "SOCKS4") {
264
        this->HTTPProxyType = CURLPROXY_SOCKS4;
265
      } else if (type == "SOCKS5") {
266
267
        this->HTTPProxyType = CURLPROXY_SOCKS5;
      }
268
    }
269
270
271
    cmSystemTools::GetEnv("HTTP_PROXY_USER", this->HTTPProxyAuth);
    std::string passwd;
    if (cmSystemTools::GetEnv("HTTP_PROXY_PASSWD", passwd)) {
272
      this->HTTPProxyAuth += ":";
273
      this->HTTPProxyAuth += passwd;
274
    }
275
  }
276
}