rc_t get_packed_and_key_from_lookup_reader( struct lookup_reader * reader,
uint64_t * key, SBuffer * packed_bases )
{
rc_t rc;
if ( reader == NULL || key == NULL || packed_bases == NULL )
{
rc = RC( rcVDB, rcNoTarg, rcReading, rcParam, rcInvalid );
ErrMsg( "get_packed_and_key_from_lookup_reader() -> %R", rc );
}
else
{
size_t num_read;
char buffer1[ 10 ];
rc = KFileRead( reader->f, reader->pos, buffer1, sizeof buffer1, &num_read );
if ( rc != 0 )
ErrMsg( "KFileRead( at %ld, to_read %u ) -> %R", reader->pos, sizeof buffer1, rc );
else if ( num_read != sizeof buffer1 )
rc = SILENT_RC( rcVDB, rcNoTarg, rcReading, rcFormat, rcInvalid );
else
{
uint16_t dna_len;
size_t to_read;
char * dst = ( char * )packed_bases->S.addr;
memmove( key, buffer1, sizeof *key );
dna_len = buffer1[ 8 ];
dna_len <<= 8;
dna_len |= buffer1[ 9 ];
dst[ 0 ] = buffer1[ 8 ];
dst[ 1 ] = buffer1[ 9 ];
dst += 2;
to_read = ( dna_len & 1 ) ? ( dna_len + 1 ) >> 1 : dna_len >> 1;
if ( to_read > ( packed_bases->buffer_size - 2 ) )
to_read = ( packed_bases->buffer_size - 2 );
if ( rc == 0 )
{
rc = KFileRead( reader->f, reader->pos + 10, dst, to_read, &num_read );
if ( rc != 0 )
ErrMsg( "KFileRead( at %ld, to_read %u ) -> %R", reader->pos + 10, to_read, rc );
else if ( num_read != to_read )
{
rc = RC( rcVDB, rcNoTarg, rcReading, rcFormat, rcInvalid );
ErrMsg( "KFileRead( %ld ) %d vs %d -> %R", reader->pos + 10, num_read, to_read, rc );
}
else
{
packed_bases->S.len = packed_bases->S.size = num_read + 2;
reader->pos += ( num_read + 10 );
}
}
}
}
return rc;
}
static rc_t CC KHttpUndyingFileRead(const KHttpUndyingFile *self,
uint64_t pos, void *buffer, size_t bsize, size_t *num_read)
{
if (self == NULL || self->file == NULL) {
return KFileRead(NULL, pos, buffer, bsize, num_read);
}
else {
rc_t rc = 0, prev_rc = 0;
int i = 0;
for (i = 0; i < RETRY_REVIVE; ++i) {
int r = 0;
for (r = 0; r < RETRY_READ; ++r) {
rc = KFileRead(self->file, pos, buffer, bsize, num_read);
if (rc == 0) {
return rc;
}
else {
DBGMSG(DBG_KNS, DBG_FLAG(DBG_KNS_ERR), (
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@3 %s KFileRead(%s, %d)(%d/%d) = %R @@@@@@@"
"\n", __FUNCTION__,
self->url, pos, r + 1, RETRY_READ, rc));
if (prev_rc == 0) {
prev_rc = rc;
}
else if (rc == prev_rc) {
break;
}
}
}
if (i < RETRY_REVIVE - 1) {
DBGMSG(DBG_KNS, DBG_FLAG(DBG_KNS_ERR), (
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@5 %s %d/%d KFileRead: Reviving... @@@@@@@@"
"\n", __FUNCTION__, i + 1, RETRY_REVIVE));
rc = Revive(self);
if (rc != 0) {
DBGMSG(DBG_KNS, DBG_FLAG(DBG_KNS_ERR), (
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@5 %s KFileRead(%s, %d): Revive = %R @@@@@@"
"\n", __FUNCTION__, self->url, pos, rc));
return rc;
}
}
else {
DBGMSG(DBG_KNS, DBG_FLAG(DBG_KNS_ERR), (
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@5 %s %d/%d KFileRead: Not Reviving @@@@@@@@"
"\n", __FUNCTION__, i + 1, RETRY_REVIVE));
}
}
return rc;
}
}
static rc_t vds_read_line( const KFile * f, uint64_t * pos, size_t * len, char * buffer, size_t buflen )
{
size_t num_read;
rc_t rc = KFileRead( f, *pos, buffer, buflen, &num_read );
if ( rc == 0 && num_read > 0 )
{
char * nl = string_chr ( buffer, num_read, '\n' );
char * cr = string_chr ( buffer, num_read, '\r' );
if ( nl != NULL )
{
if ( cr != NULL )
{
if ( nl < cr )
*len = ( nl - buffer );
else
*len = ( cr - buffer );
}
else
*len = ( nl - buffer );
}
else if ( cr != NULL )
{
*len = ( cr - buffer );
}
else
*len = 0;
*pos += ( *len + 1 );
}
return rc;
}
/** Read a character from input file */
static rc_t SpotIteratorFileReadCharWithEof(SpotIterator* self,
char* buffer)
{
rc_t rc = 0;
size_t num_read = 0;
assert(self);
/* get back the saved character */
if (self->hasCh) {
buffer[0] = self->ch;
self->hasCh = false;
}
else {
rc = KFileRead(self->file, self->filePos, buffer, 1, &num_read);
if (rc == 0) {
if (num_read == 0) {
self->eof = true;
}
else { self->filePos += num_read; }
}
else {
PLOGERR(klogErr, (klogErr, rc,
"on line $(lineno) while reading file '$(path)'",
PLOG_U64(lineno) ",path=%s", self->line, self->filename));
}
}
return rc;
}
/* returns a NUL-terminated password fitting in the buffer */
static
rc_t
ReadPassword(const struct KFile* pwd_in, size_t* last_pos, char* buf, size_t buf_size)
{
string_copy(buf, buf_size, "screwuahole", string_size("screwuahole")); return 0;
rc_t rc = 0;
size_t i =0;
do
{
size_t num_read;
if (i == buf_size)
return RC(rcApp, rcEncryptionKey, rcReading, rcParam, rcTooLong);
rc = KFileRead( pwd_in, *last_pos, & buf[i], 1, &num_read );
if (rc == 0)
{
if (num_read != 1)
return RC(rcApp, rcEncryptionKey, rcReading, rcSize, rcInvalid);
if (buf[i] == '\n')
{
buf[i] = 0;
++ *last_pos;
break;
}
}
++ *last_pos;
++ i;
}
while(rc == 0);
return rc;
}
static rc_t vdi_interactive_loop( ictx * ctx )
{
char cc[ 4 ];
uint64_t pos = 0;
rc_t rc = KOutMsg( "%S", &( ctx->PROMPT ) );
while ( rc == 0 && !ctx->done && ( 0 == Quitting() ) )
{
size_t num_read;
rc = KFileRead( ctx->std_in, pos, cc, 1, &num_read );
if ( rc != 0 )
LOGERR ( klogErr, rc, "failed to read stdin" );
else if ( num_read > 0 )
{
pos += num_read;
switch( cc[ 0 ] )
{
case '\n' : rc = vdi_interactive_newline( ctx ); break;
default : rc = vdi_on_char( ctx, cc[ 0 ] ); break;
}
}
}
if ( rc == 0 ) rc = KOutMsg( "\n" );
return rc;
}
static rc_t read_key_and_len( struct lookup_reader * reader, uint64_t pos, uint64_t *key, size_t *len )
{
size_t num_read;
char buffer[ 10 ];
rc_t rc = KFileRead( reader->f, pos, buffer, sizeof buffer, &num_read );
if ( rc != 0 )
{
ErrMsg( "read_key_and_len.KFileRead( at %ld, to_read %u ) -> %R", pos, sizeof buffer, rc );
}
else if ( num_read != sizeof buffer )
{
if ( num_read == 0 )
rc = SILENT_RC( rcVDB, rcNoTarg, rcReading, rcId, rcNotFound );
else
rc = SILENT_RC( rcVDB, rcNoTarg, rcReading, rcFormat, rcInvalid );
}
else
{
uint16_t dna_len;
size_t packed_len;
memmove( key, buffer, sizeof *key );
dna_len = buffer[ 8 ];
dna_len <<= 8;
dna_len |= buffer[ 9 ];
packed_len = ( dna_len & 1 ) ? ( dna_len + 1 ) >> 1 : dna_len >> 1;
*len = ( ( sizeof *key ) + ( sizeof dna_len ) + packed_len );
}
return rc;
}
/** Read a character from the input file */
static rc_t SpotIteratorFileReadWithEof(struct SpotIterator* self,
void* buffer, size_t bsize)
{
rc_t rc = 0;
size_t num_read = 0;
assert(self);
rc = KFileRead(self->m_file, self->m_filePos, buffer, bsize, &num_read);
if (rc == 0)
{
if (num_read == 0)
{
self->m_eof = true;
}
else
{
self->m_filePos += num_read;
}
}
else
{
plogerr(klogErr, rc, "on line $(lineno) while reading file '$(path)'",
PLOG_U64(lineno) ",path=%s", self->m_line, self->m_filename);
}
return rc;
}
static rc_t compress_loop( const KFile *src, KFile *dst )
{
rc_t rc = 0;
uint64_t pos = 0;
size_t bsize = 4096;
size_t num_read = 1;
char * buffer = malloc( bsize );
if ( buffer == NULL )
return RC( rcExe, rcFile, rcPacking, rcMemory, rcExhausted );
while ( rc == 0 && num_read > 0 )
{
rc = KFileRead ( src, pos, buffer, bsize, &num_read );
DISP_RC( rc, "KFileRead() failed" );
if ( rc == 0 && num_read > 0 )
{
size_t num_writ;
rc = KFileWrite ( dst, pos, buffer, num_read, &num_writ );
DISP_RC( rc, "KFilewrite() failed" );
pos += num_read;
}
}
OUTMSG (( "%lu bytes copied\n", pos ));
free( buffer );
return rc;
}
/* ----------------------------------------------------------------------
* Read
* read file from known position
*
* "pos" [ IN ] - starting position within file
*
* "buffer" [ OUT ] and "bsize" [ IN ] - return buffer for read
*
* "num_read" [ OUT, NULL OKAY ] - optional return parameter
* giving number of bytes actually read
*/
static
rc_t CC KSubFileRead (const KSubFile *self,
uint64_t pos,
void *buffer,
size_t bsize,
size_t *num_read)
{
size_t request;
rc_t rc;
/* -----
* self and buffer were validated as not NULL before calling here
*
* So get the KTTOCNode type: chunked files and contiguous files
* are read differently.
*/
assert (self != NULL);
assert (buffer != NULL);
assert (num_read != NULL);
*num_read = 0;
if (pos >= self->size)
{
return 0;
}
if ((pos + bsize) <= self->size)
request = bsize;
else
request = (size_t)(self->size - pos);
rc = KFileRead (self->original, self->start + pos, buffer, request, num_read);
return rc;
}
static rc_t LogFileRead_timed ( const LogFile *cself, uint64_t pos, void *buffer, size_t bsize, size_t *num_read )
{
KTimeMs_t ms = KTimeMsStamp ();
rc_t rc = KFileRead ( cself -> wrapped, pos, buffer, bsize, num_read );
ms = KTimeMsStamp () - ms;
WriteToRecorder ( cself -> rec, "R\t%lu\t%lu\t%lu\t%lu\n", pos, bsize, *num_read, ms );
return rc;
}
static
rc_t copy_file (const KFile * fin, KFile *fout)
{
rc_t rc;
uint8_t buff [64 * 1024];
size_t num_read;
uint64_t inpos;
uint64_t outpos;
assert (fin != NULL);
assert (fout != NULL);
inpos = 0;
outpos = 0;
do
{
rc = KFileRead (fin, inpos, buff, sizeof (buff), &num_read);
if (rc != 0)
{
PLOGERR (klogErr, (klogErr, rc,
"Failed to read from directory structure in creating archive at $(P)",
PLOG_U64(P), inpos));
break;
}
else if (num_read > 0)
{
size_t to_write;
inpos += (uint64_t)num_read;
STSMSG (2, ("Read %zu bytes to %lu", num_read, inpos));
/* PLOGMSG (klogDebug10, "Read $(B) Bytes for $(T)", PLOG_2(PLOG_U64(B),PLOG_U64(T)), num_read, inpos); */
to_write = num_read;
while (to_write > 0)
{
size_t num_writ;
rc = KFileWrite (fout, outpos, buff, num_read, &num_writ);
if (rc != 0)
{
PLOGERR (klogErr, (klogErr, rc,
"Failed to write to archive in creating archive at $(P)",
PLOG_U64(P), outpos));
break;
}
outpos += num_writ;
/* PLOGMSG (klogDebug10, "Wrote $(B) Bytes for $(T)", PLOG_2(PLOG_U64(B),PLOG_U64(T)), num_writ, outpos); */
to_write -= num_writ;
}
}
/* else */
/* PLOGMSG (klogDebug10, "Read $(B) Bytes for $(T)", PLOG_2(PLOG_U64(B),PLOG_U64(T)), num_read, inpos); */
if (rc != 0)
break;
} while (num_read != 0);
return rc;
}
static
rc_t copy_file (const KFile * fin, KFile *fout)
{
rc_t rc;
uint8_t buff [64 * 1024];
size_t num_read;
uint64_t inpos;
uint64_t outpos;
uint64_t fsize;
assert (fin != NULL);
assert (fout != NULL);
inpos = 0;
outpos = 0;
rc = KFileSize (fin, &fsize);
if (rc != 0)
return rc;
do
{
rc = KFileRead (fin, inpos, buff, sizeof (buff), &num_read);
if (rc != 0)
{
PLOGERR (klogErr, (klogErr, rc,
"Failed to read from directory structure in creating archive at $(P)",
PLOG_U64(P), inpos));
break;
}
else if (num_read > 0)
{
size_t to_write;
inpos += (uint64_t)num_read;
to_write = num_read;
while (to_write > 0)
{
size_t num_writ;
rc = KFileWrite (fout, outpos, buff, num_read, &num_writ);
if (rc != 0)
{
PLOGERR (klogErr, (klogErr, rc,
"Failed to write to archive in creating archive at $(P)",
PLOG_U64(P), outpos));
break;
}
outpos += num_writ;
to_write -= num_writ;
}
}
if (rc != 0)
break;
} while (num_read != 0);
return rc;
}
/* ----------------------------------------------------------------------
* Read
* read file from known position
*
* "pos" [ IN ] - starting position within file
*
* "buffer" [ OUT ] and "bsize" [ IN ] - return buffer for read
*
* "num_read" [ OUT, NULL OKAY ] - optional return parameter
* giving number of bytes actually read
*/
static
rc_t CC KCounterFileRead (const KCounterFile *cself,
uint64_t pos,
void *buffer,
size_t bsize,
size_t *num_read)
{
KCounterFile * self;
uint64_t max_position;
uint64_t temp_max_position;
rc_t rc;
/* -----
* self and buffer were validated as not NULL before calling here
*
* So get the KTTOCNode type: chunked files and contiguous files
* are read differently.
*/
assert (cself != NULL);
assert (cself->original != NULL);
assert (buffer != NULL);
assert (num_read != NULL);
assert (bsize != 0);
self = (KCounterFile*)cself;
max_position = cself->max_position;
if ((pos > max_position) && (! self->size_allowed))
{
rc = KCounterFileSeek (self, pos);
if (rc != 0)
return rc;
/* if seek failed */
if (pos > self->max_position)
{
*num_read = 0;
return 0;
}
}
rc = KFileRead (self->original, pos, buffer, bsize, num_read);
temp_max_position = pos + *num_read;
if (temp_max_position > max_position)
{
uint32_t new_bytes = (uint32_t)(temp_max_position - max_position);
check_state (self, ((char *)buffer) + (*num_read) - new_bytes, new_bytes);
*self->bytecounter = self->max_position = temp_max_position;
}
return rc;
}
/* ----------------------------------------------------------------------
* Read
* read file from known position
*
* "pos" [ IN ] - starting position within file
*
* "buffer" [ OUT ] and "bsize" [ IN ] - return buffer for read
*
* "num_read" [ OUT, NULL OKAY ] - optional return parameter
* giving number of bytes actually read
*/
static
rc_t CC CCFileRead (const CCFile *self,
uint64_t pos,
void *buffer,
size_t bsize,
size_t *num_read)
{
rc_t rc;
rc = KFileRead (self->original, pos, buffer, bsize, num_read);
if (*self->prc == 0)
*((CCFile*)self)->prc = rc;
return rc;
}
static
rc_t copy_file_skey_md5_kludge (const KFile * fin, KFile *fout)
{
/* size of HEX digest plus spzce plus * */
#define READ_SIZE 34
static const uint8_t skey[] = "skey\n";
uint8_t buff [256];
uint64_t tot_read, tot_writ;
size_t num_read, num_writ;
rc_t rc;
assert (fin);
assert (fout);
for (tot_read = 0 ; tot_read < READ_SIZE; tot_read += num_read)
{
rc = KFileRead (fin, tot_read, buff, READ_SIZE - tot_read, &num_read);
if (rc != 0)
{
PLOGERR (klogErr, (klogErr, rc,
"Failed to read from directory structure in creating archive at $(P)",
PLOG_U64(P), tot_read));
break;
}
if (num_read == 0)
break;
}
if (rc == 0)
{
if (tot_read == READ_SIZE)
{
memcpy (buff + READ_SIZE, skey, sizeof (skey));
tot_read += sizeof (skey) - 1;
}
for (tot_writ = 0; tot_writ < tot_read; tot_writ += num_writ)
{
rc = KFileWrite (fout, tot_writ, buff + tot_writ,
(uint32_t)(tot_read - tot_writ), &num_writ);
if (rc != 0)
{
PLOGERR (klogErr, (klogErr, rc,
"Failed to write to archive in creating archive at $(P)",
PLOG_U64(P), num_writ));
break;
}
}
}
return rc;
}
static rc_t LoadFromFile( struct KFile const * f, VNamelist * nl )
{
rc_t rc = 0;
uint64_t pos = 0;
char buffer[ 4096 ];
buffer_range range;
bool done = false;
range.start = buffer;
range.count = 0;
range.processed = 0;
range.state = STATE_ALPHA;
do
{
size_t num_read;
rc = KFileRead ( f, pos, ( char * )( range.start + range.processed ),
( sizeof buffer ) - range.processed, &num_read );
if ( rc == 0 )
{
done = ( num_read == 0 );
if ( !done )
{
range.start = buffer;
range.count = range.processed + num_read;
LoadFromBuffer( nl, &range );
if ( range.count > 0 )
{
memmove ( buffer, range.start, range.count );
}
range.start = buffer;
range.processed = range.count;
pos += num_read;
}
else if ( range.state == STATE_ALPHA )
{
String S;
S.addr = range.start;
S.len = S.size = range.count;
VNamelistAppendString ( nl, &S );
}
}
} while ( rc == 0 && !done );
return rc;
}
/* Read
* reads from the data fork using a blob map
*/
rc_t KColumnDataRead ( const KColumnData *self, const KColumnPageMap *pm,
size_t offset, void *buffer, size_t bsize, size_t *num_read )
{
uint64_t pos;
assert ( self != NULL );
assert ( pm != NULL );
if ( bsize == 0 )
{
assert ( num_read != NULL );
* num_read = 0;
return 0;
}
pos = pm -> pg * self -> pgsize;
return KFileRead ( self -> f, pos + offset, buffer, bsize, num_read );
}
static
rc_t CC KLoaderFile_ReadKFile(const KLoaderFile* cself, uint64_t pos, void *buffer, size_t size, size_t *num_read)
{
rc_t rc = KFileRead(cself ? cself->kfile : NULL, pos, buffer, size, num_read);
DBG(("%s: %s: %lu\n", __func__, cself->realname, *num_read));
if( rc == 0 && cself->job != NULL ) {
if( pos > cself->kfile_pos ) {
rc = KLoadProgressbar_Process(cself->job, pos - cself->kfile_pos, false);
((KLoaderFile*)cself)->kfile_pos = pos;
}
pos += *num_read;
if( pos > cself->kfile_pos ) {
rc = KLoadProgressbar_Process(cself->job, pos - cself->kfile_pos, false);
((KLoaderFile*)cself)->kfile_pos= pos;
}
}
return rc;
}
static rc_t read_loop( const KFile * f, const uint64_t a_pos, const uint64_t count,
const size_t chunk_size, uint8_t digest [ 16 ] )
{
rc_t rc = 0;
uint64_t pos = a_pos;
uint64_t n_bytes = 0;
size_t num_read = 1;
MD5State md5;
char * buffer = malloc( chunk_size );
if ( buffer == NULL )
return RC( rcExe, rcFile, rcPacking, rcMemory, rcExhausted );
MD5StateInit ( &md5 );
while ( rc == 0 && num_read > 0 )
{
size_t chunk = chunk_size;
if ( ( count > 0 ) && ( ( n_bytes + chunk ) > count ) )
{
chunk = ( count - n_bytes );
}
OUTMSG(( "about to read from pos %lu\n", pos ));
rc = KFileRead ( f, pos, buffer, chunk, &num_read );
OUTMSG(( "returned from KFileRead rc = %R, num_read = %zu\n\n", rc, num_read ));
if ( rc == 0 && num_read > 0 )
{
MD5StateAppend ( &md5, buffer, num_read );
pos += num_read;
n_bytes += num_read;
if ( ( count > 0 ) && ( n_bytes >= count ) )
{
num_read = 0;
}
}
}
OUTMSG(( "%lu bytes read total\n", n_bytes ));
free( buffer );
MD5StateFinish ( &md5, digest );
return rc;
}
/* Fill
* fill buffer as far as possible, shift unread data in buffer to buffer start
*/
static
rc_t KLoaderFile_Fill(KLoaderFile *self)
{
rc_t rc = 0;
if (self->kfile == NULL) {
rc = KLoaderFile_Open(self);
}
if( rc == 0 ) {
/* determine space in buffer available */
size_t to_read = self->buffer_size - self->avail;
if( to_read > 0 ) {
#if _DEBUGGING
if( to_read < self->buffer_size * 0.5 ) {
self->small_reads++;
if( self->small_reads > 10 ) {
PLOGMSG(klogWarn, (klogWarn, "$(filename) INEFFECTIVE READING: $(times) times, now $(bytes) bytes",
PLOG_3(PLOG_S(filename),PLOG_U32(times),PLOG_U32(bytes)), self->filename, self->small_reads, to_read));
}
}
#endif
/* shift left unread data */
memmove(self->buffer, self->buffer_pos, self->avail);
/* skip read chunk in buffer */
self->pos += self->buffer_pos - self->buffer;
/* reset pointer */
self->buffer_pos = self->buffer;
do { /* fill buffer up to eof */
size_t num_read = 0;
if( (rc = KFileRead(self->file, self->pos + self->avail,
&self->buffer[self->avail], to_read, &num_read)) == 0 ) {
self->eof = (num_read == 0);
self->avail += (uint32_t) num_read;
to_read -= num_read;
DBG(("KLoaderFile read %s from %lu %u bytes%s\n",
self->filename, self->pos + self->avail - num_read, num_read, self->eof ? " EOF" : ""));
}
} while( rc == 0 && to_read > 0 && !self->eof );
}
}
return rc;
}
static
rc_t CC
_IsPathCart (
const struct KDirectory * Directory,
const char * Path,
const char * Name,
char * BF,
size_t BFS,
bool * IsCart
)
{
rc_t RCt;
size_t nwr;
const struct KFile * File;
const char * Sg = "ncbikart";
size_t SgLen;
char SF [ 64 ];
RCt = 0;
nwr = 0;
File = NULL;
SgLen = sizeof ( Sg );
* SF = 0;
* BF = 0;
* IsCart = false;
RCt = string_printf ( BF, BFS, & nwr, "%s/%s", Path, Name );
if ( RCt == 0 ) {
RCt = KDirectoryOpenFileRead ( Directory, & File, BF );
if ( RCt == 0 ) {
RCt = KFileRead ( File, 0, SF, SgLen, & nwr );
if ( RCt == 0 ) {
* IsCart = ! string_cmp ( SF, SgLen, Sg, SgLen, SgLen );
}
KFileRelease ( File );
}
}
return RCt;
} /* _IsPathCart () */
static rc_t LoadHeader(char const **rslt, char const path[], char const base[])
{
KFile const *kf;
rc_t rc = OpenFile(&kf, path, base);
*rslt = NULL;
if (rc == 0) {
uint64_t fsize;
rc = KFileSize(kf, &fsize);
if (rc == 0) {
char *fdata = malloc(fsize+1);
if (fdata) {
size_t nread;
rc = KFileRead(kf, 0, fdata, fsize, &nread);
if (rc == 0) {
if (nread) {
fdata[nread] = '\0';
*rslt = fdata;
}
else {
free(fdata);
rc = RC(rcApp, rcArgv, rcAccessing, rcFile, rcEmpty);
(void)PLOGERR(klogErr, (klogErr, rc, "File '$(file)' is empty", "file=%s", path));
}
}
else {
(void)PLOGERR(klogErr, (klogErr, rc, "Failed to read file '$(file)'", "file=%s", path));
}
}
else {
rc = RC(rcApp, rcArgv, rcAccessing, rcMemory, rcExhausted);
(void)PLOGERR(klogErr, (klogErr, rc, "Failed to read file '$(file)'", "file=%s", path));
}
}
KFileRelease(kf);
}
else {
(void)PLOGERR(klogErr, (klogErr, rc, "Failed to open file '$(file)'", "file=%s", path));
}
return rc;
}
/* ----------------------------------------------------------------------
* Destroy
*
*/
static
rc_t CC KCounterFileDestroy (KCounterFile *self)
{
rc_t rc = 0;
uint64_t size;
assert (self != NULL);
assert (self->bytecounter != NULL);
if (self->force || ! self->size_allowed)
{
size_t num_read = 0;
uint8_t ignored[64*1024];
size = self->max_position;
if (self->dad.read_enabled)
do
{
rc = KFileRead (self->original, size,
ignored, sizeof ignored, &num_read);
size += num_read;
DBGMSG(DBG_KFS,DBG_FLAG(DBG_KFS_COUNTER),
("%s: size '%lu' num_read '%lu'\n", __func__, size, num_read));
if (rc != 0)
break;
check_state (self, ignored, num_read);
} while (num_read != 0);
}
else
{
rc = KFileSize (self->original, &size);
DBGMSG(DBG_KFS,DBG_FLAG(DBG_KFS_COUNTER),
("%s: lazy way size '%lu'\n", __func__, size));
}
*self->bytecounter = size;
if (rc == 0)
{
rc = KFileRelease (self->original);
free (self);
}
return rc;
}
static
rc_t privReadStdinLine(char* buf, size_t bsize, bool destroy)
{
rc_t rc = 0;
static const KFile* std_in = NULL;
static uint64_t pos = 0;
size_t num_read = 0;
if (destroy) {
RELEASE(KFile, std_in);
pos = 0;
return rc;
}
if (std_in == NULL) {
rc = KFileMakeStdIn(&std_in);
if (rc != 0) {
DISP_RC(rc, "KFileMakeStdIn");
return rc;
}
}
rc = KFileRead(std_in, pos, buf, bsize, &num_read);
DISP_RC(rc, "KFileRead");
pos += num_read;
if (num_read) {
bool done = false;
buf[num_read] = '\0';
while (num_read > 0 && !done) {
switch (buf[num_read - 1]) {
case '\n':
case '\r':
buf[--num_read] = '\0';
break;
default:
done = true;
break;
}
}
}
return rc;
}
static
rc_t CC
_DocFile_read_v1 (
const struct XFSFileEditor * self,
uint64_t Offset,
void * Buffer,
size_t SizeToRead,
size_t * NumReaded
)
{
struct XFSDocFileEditor * Editor;
rc_t RCt;
Editor = NULL;
RCt = 0;
if ( self == NULL ) {
return XFS_RC ( rcNull );
}
Editor = ( struct XFSDocFileEditor * ) self;
if ( Editor -> file == NULL ) {
return XFS_RC ( rcInvalid );
}
RCt = KFileRead (
Editor -> file,
Offset,
Buffer,
SizeToRead,
NumReaded
);
/* here may be debutt */
return RCt;
} /* _DocFile_read_v1 () */
static
rc_t md5(const char* path, uint8_t digest[16], const KDirectory* dir)
{
const KFile* kf = NULL;
rc_t rc = KDirectoryOpenFileRead(dir, &kf, "%s", path);
if (rc == 0) {
KFile* fnull = NULL;
rc = KFileMakeNullUpdate(&fnull);
if (rc == 0) {
KMD5SumFmt* fmt = NULL;
rc = KMD5SumFmtMakeUpdate(&fmt, fnull);
if (rc == 0) {
const KFile* md5 = NULL;
rc = KFileMakeNewMD5Read(&md5, kf, fmt, path);
if (rc == 0) {
uint64_t ps = 0;
char buffer[512];
size_t read = 0;
do {
rc = KFileRead(md5, ps, buffer, sizeof buffer, &read);
if (rc == 0)
{ ps += read; }
} while (rc == 0 && read > 0);
if (rc == 0) {
bool bin;
rc = KMD5SumFmtFind(fmt, path, digest, &bin);
}
}
RELEASE(KFile, md5);
}
RELEASE(KMD5SumFmt, fmt);
}
/* RELEASE(KFile, fnull); fnull is released by KMD5SumFmt* fmt */
}
/* RELEASE(KFile, kf); kf is released by KFile* md5 */
return rc;
}
/* compression used the sizeof of the outbuffer - the amount
* it says it didn't use */
num_comp = sizeof(self->buff) - strm->avail_out;
rc = KFileWrite (self->file, self->filePosition, self->buff, num_comp, &written);
self->filePosition += written;
*pnumwrit = avail_in - strm->avail_in;
} while (strm->avail_out == 0);
assert (strm->avail_in == 0); /* all input will be used */
return rc;
}
#if 0 /* obsolete */
static
int s_read(KBZipFile *self,
char *buffer,
size_t bsize,
size_t *num_read,
rc_t *rc)
{
bz_stream* strm;
int ret;
assert(self && buffer && bsize && num_read);
strm = &self->strm;
ret = 0;
while (!*num_read) {
strm->next_out = buffer;
strm->avail_out = bsize;
ret = BZ2_bzDecompress(strm);
assert(ret == BZ_OK || ret == BZ_STREAM_END); /* state not clobbered */
*num_read = bsize - strm->avail_out;
if (strm->avail_out > 0) {
size_t src_read;
* rc = KFileRead
(self->file, self->filePosition, self->buff, sizeof(self->buff), &src_read);
if (*rc != 0)
{ return -70; }
strm->avail_in = src_read;
self->filePosition += src_read;
strm->next_in = self->buff;
}
if (!strm->avail_in)
{ break; }
}
return ret;
}
static
rc_t KCounterFileSeek (KCounterFile * self, uint64_t pos)
{
uint64_t max_position;
rc_t rc = 0;
size_t num_read = 0;
size_t to_read;
uint8_t ignored[64*1024];
assert (self->max_position < pos);
for (max_position = self->max_position; max_position < pos; max_position += num_read)
{
to_read = (size_t)( pos - max_position );
if (to_read > sizeof ignored)
to_read = sizeof ignored;
rc = KFileRead (self->original, max_position, ignored, to_read, &num_read);
if (rc || (num_read == 0))
break;
check_state (self, ignored, num_read);
}
self->max_position = max_position;
*self->bytecounter = max_position;
return rc;
}
static
rc_t run()
{
KDirectory * pwd;
rc_t rc;
STSMSG (1, ("Open file system\n"));
rc = KDirectoryNativeDir (&pwd);
if (rc)
LOGERR (klogErr, rc, "Failed to open filesystem");
else
{
const KFile * unencrypt;
STSMSG (1, ("Open unencryptd file %s\n", UNENCRYPT));
rc = KDirectoryOpenFileRead (pwd, &unencrypt, UNENCRYPT);
if (rc)
LOGERR (klogErr, rc, "failed to open unencryptd file");
else
{
const KFile * encrypt;
STSMSG (1, ("Open encryptd file %s\n", ENCRYPT));
rc = KDirectoryOpenFileRead (pwd, &encrypt, ENCRYPT);
if (rc)
LOGERR (klogErr, rc, "Failed to open encryptd file");
else
{
const KFile * decrypt;
STSMSG (1, ("Open decrypt file\n"));
rc = KFileMakeWGAEncRead (&decrypt, encrypt, WGA_KEY, 1);
if (rc)
LOGERR (klogErr, rc, "Failed to open decrypter");
else
{
size_t tot_readu;
size_t tot_readd;
size_t num_read;
uint8_t * decoded = NULL;
uint8_t * unencoded = NULL;
int comp;
decoded = calloc ( 64 * 1024, 24 );
unencoded = calloc ( 64 * 1024, 24 );
for (tot_readu = 0; rc == 0 && tot_readu < sizeof unencoded; tot_readu += num_read)
{
STSMSG (5, ("Read unencrypted '%u' @ %lu\n", sizeof unencoded - tot_readu, tot_readu));
rc = KFileRead (unencrypt, tot_readu, unencoded + tot_readu,
sizeof unencoded - tot_readu, &num_read);
if (num_read == 0)
break;
}
if (rc == 0)
{
for (tot_readd = 0; rc == 0 && tot_readd < sizeof decoded; tot_readd += num_read)
{
STSMSG (5, ("Read decrypted '%u' @ %lu\n", sizeof decoded - tot_readd, tot_readd));
rc = KFileRead (decrypt, tot_readd, decoded + tot_readd,
sizeof decoded - tot_readd, &num_read);
if (num_read == 0)
break;
}
comp = memcmp(decoded,unencoded, sizeof decoded);
STSMSG (1, ("Read u '%zu' d '%zu' cmp '%d'", tot_readu, tot_readd, comp));
if (comp != 0)
{
rc = RC (rcExe, rcNoTarg, rcValidating, rcFile, rcInconsistent);
LOGERR (klogErr, rc, "Unencryptfailed");
{
size_t ix;
size_t limit;
size_t matched = 0;
size_t mismatched = 0;
limit = tot_readu;
if (limit < tot_readd)
limit = tot_readd;
for (ix = 0; ix < limit; ++ix)
{
if (decoded[ix] != unencoded[ix])
{
++mismatched;
STSMSG (2, ("%5.5zu: D %c %2.2X U %c %2.2X\n",
ix,
decoded[ix]?decoded[ix]:'?',decoded[ix],
unencoded[ix]?unencoded[ix]:'?',unencoded[ix]));
}
else
++matched;
}
STSMSG (2, ("matched %zu mismatched %zu",matched,mismatched));
}
}
}
free (decoded);
free (unencoded);
}
KFileRelease (decrypt);
}
KFileRelease (encrypt);
}
KFileRelease (unencrypt);
}
KDirectoryRelease (pwd);
return rc;
}
