Client.cpp

#include "Client.hpp"
#include "Cache.hpp"
#include "Dns.hpp"
#include "Http.hpp"
#include "Https.hpp"
#include "Common.hpp"
#include <unistd.h>
#include <iostream>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <xxhash.h>
#include <chrono>
#include <arpa/inet.h>
#include <sstream>
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <algorithm>
#include <vector>

//ETag -> If-None-Match
//debug.m3MM7UcOEr3qP3ZK

//can't be static, reused later
//char Client::pathVar[]="XXXXXXXXXXXXXXXX";
//std::string pathForIndex;
#ifdef HOSTSUBFOLDER
char Client::folderVar[]="";
#endif
#ifdef DEBUGFASTCGI
#include <arpa/inet.h>
#endif

std::unordered_set<Client *> Client::clients;
std::unordered_set<Client *> Client::clientToDelete;
#ifdef DEBUGFASTCGI
std::unordered_set<Client *> Client::clientToDebug;
#endif
char Client::bigStaticReadBuffer[65536];

Client::Client(int cfd) :
    EpollObject(cfd,EpollObject::Kind::Kind_Client),
    fastcgi_id(-1),
    readCache(nullptr),
    http(nullptr),
    fullyParsed(false),
    endTriggered(false),
    status(Status_Idle),
    https(false),
    gzip(false),
    partial(false),
    partialEndOfFileTrigged(false),
    outputWrited(false),
    creationTime(0),
    creationTimeOrUpdate(0),
    bodyAndHeaderFileBytesSended(0)
{
    memset(Client::pathVar,0,sizeof(Client::pathVar));
    #ifdef HOSTSUBFOLDER
    {
        strncpy(Client::pathVar,"XXXXXXXX/XXXXXXXXXXXXXXXXY",sizeof(Client::pathVar));
        memset(Client::folderVar,0,sizeof(Client::folderVar));
        strncpy(Client::folderVar,"XXXXXXXX",sizeof(Client::folderVar));
    }
    #else
        strncpy(Client::pathVar,"XXXXXXXXXXXXXXXXY",sizeof(Client::pathVar));
    #endif
    #ifdef DEBUGFASTCGI
    bytesSended=0;
    #endif
    #ifdef DEBUGFASTCGI
    std::cerr << "create client " << this << std::endl;
    #endif
    Cache::newFD(cfd,this,EpollObject::Kind::Kind_Client);
    this->kind=EpollObject::Kind::Kind_Client;
    this->fd=cfd;//should be after Cache::newFD()
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " Client::Client() " << this << " fd: " << fd << " this->fd: " << this->fd << " constructor" << std::endl;
    #endif
    clients.insert(this);
    creationTime=Common::msFrom1970();
    creationTimeOrUpdate=Common::msFrom1970();
    #ifdef DEBUGFASTCGI
    clientToDebug.insert(this);
    #endif
}

Client::~Client()
{
    #ifdef DEBUGFASTCGI
    if(!uri.empty() && !endTriggered && fastcgi_id!=-1)
    {
        std::cerr << "Client::~Client() !uri.empty() && !endTriggered && fastcgiid!=-1: " << this << " " << host << uri;
        std::cerr << " dataToWrite.size(): " << dataToWrite.size();
        std::cerr << " status: " << (int)status;
        std::cerr << " fastcgiid: " << (int)fastcgi_id;
        std::cerr << " partial: " << partial;
        std::cerr << " outputWrited: " << outputWrited;
        if(readCache!=nullptr)
            std::cerr << " readCache!=nullptr";
        else
            std::cerr << " readCache==nullptr";
        if(http!=nullptr)
            std::cerr << " http: " << http->getUrl() << " " << (int)http->get_status();
        else
            std::cerr << " nohttpsub";
        if(fullyParsed)
            std::cerr << " fullyParsed: true";
        else
            std::cerr << " fullyParsed: false";
        #ifdef DEBUGFROMIP
        if(!REMOTE_ADDR.empty())
            std::cerr << " from " << REMOTE_ADDR;
        #endif
        std::cerr << std::endl;
    }
    #endif
    #ifdef DEBUGFASTCGI
    clientToDebug.erase(this);
    #endif
    if(clients.find(this)!=clients.cend())
        clients.erase(this);
    else
    {
        std::cerr << "Client Entry not found into global list, abort()" << std::endl;
        abort();
    }
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " destructor " << this << std::endl;
    #endif
    #ifdef DEBUGFILEOPEN
    std::cerr << "Client::~Client(), readCache close: " << readCache << std::endl;
    #endif
    if(readCache!=nullptr)
    {
        readCache->close();
        delete readCache;
        readCache=nullptr;
    }
    if(http!=nullptr)
    {
        if(!http->removeClient(this))
        {
            #ifdef DEBUGFASTCGI
            std::cerr << this << " not into client list of " << http << __FILE__ << ":" << __LINE__ << std::endl;
            #endif
        }
    }
    if(fd!=-1)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << this << " fd close: " << fd << " destroy()" << std::endl;
        #endif
        epoll_ctl(epollfd,EPOLL_CTL_DEL, fd, NULL);
        ::close(fd);
        fd=-1;
    }
}

void Client::parseEvent(const epoll_event &event)
{
    #ifdef DEBUGFASTCGI
    std::cout << this << " Client event.events: " << event.events << " time: " << Common::msFrom1970() << std::endl;
    #endif
    if(event.events & EPOLLIN)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << "EPOLLIN " << this << std::endl;
        #endif
        readyToRead();
    }
    if(event.events & EPOLLOUT)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << "EPOLLOUT " << this << std::endl;
        #endif
        readyToWrite();
    }
    if(event.events & EPOLLHUP)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << "EPOLLHUP " << this << std::endl;
        #endif
        disconnect();
    }
    if(event.events & EPOLLRDHUP)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << "EPOLLRDHUP " << this << std::endl;
        #endif
        disconnect();
        #ifdef DEBUGFASTCGI
        if(fd!=-1)
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " " << "EPOLLRDHUP (abort) " << this << std::endl;
            abort();
        }
        #endif
    }
    if(event.events & EPOLLERR)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << "EPOLLERR " << this << std::endl;
        #endif
        disconnect();
    }
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << "event.events: " << event.events << " " << this << std::endl;
    #endif
}

void Client::disconnect()
{
    if(fd==-1)
        return;
    #ifdef DEBUGFASTCGI
    {
        struct stat sb;
        sb.st_size=0;
        if(fstat(fd,&sb)!=0)
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " size: " << sb.st_size << std::endl;
        else
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " Client::disconnect() but fd: " << fd << " errno: " << errno << std::endl;
    }
    #endif
    #ifdef DEBUGFILEOPEN
    std::cerr << __FILE__ << ":" << __LINE__ << " " << "Client::disconnect(), readCache close: " << fd << " " << this << std::endl;
    #endif
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << "Client::disconnect(), bytesSended: " << bytesSended << " " << this << std::endl;
    #endif
    if(fd!=-1)
    {
        if(!endTriggered)
        {
            time_t timestamp;
            time(&timestamp);
            #ifdef DEBUGFASTCGI
            //maybe just BOT detecting header
            std::cerr << this << " time " << ctime(&timestamp) << " closed before end " << bodyAndHeaderFileBytesSended << " " << host << "/" << uri << " " << __FILE__ << ":" << __LINE__ << std::endl;
            #endif
        }
        #ifdef DEBUGFASTCGI
        std::cerr << this << " fd close: " << fd << " disconnect(), dataToWrite.size(): " << dataToWrite.size() << std::endl;
        #endif
        epoll_ctl(epollfd,EPOLL_CTL_DEL, fd, NULL);
        if(::close(fd)!=0)
            std::cerr << this << " " << fd << " disconnect() failed: " << errno << std::endl;
        fd=-1;
    }
    //to debug
    if(uri.find("-setup.exe")!=std::string::npos && uri.find("ultracopier")!=std::string::npos)
    {
        if(bodyAndHeaderFileBytesSended<10000000)
        {
            time_t timestamp;
            time(&timestamp);
            std::cerr << this << " time " << ctime(&timestamp)
                     #ifdef DEBUGFROMIP
                     << " from " << REMOTE_ADDR
                     #endif
                      << " exe files ultracopier seam too small into disconnect() bodyAndHeaderFileBytesSended: " << bodyAndHeaderFileBytesSended << " " << host << "/" << uri << " time since start " << (Common::msFrom1970()-creationTime)/1000 << "s " << __FILE__ << ":" << __LINE__ << std::endl;
            if(http!=nullptr)
                std::cerr << this << " http: " << http->getQuery() << " " << __FILE__ << ":" << __LINE__ << std::endl;
            if(readCache!=nullptr)
            {
                struct stat sb;
                if(fstat(readCache->getFD(),&sb)==0)
                {
                    if(sb.st_size<10000000)
                        std::cerr << this << " exe cache ultracopier seam too small and cache FD too " << host << "/" << uri << " pathVar " << pathVar << " time since start " << (Common::msFrom1970()-creationTime)/1000 << " " << __FILE__ << ":" << __LINE__ << std::endl;
                    else
                        std::cerr << this << " exe cache ultracopier size seam ok: " << sb.st_size << " " << host << "/" << uri << " pathVar " << pathVar << " time since start " << (Common::msFrom1970()-creationTime)/1000 << " " << __FILE__ << ":" << __LINE__ << std::endl;
                }
                else
                    std::cerr << this << " exe cache ultracopier unable to stat errno " << errno << " " << host << "/" << uri << " pathVar " << pathVar << " time since start " << (Common::msFrom1970()-creationTime)/1000 << " " << __FILE__ << ":" << __LINE__ << std::endl;
            }
            #ifdef DEBUGFASTCGI
            std::cerr << getStatus() << std::endl;
            #endif
        }
    }
    if(readCache!=nullptr)
    {
        readCache->close();
        delete readCache;
        readCache=nullptr;
    }
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << "Client::disconnect(), bytesSended: " << bytesSended << " " << this << std::endl;
    #endif
    disconnectFromHttp();
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << "Client::disconnect(), bytesSended: " << bytesSended << " " << this << std::endl;
    #endif
    dataToWrite.clear();
    #ifdef DEBUGFASTCGI
    std::cerr << "disconnectFrontend client " << this << ": " << __FILE__ << ":" << __LINE__ << std::endl;
    #endif
}

void Client::disconnectFromHttp()
{
    //to debug
    if(uri.find("-setup.exe")!=std::string::npos && uri.find("ultracopier")!=std::string::npos)
    {
        if(bodyAndHeaderFileBytesSended<10000000)
        {
            std::cerr << this << " exe files ultracopier seam too small " << bodyAndHeaderFileBytesSended
             #ifdef DEBUGFROMIP
             << " from " << REMOTE_ADDR
             #endif
                      << " " << host << "/" << uri << " " << " time since start " << (Common::msFrom1970()-creationTime)/1000 << __FILE__ << ":" << __LINE__ << std::endl;
            if(http!=nullptr)
                std::cerr << this << " http: " << http->getQuery() << " " << __FILE__ << ":" << __LINE__ << std::endl;
            #ifdef DEBUGFASTCGI
            std::cerr << getStatus() << std::endl;
            #endif
        }
    }

    if(http!=nullptr)
    {
        if(!http->removeClient(this))
        {
            #ifdef DEBUGFASTCGI
            std::cerr << this << " not into client list of " << http << " " << __FILE__ << ":" << __LINE__ << std::endl;
            #endif
        }
    }
}

void Client::readyToRead()
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " fd: " << fd << " this->fd: " << this->fd << " fullyParsed: " << fullyParsed << std::endl;
    #endif
    if(fullyParsed)
        return;
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
    #endif

    /// \todo for now re-read all request, possible bug? performance problema
    if(!requestRawData.empty())
        memcpy(Client::bigStaticReadBuffer,requestRawData.data(),requestRawData.size());
    const int size=read(fd,Client::bigStaticReadBuffer+requestRawData.size(),sizeof(Client::bigStaticReadBuffer)-requestRawData.size())+requestRawData.size();
    #ifdef DEBUGFASTCGI
    //std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " additional data: " << Common::binarytoHexa(Client::bigStaticReadBuffer+requestRawData.size(),size-requestRawData.size()) << " size: " << size-requestRawData.size() << std::endl;
    #endif
    requestRawData.clear();

    /*std::string buggyData=Common::hexaToBinary("");
    if(buggyData.size()>=sizeof(Client::bigStaticReadBuffer))
        abort();
    memcpy(Client::bigStaticReadBuffer,buggyData.data(),buggyData.size());
    const int size=buggyData.size();*/

    if(size<=0)
        return;
    #ifdef DEBUGFASTCGI
    //std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " read data: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
    #endif

    std::string ifNoneMatch;
    https=false;
    uri.clear();
    host.clear();
    //all is big endian
    int pos=0;
    uint8_t var8=0;
    uint16_t var16=0;

    /*{
        std::cerr << fd << ") " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << std::endl;
    }*/

    do
    {
        if(!read8Bits(var8,Client::bigStaticReadBuffer,size,pos))
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
            requestRawData=std::string(Client::bigStaticReadBuffer,size);
            return;
        }
        if(var8!=1)
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " wrong fastcgi version: " << std::to_string(var8) << std::endl;
            #endif
            disconnect();
            return;
        }
        if(!read8Bits(var8,Client::bigStaticReadBuffer,size,pos))
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
            requestRawData=std::string(Client::bigStaticReadBuffer,size);
            return;
        }
        if(fastcgi_id==-1)
        {
            if(var8!=1)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
                #endif
                disconnect();
                return;
            }
            if(!read16Bits(var16,Client::bigStaticReadBuffer,size,pos))
            {
                std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                requestRawData=std::string(Client::bigStaticReadBuffer,size);
                return;
            }
            fastcgi_id=var16;
            if(fastcgi_id!=1)
            {
                std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error, only request with id 1 is supported, use nginx + fastcgi_keep_conn off" << std::endl;
                disconnect();
            }
        }
        else
        {
            /*
             * 1 = FCGI_BEGIN_REQUEST
             * 4 = FCGI_PARAMS
             * 5 = FCGI_STDIN
            */
            if(var8!=1 && var8!=4 && var8!=5)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " at 2nd number read, pos: "  << std::to_string(pos) << " var8: " << std::to_string(var8) << " fastcgi_id: " << std::to_string(fastcgi_id) << std::endl;
                #endif
                disconnect();
                return;
            }
            if(!read16Bits(var16,Client::bigStaticReadBuffer,size,pos))
            {
                requestRawData=std::string(Client::bigStaticReadBuffer,size);
                return;
            }
            if(fastcgi_id!=var16)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
                #endif
                disconnect();
                return;
            }
        }
        uint16_t contentLenght=0;
        uint8_t paddingLength=0;
        if(!read16Bits(contentLenght,Client::bigStaticReadBuffer,size,pos))
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
            requestRawData=std::string(Client::bigStaticReadBuffer,size);
            return;
        }
        if(!read8Bits(paddingLength,Client::bigStaticReadBuffer,size,pos))
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
            requestRawData=std::string(Client::bigStaticReadBuffer,size);
            return;
        }
        if(!canAddToPos(1,size,pos))
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
            requestRawData=std::string(Client::bigStaticReadBuffer,size);
            return;
        }
        switch (var8) {
        //FCGI_BEGIN_REQUEST
        case 1:
            //skip the content length + padding length
            if(!canAddToPos(contentLenght+paddingLength,size,pos))
            {
                std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                requestRawData=std::string(Client::bigStaticReadBuffer,size);
                return;
            }
        break;
        //FCGI_PARAMS
        case 4:
        {
            int contentLenghtAbs=contentLenght+pos;
            while(pos<contentLenghtAbs)
            {
                uint32_t varSize=0;
                uint8_t varSize8=0;
                if(!read8Bits(varSize8,Client::bigStaticReadBuffer,size,pos))
                {
                    std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                    requestRawData=std::string(Client::bigStaticReadBuffer,size);
                    return;
                }
                if(varSize8>127)
                {
                    if(!read24Bits(varSize,Client::bigStaticReadBuffer,size,pos))
                    {
                        std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                        requestRawData=std::string(Client::bigStaticReadBuffer,size);
                        return;
                    }
                }
                else
                    varSize=varSize8;

                uint32_t valSize=0;
                uint8_t valSize8=0;
                if(!read8Bits(valSize8,Client::bigStaticReadBuffer,size,pos))
                {
                    std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                    requestRawData=std::string(Client::bigStaticReadBuffer,size);
                    return;
                }
                if(valSize8>127)
                {
                    if(!read24Bits(valSize,Client::bigStaticReadBuffer,size,pos))
                    {
                        std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                        requestRawData=std::string(Client::bigStaticReadBuffer,size);
                        return;
                    }
                }
                else
                    valSize=valSize8;

                switch(varSize)
                {
                    case 9:
                    if(memcmp(Client::bigStaticReadBuffer+pos,"HTTP_HOST",varSize)==0)
                        host=std::string(Client::bigStaticReadBuffer+pos+varSize,valSize);
                    else
                    {
                        #ifdef DEBUGFASTCGI
                        //std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " other header (1): " << std::string(buff+pos,9) << std::endl;
                        #endif
                    }
                    break;
                    case 10:
                    if(memcmp(Client::bigStaticReadBuffer+pos,"HTTP_RANGE",varSize)==0)
                    {
                        // Captured for client-Range serve from warm cache (frontend Range
                        // tests). Bound the length defensively — a 64K Range header is
                        // already absurd; cap at 1024 to keep parsing cheap.
                        size_t copyLen = valSize > 1024 ? 1024 : (size_t)valSize;
                        rangeHeader.assign(Client::bigStaticReadBuffer+pos+varSize, copyLen);
                    }
                    #ifdef DEBUGFASTCGI
                    else if(memcmp(Client::bigStaticReadBuffer+pos,"HTTP_DEBUG",varSize)==0)
                        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " HTTP_DEBUG: " << std::string(Client::bigStaticReadBuffer+pos+varSize,valSize) << std::endl;
                    #endif
                    break;
                    case 11:
                    if(memcmp(Client::bigStaticReadBuffer+pos,"REQUEST_URI",varSize)==0)
                        uri=std::string(Client::bigStaticReadBuffer+pos+varSize,valSize);
                    #if defined(DEBUGFASTCGI) || defined(DEBUGFROMIP)
                    else if(memcmp(Client::bigStaticReadBuffer+pos,"REMOTE_ADDR",varSize)==0)
                    {
                        #ifdef DEBUGFROMIP
                        REMOTE_ADDR=std::string(Client::bigStaticReadBuffer+pos+varSize,valSize);
                        #endif
                        #ifdef DEBUGFASTCGI
                        std::cout << __FILE__ << ":" << __LINE__ << " " << this << " request from IP: " << std::string(Client::bigStaticReadBuffer+pos+varSize,valSize) << std::endl;
                        #endif
                    /* black list: self ip, block ip continuously downloading same thing
                        ifNoneMatch=std::string(buff+pos+varSize,8);
                        */
                    }
                    /*else if(memcmp(buff+pos,"SERVER_PORT",11)==0 && valSize==3)
                        if(memcmp(buff+pos+varSize,"443",3)==0)
                            https=true;*/
                    #endif
                    else
                    {
                        #ifdef DEBUGFASTCGI
                        //std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " other header (2): " << std::string(buff+pos,9) << std::endl;
                        #endif
                    }
                    break;
                    case 13:
                    if(memcmp(Client::bigStaticReadBuffer+pos,"HTTP_EPNOERFT",varSize)==0)
                        if(memcmp(Client::bigStaticReadBuffer+pos+varSize,"ysff43Uy",8)==0)
                        {
                            char text[]="X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nAnti loop protection";
                            #ifdef DEBUGFASTCGI
                            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << "Anti loop protection" << std::endl;
                            #endif
                            addHeaderAndWrite(text,sizeof(text)-1);
                            internalWriteEnd();
                            disconnect();
                            return;
                        }
                    break;
                    case 14:
                    if(memcmp(Client::bigStaticReadBuffer+pos,"REQUEST_SCHEME",varSize)==0 && valSize==5)
                    {
                        if(memcmp(Client::bigStaticReadBuffer+pos+varSize,"https",5)==0)
                            https=true;
                    }
                    else if(memcmp(Client::bigStaticReadBuffer+pos,"REQUEST_METHOD",varSize)==0)
                    {
                        // Confiacdn is a read-only CDN edge — reject writes before any
                        // backend connection is opened (mission item 5: never let abusive
                        // origins or mistaken clients trigger backend work for non-cacheable
                        // requests; FastCGI already buffered the body so no need to drain).
                        bool reject=false;
                        if(valSize==4 && memcmp(Client::bigStaticReadBuffer+pos+varSize,"POST",4)==0) reject=true;
                        else if(valSize==3 && memcmp(Client::bigStaticReadBuffer+pos+varSize,"PUT",3)==0) reject=true;
                        else if(valSize==6 && memcmp(Client::bigStaticReadBuffer+pos+varSize,"DELETE",6)==0) reject=true;
                        else if(valSize==5 && memcmp(Client::bigStaticReadBuffer+pos+varSize,"PATCH",5)==0) reject=true;
                        if(reject)
                        {
                            const char text[]="Status: 405 Method Not Allowed\r\nAllow: GET, HEAD\r\nContent-Type: text/plain\r\nContent-Length: 0\r\n\r\n";
                            addHeaderAndWrite(text,sizeof(text)-1);
                            internalWriteEnd();
                            disconnect();
                            return;
                        }
                    }
                    break;
                    case 18:
                    if(memcmp(Client::bigStaticReadBuffer+pos,"HTTP_IF_NONE_MATCH",varSize)==0 && valSize==8)
                        ifNoneMatch=std::string(Client::bigStaticReadBuffer+pos+varSize,8);
                    break;
                    case 20:
                    if(Http::useCompression)
                        if(memcmp(Client::bigStaticReadBuffer+pos,"HTTP_ACCEPT_ENCODING",varSize)==0 && valSize>=4)
                            gzip=std::string(Client::bigStaticReadBuffer+pos+varSize,varSize).find("gzip")!=std::string::npos;
                    break;
                    default:
                    break;
                }
                #ifdef DEBUGFASTCGI
                //std::cout << std::string(buff+pos,varSize) << ": " << std::string(buff+pos+varSize,valSize) << std::endl;
                #endif
                if(!canAddToPos(varSize+valSize,size,pos))
                {
                    std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                    requestRawData=std::string(Client::bigStaticReadBuffer,size);
                    return;
                }
            }
            if(!canAddToPos(paddingLength,size,pos))
            {
                std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                requestRawData=std::string(Client::bigStaticReadBuffer,size);
                return;
            }
        }
        break;
        //FCGI_STDIN
        case 5:
            //skip the content length + padding length
            if(!canAddToPos(contentLenght+paddingLength,size,pos))
            {
                std::cerr << __FILE__ << ":" << __LINE__ << " FastCGI protocol error: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                requestRawData=std::string(Client::bigStaticReadBuffer,size);
                return;
            }
            if(host.empty() || uri.empty())
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " host.empty() || uri.empty() and try fullyParsed=true: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << " size: " << size << std::endl;
                #endif
            }
            fullyParsed=true;
        break;
        default:
            break;
        }
    } while(pos<size);

    if(!fullyParsed)
        return;
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
    #endif

    //resolv the host or from subdomain or from uri
    {
        //resolv final url (hex, https, ...)
        const size_t &pos=host.rfind(".confiared.com");
        const size_t &mark=(host.size()-14);
        #ifdef DEBUGDNS
        const size_t &posdebug=host.rfind(".bolivia-online.com");
        const size_t &markdebug=(host.size()-19);
        if(pos==mark || posdebug==markdebug)
        {
            std::string hostb;
            if(pos==mark)
                hostb=host.substr(0,mark);
            else
                hostb=host.substr(0,markdebug);
        #else
        if(pos==mark)
        {
            std::string hostb=host.substr(0,mark);
        #endif

            size_t posb=hostb.rfind("cdn");
            size_t markb=(hostb.size()-3);
            if(posb==markb)
            {
                if(markb>1)
                    host=Common::hexaToBinary(hostb.substr(0,markb-1));
                else if(markb==0)
                {
                    const size_t poss=uri.find("/",1);
                    if(poss!=std::string::npos)
                    {
                        if(poss>2)
                        {
                            host=uri.substr(1,poss-1);
                            uri=uri.substr(poss);
                        }
                    }
                    else
                    {
                        //std::cerr << "uri '/' not found " << uri << ", host: " << host << std::endl;
                        char text[]="X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nCDN bad usage (1): contact@confiared.com";
                        addHeaderAndWrite(text,sizeof(text)-1);
                        #ifdef DEBUGFASTCGI
                        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " bad CDN usage, data: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << std::endl;
                        #endif
                        internalWriteEnd();
                        disconnect();
                        return;
                    }
                }
            }
            else
            {
                markb=(hostb.size()-4);
                posb=hostb.rfind("cdn1");
                if(posb!=markb)
                    posb=hostb.rfind("cdn2");
                if(posb!=markb)
                    posb=hostb.rfind("cdn3");
                if(posb==markb)
                {
                    if(markb>1)
                        host=Common::hexaToBinary(hostb.substr(0,markb-1));
                    else if(markb==0)
                    {
                        const size_t poss=uri.find("/",1);
                        if(poss!=std::string::npos)
                        {
                            if(poss>2)
                            {
                                host=uri.substr(1,poss-1);
                                uri=uri.substr(poss);
                            }
                        }
                        else
                        {
                            //std::cerr << "uri '/' not found " << uri << ", host: " << host << std::endl;
                            char text[]="X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nCDN bad usage (2): contact@confiared.com";
                            #ifdef DEBUGFASTCGI
                            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " bad CDN usage 2, data: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << std::endl;
                            #endif
                            addHeaderAndWrite(text,sizeof(text)-1);
                            internalWriteEnd();
                            disconnect();
                            return;
                        }
                    }
                }
            }
        }
        else
        {
            const size_t poss=uri.find("/",1);
            if(poss!=std::string::npos)
            {
                if(poss>2)
                {
                    host=uri.substr(1,poss-1);
                    uri=uri.substr(poss);
                }
            }
            else
            {
                std::cerr << "uri '/' not found " << uri << ", host: " << host << ", pos: " << pos << ", mark: " << mark
                            #ifdef DEBUGDNS
                          << ", posdebug: " << posdebug << ", markdebug: " << markdebug
                            #endif
                          << std::endl;
                char buffer[2048];
                sprintf(buffer,"%p",this);
                std::string text("X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nCDN bad usage (3): contact@confiared.com for uri: "+uri+" host: "+host+" client: "+buffer);
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " bad CDN usage 3, data: " << Common::binarytoHexa(Client::bigStaticReadBuffer,size) << std::endl;
                #endif
                addHeaderAndWrite(text.c_str(),text.size());
                internalWriteEnd();
                disconnect();
                return;
            }
        }
        #ifdef DEBUGDNS
        /*if(posdebug==markdebug)
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " posdebug==markdebug " << std::endl;
            //https=true;-> generate a bug to test http url
        }*/
        #endif
    }

    //check if robots.txt
    if(uri=="/robots.txt")
    {
        char text[]="X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nUser-agent: *\r\nDisallow: /";
        addHeaderAndWrite(text,sizeof(text)-1);
        internalWriteEnd();
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " bad CDN usage /" << std::endl;
        #endif
        disconnect();
        return;
    }
    //check if robots.txt
    if(uri=="/favicon.ico")
    {
        char text[]="X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nDropped for now";
        addHeaderAndWrite(text,sizeof(text)-1);
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " bad CDN usage favico" << std::endl;
        #endif
        internalWriteEnd();
        disconnect();
        return;
    }

    // Frontend fd is already O_NONBLOCK | O_CLOEXEC — Server*::parseEvent
    // accepts it with accept4(SOCK_NONBLOCK | SOCK_CLOEXEC), so no per-Client
    // fcntl is needed.
    Client::loadUrl(host,uri,ifNoneMatch);
}

void Client::loadUrl(const std::string &host, const std::string &uri, const std::string &ifNoneMatch)
{
    //if have request
    #ifdef DEBUGFASTCGI
    const auto p1 = std::chrono::system_clock::now();
    if(https)
        std::cout << this << " " << std::chrono::duration_cast<std::chrono::seconds>(p1.time_since_epoch()).count() << " downloading: https://" << host << uri << std::endl;
    else
        std::cout << this << " " << std::chrono::duration_cast<std::chrono::seconds>(p1.time_since_epoch()).count() << " downloading: http://" << host << uri << std::endl;
    #endif

    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
    #endif

    if(host.empty())
    {
        char text[]="X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nCDN bad usage (4): contact@confiared.com";
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN bad usage host emtpy" << std::endl;
        #endif
        addHeaderAndWrite(text,sizeof(text)-1);
        internalWriteEnd();
        disconnect();
        return;
    }
    else if(host=="debug.m3MM7UcOEr3qP3ZK") {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " debug.m3MM7UcOEr3qP3ZK: " << this->fd << " " << this << std::endl;
        #endif
        std::string reply("X-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\n");
        reply+="Current time: ";
        reply+=std::to_string(Common::msFrom1970());
        reply+="\r\n";
        reply+="Dns ("+std::to_string(Dns::dns->get_httpInProgress())+"): ";
        reply+=Dns::dns->getQueryList();
        //reply+="\r\n";
        size_t isNotValideCount=0;
        for( const auto &n : Client::clients )
            if(!n->isValid())
                isNotValideCount++;
        reply+="Clients: ";
        reply+=std::to_string(Client::clients.size());
        if(isNotValideCount>0)
            reply+=", "+std::to_string(isNotValideCount)+" not valid";
        {
            std::stringstream strm;
            strm << this;
            reply+=" (this: "+strm.str()+")";
        }
        reply+="\r\n";
        #ifdef DEBUGFASTCGI
        for (const Client * c : Client::clients)
            reply+=c->getStatus()+"\r\n";
        reply+="Backend: "+std::to_string(Backend::backendToDebug.size())+"\r\n";
        #endif
        reply+="Http: ";
        #ifdef DEBUGFASTCGI
        reply+="(http "+std::to_string(Http::httpToDebug.size()-Https::toDebug.size())+" and https "+std::to_string(Https::toDebug.size())+" backend)";
        std::unordered_set<const Http *> notIntoTheList;
        notIntoTheList.insert(Http::httpToDebug.begin(),Http::httpToDebug.end());
        #endif
        reply+="\r\n";
        {
            std::string ret;
            for( const auto &n : Http::pathToHttp )
            {
                const Http * const client=n.second;
                if(client!=nullptr)
                {
                    ret+="http "+client->getQuery();

                    {
                        std::string ret;
                        char buffer[32];
                        std::snprintf(buffer,sizeof(buffer),"%p",(void *)client->backend);
                        ret+=" backend "+std::string(buffer);
                    }
                    {
                        std::string ret;
                        char buffer[32];
                        std::snprintf(buffer,sizeof(buffer),"%p",(void *)client->backendList);
                        ret+=" backendList "+std::string(buffer);
                    }

                    ret+="\r\n";
                }
                #ifdef DEBUGFASTCGI
                notIntoTheList.erase(client);
                #endif
            }
            for( const auto &n : Https::pathToHttps )
            {
                const Http * const client=n.second;
                if(client!=nullptr)
                    ret+="https "+client->getQuery()+"\r\n";
                #ifdef DEBUGFASTCGI
                notIntoTheList.erase(client);
                #endif
            }
            for( const auto &n : Backend::addressToHttp )
            {
                in6_addr sin6_addr;
                memcpy(&sin6_addr,n.first.data(),16);

                std::string host="Unknown IPv6";
                char str[INET6_ADDRSTRLEN];
                if (inet_ntop(AF_INET6, n.first.data(), str, INET6_ADDRSTRLEN) != NULL)
                    host=str;

                ret+="backend http \""+host+"\"\r\n";
                if(n.second!=nullptr)
                {
                    ret+="busy:\r\n";
                    {
                        const std::vector<Backend *> &backend=n.second->busy;
                        for( const auto &m : backend )
                            if(m!=nullptr)
                                ret+=m->getQuery()+"\r\n";
                    }
                    ret+="idle:\r\n";
                    {
                        const std::vector<Backend *> &backend=n.second->idle;
                        for( const auto &m : backend )
                            if(m!=nullptr)
                                ret+=m->getQuery()+"\r\n";
                    }
                    ret+="pending:\r\n";
                    {
                        const std::vector<Http *> &pending=n.second->pending;
                        for( const auto &m : pending )
                            if(m!=nullptr)
                                ret+=m->getQuery()+"\r\n";
                    }
                }
                else
                    ret+="no backend list\"\r\n";
            }
            for( const auto &n : Backend::addressToHttps )
            {
                in6_addr sin6_addr;
                memcpy(&sin6_addr,n.first.data(),16);

                std::string host="Unknown IPv6";
                char str[INET6_ADDRSTRLEN];
                if (inet_ntop(AF_INET6, n.first.data(), str, INET6_ADDRSTRLEN) != NULL)
                    host=str;

                ret+="backend https \""+host+"\"\r\n";
                if(n.second!=nullptr)
                {
                    ret+="busy:\r\n";
                    {
                        const std::vector<Backend *> &backend=n.second->busy;
                        for( const auto &m : backend )
                            if(m!=nullptr)
                                ret+=m->getQuery()+"\r\n";
                    }
                    ret+="idle:\r\n";
                    {
                        const std::vector<Backend *> &backend=n.second->idle;
                        for( const auto &m : backend )
                            if(m!=nullptr)
                                ret+=m->getQuery()+"\r\n";
                    }
                    ret+="pending:\r\n";
                    {
                        const std::vector<Http *> &pending=n.second->pending;
                        for( const auto &m : pending )
                            if(m!=nullptr)
                                ret+=m->getQuery()+"\r\n";
                    }
                }
                else
                    ret+="no backend list\"\r\n";
            }
            reply+=ret;
        }
        reply+="\r\n";
        #ifdef DEBUGFASTCGI
        for (const Http * const x: notIntoTheList)
            reply+="lost http(s) "+x->getQuery()+"\r\n";
        #endif
        addHeaderAndWrite(reply.data(),reply.size());
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN end of stats" << std::endl;
    #endif
        internalWriteEnd();
        disconnect();
        return;
    }

    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
    #endif
    status=Status_WaitTheContent;
    partial=false;

    #ifdef HOSTSUBFOLDER
    {
        std::string hostwithprotocol=host;
        if(https)
            hostwithprotocol+="s";
        const uint32_t &hashhost=static_cast<uint32_t>(XXH3_64bits(hostwithprotocol.data(),hostwithprotocol.size()));
        const XXH64_hash_t &hashuri=XXH3_64bits(uri.data(),uri.size());

        //do the hash for host to define cache subfolder, hash for uri to file

        //Cache::hostsubfolder should not be changed at runtime
        Common::binarytoHexaC32Bits(reinterpret_cast<const char *>(&hashhost),folderVar);
        memcpy(pathVar,folderVar,4);

        Common::binarytoHexaC64Bits(reinterpret_cast<const char *>(&hashuri),pathVar+8+1);
        if(gzip)
            pathVar[8+1+16]='G';
        else
            pathVar[8+1+16]='R';
    }
    #else
    {
        //Cache::hostsubfolder should not be changed at runtime
        //then don't touch folderVar
        //folderVar[6]='\0';

        // System libxxhash hides the state struct's layout; use the
        // heap-allocated public API. Allocation is small (~570 bytes,
        // SIMD-aligned) and happens once per request — well below the
        // existing per-request work budget.
        XXH3_state_t *state = XXH3_createState();
        XXH3_64bits_reset(state);
        if(https)
            XXH3_64bits_update(state, "S",1);
        XXH3_64bits_update(state, host.data(),host.size());
        XXH3_64bits_update(state, uri.data(),uri.size());
        const XXH64_hash_t hashuri=XXH3_64bits_digest(state);
        XXH3_freeState(state);

        Common::binarytoHexaC64Bits(reinterpret_cast<const char *>(&hashuri),pathVar);
        if(gzip)
            pathVar[16]='G';
        else
            pathVar[16]='R';
    }
    #endif
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " pathVar: " << pathVar << std::endl;
    #endif
    #ifdef HOSTSUBFOLDER
    const std::string pathForIndex(pathVar,26);
    #else
    const std::string pathForIndex(pathVar,17);
    #endif
    bool httpBackendFound=false;
    if(http==nullptr)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
        if(!https)
        {
            if(Http::pathToHttp.find(pathForIndex)!=Http::pathToHttp.cend())
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
                #endif
                if(!Http::pathToHttp.at(pathForIndex)->isAlive())
                {
                    std::cerr << this << " http " << pathForIndex << " is not alive" << __FILE__ << ":" << __LINE__ << std::endl;
                    Http *http=Http::pathToHttp.at(pathForIndex);
                    Http::pathToHttp.erase(pathForIndex);
                    http->disconnectFrontend(true);
                    http->disconnectBackend();
                    //delete http;->do into http->disconnectBackend();
                }
                else
                {
                    httpBackendFound=true;
                    http=Http::pathToHttp.at(pathForIndex);
                    http->addClient(this);//into this call, start open cache and stream if partial have started
                }
            }
        }
        else
        {
            if(Https::pathToHttps.find(pathForIndex)!=Https::pathToHttps.cend())
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
                #endif
                if(!Https::pathToHttps.at(pathForIndex)->isAlive())
                {
                    std::cerr << this << " http " << pathForIndex << " is not alive" << __FILE__ << ":" << __LINE__ << std::endl;
                    Http *http=Https::pathToHttps.at(pathForIndex);
                    Https::pathToHttps.erase(pathForIndex);
                    http->disconnectFrontend(true);
                    http->disconnectBackend();
                    //delete http;->do into http->disconnectBackend();
                }
                else
                {
                    httpBackendFound=true;
                    http=Https::pathToHttps.at(pathForIndex);
                    http->addClient(this);//into this call, start open cache and stream if partial have started
                }
            }
        }
    }
    else
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
        httpBackendFound=true;
    }
    if(!httpBackendFound)
    //if(true)
    {
        struct stat sb;
        #if defined(DEBUGFASTCGI) || defined(DEBUGFILEOPEN)
        struct stat sb2;
        #endif
        std::string url;
        if(https)
            url="https://";
        else
            url="http://";
        url+=host;
        url+=uri;
        //try open cache
        #ifdef DEBUGFASTCGI
        const bool cacheWasExists=stat(pathVar,&sb)==0;
        if(cacheWasExists)
        {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " cache size: " << sb.st_size << std::endl;}
        #endif
        //std::cerr << "open(pathVar " << pathVar << std::endl;
        int cachefd = open(pathVar, O_RDWR | O_NOCTTY/* | O_NONBLOCK*/, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        #ifdef DEBUGFASTCGI
        const bool cacheWasExists3=stat(pathVar,&sb)==0;
        if(cacheWasExists3)
        {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " cache size: " << sb.st_size << std::endl;}
        #endif
        //if failed open cache
        if(cachefd==-1)
        {
            #ifdef DEBUGFASTCGI
            const bool cacheWasExists4=stat(pathVar,&sb)==0;
            if(cacheWasExists4)
            {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " cache size: " << sb.st_size << " exists, should not, errno: " << errno << std::endl;}
            #endif
            if(errno!=2)//if not file not found
                std::cerr << "can't open cache file " << pathForIndex << " for " << url << " due to errno: " << errno << std::endl;
            #ifdef HOSTSUBFOLDER
                ::mkdir(folderVar,S_IRWXU);
            #endif

            /*if(status==Status_WaitTheContent)
            {
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " status==Status_WaitTheContent (abort)" << std::endl;
                abort();
            }*/
            createHttpBackend();
            return;
        }
        else
        {
            #ifdef DEBUGFASTCGI
            const bool cacheWasExists2=stat(pathVar,&sb)==0;
            fstat(cachefd,&sb2);
            if(!cacheWasExists)
            {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " cache created into wrong way" << std::endl;}
            if(!cacheWasExists && cacheWasExists2)
            {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " cache created into wrong way 2" << std::endl;}
            #endif
            #ifdef DEBUGFILEOPEN
            stat(pathVar,&sb);
            fstat(cachefd,&sb2);
            std::cerr << "Client::loadUrl() open: " << pathForIndex << ", fd: " << cachefd << ", size real:" << sb.st_size << ", " << url << ", size open: " << sb2.st_size << std::endl;
            #endif
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
            #endif
            if(!ifNoneMatch.empty())
            {
                char bufferETag[6];
                if(::pread(cachefd,bufferETag,sizeof(bufferETag),2*sizeof(uint64_t)+sizeof(uint16_t))==sizeof(bufferETag))
                {
                    if(memcmp(ifNoneMatch.substr(1,6).data(),bufferETag,sizeof(bufferETag))==0)
                    {
                        //frontend 304
                        char text[]="Status: 304 Not Modified\r\n\r\n";
                        addHeaderAndWrite(text,sizeof(text)-1);
                        #ifdef DEBUGFASTCGI
                        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN 304" << std::endl;
                        #endif
                        internalWriteEnd();
                        disconnect();
                        #ifdef DEBUGFILEOPEN
                        std::cerr << "Client::loadUrl(), readCache close: " << cachefd << std::endl;
                        #endif
                        #ifdef DEBUGFASTCGI
                        std::cerr << "close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                        #endif
                        if(cachefd!=-1)
                            ::close(cachefd);
                        cachefd=-1;
                        return;
                    }
                }
            }

            fstat(cachefd,&sb);
            #ifdef DEBUGFASTCGI
            {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " cache size: " << sb.st_size << std::endl;}
            #endif
            if(sb.st_size<25)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << "close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
                if(cachefd!=-1)
                    ::close(cachefd);
                cachefd=-1;
                std::cerr << "corruption detected, new file? for " << pathForIndex << " url: " << url << std::endl;

                createHttpBackend();
                return;
            }
            uint64_t lastModificationTimeCheck=0;
            if(::pread(cachefd,&lastModificationTimeCheck,sizeof(lastModificationTimeCheck),1*sizeof(uint64_t))!=sizeof(lastModificationTimeCheck))
            {
                #ifdef DEBUGFASTCGI
                std::cerr << "close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
                if(cachefd!=-1)
                    ::close(cachefd);
                cachefd=-1;
                std::cerr << "corruption detected, bug? for " << pathForIndex << " url: " << url << std::endl;

                createHttpBackend();
                return;

                lastModificationTimeCheck=0;
            }
            uint16_t http_code=500;
            if(::pread(cachefd,&http_code,sizeof(http_code),2*sizeof(uint64_t))!=sizeof(http_code))
            {
                #ifdef DEBUGFASTCGI
                std::cerr << "close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
                if(cachefd!=-1)
                    ::close(cachefd);
                cachefd=-1;
                std::cerr << "corruption detected, bug? for " << pathForIndex << " url: " << url << std::endl;

                createHttpBackend();
                return;

                http_code=500;
            }
            //last modification time check <24h or in future to prevent time drift
            // lastModificationTimeCheck is stored in milliseconds (see Http.cpp where it's
            // set to Common::msFrom1970()); compare in milliseconds so the TTL boundary
            // (--http200Time) can be observed at sub-second precision.
            const uint64_t currentTime=time(NULL);
            const uint64_t currentTimeMs=Common::msFrom1970();
            // Cache header sanity check: a file whose lmtc is wildly out of bounds, or
            // whose http_code isn't a valid HTTP status, is likely corrupt (e.g. a
            // partial write, or an attacker / fuzzed file in the cache dir). Treat as
            // a miss rather than serving garbage to clients — also prevents corrupted
            // FastCGI bytes from reaching nginx ("unsupported FastCGI protocol version").
            const uint64_t maxFutureDriftMs = 24ULL*3600ULL*1000ULL;
            const uint64_t maxAgeMs = 30ULL*365ULL*24ULL*3600ULL*1000ULL;
            const bool lmtcUnreasonable =
                (lastModificationTimeCheck > currentTimeMs + maxFutureDriftMs) ||
                (currentTimeMs > maxAgeMs && lastModificationTimeCheck != 0 &&
                 lastModificationTimeCheck < currentTimeMs - maxAgeMs);
            const bool httpCodeUnreasonable = (http_code < 100 || http_code >= 600);
            if(lmtcUnreasonable || httpCodeUnreasonable)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex
                          << " cache header sanity fail (lmtc=" << lastModificationTimeCheck
                          << " http_code=" << http_code << "), treat as miss" << std::endl;
                #endif
                if(cachefd!=-1)
                    ::close(cachefd);
                cachefd=-1;
                ::unlink(pathVar);
                #ifdef HOSTSUBFOLDER
                ::mkdir(folderVar,S_IRWXU);
                #endif
                createHttpBackend();
                return;
            }
            const uint64_t timeToCacheMs=(uint64_t)Cache::timeToCache(http_code)*1000ULL;
            if(lastModificationTimeCheck>currentTimeMs)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " lastModificationTimeCheck>currentTimeMs, time drift?" << std::endl;
                #endif
                lastModificationTimeCheck=currentTimeMs;
            }
            if(lastModificationTimeCheck+timeToCacheMs>currentTimeMs)
            {
                //from cache load (too recent to check)
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
                #endif
                // Frontend Range: if the client sent Range and the cache is fresh,
                // serve a slice as 206 directly (or 416 if out of range). Malformed
                // Range header → falls through to normal 200 serve.
                if(!rangeHeader.empty())
                {
                    if(serveRangeFromWarmCache(cachefd))
                    {
                        if(cachefd!=-1) ::close(cachefd);
                        cachefd=-1;
                        return;
                    }
                }
                if(readCache!=nullptr)
                {
                    delete readCache;
                    readCache=nullptr;
                }
                readCache=new Cache(cachefd,this);
                readCache->set_access_time(currentTime);
                #ifdef DEBUGFASTCGI
                std::cerr << "startRead() " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
                if(startRead())
                    return;
                else//corrupted, then recreate
                {
                    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " corrupted, delete to recreate" << std::endl;
                    #ifdef DEBUGFASTCGI
                    std::cerr << "close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                    #endif
                    if(cachefd!=-1)
                        ::close(cachefd);
                    cachefd=-1;
                    #ifdef DEBUGFASTCGI
                    std::cout << __FILE__ << ":" << __LINE__ << " ::unlink(" << pathVar << std::endl;
                    #endif
                    ::unlink(pathVar);
                }
            }
            else
            {
                //http 304 load
                #ifdef DEBUGFILEOPEN
                std::cerr << "Client::loadUrl(), readCache close: " << cachefd << ", " << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
                #ifdef DEBUGFASTCGI
                std::cerr << lastModificationTimeCheck << "+" << timeToCacheMs << "<=" << currentTimeMs << "ms close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
                //without the next line descriptor lost, generate: errno 24 (Too many open files)
                if(cachefd!=-1)
                    ::close(cachefd);
                cachefd=-1;
            }

            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
            #endif
            #ifdef HOSTSUBFOLDER
                ::mkdir(folderVar,S_IRWXU);
            #endif

            createHttpBackend();
            return;
        }
    }
    else
    {
        #ifdef DEBUGFASTCGI
        std::cerr << "startRead() " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
        #endif
        /* this case is used when:
         * Http add client: this client fd: X isAlive: 1 getEndDetected(): 1 getFileMoved(): 1
         * when the file was downloaded fully, but uploading to another client */
        // http may have been nulled out as a side-effect of addClient() above —
        // e.g. addClient hits the "dead http" branch and triggers httpError →
        // disconnect() → Http::removeClient sets client->http = nullptr. Without
        // this guard, high-rate flapping (many clients churning through the
        // de-dup join path) trips a UBSan null-deref here (multi_client_high_rate
        // _flapping_stress crash). The Client is already being disconnected, so
        // there's nothing to do.
        if(http!=nullptr &&
           (http->headerWriten || http->getEndDetected() || http->getFileMoved()))
            startRead(pathVar,true);
    }
}

#ifdef DEBUGFASTCGI
std::string Client::getStatus() const
{
    std::string s;
    {
        std::stringstream strm;
        strm << this;
        s+=strm.str()+" ";
    }
    switch(status)
    {
    case Status_Idle:
        s+="Status_Idle";
        break;
    case Status_WaitTheContent:
        s+="Status_WaitTheContent";
        break;
    default:
        s+="Status_???";
        break;
    }
    s+=" "+std::to_string(fastcgi_id);
    s+=" "+std::to_string(fd);
    if(fullyParsed)
        s+=" fullyParsed";
    else
        s+=" !fullyParsed";
    if(dataToWrite.empty())
        s+=" dataToWrite.empty()";
    else
        s+=" !dataToWrite.empty()";
    if(gzip)
        s+=" gzip";
    else
        s+=" !gzip";
    if(partial)
        s+=" partial";
    else
        s+=" !partial";
    if(partialEndOfFileTrigged)
        s+=" partialEndOfFileTrigged";
    else
        s+=" !partialEndOfFileTrigged";
    if(outputWrited)
        s+=" outputWrited";
    else
        s+=" !outputWrited";
    if(https)
        s+=" https://";
    else
        s+=" http://";
    s+=host;
    s+=uri;
    s+=" ";
    {
        std::stringstream strm;
        strm << http;
        s+=" "+strm.str();
    }
    return s;
}
#endif

bool Client::canAddToPos(const int &i, const int &size, int &pos)
{
    if((pos+i)>size)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
        /*disconnect();-> request can be too big, then need buffer, don't disconnect!
         * cause: 2022/06/24 06:35:18 [error] 34889#34889: *1 recv() failed (104: Connection reset by peer) while reading response header from upstream, client: 2803:1920::2:10, server: cdn.confiared.com, request: "GET /ultracopier.first-world.info/css/style.min.css HTTP/2.0", upstream: "fastcgi://127.0.0.1:5556", host: "cdn.confiared.com", referrer: "https://ultracopier.first-world.info/" */
        return false;
    }
    pos+=i;
    return true;
}

bool Client::read8Bits(uint8_t &var, const char * const data, const int &size, int &pos)
{
    if((pos+(int)sizeof(var))>size)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
        /*disconnect();-> request can be too big, then need buffer, don't disconnect!
         * cause: 2022/06/24 06:35:18 [error] 34889#34889: *1 recv() failed (104: Connection reset by peer) while reading response header from upstream, client: 2803:1920::2:10, server: cdn.confiared.com, request: "GET /ultracopier.first-world.info/css/style.min.css HTTP/2.0", upstream: "fastcgi://127.0.0.1:5556", host: "cdn.confiared.com", referrer: "https://ultracopier.first-world.info/" */
        return false;
    }
    var=data[pos];
    pos+=sizeof(var);
    return true;
}

bool Client::read16Bits(uint16_t &var, const char * const data, const int &size, int &pos)
{
    if((pos+(int)sizeof(var))>size)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
        /*disconnect();-> request can be too big, then need buffer, don't disconnect!
         * cause: 2022/06/24 06:35:18 [error] 34889#34889: *1 recv() failed (104: Connection reset by peer) while reading response header from upstream, client: 2803:1920::2:10, server: cdn.confiared.com, request: "GET /ultracopier.first-world.info/css/style.min.css HTTP/2.0", upstream: "fastcgi://127.0.0.1:5556", host: "cdn.confiared.com", referrer: "https://ultracopier.first-world.info/" */
        return false;
    }
    uint16_t t;
    memcpy(&t,data+pos,sizeof(var));
    var=be16toh(t);
    pos+=sizeof(var);
    return true;
}

bool Client::read24Bits(uint32_t &var, const char * const data, const int &size, int &pos)
{
    if((pos+(int)sizeof(var)-1)>size)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
        /*disconnect();-> request can be too big, then need buffer, don't disconnect!
         * cause: 2022/06/24 06:35:18 [error] 34889#34889: *1 recv() failed (104: Connection reset by peer) while reading response header from upstream, client: 2803:1920::2:10, server: cdn.confiared.com, request: "GET /ultracopier.first-world.info/css/style.min.css HTTP/2.0", upstream: "fastcgi://127.0.0.1:5556", host: "cdn.confiared.com", referrer: "https://ultracopier.first-world.info/" */
        return false;
    }
    uint32_t t=0;
    memcpy(reinterpret_cast<char *>(&t)+1,data+pos,sizeof(var)-1);
    var=be32toh(t);
    pos+=sizeof(var)-1;
    return true;
}

void Client::createHttpBackend()
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " Client::createHttpBackend()" << std::endl;
    #endif

    #ifdef HOSTSUBFOLDER
    const std::string pathForIndex(pathVar,26);
    #else
    const std::string pathForIndex(pathVar,17);
    #endif

    //if was not found into loadurl but here mean need be loaded
    if(http==nullptr)
    {
        std::string url;
        if(https)
            url="https://";
        else
            url="http://";
        url+=host;
        url+=uri;
        #ifdef DEBUGFASTCGI
        struct stat sb;
        const bool cacheWasExists=stat(pathVar,&sb)==0;
        if(cacheWasExists)
        {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " cache size: " << sb.st_size << " pathVar: " << pathVar << std::endl;}
        #endif
        //try open cache
        //std::cerr << "open((path).c_str() " << path << std::endl;
        int cachefd = open(pathVar, O_RDWR | O_NOCTTY/* | O_NONBLOCK*/, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        //if failed open cache in write mode
        if(cachefd==-1)
        {
            cachefd=0;
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
            #endif
            if(errno!=2)//if not file not found
                std::cerr << "can't open cache file " << pathForIndex << " for " << url << " due to errno: " << errno << std::endl;
            #ifdef HOSTSUBFOLDER
                ::mkdir(folderVar,S_IRWXU);
            #endif

            createHttpBackendInternal(0);
        }
        else
        {
            //to debug
            if(uri.find("-setup.exe")!=std::string::npos && uri.find("ultracopier")!=std::string::npos)
            {
                struct stat sb;
                if(fstat(cachefd,&sb)==0)
                {
                    if(sb.st_size<10000000)
                    {
                        std::cerr << this << " exe cache ultracopier seam too small " << host << "/" << uri << " pathVar " << pathVar << " " << __FILE__ << ":" << __LINE__ << std::endl;
                        #ifdef DEBUGFASTCGI
                        std::cerr << getStatus() << std::endl;
                        #endif
                    }
                }
                else
                    std::cerr << this << " exe get cache size failed errno " << errno << " ultracopier seam too small " << host << "/" << uri << " pathVar " << pathVar << " " << __FILE__ << ":" << __LINE__ << std::endl;
            }

            #ifdef DEBUGFASTCGI
            const bool cacheWasExists2=stat(pathVar,&sb)==0;
            if(!cacheWasExists)
            {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " cache created into wrong way" << std::endl;}
            if(!cacheWasExists && cacheWasExists2)
            {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " cache created into wrong way 2" << std::endl;}
            #endif
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
            #endif
            #ifdef DEBUGFILEOPEN
            std::cerr << "Client::dnsRight() open: " << pathForIndex << ", fd: " << cachefd << std::endl;
            #endif
            uint64_t lastModificationTimeCheck=0;
            if(::pread(cachefd,&lastModificationTimeCheck,sizeof(lastModificationTimeCheck),1*sizeof(uint64_t))!=sizeof(lastModificationTimeCheck))
                lastModificationTimeCheck=0;
            uint16_t http_code=500;
            if(::pread(cachefd,&http_code,sizeof(http_code),2*sizeof(uint64_t))!=sizeof(http_code))
                http_code=500;
            //last modification time check <24h or in future to prevent time drift
            // see loadUrl above: lmtc is stored in milliseconds for sub-second TTL precision.
            const uint64_t currentTime=time(NULL);
            const uint64_t currentTimeMs=Common::msFrom1970();
            const uint64_t timeToCacheMs=(uint64_t)Cache::timeToCache(http_code)*1000ULL;
            if(lastModificationTimeCheck+timeToCacheMs>currentTimeMs)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
                #endif
                if(readCache!=nullptr)
                {
                    delete readCache;
                    readCache=nullptr;
                }
                readCache=new Cache(cachefd,this);
                readCache->set_access_time(currentTime);
                #ifdef DEBUGFASTCGI
                std::cerr << "startRead() " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
                if(startRead())
                    return;
                else//corrupted, then recreate
                {
                    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << pathForIndex << " corrupted, delete to recreate" << std::endl;
                    #ifdef DEBUGFASTCGI
                    std::cerr << "close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                    #endif
                    if(cachefd!=-1)
                        ::close(cachefd);
                    #ifdef DEBUGFASTCGI
                    std::cout << __FILE__ << ":" << __LINE__ << " ::unlink(" << pathVar << std::endl;
                    #endif
                    ::unlink(pathVar);
                }
                return;
            }
            #ifdef HOSTSUBFOLDER
                ::mkdir(folderVar,S_IRWXU);
            #endif

            //get the ETag to compare with client
            std::string etag;
            {
                uint8_t etagBackendSize=0;
                if(::pread(cachefd,&etagBackendSize,sizeof(etagBackendSize),3*sizeof(uint64_t))==sizeof(etagBackendSize))
                {
                    char buffer[etagBackendSize];
                    if(::pread(cachefd,buffer,etagBackendSize,3*sizeof(uint64_t)+sizeof(uint8_t))==etagBackendSize)
                    {
                        etag=std::string(buffer,etagBackendSize);
                        #ifdef DEBUGFASTCGI
                        if(etag.find('\0')!=std::string::npos)
                        {
                            #ifdef DEBUGFASTCGI
                            std::cerr << "close() fd: " << cachefd << " " << this << " " << __FILE__ << ":" << __LINE__ << std::endl;
                            #endif
                            if(cachefd!=-1)
                                ::close(cachefd);
                            cachefd=-1;
                            etag="etag contain \\0 abort";
                            #ifdef DEBUGFASTCGI
                            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
                            #endif
                            status=Status_Idle;
                            char text[]="Status: 500 Internal Server Error\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nInternal error etag 0";
                            #ifdef DEBUGFASTCGI
                            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN internal error etag 0" << std::endl;
                            #endif
                            addHeaderAndWrite(text,sizeof(text)-1);
                            internalWriteEnd();
                            disconnect();
                            return;
                        }
                        #endif
                    }
                }
            }
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
            #endif

            createHttpBackendInternal(cachefd,etag);
        }
    }
    else
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " Client::createHttpBackend() already http backend (abort)" << std::endl;
        abort();
    }
}

void Client::createHttpBackendInternal(int cachefd, std::string etag)
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " cachefd: " << cachefd << " " << this << " Client::createHttpBackendInternal()" << std::endl;
    #endif
    #ifdef HOSTSUBFOLDER
    const std::string pathForIndex(pathVar,26);
    #else
    const std::string pathForIndex(pathVar,17);
    #endif
    if(https)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " cachefd: " << cachefd << " " << this << std::endl;
        #endif
        Https *https=new Https(cachefd, //0 if no old cache file found
                              pathForIndex,this);
        if(https->tryConnect(host,uri,gzip,etag))
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " Client::createHttpBackendInternal() have successful connect" << std::endl;
            #endif
        }
        else
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " Http::dnsError()" << std::endl;
            #endif
            //Http::dnsError()
            return;
        }
        if(http==nullptr || fastcgi_id==-1 || fd==-1)//then tryConnect() have disconnected it, eg: cached Http::dnsError()
            return;
        if(Https::pathToHttps.find(pathForIndex)==Https::pathToHttps.cend())
        {
            #ifdef DEBUGFASTCGI
            if(http->cachePath.empty())
            {
                std::cerr << "Client::dnsRight(), http->cachePath.empty() can't be empty if add to Http::pathToHttp " << pathForIndex << " " << (void *)http << " " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << std::endl;
                abort();
            }
            #endif
            Https::pathToHttps[pathForIndex]=https;
        }
        else
        {
            std::cerr << "Https::pathToHttps.find(" << pathForIndex << ") already found, abort()" << std::endl;
            abort();
        }
    }
    else
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " cachefd: " << cachefd << " " << this << std::endl;
        #endif
        if(http!=nullptr)
        {
            if(!http->removeClient(this))
            {
                #ifdef DEBUGFASTCGI
                std::cerr << this << " not into client list of " << http << __FILE__ << ":" << __LINE__ << std::endl;
                #endif
            }
        }
        http=new Http(cachefd, //0 if no old cache file found
                              pathForIndex,this);
        if(http->tryConnect(host,uri,gzip,etag))
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << "http->tryConnect() ok" << std::endl;
            #endif
        }
        else
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " Http::dnsError()" << std::endl;
            #endif
            //Http::dnsError()
            return;
        }
        if(http==nullptr || fastcgi_id==-1 || fd==-1)//then tryConnect() have disconnected it, eg: cached Http::dnsError()
            return;
        if(Http::pathToHttp.find(pathForIndex)==Http::pathToHttp.cend())
        {
            #ifdef DEBUGFASTCGI
            if(http->cachePath.empty())
            {
                std::cerr << "Client::dnsRight(), http->cachePath.empty() can't be empty if add to Http::pathToHttp " << pathForIndex << " " << (void *)http << " " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << std::endl;
                abort();
            }
            #endif
            Http::pathToHttp[pathForIndex]=http;
        }
        else
        {
            std::cerr << "Http::pathToHttp.find(" << pathForIndex << ") already found, abort()" << std::endl;
            abort();
        }
    }
}

bool Client::startRead()
{
    if(readCache==nullptr)
        return false;
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " Client::startRead()" << std::endl;
    #endif
    if(!readCache->seekToContentPos())
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " Client::startRead(): !readCache->seekToContentPos(), cache corrupted?" << std::endl;
        status=Status_Idle;
        char text[]="Status: 500 Internal Server Error\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nUnable to read cache (1)";
        addHeaderAndWrite(text,sizeof(text)-1);
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN unable to read cache" << std::endl;
        #endif
        internalWriteEnd();
        disconnect();
        return false;
    }
    //readCache->setAsync();
    if(!readCache->seekToContentPos())
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " Client::startRead(): !readCache->seekToContentPos(), cache corrupted bis?" << std::endl;
        return false;
    }
    continueRead();
    return true;
}

bool Client::startRead(const std::string &path, const bool &partial)
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " partial: " << partial << std::endl;
    #endif

    //to drop dual event
    if(readCache!=nullptr)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " drop dual event" << std::endl;
        #endif
        return true;
    }

    this->partial=partial;
    //O_WRONLY -> failed, need Read too call Cache::seekToContentPos(), read used to get pos
    #ifdef DEBUGFASTCGI
    struct stat sb;
    const bool cacheWasExists=stat(path.c_str(),&sb)==0;
    if(cacheWasExists)
    {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " " << path.c_str() << " cache size: " << sb.st_size << std::endl;}
    #endif
    errno=0;
    int cachefd = ::open(path.c_str(), O_RDWR | O_NOCTTY/* | O_NONBLOCK*/, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    const int temperrno=errno;
    if(cachefd>=0)
    {
        // Tell the kernel we'll stream the body sequentially via sendfile so it
        // can do larger readahead. The cache-header pread()s before
        // seekToContentPos are random-access but cheap (≤25 bytes total) — the
        // hint pays off on the body, which dominates wall time on cold-page-
        // cache 10 MB / 100 MB hits.
        ::posix_fadvise(cachefd, 0, 0, POSIX_FADV_SEQUENTIAL);
    }
    //if failed open cache
    if(cachefd==-1)
    {
        //workaround internal bug cache PATH, -> suspect this generated corrupted cache, blocked now by random cache name
        /*const std::string temppath=path+".tmp";
        int cachefd = ::open(temppath.c_str(), O_RDWR | O_NOCTTY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        const int temperrno2=errno;*/
        const int temperrno2=errno;
        //if failed open cache
        if(cachefd==-1)
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN unable to read cache 2 " << path << ", errno: " << temperrno << ", errno2: " << temperrno2 << ", partial: " << partial << std::endl;
            struct dirent *dp;
            DIR *dfd = opendir(".");
            if(dfd != NULL) {
                while((dp = readdir(dfd)) != NULL)
                    printf("%s ", dp->d_name);
                closedir(dfd);
            }
            printf("\n");
            #endif
            status=Status_Idle;
            char text[]="Status: 500 Internal Server Error\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nUnable to read cache (2)";
            addHeaderAndWrite(text,sizeof(text)-1);
            internalWriteEnd();
            disconnect();
            return false;
        }
    }

    #ifdef DEBUGFASTCGI
    const bool cacheWasExists2=stat(path.c_str(),&sb)==0;
    if(!cacheWasExists)
    {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " cache created into wrong way" << std::endl;}
    if(!cacheWasExists && cacheWasExists2)
    {std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " cache created into wrong way 2" << std::endl;}
    #endif
    #ifdef DEBUGFILEOPEN
    std::cerr << "Client::startRead() open: " << path << ", fd: " << cachefd << std::endl;
    #endif

    const off_t &s=lseek(cachefd,1*sizeof(uint64_t),SEEK_SET);
    if(s==-1)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " unable to seek" << std::endl;
        status=Status_Idle;
        char text[]="Status: 500 Internal Server Error\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nUnable to seek";
        addHeaderAndWrite(text,sizeof(text)-1);
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN unable to seek" << std::endl;
        #endif
        internalWriteEnd();
        disconnect();
        return false;
    }
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
    #endif
    const uint64_t &currentTime=time(NULL);
    if(readCache!=nullptr)
    {
        delete readCache;
        readCache=nullptr;
    }
    readCache=new Cache(cachefd,this);
    readCache->set_access_time(currentTime);
    if(!readCache->seekToContentPos())
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " unable to seek to content" << std::endl;
        status=Status_Idle;
        char text[]="Status: 500 Internal Server Error\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nUnable to seek to content";
        addHeaderAndWrite(text,sizeof(text)-1);
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN unable to seek to content" << std::endl;
        #endif
        internalWriteEnd();
        disconnect();
        return false;
    }
    return startRead();
}

void Client::tryResumeReadAfterEndOfFile()
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " Client::tryResumeReadAfterEndOfFile(): " << bodyAndHeaderFileBytesSended << std::endl;
    #endif
    if(partialEndOfFileTrigged)
        continueRead();
    else
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " Client::tryResumeReadAfterEndOfFile() workaround: " << bodyAndHeaderFileBytesSended << std::endl;
        #endif
        //continueRead() include into readyToWrite() -> continueRead();//workaround
        readyToWrite();
    }
}

void Client::writeOutputDropDataIfNeeded(const char * const data,const size_t &size)
{
    //send in progress, drop data because the client can't receive more
    if(!dataToWrite.empty())
        return;
    //ignore if can't push, just drop data because is streaming
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " pushWithoutWriting(), write not buffer : " << Common::binarytoHexa(data,size) << std::endl;
    #endif
    errno=0;
    if(fd!=-1)
        addHeaderAndWrite(data,size);
}

void Client::continueRead()
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " " << this << " Client::continueRead() start" << std::endl;
    #endif
    #ifdef DEBUGFASTCGI
    Http::checkIngrityHttpClient();
    #endif
    if(readCache==nullptr)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " " << this << " Client::continueRead() readCache==nullptr" << std::endl;
        #endif
        return;
    }
    if(!dataToWrite.empty())
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " " << this << " Client::continueRead() !dataToWrite.empty()" << std::endl;
        #endif
        return;
    }
    /* NEVER DO THIS! generate bug
     * if(http!=nullptr)
        http->readyToRead();*/
    #ifdef DEBUGFASTCGI
    if(http)
        std::cerr << std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count() << " " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " http " << http << " http->cachePath: " << http->cachePath << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
    else
        std::cerr << std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count() <<  " " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
    #endif
    #ifdef DEBUGFASTCGI
    Http::checkIngrityHttpClient();
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
    #endif
    // Per-call cap on sendfile. The cache file already contains FastCGI-framed
    // bytes, so the kernel doesn't need to respect the 64KB FastCGI record
    // boundary — set this large enough that one syscall typically fills the
    // socket buffer and the per-response syscall count drops to ~1 per drain.
    static constexpr size_t sendfileChunk=1<<20;//1 MiB
    do {
        if(readCache==nullptr)
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " " << this << " Client::continueRead() readCache==nullptr" << std::endl;
            #endif
            return;
        }
        // Linux zero-copy: stream from the cache file straight into the FastCGI
        // socket without bouncing through user space. The cache file already
        // contains FCGI_STDOUT-framed bytes (status+headers record, then body
        // chunks, then END_REQUEST), so we just blast the kernel offset forward.
        // EAGAIN means the socket is full — return and let EPOLLOUT
        // (readyToWrite -> continueRead) resume from the same seek pos.
        if(!dataToWrite.empty())
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " sendfile path: dataToWrite not empty, defer" << std::endl;
            #endif
            return;
        }
        errno=0;
        const ssize_t s=readCache->sendfileTo(fd,sendfileChunk);
        const int sendfileErrno=errno;
        if(s<0)
        {
            if(sendfileErrno==EAGAIN || sendfileErrno==EWOULDBLOCK)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " sendfile EAGAIN, wait EPOLLOUT" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                #endif
                return;
            }
            if(sendfileErrno!=EPIPE)//EPIPE: peer closed; quiet, like the write() path
            {
                switch(sendfileErrno)
                {
                    case ECONNRESET:
                        std::cerr << fd << ") sendfile error: " << sendfileErrno << " ECONNRESET Connection reset by peer" << std::endl;
                        break;
                    default:
                        std::cerr << fd << ") sendfile error: " << sendfileErrno << std::endl;
                }
            }
            disconnect();
            return;
        }
        #ifdef DEBUGFASTCGI
        //std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " continueRead(): " << s << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
        #endif
        if(s<1)
        {
            if(!partial)
            {
                #ifdef DEBUGFASTCGI
                struct stat sb;
                if(fstat(readCache->getFD(),&sb)==0)
                    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " internalWriteEnd();disconnect(); and !partial" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << " size " << sb.st_size << std::endl;
                else
                    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " internalWriteEnd();disconnect(); and !partial" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                #endif
                //outputWrited=true; -> why is this workaround?
                internalWriteEnd();
                disconnect();
            }
            else
            {
                if(http!=nullptr)
                {
                    if(http->getEndDetected())
                    {
                        partialEndOfFileTrigged=false;
                        partial=false;
                        if(dataToWrite.empty())
                        {
                            #ifdef DEBUGFASTCGI
                            std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " internalWriteEnd();disconnect(); and dataToWrite.empty()" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                            #endif
                            internalWriteEnd();
                            disconnect();
                        }
                    }
                    else
                    {
                        partialEndOfFileTrigged=true;
                        #ifdef DEBUGFASTCGI
                        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " End of file, wait more" << std::endl;
                        #endif
                    }
                }
                else
                {
                    #ifdef DEBUGFASTCGI
                    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " http!=nullptr" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                    #endif
                    if(bodyAndHeaderFileBytesSended<=0)
                    {
                        partialEndOfFileTrigged=true;
                        #ifdef DEBUGFASTCGI
                        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " End of file, wait more, bug???" << std::endl;
                        #endif
                    }
                    else
                    {
                        #ifdef DEBUGFASTCGI
                        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " internalWriteEnd();disconnect();" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                        #endif
                        partial=false;//prevent internalWriteEnd() call this method and do infinity loop
                        partialEndOfFileTrigged=false;
                        #ifdef DEBUGFASTCGI
                        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " internalWriteEnd();disconnect();" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                        #endif
                        internalWriteEnd();
                        #ifdef DEBUGFASTCGI
                        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " internalWriteEnd();disconnect();" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                        #endif
                        disconnect();
                    }
                }
            }
            return;
        }
        partialEndOfFileTrigged=false;
        #ifdef DEBUGFASTCGI
        //std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " continueRead(): " << s << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
        #endif
        if(bodyAndHeaderFileBytesSended==0)
        {
            if(s<1)
                std::cerr << "Strange, file cache is lower than acceptable size to compute bodyAndHeaderFileBytesSended, ERROR" << std::endl;//this should never happen
            else
                bodyAndHeaderFileBytesSended+=(s-1);
        }
        else
            bodyAndHeaderFileBytesSended+=s;
        // sendfile already pushed s bytes onto the FastCGI socket; mirror the
        // bytesSended/keepalive bookkeeping that Client::write() did in the
        // pre-sendfile path.
        #ifdef DEBUGFASTCGI
        bytesSended+=s;
        creationTimeOrUpdate=Common::msFrom1970();
        std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " end of read loop;" << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
        #endif
        //if can write all, try again
    } while(1);
}

void Client::cacheError()
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << std::endl;
    #endif
    status=Status_Idle;
    char text[]="Status: 500 Internal Server Error\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nCache file error";
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " CDN cache file error" << std::endl;
    #endif
    addHeaderAndWrite(text,sizeof(text)-1);
    internalWriteEnd();
    disconnect();
}

void Client::readyToWrite()
{
    #ifdef DEBUGFASTCGI
    time_t t = time(NULL);
    std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << " t: " << t << std::endl;
    #endif
    if(!dataToWrite.empty())
    {
        while(!dataToWrite.empty())
        {
            #ifdef DEBUGFASTCGI
            std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
            #endif
            errno=0;
            ssize_t writedSize=-1;
            if(fd!=-1)
                writedSize=::write(fd,dataToWrite.data(),dataToWrite.size());
            /*if(writedSize>0)
                std::cerr << this << " real write writedSize: " << writedSize << "/" << dataToWrite.size() << __FILE__ << ":" << __LINE__ <<  " : " << Common::binarytoHexa(dataToWrite.data(),writedSize)<< std::endl;*/
            #ifdef DEBUGFASTCGI
            bytesSended+=writedSize;
            #endif
            /* when nginx disconnect: errno==EPIPE
            Eg nginx log:
            upstream sent unsupported FastCGI protocol version: 0 while reading upstream, client: 2803:1920::2:10, server: cdn.confiared.com, request: "GET /ultracopier.first-world.info/files/2.2.6.1/ultracopier-windows-x86_64-2.2.6.1-setup.exe HTTP/2.0", upstream: "fastcgi://127.0.0.1:5556", host: "cdn.confiared.com" */
            if(errno!=0 && errno!=EAGAIN)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << "fd: " << fd << " errno: " << errno << " writedSize: " << writedSize << " " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                #endif
                disconnect();
                return;
            }
            if(writedSize>0)
            {
                if((size_t)writedSize==dataToWrite.size())
                {
                    #ifdef DEBUGFASTCGI
                    //std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                    #endif
                    dataToWrite.clear();
                    continueRead();
                    //event to continue to read file
                    return;
                }
            }
            else
            {
                #ifdef DEBUGFASTCGI
                //std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                #endif
                return;//0 bytes writen, nothing to do
            }
            #ifdef DEBUGFASTCGI
            /*time_t t = time(NULL);
            std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << " t: " << t << " writedSize: " << writedSize << " dataToWrite.size(): " << dataToWrite.size() << std::endl;*/
            #endif
            dataToWrite.erase(0,writedSize);
            #ifdef DEBUGFASTCGI
            /*t = time(NULL);
            std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << " t: " << t << " writedSize: " << writedSize << " dataToWrite.size(): " << dataToWrite.size() << std::endl;*/
            //std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ <<  " dataToWrite: " << dataToWrite << std::endl;
            #endif

            /* wrong, just wait all the data is writted
             * if(endTriggered==true)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
                #endif
                endTriggered=false;

                #ifdef DEBUGFILEOPEN
                std::cerr << "Client::~Client(), readCache close: " << readCache << std::endl;
                #endif
                if(readCache!=nullptr)
                {
                    readCache->close();
                    delete readCache;
                    readCache=nullptr;
                }

                disconnect();
            }*/
        }
    }
    else
    {
        #ifdef DEBUGFASTCGI
        //std::cerr << "readyToWrite() " << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " fileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
        #endif
        continueRead();
    }
}

void Client::httpError(const std::string &errorString)
{
    #ifdef DEBUGFASTCGI
    std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this->fd << " " << this << " error: " << errorString << std::endl;
    #endif
    const std::string &fullContent=
            "Status: 500 Internal Server Error\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\nError: "+
            errorString;
    addHeaderAndWrite(fullContent.data(),fullContent.size());
    internalWriteEnd();
    disconnect();
}

void Client::sendRedirectResponse(const std::string &response)
{
    // Forward an origin 3xx response (already serialized by caller into the
    // FastCGI/CGI status+headers form). One-shot: emit, end, disconnect.
    addHeaderAndWrite(response.data(),(int)response.size());
    internalWriteEnd();
    disconnect();
}

// Serve a slice of a warm-cache file as 206 Partial Content. The cache file is
// laid out as: [25-byte header][backend etag (variable)][FastCGI STDOUT records
// containing the original HTTP headers, then body chunks][FastCGI END_REQUEST].
// We parse the headers record to learn Content-Type / Content-Length, then walk
// the body chunks to pick out [rangeStart, rangeEnd] and re-emit it as 206.
//
// Out-of-range → 416 with `Content-Range: bytes */<total>`.
// Malformed Range → return false, caller falls through to normal 200 serve.
bool Client::serveRangeFromWarmCache(int cachefd)
{
    if(rangeHeader.empty()) return false;
    if(cachefd<0) return false;

    // Quick syntactic check on Range header. Spec is "Range: bytes=N-" or
    // "bytes=N-M". Anything else (including "bytes=foo") is malformed → fall back.
    if(rangeHeader.size()<7 || rangeHeader.compare(0,6,"bytes=")!=0)
        return false;
    const std::string spec=rangeHeader.substr(6);
    const size_t dash=spec.find('-');
    if(dash==std::string::npos)
        return false;
    int64_t rangeStart=-1, rangeEnd=-1;
    {
        const std::string lo=spec.substr(0,dash);
        const std::string hi=spec.substr(dash+1);
        try {
            rangeStart=lo.empty() ? 0 : std::stoll(lo);
        } catch(...) { return false; }
        if(!hi.empty())
        {
            try {
                rangeEnd=std::stoll(hi);
            } catch(...) { return false; }
        }
        // else rangeEnd stays -1 (open-ended); resolved against contentLength below.
        if(rangeStart<0) return false;
        if(rangeEnd>=0 && rangeEnd<rangeStart) return false;
    }

    // Read cache header to find FastCGI stream offset.
    uint8_t etagBackendSize=0;
    if(::pread(cachefd,&etagBackendSize,1,3*sizeof(uint64_t))!=1)
        return false;
    const off_t fcgiStart=(off_t)(3*sizeof(uint64_t))+1+etagBackendSize;

    // First STDOUT record carries the HTTP headers ("Status: 200 OK\r\n...\r\n\r\n").
    char fcgiHdr[8];
    if(::pread(cachefd,fcgiHdr,8,fcgiStart)!=8)
        return false;
    if((uint8_t)fcgiHdr[1]!=6)  // FCGI_STDOUT
        return false;
    const uint16_t hdrSize=((uint16_t)(uint8_t)fcgiHdr[4]<<8)|(uint8_t)fcgiHdr[5];
    const uint8_t hdrPad=(uint8_t)fcgiHdr[6];
    if(hdrSize==0)
        return false;
    std::string headers(hdrSize,'\0');
    if(::pread(cachefd,&headers[0],hdrSize,fcgiStart+8)!=(ssize_t)hdrSize)
        return false;

    std::string contentType="application/octet-stream";
    int64_t contentLength=-1;
    {
        size_t pos=0;
        while(pos<headers.size())
        {
            const size_t lineEnd=headers.find('\n',pos);
            if(lineEnd==std::string::npos) break;
            std::string line=headers.substr(pos,lineEnd-pos);
            if(!line.empty() && line.back()=='\r') line.pop_back();
            if(line.empty()) break;
            const size_t colon=line.find(':');
            if(colon!=std::string::npos)
            {
                std::string name=line.substr(0,colon);
                std::transform(name.begin(),name.end(),name.begin(),
                               [](unsigned char c){return (char)std::tolower(c);});
                std::string value=line.substr(colon+1);
                while(!value.empty() && value.front()==' ') value.erase(0,1);
                if(name=="content-type") contentType=value;
                else if(name=="content-length")
                {
                    try { contentLength=std::stoll(value); } catch(...) {}
                }
            }
            pos=lineEnd+1;
        }
    }
    if(contentLength<0)
        return false;  // can't honour Range without total size

    // Resolve open-ended Range and detect 416.
    if(rangeEnd<0) rangeEnd=contentLength-1;
    if(rangeStart>=contentLength)
    {
        std::string resp("Status: 416 Range Not Satisfiable\r\n");
        resp+="Content-Range: bytes */"+std::to_string(contentLength)+"\r\n";
        resp+="Content-Type: text/plain\r\nContent-Length: 0\r\n\r\n";
        addHeaderAndWrite(resp.data(),(int)resp.size());
        internalWriteEnd();
        disconnect();
        return true;
    }
    if(rangeEnd>=contentLength) rangeEnd=contentLength-1;
    const int64_t sliceLen=rangeEnd-rangeStart+1;

    // Emit 206 status and headers as a single FastCGI STDOUT record.
    {
        std::string resp("Status: 206 Partial Content\r\n");
        resp+="Content-Type: "+contentType+"\r\n";
        resp+="Content-Length: "+std::to_string(sliceLen)+"\r\n";
        resp+="Content-Range: bytes "+std::to_string(rangeStart)+"-"+
              std::to_string(rangeEnd)+"/"+std::to_string(contentLength)+"\r\n\r\n";
        addHeaderAndWrite(resp.data(),(int)resp.size());
    }

    // Walk body chunks, pulling out the slice. Each subsequent FastCGI STDOUT
    // record holds a chunk of the body; we skip those wholly before rangeStart,
    // partially-emit chunks straddling rangeStart or rangeEnd, and stop at rangeEnd.
    off_t readPos=fcgiStart+8+(off_t)hdrSize+(off_t)hdrPad;
    int64_t bodyConsumed=0;
    int64_t bytesEmitted=0;
    static constexpr int kMaxFcgiPayload=65535-1000;  // matches addHeaderAndWrite cap
    std::vector<char> buf;
    while(bytesEmitted<sliceLen)
    {
        char chunkHdr[8];
        const ssize_t r=::pread(cachefd,chunkHdr,8,readPos);
        if(r!=8) break;
        if((uint8_t)chunkHdr[1]!=6) break;  // not STDOUT (END_REQUEST or unknown)
        const uint16_t chunkSize=((uint16_t)(uint8_t)chunkHdr[4]<<8)|(uint8_t)chunkHdr[5];
        const uint8_t chunkPad=(uint8_t)chunkHdr[6];
        if(chunkSize==0) break;  // zero-size STDOUT marks end of stream
        const off_t chunkBodyOff=readPos+8;
        readPos=chunkBodyOff+chunkSize+chunkPad;
        const int64_t chunkBodyEnd=bodyConsumed+(int64_t)chunkSize;
        // intersect [rangeStart, rangeEnd] with [bodyConsumed, chunkBodyEnd)
        const int64_t skipFront=std::max((int64_t)0, rangeStart-bodyConsumed);
        const int64_t takeUntil=std::min((int64_t)chunkSize, rangeEnd+1-bodyConsumed);
        if(takeUntil>skipFront)
        {
            const int64_t toEmit=takeUntil-skipFront;
            if((int64_t)buf.size()<toEmit) buf.resize((size_t)toEmit);
            if(::pread(cachefd,buf.data(),(size_t)toEmit,chunkBodyOff+skipFront)!=(ssize_t)toEmit)
                break;
            int64_t emitOff=0;
            while(emitOff<toEmit)
            {
                const int64_t chunkLen=std::min((int64_t)kMaxFcgiPayload,toEmit-emitOff);
                addHeaderAndWrite(buf.data()+(size_t)emitOff,(int)chunkLen);
                emitOff+=chunkLen;
            }
            bytesEmitted+=toEmit;
        }
        bodyConsumed=chunkBodyEnd;
        if(bodyConsumed>rangeEnd) break;
    }
    internalWriteEnd();
    disconnect();
    return true;
}

void Client::httpStatus(const int &code)
{
    // Propagate an origin status code to the client verbatim. Used when the
    // origin returned a non-2xx response that is not a recoverable revalidate
    // (304) and we have no stale cache to fall back to.
    const char *reason="Error";
    switch(code) {
        case 400: reason="Bad Request"; break;
        case 401: reason="Unauthorized"; break;
        case 403: reason="Forbidden"; break;
        case 404: reason="Not Found"; break;
        case 405: reason="Method Not Allowed"; break;
        case 410: reason="Gone"; break;
        case 451: reason="Unavailable For Legal Reasons"; break;
        case 500: reason="Internal Server Error"; break;
        case 501: reason="Not Implemented"; break;
        case 502: reason="Bad Gateway"; break;
        case 503: reason="Service Unavailable"; break;
        case 504: reason="Gateway Timeout"; break;
    }
    char buffer[256];
    const int n=snprintf(buffer,sizeof(buffer),
        "Status: %d %s\r\nX-Robots-Tag: noindex, nofollow\r\nContent-type: text/plain\r\n\r\n",
        code,reason);
    if(n>0 && static_cast<size_t>(n)<sizeof(buffer))
        addHeaderAndWrite(buffer,n);
    internalWriteEnd();
    disconnect();
}

int64_t Client::get_bodyAndHeaderFileBytesSended() const
{
    return bodyAndHeaderFileBytesSended;
}

bool Client::detectTimeout()
{
    #ifdef DEBUGFASTCGI
    if(http!=nullptr)
    {
        if(Http::httpToDebug.find(http)==Http::httpToDebug.cend())
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << "Client::detectTimeout(), Http::toDebug.find(http)==Http::toDebug.cend()" << std::endl;
            //abort();
        }
    }
    #endif
    /*init with creationTime=Common::msFrom1970();
     * then check too if not timeout into parse
     * if(fullyParsed)
        return false;*/
    const uint64_t msFrom1970=Common::msFrom1970();
    /*if creationTime is newer than 60min (Cache::maxDownloadTimeInMS) and:
     * if in read: creationTimeOrUpdate newer than 60s Cache::maxDownloadIdleTimeREADInMS
     * if in write: creationTimeOrUpdate newer than 60s Cache::maxDownloadIdleTimeWRITEInMS
     * then max download time is 1h! */
    if(creationTime>(msFrom1970-Cache::maxDownloadTimeInMS))
    {
        //prevent time drift
        if(creationTime>msFrom1970)
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << "Client::detectTimeout(), time drift" << std::endl;
            creationTime=msFrom1970;
        }
        if(dataToWrite.empty())
        {
            if(creationTimeOrUpdate>(msFrom1970-Cache::maxDownloadIdleTimeREADInMS))
            {
                //prevent time drift
                if(creationTimeOrUpdate>msFrom1970)
                {
                    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << "Client::detectTimeout(), time drift" << std::endl;
                    creationTimeOrUpdate=msFrom1970;
                }
                return false;
            }
        }
        else
        {
            if(creationTimeOrUpdate>(msFrom1970-Cache::maxDownloadIdleTimeWRITEInMS))
            {
                //prevent time drift
                if(creationTimeOrUpdate>msFrom1970)
                {
                    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << "Client::detectTimeout(), time drift" << std::endl;
                    creationTimeOrUpdate=msFrom1970;
                }
                return false;
            }
        }
    }


    /* workaround bug:
    ./Client.cpp:2261 temperrno==EAGAIN this 0x5605593c3050 size 64535 writedSize -1
    ./Client.cpp:1960 fd: 15 this->fd: 0x5605593c3050 client TCP buffer statured, return to wait buffer is empty fileBytesSended: 9163969, remain to write: 64535
    ./Client.cpp:182 event.events: 4 0x5605593c3050
    */
    if(!dataToWrite.empty())
    {
        const uint64_t beforeTrySize=dataToWrite.size();
        readyToWrite();
        if(dataToWrite.empty())
            return false;
        const uint64_t tempbodyAndHeaderFileBytesSended=bodyAndHeaderFileBytesSended;
        continueRead();
        const uint64_t &afterTrySize=dataToWrite.size();
        if(beforeTrySize!=afterTrySize)
        {
            creationTimeOrUpdate=msFrom1970;
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " beforeTrySize!=afterTrySize: " << beforeTrySize << "!=" << afterTrySize << " url: " << host << uri << " msFrom1970: " << msFrom1970 << std::endl;
            return false;
        }
        else
        {
            if(tempbodyAndHeaderFileBytesSended!=bodyAndHeaderFileBytesSended)
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " NO NEW DATA BUT HAVE SEND MORE DATA url: " << host << uri << " msFrom1970: " << msFrom1970 << std::endl;
            else
            {
                if(!dataToWrite.empty())
                    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " NO NEW DATA url: " << host << uri << " msFrom1970: " << msFrom1970 << " write statured" << std::endl;
                else
                    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " NO NEW DATA url: " << host << uri << " msFrom1970: " << msFrom1970 << std::endl;
            }
        }
    }

    if(fullyParsed)
    {
        if(!dataToWrite.empty())
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " Client::detectTimeout() call disconnect, remain data to write, maybe client just download the header? CURLOPT_NOBODY? elapsed time: " << (creationTimeOrUpdate-msFrom1970);
        else
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " Client::detectTimeout() call disconnect time: " << Common::msFrom1970() << " elapsed time: " << (creationTimeOrUpdate-msFrom1970) << "ms";
    }
    else
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " Client::detectTimeout() call disconnect when not fully parsed";
    std::cerr << " creationTime: " << creationTime;
    std::cerr << " creationTimeOrUpdate: " << creationTimeOrUpdate;
    std::cerr << " msFrom1970: " << msFrom1970;
    #ifdef DEBUGFASTCGI
    std::cerr << " bytesSended: " << bytesSended;
    #endif
    #ifdef DEBUGFROMIP
    if(!REMOTE_ADDR.empty())
        std::cerr << " IP: " << REMOTE_ADDR;
    #endif
    if(!uri.empty())
        std::cerr << " uri: " << uri;
    if(!host.empty())
        std::cerr << " host: " << host;

    std::cerr << " dataToWrite.size(): " << dataToWrite.size();
    std::cerr << " status: " << (int)status;
    std::cerr << " fastcgiid: " << (int)fastcgi_id;
    if(readCache!=nullptr)
        std::cerr << " readCache!=nullptr";
    else
        std::cerr << " readCache==nullptr";
    if(http!=nullptr)
    {
        std::cerr << " http: " << http->getUrl() << " " << (int)http->get_status();
        if(http->backendList!=nullptr)
        {
            std::cerr << " backendList: " << http->backendList;
            std::cerr << " busy: " << http->backendList->busy.size();
            std::cerr << " idle: " << http->backendList->idle.size();
            std::cerr << " pendding: " << http->backendList->pending.size();
        }
    }
    else
        std::cerr << " nohttpsub";
    if(fullyParsed)
        std::cerr << " fullyParsed: true";
    else
        std::cerr << " fullyParsed: false";
    if(endTriggered)
        std::cerr << " endTriggered: true";
    else
        std::cerr << " endTriggered: false";

    std::cerr << std::endl;
    disconnect();
    return true;
}

bool Client::dataToWriteIsEmpty() const
{
    return dataToWrite.empty();
}

void Client::write(const char * const data,const int &size)
{
    if(size<1)
    {
        if(size<0)
        {
            std::cerr << this << " " << __FILE__ << ":" << __LINE__ << ", Client::write() invalid size, (abort)" << std::endl;
            abort();
        }
        return;
    }
    /*Can be called without cache tempory open like httpError, readCache, ... THIS VALID NOT REFER TO FASTCGI!
    if(!isValid())
    {
        #ifdef DEBUGFASTCGI
        std::cerr << " Client::writeEnd() !isValid()" << std::endl;
        #endif
        return;
    }*/
    if(fd==-1)
    {
        if(readCache!=nullptr)
        {
            readCache->close();
            delete readCache;
            readCache=nullptr;
        }
        return;
    }
    if(data==nullptr)
        return;
    if(!dataToWrite.empty())
    {
        dataToWrite+=std::string(data,size);
        #ifdef DEBUGFASTCGI
        std::cerr << this << " " << __FILE__ << ":" << __LINE__ << ", skip to store content: " << Common::binarytoHexa(data,size) << std::endl;
        #endif
        return;
    }
    #ifdef DEBUGFASTCGI
    //std::cerr << this << " " << __FILE__ << ":" << __LINE__ << ", try real write (" << std::to_string(size) << "): " << Common::binarytoHexa(data,size) << std::endl;
    #endif

    errno=0;
    int writedSize=-1;
    if(fd!=-1)
        writedSize=::write(fd,data,size);
    #ifdef DEBUGFASTCGI
    if(writedSize>0)
    {
//        std::cerr << this << " real write writedSize: " << writedSize << " " << __FILE__ << ":" << __LINE__ <<  " : " << Common::binarytoHexa(data,writedSize) << std::endl;
        creationTimeOrUpdate=Common::msFrom1970();
    }
    #endif
    const int temperrno=errno;
    #ifdef DEBUGFASTCGI
    if(writedSize>0)
        bytesSended+=writedSize;
    #endif
    if(writedSize==size)
    {
        #ifdef DEBUGFASTCGI
        //std::cerr << this << " " << __FILE__ << ":" << __LINE__ << ", real write ok: " << Common::binarytoHexa(data,size) << std::endl;
        #endif
        return;
    }
    else
    {
        if(temperrno!=0 && temperrno!=EAGAIN)
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
            #endif
            if(temperrno!=32)//if not BROKEN PIPE
            {
                switch(temperrno)
                {
                    case 104:
                        std::cerr << fd << ") error to write: " << temperrno << "ECONNRESET Connection reset by peer" << std::endl;
                    break;
                    default:
                    std::cerr << fd << ") error to write: " << temperrno << std::endl;
                    break;
                }
            }
            disconnect();
            return;
        }
    }
    if(temperrno==EAGAIN || temperrno==0)
    {
        if(temperrno==EAGAIN)
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " temperrno==EAGAIN this " << this << " size " << size << " writedSize " << writedSize << std::endl;
            #endif
        }
        else
        {
            #ifdef DEBUGFASTCGI
            std::cerr << __FILE__ << ":" << __LINE__ << " temperrno: " << temperrno << " this " << this << " size " << size << " writedSize " << writedSize << std::endl;
            #endif
        }
        if(writedSize>0)
            dataToWrite+=std::string(data+writedSize,size-writedSize);
        else
            dataToWrite+=std::string(data,size);
        return;
    }
    else
    {
        #ifdef DEBUGFASTCGI
        std::cerr << __FILE__ << ":" << __LINE__ << " errno " << temperrno << " this " << this << " size " << size << " writedSize " << writedSize << std::endl;
        #endif
        disconnect();
        return;
    }
}

void Client::internalWriteEnd()
{
    writeEnd(get_bodyAndHeaderFileBytesSended());
}

void Client::writeEnd(const uint64_t &fileBytesSended)
{
    status=Status_Idle;
    if(get_bodyAndHeaderFileBytesSended()!=(int64_t)fileBytesSended)
    {
        #ifdef DEBUGFASTCGI
        std::cerr << " Client::writeEnd() get_fileBytesSended()!=(int64_t)fileBytesSended: " << bodyAndHeaderFileBytesSended << "!=" << bodyAndHeaderFileBytesSended << std::endl;
        #endif
        return;
    }
    /*Can be called without cache tempory open like httpError, readCache, ... THIS VALID NOT REFER TO FASTCGI!
    if(!isValid())
    {
        #ifdef DEBUGFASTCGI
        std::cerr << " Client::writeEnd() !isValid()" << std::endl;
        #endif
        return;
    }*/
    if(fd==-1)
    {
        if(readCache!=nullptr)
        {
            readCache->close();
            delete readCache;
            readCache=nullptr;
        }
        return;
    }
    creationTimeOrUpdate=Common::msFrom1970();
    #ifdef DEBUGFASTCGI
    const auto p1 = std::chrono::system_clock::now();
    std::cerr << __FILE__ << ":" << __LINE__ << " Client::writeEnd(): " << std::chrono::duration_cast<std::chrono::seconds>(p1.time_since_epoch()).count() << " bodyAndHeaderFileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
    if(http!=nullptr)
        std::cerr << http->getUrl() << " ";
    std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
    #endif
    disconnectFromHttp();
    if(!outputWrited)//mean never send nothing, header/body
    {
        #ifdef DEBUGFASTCGI
        {
            struct stat sb;
            if(fstat(readCache->getFD(),&sb)==0)
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " !outputWrited, dataToWrite.empty(): " << std::to_string(dataToWrite.empty()) << " partial: " << std::to_string(partial) << " bodyAndHeaderFileBytesSended: " << bodyAndHeaderFileBytesSended << " cache size: " << sb.st_size << std::endl;
            else
                std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " !outputWrited, dataToWrite.empty(): " << std::to_string(dataToWrite.empty()) << " partial: " << std::to_string(partial) << " bodyAndHeaderFileBytesSended: " << bodyAndHeaderFileBytesSended << std::endl;
        }
        #endif
        if(readCache!=nullptr)
        {
            readCache->close();
            delete readCache;
            readCache=nullptr;
        }
        return;
    }
    if(partial && readCache!=nullptr)
    {
        #ifdef DEBUGFASTCGI
        Http::checkIngrityHttpClient();
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << " !outputWrited" << std::endl;
        #endif
        continueRead();
    }

    if(!dataToWrite.empty())
    {
        //dataToWrite+=std::string(Http::fastcgiheaderend,sizeof(Http::fastcgiheaderend));// -> should be into the cache file
        endTriggered=true;
        #ifdef DEBUGFILEOPEN
        std::cerr << "Client::writeEnd() pre, readCache close: " << readCache << std::endl;
        #endif
        if(readCache->size()>0)
            if(readCache->size()>(ssize_t)bodyAndHeaderFileBytesSended)
            {
                #ifdef DEBUGFASTCGI
                std::cerr << __FILE__ << ":" << __LINE__ << " fd: " << fd << " this->fd: " << this << " readCache->size()>=(ssize_t)bodyAndHeaderFileBytesSended " << " fileBytesSended: " << bodyAndHeaderFileBytesSended << " remain data to send (abort)" << std::endl;
                #endif
                // case Backend::detectTimeout() timeout while downloading, when partial already downloaded
                //abort();
            }
        if(readCache!=nullptr)
        {
            readCache->close();
            delete readCache;
            readCache=nullptr;
        }
        return;
    }
    #ifdef DEBUGFILEOPEN
    std::cerr << "Client::writeEnd() post, readCache close: " << readCache << std::endl;
    #endif
    if(readCache!=nullptr)
    {
        readCache->close();
        delete readCache;
        readCache=nullptr;
    }

    fastcgi_id=-1;
    if(dataToWrite.empty())
    {
        #ifdef DEBUGFASTCGI
        Http::checkIngrityHttpClient();
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
        disconnect();
        #ifdef DEBUGFASTCGI
        Http::checkIngrityHttpClient();
        std::cerr << __FILE__ << ":" << __LINE__ << " " << this << std::endl;
        #endif
    }
    else
        endTriggered=true;
}

void Client::addHeaderAndWrite(const char * const data, const int &size)
{
    if(size>65535-1000)
    {
        std::cerr << "addHeaderAndWrite() size > 65535-1000, then greater than allowed by fastcgi, see Http::buffer and Client::continueRead() (abort)" << std::endl;
        abort();
    }
    /*Can be called without cache tempory open like httpError, readCache, ... THIS VALID NOT REFER TO FASTCGI!
    if(!isValid())
    {
        #ifdef DEBUGFASTCGI
        std::cerr << " Client::writeEnd() !isValid()" << std::endl;
        #endif
        return;
    }*/
    if(fd==-1)
    {
        if(readCache!=nullptr)
        {
            readCache->close();
            delete readCache;
            readCache=nullptr;
        }
        return;
    }
    creationTimeOrUpdate=Common::msFrom1970();
    #ifdef DEBUGFASTCGI
    //std::cerr << this << " " << __FILE__ << ":" << __LINE__ << ", outputWrited: " << outputWrited << " content (size " << size << "): " << Common::binarytoHexa(data,size) << std::endl;
    #endif
    outputWrited=true;

    //FCGI_STDOUT
    const uint16_t &sizebe=htobe16(size);
    memcpy(Http::fastcgiheaderstdout+1+1+2,&sizebe,2);
    write(Http::fastcgiheaderstdout,sizeof(Http::fastcgiheaderstdout));
    #ifdef DEBUGFASTCGI
    //std::cerr << this << " " << __FILE__ << ":" << __LINE__ << ", Http::fastcgiheaderstdout (size " << sizeof(Http::fastcgiheaderstdout) << "): " << Common::binarytoHexa(Http::fastcgiheaderstdout,sizeof(Http::fastcgiheaderstdout)) << std::endl;
    #endif
    write(data,size);
}