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
|
/*
* rsyncrypto - an rsync friendly encryption
* Copyright (C) 2006-2008 Shachar Shemesh for Lingnu Open Source Consulting ltd.
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the rsyncrypto authors give permission
* to link the code of this program with the OpenSSL library (or with modified
* versions of OpenSSL that use the same license as OpenSSL), and distribute
* linked combinations including the two. You must obey the GNU General Public
* License in all respects for all of the code used other than OpenSSL. If you
* modify this file, you may extend this exception to your version of the file,
* but you are not obligated to do so. If you do not wish to do so, delete this
* exception statement from your version.
*
* The project's homepage is at http://rsyncrypto.lingnu.com/
*/
#include <precomp.h>
#include "bufferfd.h"
const size_t read_bufferfd::DEFAULT_BUF_SIZE=8192;
const size_t write_bufferfd::DEFAULT_BUF_SIZE=8192;
#ifndef min
static inline size_t min( size_t a, size_t b ) { return a<b?a:b; }
#endif
ssize_t read_bufferfd::buffer_copy( void *buf, size_t count ) const
{
ssize_t copysize=min(endpos-startpos, count);
memcpy( buf, buffer.get()+startpos, copysize );
startpos+=copysize;
return copysize;
}
ssize_t read_bufferfd::read( void *buf, size_t count ) const
{
if( endpos>startpos )
// If there is anything in the buffer, return that
return buffer_copy( buf, count );
else {
endpos=0;
startpos=0;
ssize_t numread=autofd::read( buffer.get(), buf_size );
if( numread>0 ) {
endpos+=numread;
return buffer_copy( buf, count );
} else {
// We have an error
return numread;
}
}
}
//ssize_t write_bufferfd::buffer_copy( void *buf, size_t count ) const
ssize_t write_bufferfd::write( void *buf, size_t count )
{
size_t buffree=buf_size-buffill;
if( count>(buffree+buf_size) ) {
// No point in trying to cache this one.
flush();
return autofd::write(buf, count);
}
// Fill in the buffer with data
size_t fill=min(buffree, count);
memcpy( buffer.get()+buffill, buf, fill );
count-=fill;
buffill+=fill;
if( count>0 ) {
flush();
memcpy( buffer.get(), static_cast<const char *>(buf)+fill, count );
buffill=count;
}
return count;
}
void write_bufferfd::flush()
{
if( buffill>0 ) {
try {
// If the write was partial, shift the buffer
ssize_t count=autofd::write( buffer.get(), buffill );
if( count==buffill ) {
buffill=0;
error=false;
} else {
int diff=buffill-count;
for( int i=0; i<diff; ++i ) {
buffer[i]=buffer[i+diff];
}
buffill=diff;
}
} catch(const rscerror &exc)
{
// Mark that we have had an error on this buffer
error=true;
throw exc;
}
}
}
|
