00001
00002
00003
00004
00005
00006 #include "fsHttpFile.h"
00007 #include <stdio.h>
00008 #include "common.h"
00009 #include <limits.h>
00010 #include "fsInternetSession.h"
00011 #include "strparsing.h"
00012 #include "fsURL.h"
00013
00014 fsHttpFile::fsHttpFile()
00015 {
00016 m_pszReferer = NULL;
00017 m_pszCookies = NULL;
00018 m_pszPostData = NULL;
00019 m_pszHttpVersion = new char [100];
00020 m_dwFlags = INTERNET_FLAG_KEEP_CONNECTION;
00021 UseHttp11 (FALSE);
00022 m_bHeadersOnly = FALSE;
00023 m_pszAdditionalHeaders = NULL;
00024 m_uLeftToUpload = 0;
00025 m_bUseMultipart = TRUE;
00026 m_bEnableAutoRedirect = FALSE;
00027 }
00028
00029 fsHttpFile::~fsHttpFile()
00030 {
00031 if (m_pszReferer)
00032 delete [] m_pszReferer;
00033
00034 if (m_pszCookies)
00035 delete [] m_pszCookies;
00036
00037 if (m_pszPostData)
00038 delete [] m_pszPostData;
00039
00040 delete [] m_pszHttpVersion;
00041 }
00042
00043 fsInternetResult fsHttpFile::Open(LPCSTR pszFilePath, UINT64 uStartPos)
00044 {
00045 return OpenEx (pszFilePath, uStartPos, _UI64_MAX);
00046 }
00047
00048 fsInternetResult fsHttpFile::Read(LPBYTE pBuffer, DWORD dwToRead, DWORD *pdwRead)
00049 {
00050 if (m_hFile == NULL)
00051 {
00052 *pdwRead = 0;
00053 return IR_NOTINITIALIZED;
00054 }
00055
00056 if (!InternetReadFile (m_hFile, pBuffer, dwToRead, pdwRead))
00057 return fsWinInetErrorToIR ();
00058
00059 return IR_SUCCESS;
00060 }
00061
00062 void fsHttpFile::UseHttp11(BOOL bUse)
00063 {
00064 if (bUse)
00065 strcpy (m_pszHttpVersion, "HTTP/1.1");
00066 else
00067 strcpy (m_pszHttpVersion, "HTTP/1.0");
00068 }
00069
00070 void fsHttpFile::SetReferer(LPCSTR pszReferer)
00071 {
00072 SAFE_DELETE_ARRAY (m_pszReferer);
00073
00074 if (pszReferer)
00075 {
00076 fsnew (m_pszReferer, CHAR, strlen (pszReferer) + 1);
00077 strcpy (m_pszReferer, pszReferer);
00078 }
00079 }
00080
00081 void fsHttpFile::UseSecure(BOOL bUse)
00082 {
00083 if (bUse)
00084 m_dwFlags |= INTERNET_FLAG_SECURE;
00085 else
00086 m_dwFlags &= ~INTERNET_FLAG_SECURE;
00087 }
00088
00089 void fsHttpFile::UseCookie(BOOL bUse)
00090 {
00091 if (bUse)
00092 m_dwFlags &= ~ INTERNET_FLAG_NO_COOKIES;
00093 else
00094 m_dwFlags |= INTERNET_FLAG_NO_COOKIES;
00095 }
00096
00097 fsInternetResult fsHttpFile::SetupProxy()
00098 {
00099 if (m_hFile == NULL)
00100 return IR_NOTINITIALIZED;
00101
00102 return m_pServer->GetSession ()->ApplyProxyAuth (m_hFile);
00103 }
00104
00105 void fsHttpFile::RetreiveHeadersOnly(BOOL b)
00106 {
00107 m_bHeadersOnly = b;
00108 }
00109
00110 fsInternetResult fsHttpFile::ProcessRangesResponse()
00111 {
00112 CHAR sz [10000];
00113 DWORD dw = sizeof (sz);
00114
00115
00116
00117 BOOL bAcceptRanges = FALSE;
00118 if (HttpQueryInfo (m_hFile, HTTP_QUERY_ACCEPT_RANGES, sz, &dw, NULL))
00119 {
00120 if (stricmp (sz, "bytes") == 0)
00121 bAcceptRanges = TRUE;
00122 }
00123
00124 m_enRST = RST_NONE;
00125
00126 dw = sizeof (sz);
00127
00128
00129
00130 if (!HttpQueryInfo (m_hFile, HTTP_QUERY_CONTENT_RANGE, sz, &dw, NULL))
00131 return bAcceptRanges ? IR_DOUBTFUL_RANGESRESPONSE : IR_RANGESNOTAVAIL;
00132
00133
00134 if (strncmp (sz, "bytes", 5))
00135 return bAcceptRanges ? IR_DOUBTFUL_RANGESRESPONSE : IR_RANGESNOTAVAIL;
00136
00137 int pos = 0;
00138 while (sz [pos++] != ' ');
00139
00140 if (isdigit (sz [pos]) == false)
00141 return IR_RANGESNOTAVAIL;
00142
00143 UINT64 first = (UINT64) _atoi64 (sz + pos);
00144
00145 while (sz [pos] >= '0' && sz [pos] <= '9')
00146 pos++;
00147 pos++;
00148
00149 UINT64 last = (UINT64) _atoi64 (sz + pos);
00150
00151 if (last < first)
00152 return IR_RANGESNOTAVAIL;
00153
00154 while (sz [pos] >= '0' && sz [pos] <= '9')
00155 pos++;
00156 pos++;
00157
00158 m_uFileSize = (UINT64) _atoi64 (sz + pos);
00159
00160 if (m_uFileSize < last)
00161 return IR_RANGESNOTAVAIL;
00162
00163 m_enRST = RST_PRESENT;
00164
00165 return IR_SUCCESS;
00166 }
00167
00168 void fsHttpFile::RetreiveSuggFileName()
00169 {
00170 m_strSuggFileName = "";
00171
00172 char sz [MAX_PATH];
00173 char szFile [MAX_PATH];
00174 DWORD dwFL = MAX_PATH;
00175
00176 if (FALSE == HttpQueryInfo (m_hFile, HTTP_QUERY_CONTENT_DISPOSITION, sz, &dwFL, NULL))
00177 return;
00178
00179
00180 LPCSTR psz = fsStrStrNoCase (sz, "filename");
00181 if (psz == NULL)
00182 return;
00183
00184 psz += 8;
00185 while (*psz == ' ')
00186 psz++;
00187 bool bCharset = false;
00188 if (*psz == '*')
00189 {
00190 bCharset = true;
00191 psz++;
00192 }
00193
00194 if (*psz++ != '=')
00195 return;
00196 while (*psz == ' ') psz++;
00197
00198 BOOL bInvComms = FALSE;
00199 if (*psz == '"' || *psz == '\'')
00200 {
00201 bInvComms = TRUE;
00202 psz++;
00203 }
00204
00205 LPSTR pszFile = szFile;
00206
00207 while (*psz != ';' && *psz != 0)
00208 *pszFile++ = *psz++;
00209
00210 if (bInvComms)
00211 *(pszFile-1) = 0;
00212 else
00213 *pszFile = 0;
00214
00215 if (bCharset)
00216 {
00217 LPCSTR psz = strstr (szFile, "''");
00218 if (psz != NULL)
00219 {
00220 if (strnicmp (szFile, "utf-8", 5) == 0)
00221 {
00222 wchar_t wsz [MAX_PATH];
00223 MultiByteToWideChar (CP_UTF8, 0, psz+2, -1, wsz, MAX_PATH);
00224 WideCharToMultiByte (CP_ACP, 0, wsz, -1, szFile, MAX_PATH, "_", NULL);
00225 }
00226 else
00227 {
00228 lstrcpy (szFile, psz+2);
00229 }
00230 }
00231 }
00232
00233 m_strSuggFileName = szFile;
00234 }
00235
00236 fsInternetResult fsHttpFile::QuerySize(LPCSTR pszFilePath)
00237 {
00238
00239 fsInternetResult ir;
00240
00241
00242
00243
00244 ir = Open (pszFilePath, 0);
00245
00246 CloseHandle ();
00247 return ir;
00248 }
00249
00250 fsInternetResult fsHttpFile::Open_imp(LPCSTR pszFilePath, UINT64 uStartPos, int cTryings)
00251 {
00252 if (!m_pServer)
00253 return IR_NOTINITIALIZED;
00254
00255 HINTERNET hServer = m_pServer->GetHandle ();
00256
00257 if (!hServer)
00258 return IR_NOTINITIALIZED;
00259
00260 CloseHandle ();
00261
00262 if (lstrlen (pszFilePath) > 9000)
00263 return IR_BADURL;
00264
00265 if (cTryings > 1)
00266 return IR_WININETUNKERROR;
00267
00268 DWORD dwFlags = m_dwFlags;
00269 if (m_pszCookies)
00270 dwFlags |= INTERNET_FLAG_NO_COOKIES;
00271 if (m_bEnableAutoRedirect == FALSE)
00272 dwFlags |= INTERNET_FLAG_NO_AUTO_REDIRECT;
00273
00274 LPTSTR ppszAcceptedTypes [2] = { "*/*", NULL };
00275
00276
00277
00278
00279
00280
00281 LPCSTR pszVerb = "GET";
00282 if (m_pszPostData)
00283 pszVerb = "POST";
00284 else if (m_bHeadersOnly)
00285 pszVerb = "HEAD";
00286
00287
00288 m_hFile = HttpOpenRequest (hServer, pszVerb, pszFilePath, m_pszHttpVersion,
00289 m_pszReferer, (LPCSTR*) ppszAcceptedTypes,
00290 dwFlags | INTERNET_FLAG_RELOAD | INTERNET_FLAG_PRAGMA_NOCACHE |
00291 INTERNET_FLAG_NO_CACHE_WRITE, NULL);
00292
00293 if (m_hFile == NULL)
00294 return fsWinInetErrorToIR ();
00295
00296 fsInternetResult ir = SetupProxy ();
00297 if (ir != IR_SUCCESS)
00298 {
00299 CloseHandle ();
00300 return ir;
00301 }
00302
00303
00304 CHAR szHdr [10000] = "";
00305
00306 if (uStartPos)
00307 sprintf (szHdr, "Range: bytes=%I64u-\r\n", uStartPos);
00308
00309 if (m_pszCookies)
00310 sprintf (szHdr + lstrlen (szHdr), "Cookie: %s\r\n", m_pszCookies);
00311
00312 if (m_pszAdditionalHeaders)
00313 lstrcat (szHdr, m_pszAdditionalHeaders);
00314
00315 if (cTryings == 0)
00316 {
00317
00318 char szReq [10000];
00319 sprintf (szReq, "%s %s %s\r\nReferer: %s", pszVerb,
00320 pszFilePath, m_pszHttpVersion,
00321 m_pszReferer ? m_pszReferer : "-");
00322
00323 if (*szHdr)
00324 {
00325 strcat (szReq, "\r\n");
00326 strcat (szReq, szHdr);
00327 szReq [strlen (szReq) - 2] = 0;
00328 }
00329
00330 if ((dwFlags & INTERNET_FLAG_NO_COOKIES) == 0)
00331 {
00332 char szUrl [10000]; DWORD dw = sizeof (szUrl);
00333 fsURL url;
00334 url.Create (m_dwFlags & INTERNET_FLAG_SECURE ? INTERNET_SCHEME_HTTPS : INTERNET_SCHEME_HTTP,
00335 m_pServer->GetServerName (), m_pServer->GetServerPort (),
00336 NULL, NULL, pszFilePath, szUrl, &dw);
00337
00338 char szCookie [10000]; dw = sizeof (szCookie);
00339 *szCookie = 0;
00340
00341 InternetGetCookie (szUrl, NULL, szCookie, &dw);
00342
00343 if (*szCookie)
00344 {
00345 strcat (szReq, "\r\n");
00346 strcat (szReq, "Cookie: ");
00347 strcat (szReq, szCookie);
00348 }
00349 }
00350
00351 strcat (szReq, "\r\nHost: ");
00352 strcat (szReq, m_pServer->GetServerName ());
00353
00354 if (m_pszPostData)
00355 {
00356 lstrcat (szReq, "\r\n");
00357 lstrcat (szReq, m_pszPostData);
00358 }
00359
00360 Dialog (IFDD_TOSERVER, szReq);
00361 }
00362
00363
00364 IgnoreSecurityProblems ();
00365
00366
00367 if (!HttpSendRequest (m_hFile, *szHdr ? szHdr : NULL, (UINT)-1,
00368 m_pszPostData, m_pszPostData ? lstrlen (m_pszPostData) : 0))
00369 {
00370 ir = fsWinInetErrorToIR ();
00371
00372 DialogHttpResponse (m_hFile);
00373
00374 CloseHandle ();
00375 return ir;
00376 }
00377
00378 char szResp [10000];
00379 DWORD dwRespLen = sizeof (szResp), dwIndex = 0;
00380
00381
00382 if (HttpQueryInfo (m_hFile, HTTP_QUERY_RAW_HEADERS_CRLF, szResp, &dwRespLen, &dwIndex))
00383 {
00384 int cLines = 0;
00385
00386
00387
00388 LPCSTR pszLine = szResp;
00389 while (pszLine)
00390 {
00391 pszLine = strchr (pszLine, '\n');
00392 if (pszLine)
00393 {
00394 while (*pszLine == '\r' || *pszLine == '\n')
00395 pszLine++;
00396 cLines++;
00397 }
00398 }
00399
00400 if (cLines == 0 || cLines == 1)
00401 {
00402
00403
00404 return Open_imp (pszFilePath, uStartPos, ++cTryings);
00405 }
00406 }
00407
00408 DialogHttpResponse (m_hFile);
00409
00410 DWORD dwStatusCode;
00411 DWORD dwSize = sizeof (DWORD);
00412 if (!HttpQueryInfo(m_hFile, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER,
00413 &dwStatusCode, &dwSize, NULL))
00414 return fsWinInetErrorToIR ();
00415
00416 if (dwStatusCode < 200 || dwStatusCode >= 300)
00417 {
00418 ir = fsHttpStatusCodeToIR (dwStatusCode);
00419
00420 if (ir == IR_NEEDREDIRECT)
00421 {
00422 DWORD dwNeedLen = 0;
00423
00424 HttpQueryInfo (m_hFile, HTTP_QUERY_LOCATION, NULL, &dwNeedLen,
00425 NULL);
00426
00427 if (::GetLastError () == ERROR_INSUFFICIENT_BUFFER)
00428 {
00429 SAFE_DELETE_ARRAY (m_pszLastError);
00430 try {
00431 m_pszLastError = new char [++dwNeedLen];
00432 }catch (...) {return IR_OUTOFMEMORY;}
00433 if (m_pszLastError == NULL)
00434 return IR_OUTOFMEMORY;
00435 if (!HttpQueryInfo (m_hFile, HTTP_QUERY_LOCATION, m_pszLastError, &dwNeedLen,
00436 NULL))
00437 return IR_SERVERUNKERROR;
00438 }
00439 else
00440 return IR_SERVERUNKERROR;
00441
00442 }
00443
00444 return ir;
00445 }
00446
00447
00448 char szContLen [1000];
00449 DWORD dwLen = sizeof (szContLen);
00450 if (HttpQueryInfo (m_hFile, HTTP_QUERY_CONTENT_LENGTH, szContLen, &dwLen, NULL)) {
00451 __int64 iSize = _atoi64 (szContLen);
00452 if (iSize < 0)
00453 return IR_SERVERUNKERROR;
00454 m_uFileSize = (UINT64) iSize;
00455 }
00456 else
00457 m_uFileSize = _UI64_MAX;
00458
00459 ir = IR_SUCCESS;
00460 if (uStartPos)
00461 {
00462
00463 ir = ProcessRangesResponse ();
00464 if (ir == IR_RANGESNOTAVAIL)
00465 return ir;
00466 }
00467 else
00468 {
00469 CHAR sz [10000];
00470 DWORD dw = sizeof (sz);
00471
00472
00473 if (HttpQueryInfo (m_hFile, HTTP_QUERY_ACCEPT_RANGES, sz, &dw, NULL))
00474 {
00475 if (stricmp (sz, "bytes") == 0)
00476 m_enRST = RST_PRESENT;
00477 else
00478 m_enRST = RST_NONE;
00479 }
00480 else
00481 m_enRST = RST_UNKNOWN;
00482 }
00483
00484 m_bContentTypeValid = FALSE;
00485 m_bDateValid = FALSE;
00486
00487 CHAR szContentType [10000];
00488 DWORD dwCL = sizeof (szContentType);
00489 if (HttpQueryInfo (m_hFile, HTTP_QUERY_CONTENT_TYPE, szContentType, &dwCL, NULL))
00490 {
00491 m_strContentType = szContentType;
00492 m_bContentTypeValid = TRUE;
00493 }
00494
00495 SYSTEMTIME time;
00496 DWORD dwTL = sizeof (time);
00497 if (HttpQueryInfo (m_hFile, HTTP_QUERY_LAST_MODIFIED | HTTP_QUERY_FLAG_SYSTEMTIME,
00498 &time, &dwTL, NULL))
00499 {
00500 SystemTimeToFileTime (&time, &m_date);
00501 m_bDateValid = TRUE;
00502 }
00503
00504 RetreiveSuggFileName ();
00505
00506 return ir;
00507 }
00508
00509 BOOL fsHttpFile::Is_Secure()
00510 {
00511 return m_dwFlags & INTERNET_FLAG_SECURE;
00512 }
00513
00514 void fsHttpFile::IgnoreSecurityProblems()
00515 {
00516 DWORD dwFlags;
00517 DWORD dwBuffLen = sizeof(dwFlags);
00518
00519 InternetQueryOption (m_hFile, INTERNET_OPTION_SECURITY_FLAGS,
00520 (LPVOID)&dwFlags, &dwBuffLen);
00521
00522 dwFlags |= SECURITY_FLAG_IGNORE_UNKNOWN_CA |
00523 SECURITY_FLAG_IGNORE_WRONG_USAGE |
00524 SECURITY_FLAG_IGNORE_REVOCATION |
00525 SECURITY_FLAG_IGNORE_REDIRECT_TO_HTTPS |
00526 SECURITY_FLAG_IGNORE_REDIRECT_TO_HTTP |
00527 SECURITY_FLAG_IGNORE_CERT_DATE_INVALID |
00528 SECURITY_FLAG_IGNORE_CERT_CN_INVALID;
00529
00530 InternetSetOption (m_hFile, INTERNET_OPTION_SECURITY_FLAGS,
00531 &dwFlags, sizeof (dwFlags));
00532 }
00533
00534 BOOL fsHttpFile::get_UseHttp11()
00535 {
00536 return lstrcmpi (m_pszHttpVersion, "HTTP/1.1") == 0;
00537 }
00538
00539 LPCSTR fsHttpFile::get_Referer()
00540 {
00541 return m_pszReferer;
00542 }
00543
00544 BOOL fsHttpFile::get_UseCookie()
00545 {
00546 return (m_dwFlags & INTERNET_FLAG_NO_COOKIES) == 0;
00547 }
00548
00549 void fsHttpFile::SetCookies(LPCSTR pszCookies)
00550 {
00551 SAFE_DELETE_ARRAY (m_pszCookies);
00552
00553 if (pszCookies && *pszCookies)
00554 {
00555 fsnew (m_pszCookies, CHAR, lstrlen (pszCookies) + 1);
00556 lstrcpy (m_pszCookies, pszCookies);
00557 }
00558 }
00559
00560 void fsHttpFile::SetPostData(LPCSTR pszPostData)
00561 {
00562 SAFE_DELETE_ARRAY (m_pszPostData);
00563
00564 if (pszPostData && *pszPostData)
00565 {
00566 fsnew (m_pszPostData, CHAR, lstrlen (pszPostData) + 1);
00567 lstrcpy (m_pszPostData, pszPostData);
00568 }
00569 }
00570
00571 LPCSTR fsHttpFile::GetCookies()
00572 {
00573 return m_pszCookies;
00574 }
00575
00576 LPCSTR fsHttpFile::GetPostData()
00577 {
00578 return m_pszPostData;
00579 }
00580
00581 void fsHttpFile::SetAdditionalHeaders(LPCSTR pszAdditionalHeaders)
00582 {
00583 SAFE_DELETE_ARRAY (m_pszAdditionalHeaders);
00584
00585 if (pszAdditionalHeaders && *pszAdditionalHeaders)
00586 {
00587
00588 int l = lstrlen (pszAdditionalHeaders);
00589 if (l < 2)
00590 return;
00591 if (pszAdditionalHeaders [l - 2] != '\r')
00592 return;
00593 if (pszAdditionalHeaders [l - 1] != '\n')
00594 return;
00595
00596 fsnew (m_pszAdditionalHeaders, CHAR, lstrlen (pszAdditionalHeaders) + 1);
00597 lstrcpy (m_pszAdditionalHeaders, pszAdditionalHeaders);
00598 }
00599 }
00600
00601 fsInternetResult fsHttpFile::OpenEx(LPCSTR pszFilePath, UINT64 uStartPos, UINT64 uUploadPartSize, UINT64 uUploadTotalSize)
00602 {
00603 if (uUploadTotalSize == _UI64_MAX)
00604 return Open_imp (pszFilePath, uStartPos, 0);
00605
00606 if (uStartPos + uUploadPartSize > uUploadTotalSize)
00607 return IR_INVALIDPARAM;
00608
00609 if (!m_pServer)
00610 return IR_NOTINITIALIZED;
00611
00612 HINTERNET hServer = m_pServer->GetHandle ();
00613
00614 if (!hServer)
00615 return IR_NOTINITIALIZED;
00616
00617 CloseHandle ();
00618
00619 if (lstrlen (pszFilePath) > 9000)
00620 return IR_BADURL;
00621
00622 fsString strFilePath = pszFilePath;
00623 fsString strFileName;
00624 if (m_bUseMultipart)
00625 {
00626 LPSTR psz = strrchr (strFilePath, '/');
00627 if (psz)
00628 {
00629 strFileName = psz + 1;
00630 psz [1] = 0;
00631 }
00632 else
00633 strFileName = pszFilePath;
00634 }
00635
00636 LPTSTR ppszAcceptedTypes [2] = { "*/*", NULL };
00637
00638 m_hFile = HttpOpenRequest (hServer, "POST", strFilePath, m_pszHttpVersion,
00639 NULL, (LPCSTR*)ppszAcceptedTypes, INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_KEEP_CONNECTION, 0);
00640
00641 if (m_hFile == NULL)
00642 return fsWinInetErrorToIR ();
00643
00644 fsInternetResult ir = SetupProxy ();
00645 if (ir != IR_SUCCESS)
00646 {
00647 CloseHandle ();
00648 return ir;
00649 }
00650
00651
00652 CHAR szHdr [10000] = "";
00653
00654 if (m_bUseMultipart)
00655 lstrcpy (szHdr, "Content-Type: multipart/form-data; boundary=---------------------------284583012225247");
00656 else
00657 {
00658 lstrcpy (szHdr, "Content-Type: application/x-www-form-urlencoded");
00659 if (m_strCharset.IsEmpty () == FALSE)
00660 {
00661 lstrcat (szHdr, "; charset=");
00662 lstrcat (szHdr, m_strCharset);
00663 }
00664 }
00665
00666 if (uStartPos || uUploadPartSize != uUploadTotalSize)
00667 {
00668 if (*szHdr)
00669 lstrcat (szHdr, "\r\n");
00670 sprintf (szHdr + lstrlen (szHdr), "Range: bytes=%I64u-%I64u/%I64u", uStartPos,
00671 uStartPos + uUploadPartSize - 1, uUploadTotalSize);
00672 }
00673
00674 if (m_pszCookies)
00675 {
00676 if (*szHdr)
00677 lstrcat (szHdr, "\r\n");
00678 sprintf (szHdr + lstrlen (szHdr), "Cookie: %s", m_pszCookies);
00679 }
00680
00681 if (m_pszAdditionalHeaders)
00682 {
00683 if (*szHdr)
00684 lstrcat (szHdr, "\r\n");
00685 lstrcat (szHdr, m_pszAdditionalHeaders);
00686 }
00687
00688
00689 IgnoreSecurityProblems ();
00690
00691 int nSizeAdd = 0;
00692 fsString strMpHdr;
00693
00694 if (m_bUseMultipart)
00695 {
00696 m_strLabel = "-----------------------------284583012225247";
00697
00698 strMpHdr = m_strLabel; strMpHdr += "\r\n";
00699 strMpHdr += "Content-Disposition: form-data; name=\"uploadFormFile\"; filename=\"";
00700 strMpHdr += strFileName; strMpHdr += "\"\r\n";
00701 strMpHdr += "Content-Type: application/octet-stream\r\n\r\n";
00702
00703 nSizeAdd = strMpHdr.GetLength () + m_strLabel.GetLength () + 6;
00704 }
00705
00706 INTERNET_BUFFERS BufferIn = {0};
00707 BufferIn.dwStructSize = sizeof (INTERNET_BUFFERS);
00708 BufferIn.lpcszHeader = szHdr;
00709 BufferIn.dwHeadersLength = BufferIn.dwHeadersTotal = lstrlen (szHdr);
00710 BufferIn.dwBufferTotal = (DWORD) (uUploadPartSize + nSizeAdd);
00711
00712 if (!HttpSendRequestEx (m_hFile, &BufferIn, NULL, HSR_INITIATE, 0))
00713 {
00714 ir = fsWinInetErrorToIR ();
00715 CloseHandle ();
00716 return ir;
00717 }
00718
00719 if (m_bUseMultipart)
00720 {
00721 DWORD dw;
00722 if (FALSE == InternetWriteFile (m_hFile, strMpHdr, strMpHdr.GetLength (), &dw))
00723 {
00724 ir = fsWinInetErrorToIR ();
00725 CloseHandle ();
00726 return ir;
00727 }
00728 }
00729
00730 m_uLeftToUpload = uUploadPartSize;
00731
00732 return IR_SUCCESS;
00733 }
00734
00735 fsInternetResult fsHttpFile::Write(LPBYTE pBuffer, DWORD dwSize, DWORD *pdwWritten)
00736 {
00737 if (m_hFile == NULL)
00738 {
00739 if (pdwWritten)
00740 *pdwWritten = 0;
00741 return IR_NOTINITIALIZED;
00742 }
00743
00744 if (m_uLeftToUpload == 0)
00745 return IR_S_FALSE;
00746
00747 DWORD dwWritten;
00748
00749 BOOL bRet = InternetWriteFile (m_hFile, pBuffer, dwSize, &dwWritten);
00750
00751 if (pdwWritten)
00752 *pdwWritten = dwWritten;
00753
00754 if (!bRet)
00755 return fsWinInetErrorToIR ();
00756
00757 m_uLeftToUpload -= dwWritten;
00758
00759 if (m_uLeftToUpload == 0)
00760 {
00761 if (m_bUseMultipart)
00762 {
00763 fsString str = "\r\n"; str += m_strLabel; str += "--\r\n";
00764 DWORD dw;
00765 if (FALSE == InternetWriteFile (m_hFile, str, str.GetLength (), &dw))
00766 return fsWinInetErrorToIR ();
00767 }
00768
00769 bRet = HttpEndRequest (m_hFile, NULL, 0, NULL);
00770 if (!bRet)
00771 return fsWinInetErrorToIR ();
00772 }
00773
00774 return IR_SUCCESS;
00775 }
00776
00777 void fsHttpFile::set_UseMultipart(BOOL b)
00778 {
00779 m_bUseMultipart = b;
00780 }
00781
00782 fsString fsHttpFile::GetCookiesFromResponse()
00783 {
00784 char sz [10000];
00785 DWORD dw = sizeof (sz) - 1;
00786
00787 if (FALSE == HttpQueryInfo (m_hFile, HTTP_QUERY_SET_COOKIE, sz, &dw, NULL))
00788 return "";
00789
00790 return sz;
00791 }
00792
00793 void fsHttpFile::set_EnableAutoRedirect(BOOL b)
00794 {
00795 m_bEnableAutoRedirect = b;
00796 }
00797
00798 void fsHttpFile::set_Charset(LPCSTR psz)
00799 {
00800 m_strCharset = psz;
00801 }
