libuuu/http.cpp

   1 /*
   2  * Copyright 2019, 2023 NXP.
   3  *
   4  * Redistribution and use in source and binary forms, with or without modification,
   5  * are permitted provided that the following conditions are met:
   6  *
   7  * Redistributions of source code must retain the above copyright notice, this
   8  * list of conditions and the following disclaimer.
   9  *
  10  * Redistributions in binary form must reproduce the above copyright notice, this
  11  * list of conditions and the following disclaimer in the documentation and/or
  12  * other materials provided with the distribution.
  13  *
  14  * Neither the name of the NXP Semiconductor nor the names of its
  15  * contributors may be used to endorse or promote products derived from this
  16  * software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  */
  31
  32
  33 #ifdef _WIN32
  34 //      request += "Connection: Keep-Alive\n";
  35 #include <ws2tcpip.h>
  36 #include <windows.h>
  37 #include <winhttp.h>
  38 #pragma comment(lib, "Winhttp.lib")
  39 #else
  40 #include <sys/types.h>
  41 #include <sys/socket.h>
  42 #include <netdb.h>
  43 #define INVALID_SOCKET -1
  44 #include <unistd.h>
  45 #endif
  46
  47 #include "http.h"
  48 #include "libuuu.h"
  49 #include "liberror.h"
  50 #include "libcomm.h"
  51 #include <string.h>
  52 #include <locale>
  53 #include <codecvt>
  54
  55 uuu_askpasswd g_ask_passwd;
  56 int uuu_set_askpasswd(uuu_askpasswd ask)
  57 {
  58         g_ask_passwd = ask;
  59         return 0;
  60 }
  61
  62 map<string, pair<string, string>> g_passwd_map;
  63
  64 #ifdef UUUSSL
  65 #include <openssl/ssl.h>
  66 #include <openssl/err.h>
  67
  68 static const char* base64_table =
  69         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  70         "abcdefghijklmnopqrstuvwxyz"
  71         "0123456789+/";
  72
  73 static string base64_encode(string str)
  74 {
  75         string ret;
  76         for (size_t i = 0; i < str.length(); i += 3)
  77         {
  78                 ret.push_back(base64_table[(str[i] >> 2) & 0x3f]);
  79                 if (i + 1 < str.length())
  80                 {
  81                         int index;
  82                         index = ((str[i] & 3) << 4)
  83                                 + ((str[i + 1] >> 4) & 0xf);
  84                         ret.push_back(base64_table[index]);
  85                 }
  86                 else
  87                 {
  88                         ret.push_back(base64_table[(str[i] & 0x3) << 4]);
  89                         ret.push_back('=');
  90                         ret.push_back('=');
  91                         return ret;
  92                 }
  93
  94                 if (i + 2 < str.length())
  95                 {
  96                         int index;
  97                         index = (((str[i + 1]) & 0xF) << 2)
  98                                 + (((str[i + 2]) >> 6) & 0x3);
  99                         ret.push_back(base64_table[index]);
 100                         index = str[i + 2] & 0x3f;
 101                         ret.push_back(base64_table[index]);
 102
 103                 }
 104                 else
 105                 {
 106                         ret.push_back(base64_table[((str[i + 1]) & 0xF) << 2]);
 107                         ret.push_back('=');
 108                         return ret;
 109                 }
 110         }
 111         return ret;
 112 }
 113
 114 class CUUUSSL
 115 {
 116 public:
 117         CUUUSSL()
 118         {
 119 #if OPENSSL_VERSION_NUMBER < 0x10100000L
 120                 SSL_library_init();
 121                 SSLeay_add_ssl_algorithms();
 122                 SSL_load_error_strings();
 123 #else
 124                 OPENSSL_init_ssl(0, nullptr);
 125                 SSLeay_add_ssl_algorithms();
 126 #endif
 127         }
 128         ~CUUUSSL()
 129         {
 130         }
 131 };
 132
 133 static CUUUSSL g_uuussl;
 134
 135 #endif
 136 using namespace std;
 137
 138 #ifdef _WIN32
 139 /* Win32 implement*/
 140
 141 DWORD ChooseAuthScheme(DWORD dwSupportedSchemes)
 142 {
 143         if (dwSupportedSchemes & WINHTTP_AUTH_SCHEME_NEGOTIATE)
 144                 return WINHTTP_AUTH_SCHEME_NEGOTIATE;
 145         else if (dwSupportedSchemes & WINHTTP_AUTH_SCHEME_NTLM)
 146                 return WINHTTP_AUTH_SCHEME_NTLM;
 147         else if (dwSupportedSchemes & WINHTTP_AUTH_SCHEME_PASSPORT)
 148                 return WINHTTP_AUTH_SCHEME_PASSPORT;
 149         else if (dwSupportedSchemes & WINHTTP_AUTH_SCHEME_DIGEST)
 150                 return WINHTTP_AUTH_SCHEME_DIGEST;
 151         else if (dwSupportedSchemes & WINHTTP_AUTH_SCHEME_BASIC)
 152                 return WINHTTP_AUTH_SCHEME_BASIC;
 153
 154         return 0;
 155 }
 156
 157 HttpStream::HttpStream()
 158 {
 159         m_buff.empty();
 160         m_hConnect = 0;
 161         m_hSession = 0;
 162         m_hRequest = 0;
 163 }
 164
 165 int HttpStream::HttpGetHeader(std::string host, std::string path, int port, bool ishttps)
 166 {
 167
 168         m_hSession = WinHttpOpen(L"WinHTTP UUU/1.0",
 169                 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 170                 WINHTTP_NO_PROXY_NAME,
 171                 WINHTTP_NO_PROXY_BYPASS, 0);
 172
 173         if (!m_hSession)
 174         {
 175                 set_last_err_string("fail WinHttpOpen");
 176                 return -1;
 177         }
 178
 179         wstring_convert<codecvt_utf8_utf16<wchar_t>> converter;
 180         wstring whost = converter.from_bytes(host);
 181
 182         if (m_hSession)
 183                 m_hConnect = WinHttpConnect(m_hSession, whost.c_str(),
 184                         port, 0);
 185
 186         if (!m_hConnect)
 187         {
 188                 set_last_err_string("Fail Connection");
 189                 return -1;
 190         }
 191
 192         wstring wpath = converter.from_bytes(path);
 193
 194         m_hRequest = WinHttpOpenRequest(m_hConnect, L"GET", wpath.c_str(),
 195                         nullptr, WINHTTP_NO_REFERER,
 196                         WINHTTP_DEFAULT_ACCEPT_TYPES,
 197                         ishttps ?WINHTTP_FLAG_SECURE:0);
 198
 199         BOOL  bResults = FALSE;
 200         if (!m_hRequest)
 201         {
 202                 set_last_err_string("Fail WinHttpOpenRequest");
 203                 return -1;
 204         }
 205
 206         DWORD dwProxyAuthScheme = 0;
 207         int retry = 3;
 208
 209         pair<string, string> up = g_passwd_map[host];
 210
 211         while (1)
 212         {
 213                 DWORD status = 0;
 214                 DWORD dwSize = sizeof(status);
 215
 216                 bResults = WinHttpSendRequest(m_hRequest,
 217                         WINHTTP_NO_ADDITIONAL_HEADERS, 0,
 218                         WINHTTP_NO_REQUEST_DATA, 0,
 219                         0, 0);
 220
 221                 // End the request.
 222                 if (bResults)
 223                         bResults = WinHttpReceiveResponse(m_hRequest, NULL);
 224
 225                 // Resend the request in case of
 226                 // ERROR_WINHTTP_RESEND_REQUEST error.
 227                 if (!bResults && GetLastError() == ERROR_WINHTTP_RESEND_REQUEST)
 228                         continue;
 229
 230                 // Check the status code.
 231                 if (bResults)
 232                         bResults = WinHttpQueryHeaders(m_hRequest,
 233                                 WINHTTP_QUERY_STATUS_CODE |
 234                                 WINHTTP_QUERY_FLAG_NUMBER,
 235                                 NULL,
 236                                 &status,
 237                                 &dwSize,
 238                                 NULL);
 239
 240                 if (bResults)
 241                 {
 242                         DWORD dwSupportedSchemes;
 243                         DWORD dwFirstScheme;
 244                         DWORD dwSelectedScheme;
 245                         DWORD dwTarget;
 246
 247                         switch (status)
 248                         {
 249                         case HTTP_STATUS_OK: //200
 250                                 g_passwd_map[host] = up;
 251                                 return 0;
 252
 253                         case HTTP_STATUS_DENIED: //401
 254                                 // The server requires authentication.
 255                                 if(g_passwd_map[host].first.empty())
 256                                 {
 257                                         char user[MAX_USER_LEN];
 258                                         char passwd[MAX_USER_LEN];
 259                                         if (g_ask_passwd((char*)host.c_str(), user, passwd))
 260                                                 return -1;
 261
 262                                         up.first = user;
 263                                         up.second = passwd;
 264                                 }
 265                                 // Obtain the supported and preferred schemes.
 266                                 bResults = WinHttpQueryAuthSchemes(m_hRequest,
 267                                         &dwSupportedSchemes,
 268                                         &dwFirstScheme,
 269                                         &dwTarget);
 270
 271                                 // Set the credentials before resending the request.
 272                                 if (bResults)
 273                                 {
 274                                         dwSelectedScheme = ChooseAuthScheme(dwSupportedSchemes);
 275
 276                                         std::wstring_convert<std::codecvt_utf8<wchar_t>> convert;
 277
 278                                         if (dwSelectedScheme == 0)
 279                                         {
 280                                                 set_last_err_string("unsupported http auth");
 281                                                 return -1;
 282                                         }
 283                                         else
 284                                                 bResults = WinHttpSetCredentials(m_hRequest,
 285                                                         dwTarget,
 286                                                         dwSelectedScheme,
 287                                                         convert.from_bytes(up.first).c_str(),
 288                                                         convert.from_bytes(up.second).c_str(),
 289                                                         NULL);
 290                                 }
 291
 292                                 retry--;
 293                                 if (!retry)
 294                                         return -1;
 295
 296                                 break;
 297
 298                         case HTTP_STATUS_PROXY_AUTH_REQ:
 299                                 set_last_err_string("unsupported proxy auth");
 300                                 return -1;
 301
 302                         default:
 303                                 g_passwd_map[host] = up;
 304                                 // The status code does not indicate success.
 305                                 string_ex str;
 306                                 str.format("Error. Status code %d returned.\n", status);
 307                                 set_last_err_string(str);
 308                                 return -1;
 309                         }
 310                 }
 311         }
 312
 313         return -1;
 314 }
 315
 316 size_t HttpStream::HttpGetFileSize()
 317 {
 318         DWORD dwSize = 0;
 319         BOOL  bResults = FALSE;
 320         wstring out;
 321
 322         WinHttpQueryHeaders(m_hRequest, WINHTTP_QUERY_CONTENT_LENGTH,
 323                 WINHTTP_HEADER_NAME_BY_INDEX, nullptr,
 324                 &dwSize, WINHTTP_NO_HEADER_INDEX);
 325
 326         // Allocate memory for the buffer.
 327         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 328         {
 329                 out.resize(dwSize / sizeof(WCHAR));
 330
 331                 // Now, use WinHttpQueryHeaders to retrieve the header.
 332                 bResults = WinHttpQueryHeaders(m_hRequest,
 333                         WINHTTP_QUERY_CONTENT_LENGTH,
 334                         WINHTTP_HEADER_NAME_BY_INDEX,
 335                         (LPVOID)out.c_str(), &dwSize,
 336                         WINHTTP_NO_HEADER_INDEX);
 337         }
 338         return _wtoll(out.c_str());
 339 }
 340
 341 int HttpStream::HttpDownload(char *buff, size_t sz)
 342 {
 343         DWORD dwSize = 0;
 344         DWORD dwDownloaded = 0;
 345         while (sz)
 346         {
 347                 if (!WinHttpQueryDataAvailable(m_hRequest, &dwSize))
 348                 {
 349                         set_last_err_string("WinHttpQueryDataAvailable");
 350                         return -1;
 351                 }
 352
 353                 if (dwSize > sz)
 354                         dwSize = sz;
 355
 356                 if (!WinHttpReadData(m_hRequest, (LPVOID)buff,
 357                         dwSize, &dwDownloaded))
 358                 {
 359                         set_last_err_string("Fail at WinHttpReadData");
 360                         return -1;
 361                 }
 362                 buff += dwDownloaded;
 363                 sz -= dwDownloaded;
 364         }
 365         return 0;
 366 }
 367
 368 HttpStream::~HttpStream()
 369 {
 370         if (m_hRequest)
 371                 WinHttpCloseHandle(m_hRequest);
 372         if (m_hConnect)
 373                 WinHttpCloseHandle(m_hConnect);
 374         if (m_hSession)
 375                 WinHttpCloseHandle(m_hSession);
 376 }
 377
 378 #else
 379
 380 HttpStream::HttpStream()
 381 {
 382         m_buff.empty();
 383 }
 384
 385 int HttpStream::SendPacket(char *buff, size_t sz)
 386 {
 387 #ifdef UUUSSL
 388         if(m_ssl)
 389                 return SSL_write((SSL*)m_ssl, buff, sz);
 390 #endif
 391         return send(m_socket, buff, sz, 0);
 392 }
 393
 394
 395 int HttpStream::RecvPacket(char *buff, size_t sz)
 396 {
 397 #ifdef UUUSSL
 398         if(m_ssl)
 399                 return SSL_read((SSL*)m_ssl, buff, sz);
 400 #endif
 401         return recv(m_socket, buff, sz, 0);
 402 }
 403
 404 class CAutoAddrInfo
 405 {
 406 addrinfo *m_p;
 407 public:
 408         CAutoAddrInfo(addrinfo *pAddrInfo)
 409         {
 410                 m_p = pAddrInfo;
 411         }
 412         ~CAutoAddrInfo()
 413         {
 414                 freeaddrinfo(m_p);
 415         }
 416 };
 417 #include <iostream>
 418 int HttpStream::HttpGetHeader(std::string host, std::string path, int port, bool ishttps)
 419 {
 420         int ret;
 421         addrinfo *pAddrInfo;
 422         char s_port[10];
 423         snprintf(s_port, 10, "%d", port);
 424
 425         if (getaddrinfo(host.c_str(), s_port, 0, &pAddrInfo))
 426         {
 427                 set_last_err_string("get network address error");
 428                 return -1;
 429         }
 430
 431         CAutoAddrInfo A(pAddrInfo);
 432
 433         m_socket = socket(pAddrInfo->ai_family, pAddrInfo->ai_socktype, pAddrInfo->ai_protocol);
 434
 435         struct timeval tv;
 436         tv.tv_sec = 10;
 437         tv.tv_usec = 0;
 438
 439         setsockopt(m_socket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
 440
 441         if (m_socket == INVALID_SOCKET)
 442         {
 443                 set_last_err_string("Can't get sock");
 444                 return -1;
 445         }
 446
 447         if (connect(m_socket, pAddrInfo->ai_addr, pAddrInfo->ai_addrlen))
 448         {
 449                 set_last_err_string("connect error");
 450                 return -1;
 451         }
 452
 453         if(ishttps)
 454         {
 455 #ifdef UUUSSL
 456
 457                 const SSL_METHOD* meth =
 458 #if (OPENSSL_VERSION_NUMBER < 0x10100000L)
 459                 TLSv1_2_client_method();
 460 #else
 461                 TLS_client_method();
 462 #endif
 463                 if(!meth)
 464                 {
 465                         set_last_err_string("Failure at TLSv1_2_client_method\n");
 466                         return -1;
 467                 }
 468                 SSL_CTX *ctx = SSL_CTX_new (meth);
 469                 if(!ctx)
 470                 {
 471                         set_last_err_string("Error create ssl ctx\n");
 472                         return -1;
 473                 }
 474                 m_ssl = SSL_new (ctx);
 475                 if(!m_ssl)
 476                 {
 477                         set_last_err_string("Error create SSL\n");
 478                         return -1;
 479                 }
 480                 SSL_set_fd((SSL*)m_ssl, m_socket);
 481                 if( SSL_connect((SSL*)m_ssl) <= 0)
 482                 {
 483                         set_last_err_string("error build ssl connection");
 484                         return -1;
 485                 }
 486 #else
 487                 set_last_err_string("Can't support https");
 488                 return -1;
 489 #endif
 490         }
 491
 492         int retry = 3;
 493         pair<string, string> up = g_passwd_map[host];
 494         while(retry--)
 495         {
 496                 string userpd = up.first + ":" + up.second;
 497                 string httppath = path;
 498
 499                 if(ishttps)
 500                         httppath = "https://" + host + path;
 501
 502                 string request = "GET " + httppath + " HTTP/1.1\r\n";
 503                 request += "Host: " + host + "\r\n";
 504
 505                 if (!up.first.empty())
 506                         request += "Authorization: Basic " + base64_encode(userpd) + "\r\n";
 507
 508                 request += "User-Agent:uuu\r\nAccept: */*\r\n";
 509                 request += "\r\n";
 510
 511                 ret = SendPacket((char*)request.c_str(), request.size());
 512                 if ((size_t)(ret) != request.size())
 513                 {
 514                         set_last_err_string("http send error");
 515                         return -1;
 516                 }
 517
 518                 m_buff.resize(1024);
 519                 ret = RecvPacket((char*)m_buff.data(), m_buff.size());
 520                 if (ret < 0)
 521                 {
 522                         set_last_err_string("http recv Error");
 523                         return -1;
 524                 }
 525
 526                 int i;
 527                 for (i = 0; i < 1024 - 4; i++)
 528                 {
 529                         if (m_buff[i] == 0xd &&
 530                                 m_buff[i + 1] == 0xa &&
 531                                 m_buff[i + 2] == 0xd &&
 532                                 m_buff[i + 3] == 0xa)
 533                         {
 534                                 break;
 535                         }
 536                 }
 537
 538                 if (i >= 1024 - 4)
 539                 {
 540                         set_last_err_string("Can't find terminate");
 541                         return -1;
 542                 }
 543
 544                 m_data_start = i + 4;
 545
 546                 string str;
 547                 str.resize(i + 2);
 548                 memcpy((void*)str.c_str(), m_buff.data(), i + 2);
 549
 550                 int ret = parser_response(str);
 551                 if (ret == ERR_ACCESS_DENIED)
 552                 {
 553                         if(g_passwd_map[host].first.empty())
 554                         {
 555                                 char user[MAX_USER_LEN];
 556                                 char passwd[MAX_USER_LEN];
 557                                 if (g_ask_passwd((char*)host.c_str(), user, passwd))
 558                                         return -1;
 559
 560                                 up.first = user;
 561                                 up.second = passwd;
 562                         }
 563                         continue;
 564                 }
 565                 else if(ret == 0)
 566                 {
 567                         g_passwd_map[host] = up;
 568                         return 0;
 569                 }
 570                 g_passwd_map[host] = up;
 571         }
 572
 573         return -1;
 574 }
 575
 576 size_t HttpStream::HttpGetFileSize()
 577 {
 578         return atoll(m_response["Content-Length"].c_str());
 579 }
 580
 581 int HttpStream::parser_response(string rep)
 582 {
 583         size_t pos = rep.find("\r\n");
 584         if (pos == string::npos)
 585         {
 586                 set_last_err_string("Can't find \r\n");
 587                 return -1;
 588         }
 589
 590         string str = rep.substr(0, pos);
 591         if (str == "HTTP/1.1 401 Unauthorized")
 592                 return ERR_ACCESS_DENIED;
 593
 594         if (str != "HTTP/1.1 200 OK")
 595         {
 596                 set_last_err_string(str);
 597                 return -1;
 598         }
 599
 600         m_response.clear();
 601
 602         while (pos != string::npos)
 603         {
 604                 pos += 2;
 605                 size_t split = rep.find(':', pos);
 606                 if (split == string::npos)
 607                         break;
 608                 string key = rep.substr(pos, split - pos);
 609                 pos = rep.find("\r\n", pos);
 610                 string value = rep.substr(split + 1, pos - split - 1);
 611                 m_response[key] = value;
 612         }
 613
 614         return 0;
 615 }
 616
 617 int HttpStream::HttpDownload(char *buff, size_t sz)
 618 {
 619         size_t left = 0;
 620         if (m_data_start < m_buff.size())
 621                 left = m_buff.size() - m_data_start;
 622
 623         size_t trim_transferred = 0;
 624
 625         if (left)
 626         {
 627
 628                 trim_transferred = sz;
 629                 if (trim_transferred > left)
 630                         trim_transferred = left;
 631
 632                 memcpy(buff, m_buff.data() + m_data_start, trim_transferred);
 633                 m_data_start += trim_transferred;
 634         }
 635
 636         if (trim_transferred < sz)
 637         {
 638                 int ret = 0;
 639                 sz -= trim_transferred;
 640                 buff += trim_transferred;
 641                 while (sz && ((ret = RecvPacket(buff, sz)) > 0))
 642                 {
 643                         buff += ret;
 644                         sz -= ret;
 645                 }
 646
 647                 if (ret < 0)
 648                 {
 649                         set_last_err_string("recv error");
 650                         return -1;
 651                 }
 652         }
 653
 654         return 0;
 655 }
 656
 657 HttpStream::~HttpStream()
 658 {
 659         close(m_socket);
 660 #ifdef UUUSSL
 661         if(m_ssl)
 662         {
 663                 SSL_CTX_free(SSL_get_SSL_CTX((SSL*)m_ssl));
 664                 SSL_free((SSL*)m_ssl);
 665         }
 666 #endif
 667 }
 668
 669 #endif