1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*
Copyright (C) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
MA 02110-1335 USA.
*/
/* file.hpp provies File Sources and Sinks
*/
#ifndef TAO_CRYPT_FILE_HPP
#define TAO_CRYPT_FILE_HPP
#include "misc.hpp"
#include "block.hpp"
#include "error.hpp"
#include <stdio.h>
namespace TaoCrypt {
class Source {
ByteBlock buffer_;
word32 current_;
Error error_;
public:
explicit Source(word32 sz = 0) : buffer_(sz), current_(0) {}
Source(const byte* b, word32 sz) : buffer_(b, sz), current_(0) {}
word32 remaining() { if (GetError().What()) return 0;
else return buffer_.size() - current_; }
word32 size() const { return buffer_.size(); }
void grow(word32 sz) { buffer_.CleanGrow(sz); }
bool IsLeft(word32 sz) { if (remaining() >= sz) return true;
else { SetError(CONTENT_E); return false; } }
const byte* get_buffer() const { return buffer_.get_buffer(); }
const byte* get_current() const { return &buffer_[current_]; }
word32 get_index() const { return current_; }
void set_index(word32 i) { if (i < size()) current_ = i; }
byte operator[] (word32 i) { current_ = i; return next(); }
byte next() { if (IsLeft(1)) return buffer_[current_++]; else return 0; }
byte prev() { if (current_) return buffer_[--current_]; else return 0; }
void add(const byte* data, word32 len)
{
if (IsLeft(len)) {
memcpy(buffer_.get_buffer() + current_, data, len);
current_ += len;
}
}
void advance(word32 i) { if (IsLeft(i)) current_ += i; }
void reset(ByteBlock&);
Error GetError() { return error_; }
void SetError(ErrorNumber w) { error_.SetError(w); }
friend class FileSource; // for get()
Source(const Source& that)
: buffer_(that.buffer_), current_(that.current_) {}
Source& operator=(const Source& that)
{
Source tmp(that);
Swap(tmp);
return *this;
}
void Swap(Source& other)
{
buffer_.Swap(other.buffer_);
STL::swap(current_, other.current_);
}
};
// File Source
class FileSource {
FILE* file_;
public:
FileSource(const char* fname, Source& source);
~FileSource();
word32 size(bool use_current = false);
private:
word32 get(Source&);
word32 size_left();
FileSource(const FileSource&); // hide
FileSource& operator=(const FileSource&); // hide
};
// File Sink
class FileSink {
FILE* file_;
public:
FileSink(const char* fname, Source& source);
~FileSink();
word32 size(bool use_current = false);
private:
size_t put(Source&);
FileSink(const FileSink&); // hide
FileSink& operator=(const FileSink&); // hide
};
} // namespace
#endif // TAO_CRYPT_FILE_HPP
|
