File indexing completed on 2024-04-28 16:43:06

 // SPDX-FileCopyrightText: 2022 Michael Lang <criticaltemp@protonmail.com>
 //
 // SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 
 #include "ecurl.h"
 #include "modemcontroller.h"
 #include "settingsmanager.h"
 
 #include <netdb.h>
 
 ECurl::ECurl()
 {
     curl_global_init(CURL_GLOBAL_DEFAULT);
     ares_library_init(ARES_LIB_INIT_ALL);
 }
 
 ECurl::~ECurl()
 {
     ares_library_cleanup();
     curl_global_cleanup();
 }
 
 QByteArray ECurl::networkRequest(const QString &url, const QByteArray &data) const
 {
     CURL *curl = curl_easy_init();
     if (!curl) {
         return QByteArray();
     }
     struct curl_slist *host = NULL;
 
     // provide a buffer to store errors in
     char errbuf[CURL_ERROR_SIZE];
     curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errbuf);
 
     QString ifaceName = ModemController::instance().ifaceName;
     curl_easy_setopt(curl, CURLOPT_INTERFACE, (SL("if!") + ifaceName).toUtf8().constData());
 
     // only attempt to resolve if not using proxy
     if (SettingsManager::self()->mmsProxy().isEmpty()) {
         QString dnsServers = ModemController::instance().dnsServers;
         CURLcode supported = curl_easy_setopt(curl, CURLOPT_DNS_INTERFACE, ifaceName.toUtf8().constData());
 
         // use c-ares if curl was built without dns resolver support
         if (supported == CURLE_UNKNOWN_OPTION || supported == CURLE_NOT_BUILT_IN) {
             ares_channel channel;
 
             int aresReturn = ares_init(&channel);
 
             if (aresReturn != ARES_SUCCESS) {
                 qDebug() << "Ares init failed:" << ares_strerror(aresReturn);
             } else {
                 ares_set_local_dev(channel, ifaceName.toUtf8().constData());
                 ares_set_servers_csv(channel, dnsServers.toUtf8().constData());
 
                 CURLU *curlUrl = curl_url();
                 curl_url_set(curlUrl, CURLUPART_URL, url.toUtf8().constData(), 0);
                 char *hostname = url.toUtf8().data();
                 curl_url_get(curlUrl, CURLUPART_HOST, &hostname, 0);
                 curl_url_cleanup(curlUrl);
 
                 char *hostIp = NULL;
                 ares_gethostbyname(channel, hostname, AF_UNSPEC, aresResolveCallback, (void *)&hostIp);
                 aresResolveWait(channel);
 
                 if (hostIp == NULL) {
                     qDebug() << "Failed to resolve:" << hostname;
                 }
 
                 const char *resolve = QByteArray("+").append(hostname).append(":80:[").append(hostIp).append("]").constData();
                 host = curl_slist_append(NULL, resolve);
                 curl_easy_setopt(curl, CURLOPT_RESOLVE, host);
 
                 curl_free(hostname);
                 ares_destroy(channel);
             }
         } else {
             curl_easy_setopt(curl, CURLOPT_DNS_SERVERS, dnsServers.toUtf8().constData());
         }
     }
 
     curl_easy_setopt(curl, CURLOPT_URL, url.toUtf8().constData());
     curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
     curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 60L);
     curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 30L);
 
     // Fake user agent for carrier network compatibility
     curl_easy_setopt(curl, CURLOPT_USERAGENT, "Android MmsLib/1.0");
 
     if (!SettingsManager::self()->mmsProxy().isEmpty()) {
         QString proxy = SettingsManager::self()->mmsProxy() + SL(":") + QString::number(SettingsManager::self()->mmsPort());
         curl_easy_setopt(curl, CURLOPT_PROXY, proxy.toUtf8().constData());
     }
 
     if (!data.isEmpty()) {
         curl_easy_setopt(curl, CURLOPT_POST, 1L);
         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.constData());
         curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, data.length());
 
         QString len = QString::number(data.length());
         struct curl_slist *headers = NULL;
         headers = curl_slist_append(headers, "Content-Type: application/vnd.wap.mms-message");
         headers = curl_slist_append(headers, (SL("Content-Length: ") + len).toUtf8().constData());
         curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
     }
 
     QByteArray response;
     const QByteArray *pointer = &response;
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlWriteFunction);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, pointer);
 
     CURLcode res = curl_easy_perform(curl);
     curl_easy_cleanup(curl);
     curl_slist_free_all(host);
 
     if (res != CURLE_OK) {
         qDebug() << "Network Error:" << errbuf;
         return QByteArray();
     } else {
         return response;
     }
 }
 
 size_t ECurl::curlWriteFunction(char *chunk, size_t size, size_t len, QByteArray *response)
 {
     response->append(chunk, static_cast<int>(size * len));
     return size * len;
 }
 
 void ECurl::aresResolveCallback(void *arg, int status, int timeouts, struct hostent *host)
 {
     char **hostIp = (char **)arg;
 
     // when the ares handle is getting destroyed, the 'arg' pointer may not
     // be valid so only defer it when we know the 'status' says its fine!
     if (!host || status != ARES_SUCCESS) {
         return;
     }
 
     char ip[INET6_ADDRSTRLEN];
 
     for (int i = 0; host->h_addr_list[i]; ++i) {
         ares_inet_ntop(host->h_addrtype, host->h_addr_list[i], ip, sizeof(ip));
         if (i > 0) {
             strcat(*hostIp, ",");
             strcat(*hostIp, strdup(ip));
         } else {
             *hostIp = strdup(ip);
         }
 
         qDebug() << "Found IP for" << host->h_name << *hostIp;
     }
 
     (void)timeouts; // ignored
 }
 
 void ECurl::aresResolveWait(ares_channel channel)
 {
     qint64 start = QTime::currentTime().msecsSinceStartOfDay();
 
     for (;;) {
         struct timeval *tvp, tv;
         fd_set read_fds, write_fds;
         int nfds;
 
         FD_ZERO(&read_fds);
         FD_ZERO(&write_fds);
         nfds = ares_fds(channel, &read_fds, &write_fds);
         if (nfds == 0) {
             break;
         }
         tvp = ares_timeout(channel, NULL, &tv);
         int count = select(nfds, &read_fds, &write_fds, NULL, tvp);
         if (count == -1) {
             qDebug() << "Error waiting for c-ares read/write descriptors";
             break;
         }
         if (QTime::currentTime().msecsSinceStartOfDay() - start > 15 * 1000) {
             qDebug() << "Resovler timeout";
             break;
         }
         ares_process(channel, &read_fds, &write_fds);
     }
 }