curlhttpt.cpp

Go to the documentation of this file.

/*****************************************************************************
 *
 *  curlhttpt.cpp - CURLHTTPTransport
 *
 * $Id: curlhttpt.cpp 3822 2020-11-03 18:54:47Z scribe $
 *
 * Copyright 2004-2013 CrossWire Bible Society (http://www.crosswire.org)
 *  CrossWire Bible Society
 *  P. O. Box 2528
 *  Tempe, AZ  85280-2528
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation version 2.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 */

#include <vector>
#include <cctype>

#include <curl/curl.h>
#include <curl/easy.h>

#include <swlog.h>
#include <filemgr.h>
#include <curlhttpt.h>

using std::vector;


SWORD_NAMESPACE_START

namespace {

    struct FtpFile {
        const char *filename;
        int fd;
        SWBuf *destBuf;
    };


    static int my_httpfwrite(void *buffer, size_t size, size_t nmemb, void *stream) {
        struct FtpFile *out = (struct FtpFile *)stream;
        if (out && !out->fd && !out->destBuf) {
            /* open file for writing */
            out->fd = FileMgr::createPathAndFile(out->filename);
            if (out->fd < 0)
                return -1; /* failure, can't open file to write */
        }
        if (out->destBuf) {
            int s = (int)out->destBuf->size();
            out->destBuf->size(s+(size*nmemb));
            memcpy(out->destBuf->getRawData()+s, buffer, size*nmemb);
            return (int)nmemb;
        }
        return (int)FileMgr::write(out->fd, buffer, size * nmemb);
    }


    static int my_httpfprogress(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow) {
        if (clientp) {
            if (dltotal < 0) dltotal = 0;
            if (dlnow < 0) dlnow = 0;
            if (dlnow > dltotal) dlnow = dltotal;
            ((StatusReporter *)clientp)->update(dltotal, dlnow);
        }
        return 0;
    }


    static int myhttp_trace(CURL *handle, curl_infotype type, unsigned char *data, size_t size, void *userp) {
        SWBuf header;
        (void)userp; /* prevent compiler warning */
        (void)handle; /* prevent compiler warning */

        switch (type) {
        case CURLINFO_TEXT: header = "TEXT"; break;
        case CURLINFO_HEADER_OUT: header = "=> Send header"; break;
        case CURLINFO_HEADER_IN: header = "<= Recv header"; break;

        // these we don't want to log (HUGE)
        case CURLINFO_DATA_OUT: header = "=> Send data";
        case CURLINFO_SSL_DATA_OUT: header = "=> Send SSL data";
        case CURLINFO_DATA_IN: header = "<= Recv data";
        case CURLINFO_SSL_DATA_IN: header = "<= Recv SSL data";
        default: /* in case a new one is introduced to shock us */
            return 0;
        }

        if (size > 120) size = 120;
        SWBuf text;
        text.size(size);
        memcpy(text.getRawData(), data, size);
SWLOGD("CURLHTTPTransport: %s: %s", header.c_str(), text.c_str());
        return 0;
    }
}


CURLHTTPTransport::CURLHTTPTransport(const char *host, StatusReporter *sr) : RemoteTransport(host, sr) {
    session = (CURL *)curl_easy_init();
}


CURLHTTPTransport::~CURLHTTPTransport() {
    curl_easy_cleanup(session);
}


char CURLHTTPTransport::getURL(const char *destPath, const char *sourceURL, SWBuf *destBuf) {
    signed char retVal = 0;
    struct FtpFile ftpfile = {destPath, 0, destBuf};

    CURLcode res;

    if (session) {
        curl_easy_setopt(session, CURLOPT_URL, sourceURL);

        SWBuf credentials = u + ":" + p;
        curl_easy_setopt(session, CURLOPT_USERPWD, credentials.c_str());
        curl_easy_setopt(session, CURLOPT_WRITEFUNCTION, my_httpfwrite);
        if (!passive)
            curl_easy_setopt(session, CURLOPT_FTPPORT, "-");
        curl_easy_setopt(session, CURLOPT_NOPROGRESS, 0);
        curl_easy_setopt(session, CURLOPT_FAILONERROR, 1);
        curl_easy_setopt(session, CURLOPT_PROGRESSDATA, statusReporter);
        curl_easy_setopt(session, CURLOPT_PROGRESSFUNCTION, my_httpfprogress);
        curl_easy_setopt(session, CURLOPT_DEBUGFUNCTION, myhttp_trace);
        /* Set a pointer to our struct to pass to the callback */
        curl_easy_setopt(session, CURLOPT_FILE, &ftpfile);

        /* Switch on full protocol/debug output */
        curl_easy_setopt(session, CURLOPT_VERBOSE, true);
#ifndef OLDCURL
        curl_easy_setopt(session, CURLOPT_CONNECTTIMEOUT_MS, timeoutMillis);
        curl_easy_setopt(session, CURLOPT_TIMEOUT_MS, timeoutMillis);
#else
        curl_easy_setopt(session, CURLOPT_CONNECTTIMEOUT, timeoutMillis/1000);
        curl_easy_setopt(session, CURLOPT_TIMEOUT, timeoutMillis/1000);
#endif

        /* Disable checking host certificate */
        if (isUnverifiedPeerAllowed()) {
            curl_easy_setopt(session, CURLOPT_SSL_VERIFYPEER, false);
        }

        /* FTP connection settings */

#if (LIBCURL_VERSION_MAJOR > 7) || \
   ((LIBCURL_VERSION_MAJOR == 7) && (LIBCURL_VERSION_MINOR > 10)) || \
   ((LIBCURL_VERSION_MAJOR == 7) && (LIBCURL_VERSION_MINOR == 10) && (LIBCURL_VERSION_PATCH >= 5))
#      define EPRT_AVAILABLE 1
#endif

#ifdef EPRT_AVAILABLE
        curl_easy_setopt(session, CURLOPT_FTP_USE_EPRT, 0);
SWLOGD("***** using CURLOPT_FTP_USE_EPRT\n");
#endif


SWLOGD("***** About to perform curl easy action. \n");
SWLOGD("***** destPath: %s \n", destPath);
SWLOGD("***** sourceURL: %s \n", sourceURL);
        res = curl_easy_perform(session);
SWLOGD("***** Finished performing curl easy action. \n");

        if(CURLE_OK != res) {
            if (CURLE_OPERATION_TIMEDOUT == res
#ifdef CURLE_FTP_ACCEPT_TIMEOUT
                || CURLE_FTP_ACCEPT_TIMEOUT == res
#endif
               ) {
                retVal = -2;
            }
            else {
                retVal = -1;
            }
        }
    }

    if (ftpfile.fd > 0)
        FileMgr::closeFile(ftpfile.fd); /* close the local file */

    return retVal;
}


// we need to find the 2nd "<td" & then find the ">" after that.  The size starts with the next non-space char
const char *findSizeStart(const char *buffer) {
    const char *listing = buffer;
    const char *pEnd;
    
    pEnd = strstr(listing, "<td");
    if(pEnd == NULL) {
        return NULL;
    }
    listing = pEnd+2;
    pEnd = strstr(listing, "<td");
    if(pEnd == NULL)
        return NULL;
    listing = pEnd+2;
    pEnd = strchr(listing, '>');
    if(pEnd == NULL)
        return NULL;

    return pEnd+1;
}


vector<struct DirEntry> CURLHTTPTransport::getDirList(const char *dirURL) {
    
    vector<struct DirEntry> dirList;
    
    SWBuf dirBuf;
    const char *pBuf;
    char *pBufRes;
    SWBuf possibleName;
    double fSize;
    int possibleNameLength = 0;
    
    if (!getURL("", dirURL, &dirBuf)) {
        pBuf = strstr(dirBuf, "<a href=\"");//Find the next link to a possible file name.
        while (pBuf != NULL) {
            pBuf += 9;//move to the start of the actual name.
            pBufRes = (char *)strchr(pBuf, '\"');//Find the end of the possible file name
            if (!pBufRes)
                break;
            possibleNameLength = (int)(pBufRes - pBuf);
            possibleName.setFormatted("%.*s", possibleNameLength, pBuf);
            if (isalnum(possibleName[0])) {
SWLOGD("getDirListHTTP: Found a file: %s", possibleName.c_str());
                pBuf = pBufRes;
                pBufRes = (char *)findSizeStart(pBuf);
                fSize = 0;
                if(pBufRes != NULL) {
                    pBuf = pBufRes;
                    fSize = strtod(pBuf, &pBufRes);
                    if (pBufRes[0] == 'K')
                        fSize *= 1024;
                    else if (pBufRes[0] == 'M')
                        fSize *= 1048576;
                    pBuf = pBufRes;
                }
                struct DirEntry i;
                i.name = possibleName;
                i.size = (long unsigned int)fSize;
                i.isDirectory = possibleName.endsWith("/");
                dirList.push_back(i);
            } else {
                pBuf += possibleNameLength;
            }
            pBuf++;
            pBuf = strstr(pBuf, "<a href=\"");//Find the next link to a possible file name.
        }
    }
    else
    {
        SWLog::getSystemLog()->logWarning("FTPURLGetDir: failed to get dir %s\n", dirURL);
    }
    return dirList;
}

SWORD_NAMESPACE_END