src/ExternalConn.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2011 Kry ( elkry@users.sourceforge.net / http://www.amule.org )
   5 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   6 // Copyright (c) 2008-2011 Froenchenko Leonid (lfroen@gmail.com)
   7 //
   8 // Any parts of this program derived from the xMule, lMule or eMule project,
   9 // or contributed by third-party developers are copyrighted by their
  10 // respective authors.
  11 //
  12 // This program is free software; you can redistribute it and/or modify
  13 // it under the terms of the GNU General Public License as published by
  14 // the Free Software Foundation; either version 2 of the License, or
  15 // (at your option) any later version.
  16 //
  17 // This program is distributed in the hope that it will be useful,
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 // GNU General Public License for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License
  23 // along with this program; if not, write to the Free Software
  24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  25 //
  26
  27 #ifndef EXTERNALCONN_H
  28 #define EXTERNALCONN_H
  29
  30
  31
  32 #include <ec/cpp/ECSpecialTags.h>
  33
  34 #include "amuleIPV4Address.h"   // for amuleIPV4Address
  35 #include "RLE.h"        // for RLE
  36 #include "DownloadQueue.h"
  37 #include "PartFile.h"                   // for SourcenameItemMap
  38
  39 #ifndef ASIO_SOCKETS
  40 class wxSocketEvent;
  41 #endif
  42
  43 template <class T, ec_tagname_t OP>
  44 class CTagSet : public std::set<T> {
  45                 void InSet(const CECTag *tag, uint32)
  46                 {
  47                         this->insert(tag->GetInt());            // don't remove this->
  48                 }
  49                 void InSet(const CECTag *tag, const CMD4Hash&)
  50                 {
  51                         this->insert(tag->GetMD4Data());        // don't remove this->
  52                 }
  53         public:
  54                 CTagSet(const CECPacket *request) : std::set<T>()
  55                 {
  56                         for (CECPacket::const_iterator it = request->begin(); it != request->end(); ++it) {
  57                                 const CECTag *tag = & *it;
  58                                 if ( tag->GetTagName() == OP ) {
  59                                         InSet(tag, T());
  60                                 }
  61                         }
  62                 }
  63 };
  64
  65
  66 class CObjTagMap {
  67                 std::map<uint32, CValueMap> m_obj_map;
  68         public:
  69                 CValueMap &GetValueMap(uint32 ECID)
  70                 {
  71                         return m_obj_map[ECID];
  72                 }
  73
  74                 size_t size()
  75                 {
  76                         return m_obj_map.size();
  77                 }
  78 };
  79
  80
  81 class CECServerSocket;
  82 class ECNotifier;
  83 class ExternalConn;
  84
  85 class CExternalConnListener : public CLibSocketServer
  86 {
  87 public:
  88         CExternalConnListener(const amuleIPV4Address& adr, int flags, ExternalConn * conn)
  89                 : CLibSocketServer(adr, flags), m_conn(conn) {}
  90         void OnAccept();
  91 private:
  92         ExternalConn * m_conn;
  93 };
  94
  95
  96 class ExternalConn : public wxEvtHandler
  97 {
  98 private:
  99         typedef std::set<CECServerSocket *> SocketSet;
 100         SocketSet socket_list;
 101
 102 public:
 103         ExternalConn(amuleIPV4Address addr, wxString *msg);
 104         ~ExternalConn();
 105
 106         CExternalConnListener *m_ECServer;
 107         ECNotifier *m_ec_notifier;
 108
 109         void AddSocket(CECServerSocket *s);
 110         void RemoveSocket(CECServerSocket *s);
 111         void KillAllSockets();
 112         void ResetAllLogs();
 113
 114 #ifndef ASIO_SOCKETS
 115 private:
 116         // event handlers (these functions should _not_ be virtual)
 117         void OnServerEvent(wxSocketEvent& event);
 118         DECLARE_EVENT_TABLE()
 119 #endif
 120 };
 121
 122 class ECUpdateMsgSource {
 123         public:
 124                 virtual ~ECUpdateMsgSource()
 125                 {
 126                 }
 127                 virtual CECPacket *GetNextPacket() = 0;
 128 };
 129
 130 class ECPartFileMsgSource : public ECUpdateMsgSource {
 131                 typedef struct {
 132                         bool m_new;
 133                         bool m_comment_changed;
 134                         bool m_removed;
 135                         bool m_finished;
 136                         bool m_dirty;
 137                         const CPartFile *m_file;
 138                 } PARTFILE_STATUS;
 139                 std::map<CMD4Hash, PARTFILE_STATUS> m_dirty_status;
 140         public:
 141                 ECPartFileMsgSource();
 142
 143                 void SetDirty(const CPartFile *file);
 144                 void SetNew(const CPartFile *file);
 145                 void SetCompleted(const CPartFile *file);
 146                 void SetRemoved(const CPartFile *file);
 147
 148                 virtual CECPacket *GetNextPacket();
 149
 150 };
 151
 152 class ECKnownFileMsgSource : public ECUpdateMsgSource {
 153                 typedef struct {
 154                         bool m_new;
 155                         bool m_comment_changed;
 156                         bool m_removed;
 157                         bool m_dirty;
 158                         const CKnownFile *m_file;
 159                 } KNOWNFILE_STATUS;
 160                 std::map<CMD4Hash, KNOWNFILE_STATUS> m_dirty_status;
 161         public:
 162                 ECKnownFileMsgSource();
 163
 164                 void SetDirty(const CKnownFile *file);
 165                 void SetNew(const CKnownFile *file);
 166                 void SetRemoved(const CKnownFile *file);
 167
 168                 virtual CECPacket *GetNextPacket();
 169 };
 170
 171 class ECClientMsgSource : public ECUpdateMsgSource {
 172         public:
 173                 virtual CECPacket *GetNextPacket();
 174 };
 175
 176 class ECStatusMsgSource : public ECUpdateMsgSource {
 177                 uint32 m_last_ed2k_status_sent;
 178                 uint32 m_last_kad_status_sent;
 179                 void *m_server;
 180
 181                 uint32 GetEd2kStatus();
 182                 uint32 GetKadStatus();
 183         public:
 184                 ECStatusMsgSource();
 185
 186                 virtual CECPacket *GetNextPacket();
 187 };
 188
 189 class ECSearchMsgSource : public ECUpdateMsgSource {
 190                 typedef struct {
 191                         bool m_new;
 192                         bool m_child_dirty;
 193                         bool m_dirty;
 194                         const CSearchFile *m_file;
 195                 } SEARCHFILE_STATUS;
 196                 std::map<CMD4Hash, SEARCHFILE_STATUS> m_dirty_status;
 197         public:
 198                 ECSearchMsgSource();
 199
 200                 void SetDirty(const CSearchFile *file);
 201                 void SetChildDirty(const CSearchFile *file);
 202
 203                 void FlushStatus();
 204
 205                 virtual CECPacket *GetNextPacket();
 206 };
 207
 208 class ECNotifier {
 209                 //
 210                 // designated priority for each type of update
 211                 //
 212                 enum EC_SOURCE_PRIO {
 213                         EC_PARTFILE = 0,
 214                         EC_SEARCH,
 215                         EC_CLIENT,
 216                         EC_STATUS,
 217                         EC_KNOWN,
 218
 219                         EC_STATUS_LAST_PRIO
 220                 };
 221
 222                 //ECUpdateMsgSource *m_msg_source[EC_STATUS_LAST_PRIO];
 223                 std::map<CECServerSocket *, ECUpdateMsgSource **> m_msg_source;
 224
 225                 void NextPacketToSocket();
 226
 227                 CECPacket *GetNextPacket(ECUpdateMsgSource *msg_source_array[]);
 228                 // Make class non assignable
 229                 void operator=(const ECNotifier&);
 230                 ECNotifier(const ECNotifier&);
 231         public:
 232                 ECNotifier();
 233                 ~ECNotifier();
 234
 235                 void Add_EC_Client(CECServerSocket *sock);
 236                 void Remove_EC_Client(CECServerSocket *sock);
 237
 238                 CECPacket *GetNextPacket(CECServerSocket *sock);
 239
 240                 //
 241                 // Interface to notification macros
 242                 //
 243                 void DownloadFile_SetDirty(const CPartFile *file);
 244                 void DownloadFile_RemoveFile(const CPartFile *file);
 245                 void DownloadFile_RemoveSource(const CPartFile *file);
 246                 void DownloadFile_AddFile(const CPartFile *file);
 247                 void DownloadFile_AddSource(const CPartFile *file);
 248
 249                 void SharedFile_AddFile(const CKnownFile *file);
 250                 void SharedFile_RemoveFile(const CKnownFile *file);
 251                 void SharedFile_RemoveAllFiles();
 252
 253 };
 254
 255
 256 #endif // EXTERNALCONN_H
 257 // File_checked_for_headers