Line data    Source code

       1             : // Copyright (c) 2010 Satoshi Nakamoto
       2             : // Copyright (c) 2009-2013 The Bitcoin Core developers
       3             : // Distributed under the MIT software license, see the accompanying
       4             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5             : 
       6             : #ifndef BITCOIN_ALERT_H
       7             : #define BITCOIN_ALERT_H
       8             : 
       9             : #include "serialize.h"
      10             : #include "sync.h"
      11             : 
      12             : #include <map>
      13             : #include <set>
      14             : #include <stdint.h>
      15             : #include <string>
      16             : 
      17             : class CAlert;
      18             : class CNode;
      19             : class uint256;
      20             : 
      21             : extern std::map<uint256, CAlert> mapAlerts;
      22             : extern CCriticalSection cs_mapAlerts;
      23             : 
      24             : /** Alerts are for notifying old versions if they become too obsolete and
      25             :  * need to upgrade.  The message is displayed in the status bar.
      26             :  * Alert messages are broadcast as a vector of signed data.  Unserializing may
      27             :  * not read the entire buffer if the alert is for a newer version, but older
      28             :  * versions can still relay the original data.
      29             :  */
      30        1029 : class CUnsignedAlert
      31             : {
      32             : public:
      33             :     int nVersion;
      34             :     int64_t nRelayUntil;      // when newer nodes stop relaying to newer nodes
      35             :     int64_t nExpiration;
      36             :     int nID;
      37             :     int nCancel;
      38             :     std::set<int> setCancel;
      39             :     int nMinVer;            // lowest version inclusive
      40             :     int nMaxVer;            // highest version inclusive
      41             :     std::set<std::string> setSubVer;  // empty matches all
      42             :     int nPriority;
      43             : 
      44             :     // Actions
      45             :     std::string strComment;
      46             :     std::string strStatusBar;
      47             :     std::string strReserved;
      48             : 
      49          16 :     ADD_SERIALIZE_METHODS;
      50             : 
      51             :     template <typename Stream, typename Operation>
      52          16 :     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
      53          16 :         READWRITE(this->nVersion);
      54          16 :         nVersion = this->nVersion;
      55          16 :         READWRITE(nRelayUntil);
      56          16 :         READWRITE(nExpiration);
      57          16 :         READWRITE(nID);
      58          16 :         READWRITE(nCancel);
      59          16 :         READWRITE(setCancel);
      60          16 :         READWRITE(nMinVer);
      61          16 :         READWRITE(nMaxVer);
      62          16 :         READWRITE(setSubVer);
      63          16 :         READWRITE(nPriority);
      64             : 
      65          48 :         READWRITE(LIMITED_STRING(strComment, 65536));
      66          48 :         READWRITE(LIMITED_STRING(strStatusBar, 256));
      67          48 :         READWRITE(LIMITED_STRING(strReserved, 256));
      68          16 :     }
      69             : 
      70             :     void SetNull();
      71             : 
      72             :     std::string ToString() const;
      73             : };
      74             : 
      75             : /** An alert is a combination of a serialized CUnsignedAlert and a signature. */
      76         412 : class CAlert : public CUnsignedAlert
      77             : {
      78             : public:
      79             :     std::vector<unsigned char> vchMsg;
      80             :     std::vector<unsigned char> vchSig;
      81             : 
      82          24 :     CAlert()
      83          72 :     {
      84          24 :         SetNull();
      85          24 :     }
      86             : 
      87          24 :     ADD_SERIALIZE_METHODS;
      88             : 
      89             :     template <typename Stream, typename Operation>
      90           0 :     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
      91          24 :         READWRITE(vchMsg);
      92          24 :         READWRITE(vchSig);
      93           0 :     }
      94             : 
      95             :     void SetNull();
      96             :     bool IsNull() const;
      97             :     uint256 GetHash() const;
      98             :     bool IsInEffect() const;
      99             :     bool Cancels(const CAlert& alert) const;
     100             :     bool AppliesTo(int nVersion, const std::string& strSubVerIn) const;
     101             :     bool AppliesToMe() const;
     102             :     bool RelayTo(CNode* pnode) const;
     103             :     bool CheckSignature(const std::vector<unsigned char>& alertKey) const;
     104             :     bool ProcessAlert(const std::vector<unsigned char>& alertKey, bool fThread = true); // fThread means run -alertnotify in a free-running thread
     105             :     static void Notify(const std::string& strMessage, bool fThread);
     106             : 
     107             :     /*
     108             :      * Get copy of (active) alert object by hash. Returns a null alert if it is not found.
     109             :      */
     110             :     static CAlert getAlertByHash(const uint256 &hash);
     111             : };
     112             : 
     113             : #endif // BITCOIN_ALERT_H