// Copyright (с) 2008 Сатоси Накамото
//
// Разрешение Настоящим предоставляется бесплатно, любому лицу, приобретающему копию
// это программное обеспечение и связанные с ним файлы документации ( "Программного обеспечения"), иметь дело
// Программного обеспечения без ограничений, в том числе, без ограничения прав
// использовать, копировать, изменять, объединять, публиковать, распространять, сублицензировать и / или продавать
// копии программного обеспечения, а также разрешать лицам, которым данное программное обеспечение
// обставленная сделать так, при соблюдении следующих условий:
//
// выше уведомление об авторских правах и данное разрешение должно быть включено в
// все копии или существенные части Программного обеспечения.
//
// ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ "КАК ЕСТЬ", БЕЗ КАКИХ, ЯВНЫХ ИЛИ
// ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ, ГАРАНТИИ КОММЕРЧЕСКОЙ,
// ПРИГОДНОСТИ ДЛЯ КОНКРЕТНЫХ ЦЕЛЕЙ И ОТСУТСТВИЯ НАРУШЕНИЙ. НИ В КОЕМ СЛУЧАЕ
// АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ ОТВЕТСТВЕННОСТИ ЗА Claim, УБЫТКОВ ИЛИ
// ДРУГОЙ ОТВЕТСТВЕННОСТИ, НЕЗАВИСИМО ОТ ДЕЙСТВИЯ ДОГОВОРА, ГРАЖДАНСКОГО ПРАВОНАРУШЕНИЯ ИЛИ ИНАЧЕ, ВОЗНИКАЮЩИЕ
// ИЗ, ИЗ ИЛИ В СВЯЗИ С ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ИЛИ ИСПОЛЬЗОВАНИЕМ ИЛИ ИНЫМИ ДЕЙСТВИЯМИ
// В ПРОГРАММЕ.

класс CMessageHeader;
класс CAddress;
класс CINV;
класс CRequestTracker;
класс CNode;



статического сопзЬ без знака короткого DEFAULT_PORT = htons (2222);
статический Const беззнаковый INT BROADCAST_HOPS = 5;
перечисление
{
    NODE_NETWORK = (1 << 0),
};







BOOL AddAddress (CAddrDB& addrdb, Const CAddress& адр);
CNode * FindNode (беззнаковое целочисленное значение ф);
CNode * ConnectNode (CAddress addrConnect, Int64 nTimeout = 0);
недействительный AbandonRequests (недействительный (* п) (пустота *, CDataStream&), Аннулирует * param1);
BOOL AnySubscribed (беззнаковое INT nChannel);
аннулированию ThreadBitcoinMiner (недействительный * PARG);
BOOL StartNode (строка& strError = REF (строка ()));
BOOL StopNode ();
аннулированию CheckForShutdown (Int N);









//
// Заголовок сообщения
// (4) сообщение о начале
Команда // (12)
// (4) размер

// Начало строки сообщения предназначена для маловероятен в нормальных данных.
// Символы редко используются верхний ASCII, не действительный, как UTF-8, и производят
// большой 4-байтовый INT в любом выравнивании.
статический Const символ pchMessageStart [4] = {0xf9, 0xbe, 0xb4, 0xd9};

класс CMessageHeader
{
общественности:
    перечисление {COMMAND_SIZE = 12};
    символ pchMessageStart [SizeOf (:: pchMessageStart)];
    символ pchCommand [COMMAND_SIZE];
    неподписанных INT nMessageSize;

    CMessageHeader ()
    {
        тетср (pchMessageStart, :: pchMessageStart, SizeOf (pchMessageStart));
        MemSet (pchCommand, 0, SizeOf (pchCommand));
        pchCommand [1] = 1;
        nMessageSize = -1;
    }

    CMessageHeader (Const символ * pszCommand, неподписанный INT nMessageSizeIn)
    {
        тетср (pchMessageStart, :: pchMessageStart, SizeOf (pchMessageStart));
        strncpy (pchCommand, pszCommand, COMMAND_SIZE);
        nMessageSize = nMessageSizeIn;
    }

    IMPLEMENT_SERIALIZE
    (
        READWRITE (FLATDATA (pchMessageStart));
        READWRITE (FLATDATA (pchCommand));
        READWRITE (nMessageSize);
    )

    Строка GetCommand ()
    {
        если (pchCommand [COMMAND_SIZE-1] == 0)
            возвращенная строка (pchCommand, pchCommand + StrLen (pchCommand));
        еще
            возвращенная строка (pchCommand, pchCommand + COMMAND_SIZE);
    }

    BOOL IsValid ()
    {
        // Проверка начала строки
        если (memcmp (pchMessageStart, :: pchMessageStart, SizeOf (pchMessageStart))! = 0)
            вернуться ложным;

        // Проверяем командную строку на наличие ошибок
        для (полукокса * р1 = pchCommand; р1 < pchCommand + COMMAND_SIZE; p1 ++)
        {
            если (* p1 == 0)
            {
                // Должно быть все нули после первого нуля
                для (p1; < pchCommand + COMMAND_SIZE; p1 ++)
                    если (* p1! = 0)
                        вернуться ложным;
            }
            иначе если (* p1 < '' || * p1 > 0x7E)
                вернуться ложным;
        }

        // Размер сообщения
        если (nMessageSize > 0x10000000)
        {
            Е ("CMessageHeader :: IsValid (): nMessageSize слишком большой% и \ ​​п", NMessageSize);
            вернуться ложным;
        }

        возвращает истину;
    }
};







статический Const символ без знака pchIPv4 [12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff};

класс CAddress
{
общественности:
    UInt64 nServices;
    символ без знака pchReserved [12];
    беззнаковое целочисленное значение ф;
    неподписанный короткий порт;

    только // диск
    неподписанных INT NTime;

    CAddress ()
    {
        nServices = 0;
        тетср (pchReserved, pchIPv4, SizeOf (pchReserved));
        ф = 0;
        Порт = DEFAULT_PORT;
        Ntime = GetAdjustedTime ();
    }

    CAddress (беззнаковое INT IPIN, неподписанные короткий Portin, uint64 nServicesIn = 0)
    {
        nServices = nServicesIn;
        тетср (pchReserved, pchIPv4, SizeOf (pchReserved));
        ф = IPIN;
        Порт = Portin;
        Ntime = GetAdjustedTime ();
    }

    Явный CAddress (Const символ * pszIn, uint64 nServicesIn = 0)
    {
        nServices = nServicesIn;
        тетср (pchReserved, pchIPv4, SizeOf (pchReserved));
        ф = 0;
        Порт = DEFAULT_PORT;
        Ntime = GetAdjustedTime ();

        символьный ПСЗ [100];
        если (STRLEN (pszIn) > ARRAYLEN (ПСЗ) -1)
            вернуть;
        зЬгср (ПСЗ, pszIn);
        беззнаковое целочисленное значение а, б, в, г, д;
        если (sscanf (ПСЗ, "% U% U% U% и:...% U", &а, &б, &с, &д, &е) < 4)
            вернуть;
        символ * pszPort = strchr (ПСЗ, ':');
        если (pszPort)
        {
            * PszPort ++ = '\ 0';
            Порт = htons (atoi (pszPort));
        }
        ф = inet_addr (ПСЗ);
    }

    IMPLEMENT_SERIALIZE
    (
        если (nType & SER_DISK)
        {
            READWRITE (nVersion);
            READWRITE (Ntime);
        }
        READWRITE (nServices);
        READWRITE (FLATDATA (pchReserved));
        READWRITE (ф);
        READWRITE (порт);
    )

    друг оператор рядный BOOL == (Const CAddress& а, Const CAddress& б)
    {
        Возвращение (memcmp (a.pchReserved, b.pchReserved, SizeOf (a.pchReserved)) == 0 &&
                a.ip == b.ip &&
                a.port == b.port);
    }

    друг оператор рядный BOOL<(Const CAddress& а, Const CAddress& б)
    {
        INT RET = memcmp (a.pchReserved, b.pchReserved, SizeOf (a.pchReserved));
        если (RET < 0)
            возвращает истину;
        иначе если (в отставке == 0)
        {
            если (ntohl (a.ip) < ntohl (b.ip))
                возвращает истину;
            иначе если (a.ip == b.ip)
                возвратные ntohs (a.port) < ntohs (b.port);
        }
        вернуться ложным;
    }

    вектор<неподписанные символ> GetKey () Const
    {
        CDataStream сс;
        сс << FLATDATA (pchReserved) << IP << порт;
        обратный вектор<неподписанные символ>((Неподписанные символ *)&ss.begin () [0], (неподписанные символ *)&ss.end () [0]);
    }

    BOOL IsIPv4 () Const
    {
        Возвращение (memcmp (pchReserved, pchIPv4, SizeOf (pchIPv4)) == 0);
    }

    символ без знака GetByte (Int N) Const
    {
        Возвращение ((неподписанные символ *)&ф) [3-п];
    }

    Строка ToString () Const
    {
        вернуться strprintf ("% U% U% U% и:...% U", GetByte (3), GetByte (2), GetByte (1), GetByte (0), ntohs (порт));
    }

    недействительным печати () сопзЬ
    {
        Е ("CAddress (% s) \ п", ToString () c_str ()).
    }
};







перечисление
{
    MSG_TX = 1,
    MSG_BLOCK,
    MSG_REVIEW,
    MSG_PRODUCT,
    MSG_TABLE,
};

статический Const символ * ppszTypeName [] =
{
    "ОШИБКА",
    "Техас",
    "блок",
    "обзор",
    "продукт",
    "Таблица",
};

класс CINV
{
общественности:
    тип INT;
    uint256 хэш;

    CINV ()
    {
        тип = 0;
        хэш = 0;
    }

    CINV (интермедиат typeIn, Const uint256& Хашина)
    {
        тип = typeIn;
        хэш = Хашина;
    }

    CINV (Const строка& strType, Const uint256& Хашина)
    {
        Int я;
        для (я = 1; я < ARRAYLEN (ppszTypeName); я ++)
        {
            если (strType == ppszTypeName [I])
            {
                тип = я;
                ломать;
            }
        }
        если (я == ARRAYLEN (ppszTypeName))
            бросить STD :: out_of_range (strprintf ("CI :: CI (строка, uint256): неизвестный типа '% s'", StrType.c_str ()));
        хэш = Хашина;
    }

    IMPLEMENT_SERIALIZE
    (
        READWRITE (тип);
        READWRITE (хэш);
    )

    друг оператор рядный BOOL<(Const CINV& а, Const CINV& б)
   

    BOOL IsKnownType () Const
    {
        Возвращение (тип >= 1 && тип < ARRAYLEN (ppszTypeName));
    }

    Const символ * GetCommand () Const
    {
        если (! IsKnownType ())
            бросить STD :: out_of_range (strprintf ("CINV :: GetCommand (): тип =% неизвестный тип", тип));
        вернуть ppszTypeName [тип];
    }

    Строка ToString () Const
    {
        вернуться strprintf ("% S% s"., GetCommand (), hash.ToString () зиЬзЬг (0,6) .c_str ());
    }

    недействительным печати () сопзЬ
    {
        Е ("CINV (% s) \ п", ToString () c_str ()).
    }
};





класс CRequestTracker
{
общественности:
    недействительный (* п) (пустота *, CDataStream&);
    недействительные * param1;

    Явный CRequestTracker (аннулируются (* fnIn) (пустота *, CDataStream&) = NULL, аннулируются * param1In = NULL)
    {
        п = fnIn;
        param1 = param1In;
    }

    BOOL IsNull ()
    {
        вернуться Fn == NULL;
    }
};





ехЬегп BOOL fClient;
ехЬегп nLocalServices uint64;
ехЬегп CAddress addrLocalHost;
ехЬегп CNode * pnodeLocalHost;
ехЬегп BOOL fShutdown;
ехЬегп массив vfThreadRunning;
ехЬегп вектор vNodes;
ехЬегп cs_vNodes CCriticalSection;
ехЬегп карта<вектор<неподписанные символ>, CAddress> mapAddresses;
ехЬегп cs_mapAddresses CCriticalSection;
ехЬегп карта mapRelay;
ехЬегп Deque<пара > vRelayExpiration;
ехЬегп CCriticalSection cs_mapRelay;
ехЬегп карта mapAlreadyAskedFor;





класс CNode
{
общественности:
    // разъем
    UInt64 nServices;
    SOCKET hSocket;
    CDataStream vSend;
    CDataStream vRecv;
    CCriticalSection cs_vSend;
    CCriticalSection cs_vRecv;
    неподписанных INT nPushPos;
    CAddress адр;
    INT nVersion;
    BOOL fClient;
    BOOL fInbound;
    BOOL fNetworkNode;
    BOOL fDisconnect;
защищенный:
    INT nRefCount;
общественности:
    int64 nReleaseTime;
    карта mapRequests;
    CCriticalSection cs_mapRequests;

    // потоп
    вектор vAddrToSend;
    задавать setAddrKnown;

    // реле инвентаризации на основе
    вектор vInventoryToSend;
    задавать setInventoryKnown;
    CCriticalSection cs_inventory;
    MultiMap mapAskFor;

    // трансляция и подписка
    вектор<голец> vfSubscribe;


    CNode (РАЗЪЕМ hSocketIn, CAddress addrIn)
    {
        nServices = 0;
        hSocket = hSocketIn;
        vSend.SetType (SER_NETWORK);
        vRecv.SetType (SER_NETWORK);
        nPushPos = -1;
        адр = addrIn;
        nVersion = 0;
        fClient = ложь; // устанавливается версия сообщения
        fInbound = ложь;
        fNetworkNode = ложь;
        fDisconnect = FALSE;
        nRefCount = 0;
        nReleaseTime = 0;
        vfSubscribe.assign (256, ложь);

        // Поместить сообщение версии
        беззнаковая INT Ntime = GetAdjustedTime ();
        PushMessage ("версия", версия, nLocalServices, Ntime);
    }

    ~ CNode ()
    {
        если (hSocket! = INVALID_SOCKET)
            closesocket (hSocket);
    }

частный:
    CNode (Const CNode&);
    недействительный оператор = (Const CNode&);
общественности:


    BOOL ReadyToDisconnect ()
    GetRefCount () <= 0;
   

    ИНТ GetRefCount ()
    {
        вернуться макс (nRefCount, 0) + (GetTime () < nReleaseTime? 1: 0);
    }

    аннулированию AddRef (Int64 nTimeout = 0)
    {
        если (nTimeout! = 0)
            nReleaseTime = макс (nReleaseTime, GetTime () + nTimeout);
        еще
            nRefCount ++;
    }

    аннулируются Release ()
    {
        nRefCount--;
    }



    недействительным AddInventoryKnown (Const CINV& и)
    {
        CRITICAL_BLOCK (cs_inventory)
            setInventoryKnown.insert (INV);
    }

    аннулированию AskFor (константный CINV& и)
    {
        // Мы используем mapAskFor в качестве приоритетной очереди,
        // ключ самое раннее время запрос может быть отправлен
        int64& nRequestTime = mapAlreadyAskedFor [INV];
        Е ("askfor% s% I64d \ п", Inv.ToString () c_str (), nRequestTime).
        nRequestTime = макс (nRequestTime + 2 * 60, GetTime ());
        mapAskFor.insert (make_pair (nRequestTime, INV));
    }



    аннулированию BeginMessage (Const символ * pszCommand)
    {
        EnterCriticalSection (&cs_vSend);
        если (nPushPos! = -1)
            AbortMessage ();
        nPushPos = vSend.size ();
        vSend << CMessageHeader (pszCommand, 0);
        Е ("отправка:% -12s ", PszCommand);
    }

    аннулированию AbortMessage ()
    {
        если (nPushPos == -1)
            вернуть;
        vSend.resize (nPushPos);
        nPushPos = -1;
        LeaveCriticalSection (&cs_vSend);
        Е ("(Прерванный) \ п");
    }

    EndMessage недействительными ()
    {
        если (nPushPos == -1)
            вернуть;

        // Patch в размере
        без знака INT nРазмер: = vSend.size () - nPushPos - SizeOf (CMessageHeader);
        тетср ((символ *)&vSend [nPushPos] + offsetof (CMessageHeader, nMessageSize), &nРазмер:, SizeOf (nРазмер:));

        Е ("(% D байт)  ", NРазмер:);
        // для (INT I = nPushPos + SizeOf (CMessageHeader); я < мин (vSend.size (), nPushPos + SizeOf (CMessageHeader) + 20U); я ++)
        // Е ("% 02x ", VSend [я] & 0xff);
        Е ("\ п");

        nPushPos = -1;
        LeaveCriticalSection (&cs_vSend);
    }

    аннулированию EndMessageAbortIfEmpty ()
    {
        если (nPushPos == -1)
            вернуть;
        INT nРазмер: = vSend.size () - nPushPos - SizeOf (CMessageHeader);
        если (nРазмер: > 0)
            EndMessage ();
        еще
            AbortMessage ();
    }

    Const символ * GetMessageCommand () Const
    {
        если (nPushPos == -1)
            вернуть "";
        вернуть &vSend [nPushPos] + offsetof (CMessageHeader, pchCommand);
    }




    недействительным PushMessage (Const символ * pszCommand)
    {
        пытаться
        {
            BeginMessage (pszCommand);
            EndMessage ();
        }
        поймать (...)
        {
            AbortMessage ();
            бросить;
        }
    }

    шаблон<имяТипа T1>
    недействительный PushMessage (Const символ * pszCommand, Const Т1& a1)
    {
        пытаться
        {
            BeginMessage (pszCommand);
            vSend << a1;
            EndMessage ();
        }
        поймать (...)
        {
            AbortMessage ();
            бросить;
        }
    }

    шаблон<Ьурепате Т1, Т2 Ьурепате>
    недействительный PushMessage (Const символ * pszCommand, Const Т1& a1, Const T2& a2)
    {
        пытаться
        {
            BeginMessage (pszCommand);
            vSend << a1 << a2;
            EndMessage ();
        }
        поймать (...)
        {
            AbortMessage ();
            бросить;
        }
    }

    шаблон<Ьурепате Т1, Т2 Ьурепата, Ьурепате Т3>
    недействительный PushMessage (Const символ * pszCommand, Const Т1& a1, Const T2& a2, Const T3& a3)
    {
        пытаться
        {
            BeginMessage (pszCommand);
            vSend << a1 << a2 << a3;
            EndMessage ();
        }
        поймать (...)
        {
            AbortMessage ();
            бросить;
        }
    }

    шаблон<Ьурепате Т1, Т2 Ьурепата, Ьурепате Т3, Т4 Ьурепате>
    недействительный PushMessage (Const символ * pszCommand, Const Т1& a1, Const T2& a2, Const T3& a3, Const T4& a4)
    {
        пытаться
        {
            BeginMessage (pszCommand);
            vSend << a1 << a2 << a3 << a4;
            EndMessage ();
        }
        поймать (...)
        {
            AbortMessage ();
            бросить;
        }
    }


    аннулированию PushRequest (Const символ * pszCommand,
                     недействительный (* п) (пустота *, CDataStream&), Аннулирует * param1)
    {
        uint256 hashReply;
        RAND_bytes ((неподписанные символ *)&hashReply, SizeOf (hashReply));

        CRITICAL_BLOCK (cs_mapRequests)
            mapRequests [hashReply] = CRequestTracker (п, param1);

        PushMessage (pszCommand, hashReply);
    }

    шаблон<имяТипа T1>
    аннулированию PushRequest (Const символ * pszCommand, константный T1& a1,
                     недействительный (* п) (пустота *, CDataStream&), Аннулирует * param1)
    {
        uint256 hashReply;
        RAND_bytes ((неподписанные символ *)&hashReply, SizeOf (hashReply));

        CRITICAL_BLOCK (cs_mapRequests)
            mapRequests [hashReply] = CRequestTracker (п, param1);

        PushMessage (pszCommand, hashReply, a1);
    }

    шаблон<Ьурепате Т1, Т2 Ьурепате>
    аннулированию PushRequest (Const символ * pszCommand, константный T1& a1, Const T2& a2,
                     недействительный (* п) (пустота *, CDataStream&), Аннулирует * param1)
    {
        uint256 hashReply;
        RAND_bytes ((неподписанные символ *)&hashReply, SizeOf (hashReply));

        CRITICAL_BLOCK (cs_mapRequests)
            mapRequests [hashReply] = CRequestTracker (п, param1);

        PushMessage (pszCommand, hashReply, a1, a2);
    }



    BOOL IsSubscribed (беззнаковое INT nChannel);
    аннулируются Подписаться (беззнаковое целочисленное значение nChannel, беззнаковое целочисленное значение nHops = 0);
    недействительный CancelSubscribe (беззнаковый INT nChannel);
    Отключить недействительными ();
};










рядный недействительным RelayInventory (Const CINV& и)
{
    // Помещаем в списки, чтобы предложить другие узлы
    CRITICAL_BLOCK (cs_vNodes)
        Еогеасп (CNode * pnode, vNodes)
            CRITICAL_BLOCK (pnode->cs_inventory)
                если (! pnode->setInventoryKnown.count (INV))
                    pnode->vInventoryToSend.push_back (INV);
}

шаблон<Ьурепате Т>
недействительным RelayMessage (Const CINV& INV, сопзЬ Т& а)
{
    CDataStream сс (SER_NETWORK);
    сс << а;
    RelayMessage (INV, сс);
}

шаблон<>
рядный недействительным RelayMessage<>(Const CINV& и, Const CDataStream& сс)
{
    CRITICAL_BLOCK (cs_mapRelay)
    {
        // Сохранить оригинальное сериализованное сообщение так новые версии сохраняются
        mapRelay [INV] = сс;

        // Expire старых сообщений реле
        vRelayExpiration.push_back (make_pair (GetTime () + 10 * 60, INV));
        в то время как (! vRelayExpiration.empty () && vRelayExpiration.front (). первый < GetTime ())
        {
            mapRelay.erase (vRelayExpiration.front () второй.);
            vRelayExpiration.pop_front ();
        }
    }

    RelayInventory (INV);
}