1 // 2 // This file is part of the aMule Project. 3 // 4 // Copyright (c) 2006-2011 Mikkel Schubert ( xaignar@amule.org / http:://www.amule.org ) 5 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org ) 6 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net ) 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 TASKS_H 28 #define TASKS_H 29 30 #include "ThreadScheduler.h" 31 #include <common/Path.h> 32 33 class CKnownFile; 34 class CPartFile; 35 class CFileAutoClose; 36 37 38 /** 39 * This task performs MD4 and/or AICH hashings of a file, 40 * depending on the type. For new shared files (using the 41 * first constructor, with part == NULL), both MD4 and 42 * AICH hashes are created. For incomplete partfiles 43 * (rehashed due to changed timestamps), only MD4 hashing 44 * is done. For complete partfiles, both MD4 and AICH 45 * hashing is done. 46 * 47 * For existing shared files (using the second constructor), 48 * only an AICH hash is created. 49 * 50 * @see CHashingEvent 51 * @see CAICHSyncTask 52 */ 53 class CHashingTask : public CThreadTask 54 { 55 public: 56 /** 57 * Schedules a partfile or new shared file for hashing. 58 * 59 * @param path The full path, without filename. 60 * @param filename The actual filename. 61 * @param part Used to identify the owner in the event-handler (PartFiles only). 62 * 63 * CHashingEvents sent by this type of tasks have the id MULE_EVT_HASHING. 64 * @see EVT_MULE_HASHING 65 */ 66 CHashingTask(const CPath& path, const CPath& filename, const CPartFile* part = NULL); 67 68 /** 69 * Schedules a KnownFile to have a AICH hashset created, used by CAICHSyncTask. 70 * 71 * CHashingEvents sent by this type of tasks have the id MULE_EVT_AICH_HASHING. 72 * @see EVT_MULE_AICH_HASHING 73 **/ 74 CHashingTask(const CKnownFile* toAICHHash); 75 76 protected: 77 //! Specifies which hashes should be calculated when the task is executed. 78 enum EHashes { 79 EH_AICH = 1, 80 EH_MD4 = 2 81 }; 82 83 //! @see CThreadTask::OnLastTask 84 virtual void OnLastTask(); 85 86 //! @see CThreadTask::Entry 87 virtual void Entry(); 88 89 /** 90 * Helper function for hashing a PARTSIZE chunk of a file. 91 * 92 * @param file The file to read from. 93 * @param part The number of the part to hash. 94 * @param owner The known- (or part) file representing that file. 95 * @bool createAICH Specifies if AICH hash-sets should be created as well. 96 * @return Returns false on read-errors, true otherwise. 97 * 98 * This function will create a MD4 hash and, if specified, a AICH hashset for 99 * the next part of the file. This function makes the assumption that it wont 100 * be called for closed or EOF files. 101 */ 102 bool CreateNextPartHash(CFileAutoClose& file, uint16 part, CKnownFile* owner, EHashes toHash); 103 104 105 //! The path to the file to be hashed (shared or part), without filename. 106 CPath m_path; 107 //! The filename of the file to be hashed (filename only). 108 CPath m_filename; 109 //! Specifies which hash-types should be calculated 110 EHashes m_toHash; 111 //! If a partfile or an AICH hashing, this pointer stores it for callbacks. 112 const CKnownFile* m_owner; 113 114 private: 115 void SetHashingProgress(uint16 part); 116 }; 117 118 119 /** 120 * This task synchronizes the AICH hashlist. 121 * 122 * Shared files that are lacking a AICH-hash are scheduled for hashing. 123 */ 124 class CAICHSyncTask : public CThreadTask 125 { 126 public: 127 CAICHSyncTask(); 128 129 protected: 130 /** See CThreadTask::Entry */ 131 virtual void Entry(); 132 133 /** Converts old known2.met files to known2_64.met files. */ 134 bool ConvertToKnown2ToKnown264(); 135 }; 136 137 138 /** 139 * This task performs the final tasks on a complete download. 140 * 141 * This includes finding a usable destination filename, removing 142 * old data files and moving the part-file (potentially to a 143 * different partition). 144 **/ 145 class CCompletionTask : public CThreadTask 146 { 147 public: 148 /** 149 * Creates a thread which will complete the given download. 150 */ 151 CCompletionTask(const CPartFile* file); 152 153 protected: 154 /** See CThreadTask::Entry */ 155 virtual void Entry(); 156 157 /** See CThreadTask::OnExit */ 158 virtual void OnExit(); 159 160 //! The target filename. 161 CPath m_filename; 162 //! The full path to the .met-file 163 CPath m_metPath; 164 //! The category of the download. 165 uint8 m_category; 166 //! Owner of the file, used when sending completion-event. 167 const CPartFile* m_owner; 168 //! Specifies if an error occured during completion. 169 bool m_error; 170 //! The resulting full path. File may be be renamed. 171 CPath m_newName; 172 }; 173 174 175 /** 176 * This task preallocates space for a newly created partfile. 177 */ 178 class CAllocateFileTask : public CThreadTask 179 { 180 public: 181 /** Creates a thread that will allocate disk space for the full file. */ 182 CAllocateFileTask(CPartFile *file, bool pause); 183 184 protected: 185 /** See CThreadTask::Entry */ 186 virtual void Entry(); 187 188 /** See CThreadTask::OnExit */ 189 virtual void OnExit(); 190 191 private: 192 //! The partfile for which this task allocates space. 193 CPartFile * m_file; 194 195 //! Should this download start paused? 196 bool m_pause; 197 198 //! Result of the preallocation. 199 long m_result; 200 }; 201 202 203 /** 204 * This event is used to signal the completion of a hashing event. 205 * 206 * @see CHashingTask 207 */ 208 class CHashingEvent : public wxEvent 209 { 210 public: 211 /** 212 * @param type MULE_EVT_HASHING or MULE_EVT_AICH_HASHING. 213 * @param result 214 */ 215 CHashingEvent(wxEventType type, CKnownFile* result, const CKnownFile* owner = NULL); 216 217 /** @see wxEvent::Clone */ 218 virtual wxEvent* Clone() const; 219 220 /** Returns the owner (may be NULL) of the hashing result. */ 221 const CKnownFile* GetOwner() const; 222 /** Returns a CKnownfile used to store the results of the hashing. */ 223 CKnownFile* GetResult() const; 224 225 private: 226 //! The file owner. 227 const CKnownFile* m_owner; 228 //! The hashing results. 229 CKnownFile* m_result; 230 }; 231 232 233 /** 234 * This event is sent when a part-file has been completed. 235 */ 236 class CCompletionEvent : public wxEvent 237 { 238 public: 239 /** Constructor, see getter funtion for description of parameters. */ 240 CCompletionEvent(bool errorOccured, const CPartFile* owner, const CPath& fullPath); 241 242 /** @see wxEvent::Clone */ 243 virtual wxEvent* Clone() const; 244 245 /** Returns true if completion failed. */ 246 bool ErrorOccured() const; 247 248 /** Returns the owner of the file that was being completed. */ 249 const CPartFile* GetOwner() const; 250 251 /** Returns the full path to the completed file (empty on failure). */ 252 const CPath& GetFullPath() const; 253 private: 254 //! The full path to the completed file. 255 CPath m_fullPath; 256 257 //! The owner of the completed .part file. 258 const CPartFile* m_owner; 259 260 //! Specifies if completion failed. 261 bool m_error; 262 }; 263 264 265 /** 266 * This event is sent when preallocation of a new partfile is finished. 267 */ 268 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_ALLOC_FINISHED, -1); 269 class CAllocFinishedEvent : public wxEvent 270 { 271 public: 272 /** Constructor, see getter function for description of parameters. */ CAllocFinishedEvent(CPartFile * file,bool pause,long result)273 CAllocFinishedEvent(CPartFile *file, bool pause, long result) 274 : wxEvent(-1, MULE_EVT_ALLOC_FINISHED), 275 m_file(file), m_pause(pause), m_result(result) 276 {} 277 278 /** @see wxEvent::Clone */ 279 virtual wxEvent *Clone() const; 280 281 /** Returns the partfile for which preallocation was requested. */ GetFile()282 CPartFile *GetFile() const throw() { return m_file; } 283 284 /** Returns whether the partfile should start paused. */ IsPaused()285 bool IsPaused() const throw() { return m_pause; } 286 287 /** Returns the result of preallocation: true on success, false otherwise. */ Succeeded()288 bool Succeeded() const throw() { return m_result == 0; } 289 290 /** Returns the result of the preallocation. */ GetResult()291 long GetResult() const throw() { return m_result; } 292 293 private: 294 //! The partfile for which preallocation was requested. 295 CPartFile * m_file; 296 297 //! Should the download start paused? 298 bool m_pause; 299 300 //! Result of preallocation 301 long m_result; 302 }; 303 304 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_HASHING, -1) 305 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_AICH_HASHING, -1) 306 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_FILE_COMPLETED, -1) 307 308 309 typedef void (wxEvtHandler::*MuleHashingEventFunction)(CHashingEvent&); 310 typedef void (wxEvtHandler::*MuleCompletionEventFunction)(CCompletionEvent&); 311 typedef void (wxEvtHandler::*MuleAllocFinishedEventFunction)(CAllocFinishedEvent&); 312 313 //! Event-handler for completed hashings of new shared files and partfiles. 314 #define EVT_MULE_HASHING(func) \ 315 DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_HASHING, -1, -1, \ 316 (wxObjectEventFunction) (wxEventFunction) \ 317 wxStaticCastEvent(MuleHashingEventFunction, &func), (wxObject*) NULL), 318 319 //! Event-handler for completed hashings of files that were missing a AICH hash. 320 #define EVT_MULE_AICH_HASHING(func) \ 321 DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_AICH_HASHING, -1, -1, \ 322 (wxObjectEventFunction) (wxEventFunction) \ 323 wxStaticCastEvent(MuleHashingEventFunction, &func), (wxObject*) NULL), 324 325 //! Event-handler for completion of part-files. 326 #define EVT_MULE_FILE_COMPLETED(func) \ 327 DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_FILE_COMPLETED, -1, -1, \ 328 (wxObjectEventFunction) (wxEventFunction) \ 329 wxStaticCastEvent(MuleCompletionEventFunction, &func), (wxObject*) NULL), 330 331 //! Event-handler for partfile preallocation finished events. 332 #define EVT_MULE_ALLOC_FINISHED(func) \ 333 DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_ALLOC_FINISHED, -1, -1, \ 334 (wxObjectEventFunction) (wxEventFunction) \ 335 wxStaticCastEvent(MuleAllocFinishedEventFunction, &func), (wxObject*) NULL), 336 337 338 #endif // TASKS_H 339 // File_checked_for_headers 340