src/ExternalConn.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 Kry ( elkry@users.sourceforge.net / http://www.amule.org )
   5 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26 #ifndef EXTERNALCONN_H
  27 #define EXTERNALCONN_H
  28
  29
  30
  31 #include <ec/cpp/ECSpecialTags.h>
  32
  33 #include "amuleIPV4Address.h"   // for amuleIPV4Address
  34 #include "RLE.h"        // for RLE
  35 #include "DownloadQueue.h"
  36
  37 class wxSocketServer;
  38 class wxSocketEvent;
  39
  40 //
  41 // T - type of item
  42 // E - type of encoder
  43 // C - type of container in theApp
  44 template <class T, class E, class C>
  45 class CFileEncoderMap : public std::map<T *, E> {
  46         public:
  47                 void UpdateEncoders(C *container)
  48                 {
  49                         // check if encoder contains files that no longer in container
  50                         // or, we have new files without encoder yet
  51                         std::set<T *> curr_files, dead_files;
  52                         for (unsigned int i = 0; i < container->GetFileCount(); i++) {
  53                                 // cast for case of 'const'
  54                                 T *cur_file = (T *)container->GetFileByIndex(i);
  55                                 curr_files.insert(cur_file);
  56                                 if ( this->count(cur_file) == 0 ) {
  57                                         this->operator [](cur_file) = E(cur_file);
  58                                 }
  59                         }
  60                         //
  61                         // curr_files set is created to minimize lookup time in download queue,
  62                         // since GetFileByID have loop inside leading to O(n), in this case
  63                         // it will mean O(n^2)
  64                         typename std::map<T *, E>::iterator i;
  65                         for(i = this->begin(); i != this->end(); i++) {
  66                                 if ( curr_files.count(i->first) == 0 ) {
  67                                         dead_files.insert(i->first);
  68                                 }
  69                         }
  70                         typename std::set<T *>::iterator j;
  71                         for(j = dead_files.begin(); j != dead_files.end(); j++) {
  72                                 this->erase(*j);
  73                         }
  74                 }
  75 };
  76
  77 /*!
  78  * PartStatus strings are quite long - RLE encoding will help.
  79  *
  80  * Instead of sending each time full part-status string, send
  81  * RLE encoded difference from previous one.
  82  *
  83  * However, gap status is different - it's already kind of RLE
  84  * encoding, so futher compression will help a litter (Shannon
  85  * theorem). Instead, calculate diff between list of gaps.
  86  */
  87 class CPartFile_Encoder {
  88                 //
  89                 // List of gaps sent to particular client. Since clients
  90                 // can request lists in different time, they can get
  91                 // different results
  92                 PartFileEncoderData m_enc_data;
  93
  94                 // gaps are also RLE encoded, but list have variable size by it's nature.
  95                 // so realloc buffer when needed.
  96                 // This buffer only needed on core-side, where list is turned into array
  97                 // before passing to RLE. Decoder will just use RLE internal buffer
  98                 // Buffer can be static, since it is accessed with mutex locked
  99                 typedef std::vector<uint64> GapBuffer;
 100                 static GapBuffer m_gap_buffer;
 101
 102                 CPartFile *m_file;
 103         public:
 104                 // encoder side
 105                 CPartFile_Encoder(CPartFile *file);
 106
 107                 // decoder side
 108                 CPartFile_Encoder(int size);
 109
 110                 ~CPartFile_Encoder();
 111
 112                 // stl side :)
 113                 CPartFile_Encoder();
 114
 115                 CPartFile_Encoder(const CPartFile_Encoder &obj);
 116
 117                 CPartFile_Encoder &operator=(const CPartFile_Encoder &obj);
 118
 119                 // encode - take data from m_file
 120                 void Encode(CECTag *parent_tag);
 121
 122                 void ResetEncoder()
 123                 {
 124                         m_enc_data.ResetEncoder();
 125                 }
 126 };
 127
 128 typedef CFileEncoderMap<CPartFile , CPartFile_Encoder, CDownloadQueue> CPartFile_Encoder_Map;
 129
 130 /*
 131  * Encode 'obtained parts' info to be sent to remote gui
 132  */
 133 class CKnownFile_Encoder {
 134                 RLE_Data m_enc_data;
 135                 CKnownFile *m_file;
 136         public:
 137                 CKnownFile_Encoder(CKnownFile *file);
 138                 ~CKnownFile_Encoder();
 139
 140                 // stl side :)
 141                 CKnownFile_Encoder();
 142
 143                 CKnownFile_Encoder(const CKnownFile_Encoder &obj);
 144
 145                 CKnownFile_Encoder &operator=(const CKnownFile_Encoder &obj);
 146                 // encode - take data from m_file
 147                 void Encode(CECTag *parent_tag);
 148
 149                 void ResetEncoder()
 150                 {
 151                         m_enc_data.ResetEncoder();
 152                 }
 153 };
 154
 155 typedef CFileEncoderMap<CKnownFile , CKnownFile_Encoder, CSharedFileList> CKnownFile_Encoder_Map;
 156
 157 template <class T, ec_tagname_t OP>
 158 class CTagSet : public std::set<T> {
 159                 void InSet(const CECTag *tag, uint32)
 160                 {
 161                         this->insert(tag->GetInt());
 162                 }
 163                 void InSet(const CECTag *tag, CMD4Hash)
 164                 {
 165                         this->insert(tag->GetMD4Data());
 166                 }
 167         public:
 168                 CTagSet(const CECPacket *request) : std::set<T>()
 169                 {
 170                         for (unsigned int i = 0;i < request->GetTagCount();i++) {
 171                                 const CECTag *tag = request->GetTagByIndex(i);
 172                                 if ( tag->GetTagName() == OP ) {
 173                                         this->InSet(tag, T());
 174                                 }
 175                         }
 176                 }
 177 };
 178
 179
 180 class CObjTagMap {
 181                 std::map<void *, CValueMap> m_obj_map;
 182         public:
 183                 CValueMap &GetValueMap(void *object)
 184                 {
 185                         return m_obj_map[object];
 186                 }
 187
 188                 size_t size()
 189                 {
 190                         return m_obj_map.size();
 191                 }
 192
 193                 void RemoveDeleted(std::set<void *>& WXUNUSED(current_set))
 194                 {/*
 195                         for(std::map<void *, CValueMap>::iterator i = m_obj_map.begin(); i != m_obj_map.end(); i++) {
 196                                 if ( !current_set.count(i->first) ) {
 197                                         m_obj_map.erase(i->first);
 198                                 }
 199                         }
 200                         */
 201                 }
 202 };
 203
 204
 205 class CECServerSocket;
 206
 207
 208 class ExternalConn : public wxEvtHandler
 209 {
 210 private:
 211         typedef std::set<CECServerSocket *> SocketSet;
 212         SocketSet socket_list;
 213
 214 public:
 215         ExternalConn(amuleIPV4Address addr, wxString *msg);
 216         ~ExternalConn();
 217
 218         wxSocketServer *m_ECServer;
 219
 220         static CECPacket *ProcessRequest2(
 221                 const CECPacket *request,
 222                 CPartFile_Encoder_Map &,
 223                 CKnownFile_Encoder_Map &,
 224                 CObjTagMap &);
 225
 226         static CECPacket *Authenticate(const CECPacket *);
 227
 228         void AddSocket(CECServerSocket *s);
 229         void RemoveSocket(CECServerSocket *s);
 230         void KillAllSockets();
 231
 232 private:
 233         // event handlers (these functions should _not_ be virtual)
 234         void OnServerEvent(wxSocketEvent& event);
 235         DECLARE_EVENT_TABLE()
 236 };
 237
 238 #endif // EXTERNALCONN_H
 239 // File_checked_for_headers