source: trunk/Item.cpp @ 76

Revision 76, 13.2 KB checked in by lowjoel, 7 years ago (diff)

Warning fixes.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1// Item.cpp
2// $Id$
3//
4// Eraser. Secure data removal. For Windows.
5// Copyright © 1997-2001  Sami Tolvanen (sami@tolvanen.com).
6//
7// This program is free software; you can redistribute it and/or
8// modify it under the terms of the GNU General Public License
9// as published by the Free Software Foundation; either version 2
10// of the License, or (at your option) any later version.
11//
12// This program is distributed in the hope that it will be useful,
13// but WITHOUT ANY WARRANTY; without even the implied warranty of
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15// GNU General Public License for more details.
16//
17// You should have received a copy of the GNU General Public License
18// along with this program; if not, write to the Free Software
19// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20// 02111-1307, USA.
21
22#include "stdafx.h"
23#include "Eraser.h"
24#include "Item.h"
25//#include "EraserDll\Pass.h"
26
27#ifdef _DEBUG
28#undef THIS_FILE
29static char THIS_FILE[]=__FILE__;
30#define new DEBUG_NEW
31#endif
32
33//////////////////////////////////////////////////////////////////////
34// Construction/Destruction
35//////////////////////////////////////////////////////////////////////
36
37CItem::CItem() :
38m_bWildCardsInSubfolders(FALSE),
39m_bUseWildcards(FALSE),
40m_bRemoveFolder(FALSE),
41m_bSubfolders(TRUE),
42m_bRemoveOnlySub(FALSE),
43m_tType(Drive),
44m_bPersistent(FALSE)
45{
46
47}
48
49CItem::CItem(const CItem& op)
50{
51    Copy(op);
52}
53
54CItem::~CItem()
55{
56
57}
58
59CItem& CItem::operator=(const CItem& op)
60{
61    if (this != &op)
62        Copy(op);
63
64    return *this;
65}
66
67void CItem::Copy(const CItem& op)
68{
69    m_strData           = op.m_strData;
70    m_bUseWildcards     = op.m_bUseWildcards;
71    m_bWildCardsInSubfolders = op.m_bWildCardsInSubfolders;
72    m_bRemoveFolder     = op.m_bRemoveFolder;
73    m_bSubfolders       = op.m_bSubfolders;
74    m_bRemoveOnlySub    = op.m_bRemoveOnlySub;
75    m_tType             = op.m_tType;
76    m_bPersistent       = op.m_bPersistent;
77    m_iFinishAction     = op.m_iFinishAction;
78}
79
80BOOL CItem::SetDrive(const CString& str)
81{
82    if (str.GetLength() > _MAX_DRIVE || str.Find(":\\") != 1)
83        return FALSE;
84    else
85    {
86        m_tType   = Drive;
87        m_strData = str;
88
89        return TRUE;
90    }
91}
92
93BOOL CItem::SetFolder(const CString& str)
94{
95    if (str.Find(":\\") != 1)
96        return FALSE;
97    else
98    {
99        m_tType   = Folder;
100        m_strData = str;
101
102        if (m_strData[m_strData.GetLength() - 1] != '\\')
103            m_strData += "\\";
104
105        return TRUE;
106    }
107}
108
109BOOL CItem::SetFile(const CString& str)
110{
111    m_tType   = File;
112    m_strData = str;
113
114    return TRUE;
115}
116
117void CItem::Serialize(CArchive& ar)
118{
119    if (ar.IsStoring())
120    {
121        ar << static_cast<WORD>(m_tType);
122        ar << m_strData;
123        ar << m_bWildCardsInSubfolders;
124        ar << m_bUseWildcards;
125        ar << m_bRemoveFolder;
126        ar << m_bRemoveOnlySub;
127        ar << m_bSubfolders;
128        ar << m_bPersistent;
129        ar << m_iFinishAction;
130    }
131    else
132    {
133        WORD wTmp = 0;
134        ar >> wTmp;
135        m_tType = static_cast<Type>(wTmp);
136
137        ar >> m_strData;
138        ar >> m_bWildCardsInSubfolders;
139        ar >> m_bUseWildcards;
140        ar >> m_bRemoveFolder;
141        ar >> m_bRemoveOnlySub;
142        ar >> m_bSubfolders;
143        ar >> m_bPersistent;
144        ar >> m_iFinishAction;
145    }
146}
147
148#ifdef SCHEDULER_IMPORT_COMPATIBLE
149void CItem::Serialize40(CArchive& ar)
150{
151    if (ar.IsLoading())
152    {
153        WORD wTmp = 0;
154        ar >> wTmp;
155        m_tType = static_cast<Type>(wTmp);
156
157        ar >> m_strData;
158        ar >> m_bUseWildcards;
159        ar >> m_bRemoveFolder;
160        ar >> m_bRemoveOnlySub;
161        ar >> m_bSubfolders;
162        ar >> m_bPersistent;
163        ar >> m_iFinishAction;
164    }
165}
166
167void CItem::Serialize30(CArchive& ar)
168{
169    if (ar.IsLoading())
170    {
171        WORD wTmp = 0;
172        ar >> wTmp;
173        m_tType = static_cast<Type>(wTmp);
174
175        ar >> m_strData;
176        ar >> m_bRemoveFolder;
177        ar >> m_bRemoveOnlySub;
178        ar >> m_bSubfolders;
179        ar >> m_iFinishAction;
180    }
181}
182#endif // SCHEDULER_IMPORT_COMPATIBLE
183
184//////////////////////////////////////////////////////////////////////
185// Construction/Destruction
186//////////////////////////////////////////////////////////////////////
187
188CScheduleItem::CScheduleItem() :
189CItem(),
190m_dwTime(0),
191m_scWhen(Day),
192m_uTimerID(0),
193m_bQueued(FALSE),
194m_ehContext(ERASER_INVALID_CONTEXT),
195m_bMethod(0)
196{
197    m_odtNext = GetTimeTimeZoneBased();
198    m_odtLast.SetStatus(COleDateTime::null);
199}
200
201CScheduleItem::CScheduleItem(const CScheduleItem& op) :
202CItem(),
203m_bQueued(FALSE)
204{
205    Copy(op);
206}
207
208CScheduleItem::~CScheduleItem()
209{
210    if (m_ehContext != ERASER_INVALID_CONTEXT)
211        eraserDestroyContext(m_ehContext);
212}
213
214void CScheduleItem::Copy(const CScheduleItem& op)
215{
216    // CItem
217    CItem::Copy(op);
218
219    // CScheduleItem
220    m_ehContext = ERASER_INVALID_CONTEXT;
221
222    m_dwTime       = op.m_dwTime;
223    m_odtNext      = op.m_odtNext;
224    m_odtLast      = op.m_odtLast;
225    m_scWhen       = op.m_scWhen;
226    m_uTimerID     = op.m_uTimerID;
227    m_tsStatistics = op.m_tsStatistics;
228}
229UINT CScheduleItem::GetTimeSpan(const COleDateTime& odt) const
230{
231    // calculates the time in milliseconds
232    // before the task is to be run
233
234    COleDateTime        odtCurrent;
235    COleDateTimeSpan    odtSpan;
236    double              dSeconds;
237    UINT                uResult;
238
239    odtCurrent  = GetTimeTimeZoneBased();
240    odtSpan     = odt - odtCurrent;
241
242    dSeconds    = odtSpan.GetTotalSeconds();
243
244    if (dSeconds < 0.0)
245        return 0;
246    else
247    {
248        uResult = static_cast<UINT>((dSeconds * 1000));
249        return uResult;
250    }
251}
252
253UINT CScheduleItem::GetTimeSpan() const
254{
255    return GetTimeSpan(m_odtNext);
256}
257
258BOOL CScheduleItem::ScheduledNow()
259{
260    // check whether the task is scheduled to be
261    // executed in the near future or a while ago
262
263    const double dTimeFrame = 120.0; // seconds
264
265    COleDateTime        odtCurrent;
266    COleDateTimeSpan    odtSpan;
267    double              dSeconds;
268
269    odtCurrent  = GetTimeTimeZoneBased();
270    odtSpan     = m_odtNext - odtCurrent;
271
272    dSeconds    = odtSpan.GetTotalSeconds();
273
274    return ((dSeconds >= 0.0 && dSeconds < dTimeFrame) ||
275            (dSeconds <= 0.0 && dSeconds > -dTimeFrame));
276}
277
278BOOL CScheduleItem::StillValid()
279{
280    return (GetTimeSpan() > 0);
281}
282
283BOOL CScheduleItem::CalcNextTime()
284{
285    // calculates the time of the next run
286    if (m_scWhen == Reboot) 
287    {return TRUE;}
288    else
289    {
290    // now
291    m_odtNext = GetTimeTimeZoneBased();
292
293    m_odtNext.SetDateTime(m_odtNext.GetYear(),
294                          m_odtNext.GetMonth(),
295                          m_odtNext.GetDay(),
296                          GetHour(),
297                          GetMinute(),
298                          0);
299
300    // set the correct day
301    if (m_scWhen == Day)
302    {
303        // daily
304
305        if (StillValid())
306            return TRUE;
307
308        // not valid anymore, tomorrow again
309        COleDateTimeSpan odtSpan;
310        odtSpan.SetDateTimeSpan(1, 0, 0, 0);
311
312        m_odtNext += odtSpan;
313    }
314    else
315    {
316        // weekly
317        if (m_odtNext.GetDayOfWeek() == m_scWhen)
318        {
319            // correct day
320            if (StillValid())
321                return TRUE;
322
323            // next week
324            COleDateTimeSpan odtSpan;
325            odtSpan.SetDateTimeSpan(7, 0, 0, 0);
326
327            m_odtNext += odtSpan;
328        }
329        else
330        {
331            // wrong day
332            int iDaysToAdd;
333            int iDay = m_odtNext.GetDayOfWeek();
334
335            for (iDaysToAdd = 0; iDay != m_scWhen; iDaysToAdd++)
336            {
337                if (iDay == 7) iDay = 0;
338                iDay++;
339            }
340
341            COleDateTimeSpan odtSpan;
342            odtSpan.SetDateTimeSpan(iDaysToAdd, 0, 0, 0);
343
344            m_odtNext += odtSpan;
345        }
346
347        ASSERT(m_odtNext.GetDayOfWeek() == m_scWhen);
348    }
349
350    ASSERT(StillValid());
351    }
352    return TRUE;
353}
354
355BOOL CScheduleItem::SetTime(WORD wHour, WORD wMinute)
356{
357    if (wHour > 23 || wMinute > 59)
358        return FALSE;
359    else
360    {
361        m_dwTime = static_cast<DWORD>(MAKEWPARAM(wHour, wMinute));
362        return TRUE;
363    }
364}
365
366BOOL CScheduleItem::SetTime(DWORD dwTime)
367{
368    return SetTime(LOWORD(dwTime), HIWORD(dwTime));
369}
370CString     CScheduleItem::GetId() const
371{ 
372    CString m_strId;
373    m_strId.Format("%d",m_uTimerID);
374    return  "Eraser"+m_strId;
375}
376WORD CScheduleItem::GetHour() const
377{
378    return LOWORD(m_dwTime);
379}
380
381WORD CScheduleItem::GetMinute() const
382{
383    return HIWORD(m_dwTime);
384}
385
386BOOL CScheduleItem::GetNextTime(CString& str) const
387{
388    str = m_odtNext.Format();
389    return TRUE;
390}
391
392BOOL CScheduleItem::SetNextTime(CString& str)
393{
394    try
395    {
396        return m_odtNext.ParseDateTime((LPCTSTR) str);
397    }
398    catch (CException *e)
399    {
400        ASSERT(FALSE);
401        REPORT_ERROR(e);
402        e->Delete();
403
404        return FALSE;
405    }
406    catch (...)
407    {
408        ASSERT(FALSE);
409        return FALSE;
410    }
411}
412
413CScheduleItem& CScheduleItem::operator=(const CScheduleItem& op)
414{
415    if (this != &op)
416        Copy(op);
417
418    return *this;
419}
420
421void CScheduleItem::Serialize(CArchive& ar)
422{
423    if (ar.IsStoring())
424    {
425        ar << m_dwTime;
426        ar << m_odtNext;
427        ar << m_odtLast;
428        ar << static_cast<WORD>(m_scWhen);
429        m_tsStatistics.Serialize(ar);
430        ar << m_bMethod;
431        ar << m_nRndPass;
432        ar << m_uEraseItems;
433       
434    }
435    else
436    {
437        WORD wTmp = 0;
438        ar >> m_dwTime;
439        ar >> m_odtNext;
440        ar >> m_odtLast;
441        ar >> wTmp;
442        m_scWhen = static_cast<Schedule>(wTmp);
443        m_tsStatistics.Serialize(ar);
444       
445        ar >> m_bMethod;
446        ar >> m_nRndPass;
447        ar >> m_uEraseItems;
448                       
449        m_uTimerID = 0;
450        m_ehContext = ERASER_INVALID_CONTEXT;
451    }
452
453    CItem::Serialize(ar);
454}
455
456void CScheduleItem::Serialize41(CArchive& ar)
457{
458    if (ar.IsStoring())
459    {       
460        ar << m_dwTime;
461        ar << m_odtNext;
462        ar << m_odtLast;
463        ar << static_cast<WORD>(m_scWhen);
464        m_tsStatistics.Serialize(ar);
465    }
466    else
467    {
468        WORD wTmp = 0;
469        ar >> m_dwTime;
470        ar >> m_odtNext;
471        ar >> m_odtLast;
472        ar >> wTmp;
473        m_scWhen = static_cast<Schedule>(wTmp);
474        m_tsStatistics.Serialize(ar);
475               
476        m_uTimerID = 0;
477        m_ehContext = ERASER_INVALID_CONTEXT;
478    }
479    CItem::Serialize(ar);
480}
481
482#ifdef SCHEDULER_IMPORT_COMPATIBLE
483void CScheduleItem::Serialize40(CArchive& ar)
484{
485    // support for loading only the old format used in
486    // Eraser 4.0
487
488    if (ar.IsLoading())
489    {
490        WORD wTmp = 0;
491
492        ar >> m_dwTime;
493        ar >> m_odtNext;
494        ar >> m_odtLast;
495        ar >> wTmp;
496        m_scWhen = static_cast<Schedule>(wTmp);
497        m_tsStatistics.Serialize(ar);
498
499        m_uTimerID = 0;
500        m_ehContext = ERASER_INVALID_CONTEXT;
501
502        CItem::Serialize40(ar);
503    }
504}
505
506void CScheduleItem::Serialize30(CArchive& ar)
507{
508    // support for loading only the old format used in
509    // Eraser 3.0
510
511    if (ar.IsLoading())
512    {
513        WORD wTmp = 0;
514
515        ar >> m_dwTime;
516        ar >> m_odtNext;
517        ar >> m_odtLast;
518        ar >> wTmp;
519        m_scWhen = static_cast<Schedule>(wTmp);
520        m_tsStatistics.Serialize(ar);
521
522        m_uTimerID = 0;
523        m_ehContext = ERASER_INVALID_CONTEXT;
524    }
525
526    CItem::Serialize30(ar);
527}
528
529void CScheduleItem::Serialize21(CArchive& ar)
530{
531    // support for loading only the old format used in
532    // Eraser Scheduler 2.1
533
534    if (ar.IsLoading())
535    {
536        WORD wTmp = 0;
537
538        ar >> m_dwTime;
539        ar >> m_odtNext;
540        ar >> wTmp; m_scWhen = static_cast<Schedule>(wTmp);
541        ar >> wTmp; m_tType = static_cast<Type>(wTmp);
542        ar >> m_strData;
543        ar >> m_bRemoveFolder;
544        ar >> m_bRemoveOnlySub;
545        ar >> m_bSubfolders;
546        m_tsStatistics.Serialize(ar);
547
548        m_uTimerID = 0;
549        m_ehContext = ERASER_INVALID_CONTEXT;
550    }
551}
552#endif // SCHEDULER_IMPORT_COMPATIBLE
553
554BOOL CScheduleItem::IsRunning()
555{
556    E_UINT8 uRunning = 0;
557    return (eraserOK(eraserIsRunning(m_ehContext, &uRunning)) && uRunning != 0);
558}
559
560void CScheduleItem::UpdateStatistics()
561{
562    try
563    {
564        E_UINT64 uWiped = 0;
565        E_UINT64 uArea = 0;
566        E_UINT32 uTime = 0;
567        VERIFY(eraserOK(eraserStatGetWiped(m_ehContext, &uWiped)));
568        VERIFY(eraserOK(eraserStatGetArea(m_ehContext, &uArea)));
569        VERIFY(eraserOK(eraserStatGetTime(m_ehContext, &uTime)));
570
571        if (m_tsStatistics.m_dwTimes > 0)
572        {
573            DWORD dwTmp;
574
575            dwTmp = static_cast<DWORD>((uWiped + 512) / 1024);
576            dwTmp += m_tsStatistics.m_dwAveWritten * (m_tsStatistics.m_dwTimes - 1);
577            dwTmp /= m_tsStatistics.m_dwTimes;
578
579            m_tsStatistics.m_dwAveWritten = dwTmp;
580
581            dwTmp = static_cast<DWORD>((uArea + 512) / 1024);
582            dwTmp += m_tsStatistics.m_dwAveArea * (m_tsStatistics.m_dwTimes - 1);
583            dwTmp /= m_tsStatistics.m_dwTimes;
584
585            m_tsStatistics.m_dwAveArea = dwTmp;
586
587            dwTmp = uTime;
588            dwTmp += m_tsStatistics.m_dwAveTime * (m_tsStatistics.m_dwTimes - 1);
589            dwTmp /= m_tsStatistics.m_dwTimes;
590
591            m_tsStatistics.m_dwAveTime = dwTmp;
592        }
593    }
594    catch (...)
595    {
596        ASSERT(FALSE);
597    }
598}
599
600void CTaskStatistics::Serialize(CArchive& ar)
601{
602    if (ar.IsStoring())
603    {
604        ar << m_dwAveArea;
605        ar << m_dwAveWritten;
606        ar << m_dwAveTime;
607
608        ar << m_dwTimes;
609        ar << m_dwTimesInterrupted;
610        ar << m_dwTimesSuccess;
611    }
612    else
613    {
614        ar >> m_dwAveArea;
615        ar >> m_dwAveWritten;
616        ar >> m_dwAveTime;
617
618        ar >> m_dwTimes;
619        ar >> m_dwTimesInterrupted;
620        ar >> m_dwTimesSuccess;
621    }
622}
Note: See TracBrowser for help on using the repository browser.