|
1 /** |
|
2 * Copyright (c) 2010 Sasken Communication Technologies Ltd. |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html" |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Chandradeep Gandhi, Sasken Communication Technologies Ltd - Initial contribution |
|
11 * |
|
12 * Contributors: |
|
13 * Manasij Roy, Nalina Hariharan |
|
14 * |
|
15 * Description: |
|
16 * The Transport Manager Utility class provides the http/https transaction |
|
17 * methods for the smf framework |
|
18 * |
|
19 */ |
|
20 |
|
21 // Include files |
|
22 #include <QNetworkAccessManager> |
|
23 #include <QNetworkReply> |
|
24 #include <QSettings> |
|
25 #include <zlib.h> |
|
26 // For proxy settings on emulator only - REMOVE for device |
|
27 #include <QNetworkProxy> |
|
28 |
|
29 #include "smftransportmanagerutil.h" |
|
30 #include "smfpluginmanager.h" |
|
31 |
|
32 // Static Global constants |
|
33 static const char kSmfUserAgent[] = "SmfFrameWork"; |
|
34 static const char kSmfCacheControl[] = "no-cache"; |
|
35 static const char kSmfAcceptEncoding[] = "gzip"; |
|
36 |
|
37 // Static data initialisation |
|
38 SmfTransportManagerUtil* SmfTransportManagerUtil::m_myInstance = NULL; |
|
39 |
|
40 /** |
|
41 * Method to get the instance of SmfTransportManagerUtil class |
|
42 * @return The instance of SmfTransportManager class |
|
43 */ |
|
44 SmfTransportManagerUtil* SmfTransportManagerUtil::getInstance ( ) |
|
45 { |
|
46 if(NULL == m_myInstance) |
|
47 m_myInstance = new SmfTransportManagerUtil( ); |
|
48 return m_myInstance; |
|
49 } |
|
50 |
|
51 /** |
|
52 * Constructor with default argument |
|
53 * @param aParent The parent object |
|
54 */ |
|
55 SmfTransportManagerUtil::SmfTransportManagerUtil ( ) |
|
56 : m_networkAccessManager ( this ) |
|
57 { |
|
58 // Storage of settings (Only data usage as of now) |
|
59 m_settings = new QSettings("Sasken", "SmfTransportManager"); |
|
60 |
|
61 // Create the settings if no data is stored |
|
62 if( !m_settings->contains("Sent Data") ) |
|
63 m_settings->setValue("Sent Data", 0); |
|
64 if( !m_settings->contains("Received Data") ) |
|
65 m_settings->setValue("Received Data", 0); |
|
66 } |
|
67 |
|
68 |
|
69 /** |
|
70 * Destructor |
|
71 */ |
|
72 SmfTransportManagerUtil::~SmfTransportManagerUtil ( ) |
|
73 { |
|
74 m_activeNetwReplyList.clear(); |
|
75 |
|
76 if(m_settings) |
|
77 delete m_settings; |
|
78 |
|
79 if(m_myInstance) |
|
80 delete m_myInstance; |
|
81 } |
|
82 |
|
83 |
|
84 /** |
|
85 * Method that does a http GET request. Returns the unique QNetworkReply |
|
86 * instance for this transaction to the plugin manager to trace the |
|
87 * proper response. |
|
88 * @param aRequest The request formed by the plugin |
|
89 * @param aUrlList The list of accessible Urls for this plugin |
|
90 * @param aSOPCompliant [out] Output parameter indicating Same Origin |
|
91 * Policy Compliance. Contains true if the request complies to the policy, |
|
92 * else false. If it is false, the network request will not performed |
|
93 * @return The unique QNetworkReply instance for this transaction |
|
94 */ |
|
95 QNetworkReply* SmfTransportManagerUtil::get ( |
|
96 QNetworkRequest &aRequest, |
|
97 const QList<QUrl> &aUrlList, |
|
98 bool &aSOPCompliant ) |
|
99 { |
|
100 bool found = false; |
|
101 QString hostName = aRequest.url().host(); |
|
102 |
|
103 // Same Origin Policy checking |
|
104 // Check if the host name of the url in the request created by the |
|
105 // plugin is among the authorised url host name list |
|
106 foreach(QUrl url, aUrlList) |
|
107 { |
|
108 if(0 == hostName.compare(url.host())) |
|
109 { |
|
110 found = true; |
|
111 break; |
|
112 } |
|
113 } |
|
114 |
|
115 if(found) |
|
116 { |
|
117 aSOPCompliant = true; |
|
118 |
|
119 // Set header to accept gzip encoded data |
|
120 aRequest.setRawHeader("Accept-encoding", kSmfAcceptEncoding); |
|
121 |
|
122 // Set the cache control |
|
123 aRequest.setRawHeader("Cache-Control", kSmfCacheControl); |
|
124 |
|
125 // Put the same user agent for all requests sent by Smf |
|
126 aRequest.setRawHeader("User-Agent", kSmfUserAgent); |
|
127 |
|
128 QNetworkReply* reply = m_networkAccessManager.get(aRequest); |
|
129 |
|
130 connect(&m_networkAccessManager, SIGNAL(finished(QNetworkReply *)), |
|
131 this, SLOT(networkReplyFinished(QNetworkReply *))); |
|
132 |
|
133 connect(&m_networkAccessManager, SIGNAL(error(QNetworkReply::NetworkError)), |
|
134 this, SLOT(networkReplyError(QNetworkReply::NetworkError))); |
|
135 |
|
136 m_activeNetwReplyList.append(reply); |
|
137 |
|
138 return reply; |
|
139 } |
|
140 else |
|
141 { |
|
142 // Error :: SAME ORIGIN POLICY violation!!! |
|
143 aSOPCompliant = false; |
|
144 return NULL; |
|
145 } |
|
146 } |
|
147 |
|
148 |
|
149 /** |
|
150 * Method that does a http POST request. Returns the unique QNetworkReply |
|
151 * instance for this transaction to the plugin manager to trace the |
|
152 * proper response. |
|
153 * @param aRequest The request formed by the plugin |
|
154 * @param aPostData The data to be posted via http POST request |
|
155 * @param aUrlList The list of accessible Urls for this plugin |
|
156 * @param aSOPCompliant [out] Output parameter indicating Same Origin |
|
157 * Policy Compliance. Contains true if the request complies to the policy, |
|
158 * else false. If it is false, the network request will not performed |
|
159 * @return The unique QNetworkReply instance for this transaction |
|
160 */ |
|
161 QNetworkReply* SmfTransportManagerUtil::post ( |
|
162 QNetworkRequest &aRequest, |
|
163 const QByteArray& aPostData, |
|
164 const QList<QUrl> &aUrlList, |
|
165 bool &aSOPCompliant ) |
|
166 { |
|
167 bool found = false; |
|
168 QString hostName = aRequest.url().host(); |
|
169 |
|
170 // Same Origin Policy checking |
|
171 // Check if the host name of the url in the request created by the |
|
172 // plugin is among the authorised url host name list |
|
173 foreach(QUrl url, aUrlList) |
|
174 { |
|
175 if(0 == hostName.compare(url.host())) |
|
176 { |
|
177 found = true; |
|
178 break; |
|
179 } |
|
180 } |
|
181 |
|
182 if(found) |
|
183 { |
|
184 aSOPCompliant = true; |
|
185 |
|
186 // Set the cache control |
|
187 aRequest.setRawHeader("Cache-Control", kSmfCacheControl); |
|
188 |
|
189 // Put the same user agent for all requests sent by Smf |
|
190 aRequest.setRawHeader("User-Agent", kSmfUserAgent); |
|
191 |
|
192 QNetworkReply* reply = m_networkAccessManager.post(aRequest, aPostData); |
|
193 |
|
194 connect(&m_networkAccessManager, SIGNAL(finished(QNetworkReply *)), |
|
195 this, SLOT(networkReplyFinished(QNetworkReply *))); |
|
196 |
|
197 connect(&m_networkAccessManager, SIGNAL(error(QNetworkReply::NetworkError)), |
|
198 this, SLOT(networkReplyError(QNetworkReply::NetworkError))); |
|
199 |
|
200 m_activeNetwReplyList.append(reply); |
|
201 |
|
202 return reply; |
|
203 } |
|
204 else |
|
205 { |
|
206 // Error :: SAME ORIGIN POLICY violation!!! |
|
207 aSOPCompliant = false; |
|
208 return NULL; |
|
209 } |
|
210 } |
|
211 |
|
212 |
|
213 /** |
|
214 * Method that does a http HEAD request. Returns the unique QNetworkReply |
|
215 * instance for this transaction to the plugin manager to trace the |
|
216 * proper response. |
|
217 * @param aRequest The request formed by the plugin |
|
218 * @param aUrlList The list of accessible Urls for this plugin |
|
219 * @param aSOPCompliant [out] Output parameter indicating Same Origin |
|
220 * Policy Compliance. Contains true if the request complies to the policy, |
|
221 * else false. If it is false, the network request will not performed |
|
222 * @return The unique QNetworkReply instance for this transaction |
|
223 */ |
|
224 QNetworkReply* SmfTransportManagerUtil::head ( |
|
225 QNetworkRequest& aRequest, |
|
226 const QList<QUrl> &aUrlList, |
|
227 bool &aSOPCompliant ) |
|
228 { |
|
229 bool found = false; |
|
230 QString hostName = aRequest.url().host(); |
|
231 |
|
232 // Same Origin Policy checking |
|
233 // Check if the host name of the url in the request created by the |
|
234 // plugin is among the authorised url host name list |
|
235 foreach(QUrl url, aUrlList) |
|
236 { |
|
237 if(0 == hostName.compare(url.host())) |
|
238 { |
|
239 found = true; |
|
240 break; |
|
241 } |
|
242 } |
|
243 |
|
244 if(found) |
|
245 { |
|
246 aSOPCompliant = true; |
|
247 // Set the cache control |
|
248 aRequest.setRawHeader("Cache-Control", kSmfCacheControl); |
|
249 |
|
250 // Put the same user agent for all requests sent by Smf |
|
251 aRequest.setRawHeader("User-Agent", kSmfUserAgent); |
|
252 |
|
253 QNetworkReply* reply = m_networkAccessManager.head(aRequest); |
|
254 |
|
255 connect(&m_networkAccessManager, SIGNAL(finished(QNetworkReply *)), |
|
256 this, SLOT(networkReplyFinished(QNetworkReply *))); |
|
257 |
|
258 connect(&m_networkAccessManager, SIGNAL(error(QNetworkReply::NetworkError)), |
|
259 this, SLOT(networkReplyError(QNetworkReply::NetworkError))); |
|
260 |
|
261 m_activeNetwReplyList.append(reply); |
|
262 |
|
263 return reply; |
|
264 } |
|
265 else |
|
266 { |
|
267 // Error :: SAME ORIGIN POLICY violation!!! |
|
268 aSOPCompliant = false; |
|
269 return NULL; |
|
270 } |
|
271 } |
|
272 |
|
273 |
|
274 /** |
|
275 * Method that does a http PUT request. Returns the unique QNetworkReply |
|
276 * instance for this transaction to the plugin manager to trace the |
|
277 * proper response. |
|
278 * @param aRequest The request formed by the plugin |
|
279 * @param aPostData The data to be posted via http PUT request |
|
280 * @param aUrlList The list of accessible Urls for this plugin |
|
281 * @param aSOPCompliant [out] Output parameter indicating Same Origin |
|
282 * Policy Compliance. Contains true if the request complies to the policy, |
|
283 * else false. If it is false, the network request will not performed |
|
284 * @return The unique QNetworkReply instance for this transaction |
|
285 */ |
|
286 QNetworkReply* SmfTransportManagerUtil::put ( |
|
287 QNetworkRequest &aRequest, |
|
288 const QByteArray& aPostData, |
|
289 const QList<QUrl> &aUrlList, |
|
290 bool &aSOPCompliant ) |
|
291 { |
|
292 bool found = false; |
|
293 QString hostName = aRequest.url().host(); |
|
294 |
|
295 // Same Origin Policy checking |
|
296 // Check if the host name of the url in the request created by the |
|
297 // plugin is among the authorised url host name list |
|
298 foreach(QUrl url, aUrlList) |
|
299 { |
|
300 if(0 == hostName.compare(url.host())) |
|
301 { |
|
302 found = true; |
|
303 break; |
|
304 } |
|
305 } |
|
306 |
|
307 if(found) |
|
308 { |
|
309 aSOPCompliant = true; |
|
310 // Set the cache control |
|
311 aRequest.setRawHeader("Cache-Control", kSmfCacheControl); |
|
312 |
|
313 // Put the same user agent for all requests sent by Smf |
|
314 aRequest.setRawHeader("User-Agent", kSmfUserAgent); |
|
315 |
|
316 QNetworkReply* reply = m_networkAccessManager.put(aRequest, aPostData); |
|
317 |
|
318 connect(&m_networkAccessManager, SIGNAL(finished(QNetworkReply *)), |
|
319 this, SLOT(networkReplyFinished(QNetworkReply *))); |
|
320 |
|
321 connect(&m_networkAccessManager, SIGNAL(error(QNetworkReply::NetworkError)), |
|
322 this, SLOT(networkReplyError(QNetworkReply::NetworkError))); |
|
323 |
|
324 m_activeNetwReplyList.append(reply); |
|
325 |
|
326 return reply; |
|
327 } |
|
328 else |
|
329 { |
|
330 // Error :: SAME ORIGIN POLICY violation!!! |
|
331 aSOPCompliant = false; |
|
332 return NULL; |
|
333 } |
|
334 } |
|
335 |
|
336 |
|
337 /** |
|
338 * Method that does a http DELETE request. Returns the unique QNetworkReply |
|
339 * instance for this transaction to the plugin manager to trace the |
|
340 * proper response. |
|
341 * @param aRequest The request formed by the plugin |
|
342 * @param aUrlList The list of accessible Urls for this plugin |
|
343 * @param aSOPCompliant [out] Output parameter indicating Same Origin |
|
344 * Policy Compliance. Contains true if the request complies to the policy, |
|
345 * else false. If it is false, the network request will not performed |
|
346 * @return The unique QNetworkReply instance for this transaction |
|
347 */ |
|
348 QNetworkReply* SmfTransportManagerUtil::deleteResource ( |
|
349 QNetworkRequest &aRequest, |
|
350 const QList<QUrl> &aUrlList, |
|
351 bool &aSOPCompliant ) |
|
352 { |
|
353 bool found = false; |
|
354 QString hostName = aRequest.url().host(); |
|
355 |
|
356 // Same Origin Policy checking |
|
357 // Check if the host name of the url in the request created by the |
|
358 // plugin is among the authorised url host name list |
|
359 foreach(QUrl url, aUrlList) |
|
360 { |
|
361 if(0 == hostName.compare(url.host())) |
|
362 { |
|
363 found = true; |
|
364 break; |
|
365 } |
|
366 } |
|
367 |
|
368 if(found) |
|
369 { |
|
370 aSOPCompliant = true; |
|
371 // Set the cache control |
|
372 aRequest.setRawHeader("Cache-Control", kSmfCacheControl); |
|
373 |
|
374 // Put the same user agent for all requests sent by Smf |
|
375 aRequest.setRawHeader("User-Agent", kSmfUserAgent); |
|
376 |
|
377 QNetworkReply* reply = m_networkAccessManager.deleteResource(aRequest); |
|
378 |
|
379 connect(&m_networkAccessManager, SIGNAL(finished(QNetworkReply *)), |
|
380 this, SLOT(networkReplyFinished(QNetworkReply *))); |
|
381 |
|
382 connect(&m_networkAccessManager, SIGNAL(error(QNetworkReply::NetworkError)), |
|
383 this, SLOT(networkReplyError(QNetworkReply::NetworkError))); |
|
384 |
|
385 m_activeNetwReplyList.append(reply); |
|
386 |
|
387 return reply; |
|
388 } |
|
389 else |
|
390 { |
|
391 // Error :: SAME ORIGIN POLICY violation!!! |
|
392 aSOPCompliant = false; |
|
393 return NULL; |
|
394 } |
|
395 } |
|
396 |
|
397 |
|
398 /** |
|
399 * Method that cancels the service request by cancelling the current |
|
400 * http transaction. |
|
401 * @param aCancelReply The QNetworkReply instance whose transaction |
|
402 * has to be cancelled |
|
403 * @return Returns true for success, else false |
|
404 */ |
|
405 bool SmfTransportManagerUtil::cancelRequest ( |
|
406 QNetworkReply *aCancelReply ) |
|
407 { |
|
408 // Checks if this transaction is running |
|
409 if( aCancelReply->isRunning() ) |
|
410 { |
|
411 // Aborts the running transaction |
|
412 aCancelReply->abort(); |
|
413 } |
|
414 // Close the connection |
|
415 aCancelReply->close(); |
|
416 |
|
417 int index = m_activeNetwReplyList.indexOf(aCancelReply); |
|
418 if( index >= 0 ) |
|
419 m_activeNetwReplyList.removeAt(index); |
|
420 |
|
421 return true; |
|
422 } |
|
423 |
|
424 |
|
425 |
|
426 /* |
|
427 * Method that is called whenever a new network configuration is added to the system. |
|
428 * @param aResult SmfTransportResult |
|
429 */ |
|
430 void SmfTransportManagerUtil::configurationAdded ( const SmfTransportResult &aResult ) |
|
431 { |
|
432 // Inform PM and plugins that a new IAP ia added, and hence resend the request |
|
433 SmfPluginManager::getInstance()->responseAvailable ( aResult, NULL, NULL ); |
|
434 } |
|
435 |
|
436 /* |
|
437 * Method that is called when the state of the network configuration changes. |
|
438 * @param aResult SmfTransportResult |
|
439 */ |
|
440 void SmfTransportManagerUtil::configurationChanged ( const SmfTransportResult &aResult ) |
|
441 { |
|
442 // Inform PM and plugins that the IAP is changed, and hence resend the request |
|
443 SmfPluginManager::getInstance()->responseAvailable ( aResult, NULL, NULL ); |
|
444 } |
|
445 |
|
446 /* |
|
447 * Method that is called when a configuration is about to be removed from the system. |
|
448 * The removed configuration is invalid but retains name and identifier. |
|
449 * @param aResult SmfTransportResult |
|
450 */ |
|
451 void SmfTransportManagerUtil::configurationRemoved ( const SmfTransportResult &aResult ) |
|
452 { |
|
453 // Inform PM and plugins that the IAP is to be deleted, and |
|
454 // hence resend the request |
|
455 SmfPluginManager::getInstance()->responseAvailable ( aResult, NULL, NULL ); |
|
456 |
|
457 } |
|
458 |
|
459 |
|
460 /** |
|
461 * Method to indicate the http transaction has finished. |
|
462 * @param aNetworkReply The QNetworkReply instance for which the http |
|
463 * transaction was made |
|
464 */ |
|
465 void SmfTransportManagerUtil::networkReplyFinished ( QNetworkReply *aNetworkReply ) |
|
466 { |
|
467 // remove the QNetworkReply instance from the list of outstanding transactions |
|
468 int index = m_activeNetwReplyList.indexOf(aNetworkReply); |
|
469 if( index >= 0 ) |
|
470 m_activeNetwReplyList.removeAt(index); |
|
471 |
|
472 // indicate the result of transaction to the plugin manager |
|
473 SmfTransportResult trResult; |
|
474 convertErrorType(aNetworkReply->error(), trResult); |
|
475 |
|
476 // Store the data received |
|
477 bool converted = false; |
|
478 quint64 data = m_settings->value("Received Data").toULongLong(&converted); |
|
479 if(converted) |
|
480 { |
|
481 data += aNetworkReply->readBufferSize(); |
|
482 m_settings->setValue("Received Data", data); |
|
483 } |
|
484 |
|
485 int error = 0; |
|
486 QByteArray *arr = NULL; |
|
487 |
|
488 // Read the response from the device |
|
489 QByteArray response = aNetworkReply->readAll(); |
|
490 |
|
491 // Check if the http response header has the raw header "Content-Encoding:gzip" |
|
492 // If so, inflate the gzip deflated data |
|
493 QByteArray headerKey("Content-Encoding"); |
|
494 if(aNetworkReply->hasRawHeader(headerKey)) |
|
495 { |
|
496 SmfPluginManager::getInstance()->server()->writeLog("Response is gzip encoded!!!"); |
|
497 if( "gzip" == QString(aNetworkReply->rawHeader(headerKey))) |
|
498 arr = inflateResponse(response, error); |
|
499 else |
|
500 SmfPluginManager::getInstance()->server()->writeLog("Unsupported encoding format!!! - error"); |
|
501 } |
|
502 else |
|
503 SmfPluginManager::getInstance()->server()->writeLog("Response is not gzip encoded"); |
|
504 |
|
505 |
|
506 SmfPluginManager::getInstance()->responseAvailable ( trResult, aNetworkReply, arr ); |
|
507 } |
|
508 |
|
509 |
|
510 /** |
|
511 * Method to deflate a gzipped network response. Once this method is called, |
|
512 * QNetworkReply internal buffer for holding network response is emptied. |
|
513 * @param aResponse The QByteArray instance holding the gzip encoded data |
|
514 * @param aError Argument indicating error |
|
515 * @return a QByteArray* containing the deflated data. If deflating fails, |
|
516 * the encoded data itself without deflation is returned. |
|
517 */ |
|
518 QByteArray* SmfTransportManagerUtil::inflateResponse ( QByteArray &aResponse, int& aError ) |
|
519 { |
|
520 Q_UNUSED(aError) |
|
521 // Read the response from the device |
|
522 SmfPluginManager::getInstance()->server()->writeLog("Encoded response content = "+QString(aResponse.toHex())); |
|
523 SmfPluginManager::getInstance()->server()->writeLog("Encoded response content size = "+QString::number(aResponse.size(), 10)); |
|
524 |
|
525 // Get the uncompressed size of the response (last 4 bytes of the compressed data as per GZIP format spec) |
|
526 QByteArray sizeStr; |
|
527 for(int count = 1 ; count <= 4 ; count++) |
|
528 sizeStr.append(aResponse[aResponse.size()-count]); |
|
529 SmfPluginManager::getInstance()->server()->writeLog("Size string as a string = "+QString(sizeStr.toHex())); |
|
530 bool ok = false; |
|
531 int uncomSize = sizeStr.toHex().toInt(&ok, 16); |
|
532 SmfPluginManager::getInstance()->server()->writeLog("Size of uncompressed data = "+QString::number(uncomSize, 10)); |
|
533 |
|
534 // Initialize the data required for zlib method call |
|
535 z_stream stream; |
|
536 unsigned char *out = new unsigned char[uncomSize]; |
|
537 if(out) |
|
538 SmfPluginManager::getInstance()->server()->writeLog("Memory allocated for output buffer"); |
|
539 else |
|
540 { |
|
541 //Error |
|
542 SmfPluginManager::getInstance()->server()->writeLog("Memory not allocated for output buffer!!!"); |
|
543 return NULL; |
|
544 } |
|
545 stream.zalloc = Z_NULL; |
|
546 stream.zfree = Z_NULL; |
|
547 stream.opaque = Z_NULL; |
|
548 stream.avail_in = 0; |
|
549 stream.next_in = Z_NULL; |
|
550 |
|
551 int ret = inflateInit2(&stream, 16+MAX_WBITS); |
|
552 SmfPluginManager::getInstance()->server()->writeLog("return value of inflateInit2() = "+QString::number(ret, 10)); |
|
553 if(Z_OK != ret) |
|
554 { |
|
555 SmfPluginManager::getInstance()->server()->writeLog("Error in inflateInit2, returning..."); |
|
556 delete[] out; |
|
557 return NULL; |
|
558 } |
|
559 |
|
560 // Initialize the data required for inflate() method call |
|
561 stream.avail_in = aResponse.size(); |
|
562 stream.next_in = (unsigned char *)aResponse.data(); |
|
563 stream.avail_out = uncomSize; |
|
564 stream.next_out = out; |
|
565 |
|
566 ret = inflate(&stream, Z_NO_FLUSH); |
|
567 SmfPluginManager::getInstance()->server()->writeLog("return value of inflate() = "+QString::number(ret, 10)); |
|
568 |
|
569 switch (ret) |
|
570 { |
|
571 // fall through |
|
572 case Z_NEED_DICT: |
|
573 case Z_DATA_ERROR: |
|
574 case Z_MEM_ERROR: |
|
575 { |
|
576 (void)inflateEnd(&stream); |
|
577 delete[] out; |
|
578 return NULL; |
|
579 } |
|
580 } |
|
581 |
|
582 SmfPluginManager::getInstance()->server()->writeLog("total bytes read so far = "+QString::number(stream.total_in, 10)); |
|
583 SmfPluginManager::getInstance()->server()->writeLog("total bytes output so far = "+QString::number(stream.total_out, 10)); |
|
584 |
|
585 // Write the inflated data to a QByteArray |
|
586 QByteArray *uncompressedData = new QByteArray((char *)out); |
|
587 delete[] out; |
|
588 |
|
589 // If there is some unwanted data at the end of uncompressed data, chop them |
|
590 int chopLength = uncompressedData->size() - uncomSize; |
|
591 SmfPluginManager::getInstance()->server()->writeLog("uncompressedData before chopping = "+QString(uncompressedData->toHex())); |
|
592 SmfPluginManager::getInstance()->server()->writeLog("old size of uncompressed data = "+QString::number(uncompressedData->size(), 10)); |
|
593 uncompressedData->chop(chopLength); |
|
594 SmfPluginManager::getInstance()->server()->writeLog("new size of uncompressed data = "+QString::number(uncompressedData->size(), 10)); |
|
595 SmfPluginManager::getInstance()->server()->writeLog("uncompressedData after chopping = "+QString(uncompressedData->toHex())); |
|
596 |
|
597 // Write the uncompressed data to a file |
|
598 QFile file1("c:\\data\\uncompressedflickrresponse.txt"); |
|
599 if (!file1.open(QIODevice::WriteOnly)) |
|
600 SmfPluginManager::getInstance()->server()->writeLog("File to write the uncompressed response could not be opened"); |
|
601 file1.write(uncompressedData->data()); |
|
602 file1.close(); |
|
603 SmfPluginManager::getInstance()->server()->writeLog("uncompressed data written to c:\\data\\uncompressedflickrresponse.txt"); |
|
604 |
|
605 return uncompressedData; |
|
606 } |
|
607 |
|
608 /** |
|
609 * Method called when the QNetworkReply detects an error in processing. |
|
610 * @param aError The QNetworkReply error code |
|
611 */ |
|
612 void SmfTransportManagerUtil::networkReplyError ( QNetworkReply::NetworkError aError ) |
|
613 { |
|
614 // indicate the error to the plugin manager |
|
615 SmfTransportResult trResult; |
|
616 convertErrorType(aError, trResult); |
|
617 |
|
618 SmfPluginManager::getInstance()->responseAvailable ( trResult, NULL, NULL ); |
|
619 } |
|
620 |
|
621 |
|
622 /** |
|
623 * Method to convert QNetworkReply Error to the type SmfTransportResult |
|
624 * QNetworkRequest received before executing the web query. |
|
625 * @param aError The QNetworkReply Error |
|
626 * @param aResult [out] The SmfTransportResult error |
|
627 */ |
|
628 void SmfTransportManagerUtil::convertErrorType( const QNetworkReply::NetworkError &aError, |
|
629 SmfTransportResult &aResult ) |
|
630 { |
|
631 switch(aError) |
|
632 { |
|
633 case QNetworkReply::NoError: |
|
634 aResult = SmfTransportOpNoError; |
|
635 break; |
|
636 |
|
637 case QNetworkReply::ConnectionRefusedError: |
|
638 aResult = SmfTransportOpConnectionRefusedError; |
|
639 break; |
|
640 |
|
641 case QNetworkReply::RemoteHostClosedError: |
|
642 aResult = SmfTransportOpRemoteHostClosedError; |
|
643 break; |
|
644 |
|
645 case QNetworkReply::HostNotFoundError: |
|
646 aResult = SmfTransportOpHostNotFoundError; |
|
647 break; |
|
648 |
|
649 case QNetworkReply::TimeoutError: |
|
650 aResult = SmfTransportOpTimeoutError; |
|
651 break; |
|
652 |
|
653 case QNetworkReply::OperationCanceledError: |
|
654 aResult = SmfTransportOpOperationCanceledError; |
|
655 break; |
|
656 |
|
657 case QNetworkReply::SslHandshakeFailedError: |
|
658 aResult = SmfTransportOpSslHandshakeFailedError; |
|
659 break; |
|
660 |
|
661 case QNetworkReply::ProxyConnectionRefusedError: |
|
662 aResult = SmfTransportOpProxyConnectionRefusedError; |
|
663 break; |
|
664 |
|
665 case QNetworkReply::ProxyConnectionClosedError: |
|
666 aResult = SmfTransportOpProxyConnectionClosedError; |
|
667 break; |
|
668 |
|
669 case QNetworkReply::ProxyNotFoundError: |
|
670 aResult = SmfTransportOpProxyNotFoundError; |
|
671 break; |
|
672 |
|
673 case QNetworkReply::ProxyTimeoutError: |
|
674 aResult = SmfTransportOpProxyTimeoutError; |
|
675 break; |
|
676 |
|
677 case QNetworkReply::ProxyAuthenticationRequiredError: |
|
678 aResult = SmfTransportOpProxyAuthenticationRequiredError; |
|
679 break; |
|
680 |
|
681 case QNetworkReply::ContentAccessDenied: |
|
682 aResult = SmfTransportOpContentAccessDenied; |
|
683 break; |
|
684 |
|
685 case QNetworkReply::ContentOperationNotPermittedError: |
|
686 aResult = SmfTransportOpContentOperationNotPermittedError; |
|
687 break; |
|
688 |
|
689 case QNetworkReply::ContentNotFoundError: |
|
690 aResult = SmfTransportOpContentNotFoundError; |
|
691 break; |
|
692 |
|
693 case QNetworkReply::AuthenticationRequiredError: |
|
694 aResult = SmfTransportOpAuthenticationRequiredError; |
|
695 break; |
|
696 |
|
697 case QNetworkReply::ContentReSendError: |
|
698 aResult = SmfTransportOpContentReSendError; |
|
699 break; |
|
700 |
|
701 case QNetworkReply::ProtocolUnknownError: |
|
702 aResult = SmfTransportOpProtocolUnknownError; |
|
703 break; |
|
704 |
|
705 case QNetworkReply::ProtocolInvalidOperationError: |
|
706 aResult = SmfTransportOpProtocolInvalidOperationError; |
|
707 break; |
|
708 |
|
709 case QNetworkReply::UnknownNetworkError: |
|
710 aResult = SmfTransportOpUnknownNetworkError; |
|
711 break; |
|
712 |
|
713 case QNetworkReply::UnknownProxyError: |
|
714 aResult = SmfTransportOpUnknownProxyError; |
|
715 break; |
|
716 |
|
717 case QNetworkReply::UnknownContentError: |
|
718 aResult = SmfTransportOpUnknownContentError; |
|
719 break; |
|
720 |
|
721 case QNetworkReply::ProtocolFailure: |
|
722 aResult = SmfTransportOpProtocolFailure; |
|
723 break; |
|
724 |
|
725 default: |
|
726 ; |
|
727 } |
|
728 } |
|
729 |