Mercurial > hg > orthanc

comparison Plugins/Engine/OrthancPlugins.cpp @ 3387:a48d652f1500

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
new function OrthancPluginHttpClientChunkedBody(), new class OrthancPlugins::HttpClient
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 05 Jun 2019 17:17:48 +0200
parents f6374c36a671
children ad434967a68c
comparison
equal deleted inserted replaced
3386:af9432e46c07 3387:a48d652f1500
971 unsigned int size = params_.getMoveSize(driver); 971 unsigned int size = params_.getMoveSize(driver);
972 972
973 return new Driver(driver, size, params_.applyMove, params_.freeMove); 973 return new Driver(driver, size, params_.applyMove, params_.freeMove);
974 } 974 }
975 }; 975 };
976 976
977
978
979 class OrthancPlugins::ChunkedBody : public HttpClient::IChunkedBody
980 {
981 private:
982 const _OrthancPluginHttpClientChunkedBody& params_;
983 PluginsErrorDictionary& errorDictionary_;
984
985 public:
986 ChunkedBody(const _OrthancPluginHttpClientChunkedBody& params,
987 PluginsErrorDictionary& errorDictionary) :
988 params_(params),
989 errorDictionary_(errorDictionary)
990 {
991 }
992
993 virtual bool ReadNextChunk(std::string& chunk)
994 {
995 if (params_.bodyDone(params_.body))
996 {
997 return false;
998 }
999 else
1000 {
1001 size_t size = params_.bodyChunkSize(params_.body);
1002
1003 chunk.resize(size);
1004
1005 if (size != 0)
1006 {
1007 const void* data = params_.bodyChunkData(params_.body);
1008 memcpy(&chunk[0], data, size);
1009 }
1010
1011 OrthancPluginErrorCode error = params_.bodyNext(params_.body);
1012
1013 if (error != OrthancPluginErrorCode_Success)
1014 {
1015 errorDictionary_.LogError(error, true);
1016 throw OrthancException(static_cast<ErrorCode>(error));
1017 }
1018 else
1019 {
1020 return true;
1021 }
1022 }
1023 }
1024 };
977 1025
978 1026
979 OrthancPlugins::OrthancPlugins() 1027 OrthancPlugins::OrthancPlugins()
980 { 1028 {
981 /* Sanity check of the compiler */ 1029 /* Sanity check of the compiler */
2035 2083
2036 CopyToMemoryBuffer(*p.target, compressed.size() > 0 ? compressed.c_str() : NULL, compressed.size()); 2084 CopyToMemoryBuffer(*p.target, compressed.size() > 0 ? compressed.c_str() : NULL, compressed.size());
2037 } 2085 }
2038 2086
2039 2087
2040 void OrthancPlugins::CallHttpClient(const void* parameters) 2088 static void RunHttpClient(HttpClient& client,
2041 { 2089 const _OrthancPluginCallHttpClient2& parameters)
2042 const _OrthancPluginCallHttpClient& p = *reinterpret_cast<const _OrthancPluginCallHttpClient*>(parameters); 2090 {
2043 2091 client.SetUrl(parameters.url);
2044 HttpClient client; 2092 client.SetConvertHeadersToLowerCase(false);
2045 client.SetUrl(p.url); 2093
2046 2094 if (parameters.timeout != 0)
2047 if (p.username != NULL && 2095 {
2048 p.password != NULL) 2096 client.SetTimeout(parameters.timeout);
2049 { 2097 }
2050 client.SetCredentials(p.username, p.password); 2098
2051 } 2099 if (parameters.username != NULL &&
2052 2100 parameters.password != NULL)
2053 switch (p.method) 2101 {
2102 client.SetCredentials(parameters.username, parameters.password);
2103 }
2104
2105 if (parameters.certificateFile != NULL)
2106 {
2107 std::string certificate(parameters.certificateFile);
2108 std::string key, password;
2109
2110 if (parameters.certificateKeyFile)
2111 {
2112 key.assign(parameters.certificateKeyFile);
2113 }
2114
2115 if (parameters.certificateKeyPassword)
2116 {
2117 password.assign(parameters.certificateKeyPassword);
2118 }
2119
2120 client.SetClientCertificate(certificate, key, password);
2121 }
2122
2123 client.SetPkcs11Enabled(parameters.pkcs11 ? true : false);
2124
2125 for (uint32_t i = 0; i < parameters.headersCount; i++)
2126 {
2127 if (parameters.headersKeys[i] == NULL ||
2128 parameters.headersValues[i] == NULL)
2129 {
2130 throw OrthancException(ErrorCode_NullPointer);
2131 }
2132
2133 client.AddHeader(parameters.headersKeys[i], parameters.headersValues[i]);
2134 }
2135
2136 switch (parameters.method)
2054 { 2137 {
2055 case OrthancPluginHttpMethod_Get: 2138 case OrthancPluginHttpMethod_Get:
2056 client.SetMethod(HttpMethod_Get); 2139 client.SetMethod(HttpMethod_Get);
2057 break; 2140 break;
2058 2141
2059 case OrthancPluginHttpMethod_Post: 2142 case OrthancPluginHttpMethod_Post:
2060 client.SetMethod(HttpMethod_Post); 2143 client.SetMethod(HttpMethod_Post);
2061 client.GetBody().assign(p.body, p.bodySize);
2062 break; 2144 break;
2063 2145
2064 case OrthancPluginHttpMethod_Put: 2146 case OrthancPluginHttpMethod_Put:
2065 client.SetMethod(HttpMethod_Put); 2147 client.SetMethod(HttpMethod_Put);
2066 client.GetBody().assign(p.body, p.bodySize);
2067 break; 2148 break;
2068 2149
2069 case OrthancPluginHttpMethod_Delete: 2150 case OrthancPluginHttpMethod_Delete:
2070 client.SetMethod(HttpMethod_Delete); 2151 client.SetMethod(HttpMethod_Delete);
2071 break; 2152 break;
2072 2153
2073 default: 2154 default:
2074 throw OrthancException(ErrorCode_ParameterOutOfRange); 2155 throw OrthancException(ErrorCode_ParameterOutOfRange);
2075 } 2156 }
2076 2157
2077 std::string s;
2078 client.ApplyAndThrowException(s);
2079
2080 if (p.method != OrthancPluginHttpMethod_Delete)
2081 {
2082 CopyToMemoryBuffer(*p.target, s);
2083 }
2084 }
2085
2086
2087 void OrthancPlugins::CallHttpClient2(const void* parameters)
2088 {
2089 const _OrthancPluginCallHttpClient2& p = *reinterpret_cast<const _OrthancPluginCallHttpClient2*>(parameters);
2090
2091 HttpClient client;
2092 client.SetUrl(p.url);
2093 client.SetConvertHeadersToLowerCase(false);
2094
2095 if (p.timeout != 0)
2096 {
2097 client.SetTimeout(p.timeout);
2098 }
2099
2100 if (p.username != NULL &&
2101 p.password != NULL)
2102 {
2103 client.SetCredentials(p.username, p.password);
2104 }
2105
2106 if (p.certificateFile != NULL)
2107 {
2108 std::string certificate(p.certificateFile);
2109 std::string key, password;
2110
2111 if (p.certificateKeyFile)
2112 {
2113 key.assign(p.certificateKeyFile);
2114 }
2115
2116 if (p.certificateKeyPassword)
2117 {
2118 password.assign(p.certificateKeyPassword);
2119 }
2120
2121 client.SetClientCertificate(certificate, key, password);
2122 }
2123
2124 client.SetPkcs11Enabled(p.pkcs11 ? true : false);
2125
2126 for (uint32_t i = 0; i < p.headersCount; i++)
2127 {
2128 if (p.headersKeys[i] == NULL ||
2129 p.headersValues[i] == NULL)
2130 {
2131 throw OrthancException(ErrorCode_NullPointer);
2132 }
2133
2134 client.AddHeader(p.headersKeys[i], p.headersValues[i]);
2135 }
2136
2137 switch (p.method)
2138 {
2139 case OrthancPluginHttpMethod_Get:
2140 client.SetMethod(HttpMethod_Get);
2141 break;
2142
2143 case OrthancPluginHttpMethod_Post:
2144 client.SetMethod(HttpMethod_Post);
2145 client.GetBody().assign(p.body, p.bodySize);
2146 break;
2147
2148 case OrthancPluginHttpMethod_Put:
2149 client.SetMethod(HttpMethod_Put);
2150 client.GetBody().assign(p.body, p.bodySize);
2151 break;
2152
2153 case OrthancPluginHttpMethod_Delete:
2154 client.SetMethod(HttpMethod_Delete);
2155 break;
2156
2157 default:
2158 throw OrthancException(ErrorCode_ParameterOutOfRange);
2159 }
2160
2161 std::string body; 2158 std::string body;
2162 HttpClient::HttpHeaders headers; 2159 HttpClient::HttpHeaders headers;
2163 2160
2164 bool success = client.Apply(body, headers); 2161 bool success = client.Apply(body, headers);
2165 2162
2166 // The HTTP request has succeeded 2163 // The HTTP request has succeeded
2167 *p.httpStatus = static_cast<uint16_t>(client.GetLastStatus()); 2164 *parameters.httpStatus = static_cast<uint16_t>(client.GetLastStatus());
2168 2165
2169 if (!success) 2166 if (!success)
2170 { 2167 {
2171 HttpClient::ThrowException(client.GetLastStatus()); 2168 HttpClient::ThrowException(client.GetLastStatus());
2172 } 2169 }
2173 2170
2174 // Copy the HTTP headers of the answer, if the plugin requested them 2171 // Copy the HTTP headers of the answer, if the plugin requested them
2175 if (p.answerHeaders != NULL) 2172 if (parameters.answerHeaders != NULL)
2176 { 2173 {
2177 Json::Value json = Json::objectValue; 2174 Json::Value json = Json::objectValue;
2178 2175
2179 for (HttpClient::HttpHeaders::const_iterator 2176 for (HttpClient::HttpHeaders::const_iterator
2180 it = headers.begin(); it != headers.end(); ++it) 2177 it = headers.begin(); it != headers.end(); ++it)
2181 { 2178 {
2182 json[it->first] = it->second; 2179 json[it->first] = it->second;
2183 } 2180 }
2184 2181
2185 std::string s = json.toStyledString(); 2182 std::string s = json.toStyledString();
2186 CopyToMemoryBuffer(*p.answerHeaders, s); 2183 CopyToMemoryBuffer(*parameters.answerHeaders, s);
2187 } 2184 }
2188 2185
2189 // Copy the body of the answer if it makes sense 2186 // Copy the body of the answer if it makes sense
2190 if (p.method != OrthancPluginHttpMethod_Delete) 2187 if (parameters.method != OrthancPluginHttpMethod_Delete)
2191 { 2188 {
2192 CopyToMemoryBuffer(*p.answerBody, body); 2189 CopyToMemoryBuffer(*parameters.answerBody, body);
2193 } 2190 }
2191 }
2192
2193
2194 void OrthancPlugins::CallHttpClient(const void* parameters)
2195 {
2196 const _OrthancPluginCallHttpClient& p = *reinterpret_cast<const _OrthancPluginCallHttpClient*>(parameters);
2197
2198 _OrthancPluginCallHttpClient2 converted;
2199 memset(&converted, 0, sizeof(converted));
2200
2201 uint16_t httpStatus;
2202
2203 converted.answerBody = p.target;
2204 converted.answerHeaders = NULL;
2205 converted.httpStatus = &httpStatus;
2206 converted.method = p.method;
2207 converted.url = p.url;
2208 converted.headersCount = 0;
2209 converted.headersKeys = NULL;
2210 converted.headersValues = NULL;
2211 converted.body = p.body;
2212 converted.bodySize = p.bodySize;
2213 converted.username = p.username;
2214 converted.password = p.password;
2215 converted.timeout = 0; // Use default timeout
2216 converted.certificateFile = NULL;
2217 converted.certificateKeyFile = NULL;
2218 converted.certificateKeyPassword = NULL;
2219 converted.pkcs11 = false;
2220
2221 HttpClient client;
2222 RunHttpClient(client, converted);
2223 }
2224
2225
2226 void OrthancPlugins::CallHttpClient2(const void* parameters)
2227 {
2228 const _OrthancPluginCallHttpClient2& p = *reinterpret_cast<const _OrthancPluginCallHttpClient2*>(parameters);
2229
2230 HttpClient client;
2231
2232 if (p.method == OrthancPluginHttpMethod_Post ||
2233 p.method == OrthancPluginHttpMethod_Put)
2234 {
2235 client.GetBody().assign(p.body, p.bodySize);
2236 }
2237
2238 RunHttpClient(client, p);
2239 }
2240
2241
2242 void OrthancPlugins::HttpClientChunkedBody(const void* parameters)
2243 {
2244 const _OrthancPluginHttpClientChunkedBody& p =
2245 *reinterpret_cast<const _OrthancPluginHttpClientChunkedBody*>(parameters);
2246
2247 if (p.method != OrthancPluginHttpMethod_Post &&
2248 p.method != OrthancPluginHttpMethod_Put)
2249 {
2250 throw OrthancException(ErrorCode_ParameterOutOfRange,
2251 "This plugin service is only allowed for PUT and POST HTTP requests");
2252 }
2253
2254 ChunkedBody body(p, pimpl_->dictionary_);
2255
2256 HttpClient client;
2257 client.SetBody(body);
2258
2259 _OrthancPluginCallHttpClient2 converted;
2260 memset(&converted, 0, sizeof(converted));
2261
2262 converted.answerBody = p.answerBody;
2263 converted.answerHeaders = p.answerHeaders;
2264 converted.httpStatus = p.httpStatus;
2265 converted.method = p.method;
2266 converted.url = p.url;
2267 converted.headersCount = p.headersCount;
2268 converted.headersKeys = p.headersKeys;
2269 converted.headersValues = p.headersValues;
2270 converted.body = NULL;
2271 converted.bodySize = 0;
2272 converted.username = p.username;
2273 converted.password = p.password;
2274 converted.timeout = p.timeout;
2275 converted.certificateFile = p.certificateFile;
2276 converted.certificateKeyFile = p.certificateKeyFile;
2277 converted.certificateKeyPassword = p.certificateKeyPassword;
2278 converted.pkcs11 = p.pkcs11;
2279
2280 RunHttpClient(client, converted);
2194 } 2281 }
2195 2282
2196 2283
2197 void OrthancPlugins::CallPeerApi(const void* parameters) 2284 void OrthancPlugins::CallPeerApi(const void* parameters)
2198 { 2285 {
2870 2957
2871 case _OrthancPluginService_CallHttpClient2: 2958 case _OrthancPluginService_CallHttpClient2:
2872 CallHttpClient2(parameters); 2959 CallHttpClient2(parameters);
2873 return true; 2960 return true;
2874 2961
2962 case _OrthancPluginService_HttpClientChunkedBody:
2963 HttpClientChunkedBody(parameters);
2964 return true;
2965
2875 case _OrthancPluginService_ConvertPixelFormat: 2966 case _OrthancPluginService_ConvertPixelFormat:
2876 ConvertPixelFormat(parameters); 2967 ConvertPixelFormat(parameters);
2877 return true; 2968 return true;
2878 2969
2879 case _OrthancPluginService_GetFontsCount: 2970 case _OrthancPluginService_GetFontsCount: