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
131
132
133
134
135
136
137
138
|
#ifndef __EYETIL_H
#define __EYETIL_H
#include <vector>
#include <string>
#include <fstream>
#include <archive.h>
#include <archive_entry.h>
#include "openssl/md5.h"
#include "soapH.h"
struct throwable_exit {
int rc;
throwable_exit(int rc_) : rc(rc_) { }
};
class binary_t : public std::vector<unsigned char> {
public:
binary_t() { }
binary_t(size_type n) : std::vector<unsigned char>(n) { }
binary_t(const std::string& h) { from_hex(h); }
binary_t(const void *d,size_t s) { from_data(d,s); }
binary_t& from_hex(const std::string& h);
binary_t& from_data(const void *d,size_t s);
binary_t& make_nonce();
std::string hex() const;
binary_t md5() const;
};
struct md5_digester {
MD5_CTX ctx;
md5_digester() { init(); }
void init();
void update(const void *d,size_t l);
binary_t final();
template<typename T>
void update(const T& x) { update(&x,sizeof(x)); }
template<typename T>
struct update_iterator : public std::iterator<std::output_iterator_tag,T,void,T*,T&> {
md5_digester *d;
update_iterator(md5_digester *d_) : d(d_) { }
update_iterator(const update_iterator& x) : d(x.d) { }
update_iterator& operator*() { return *this; }
update_iterator& operator++() { return *this; }
update_iterator& operator++(int) { return *this; }
update_iterator& operator=(const T& x) {
d->update(x); return *this;
}
};
template<typename T>
update_iterator<T> updater() {
return update_iterator<T>(this);
}
};
template<> inline void md5_digester::update<binary_t>(const binary_t& x) {
update((const unsigned char*)&(x.front()),x.size());
}
#pragma pack(1)
struct block512_t {
enum { words = 512 / sizeof(uint16_t) };
uint16_t data[words];
inline uint8_t *dptr(size_t o) { return ((uint8_t*)this)+o; }
static uint16_t tcpcksum(block512_t& data);
};
#pragma pack()
struct integrity_digester {
md5_digester md5;
size_t data_size;
block512_t data;
integrity_digester() : data_size(0) { }
void update(const void *d,size_t s);
binary_t final(const std::string& ukey);
};
class tmpdir_t {
public:
std::string dir;
tmpdir_t(const std::string& dt);
~tmpdir_t();
std::string get_file(const std::string& f);
};
class tarchive_t {
public:
struct archive *a;
struct archive_entry *e;
tarchive_t(const char *);
~tarchive_t();
bool read_next_header();
std::string entry_pathname();
bool read_data_into_fd(int fd);
};
struct mimewrite_base {
virtual ~mimewrite_base() { }
virtual int write(const char *buf,size_t len) = 0;
virtual void close() = 0;
};
struct mimewrite_string : public mimewrite_base {
std::string str;
int write(const char *buf,size_t len) { str.append(buf,len); return SOAP_OK; };
void close() { }
};
struct mimewrite_tarfile : public mimewrite_base {
std::string fn;
std::fstream f;
integrity_digester idigest;
mimewrite_tarfile(tmpdir_t& d);
~mimewrite_tarfile();
int write(const char *buf,size_t len);
void close() { }
};
binary_t integrity_digest(const void *ptr,size_t size,
const std::string& ukey);
#endif /* __EYETIL_H */
|
