rc_t ProcessOneDoFile (ProcessOne * self)
{
rc_t rc = 0;
KFile * mfile;
PLOGMSG (klogInfo, "ProcessOneDoFile: $(F)", PLOG_S(F), self->path);
rc = KFileMakeNewMD5Read (&mfile, self->file, self->md5, self->path);
if (rc == 0)
{
const KFile * bfile;
rc = KFileMakeBuf (&bfile, mfile, 64*1024);
if (rc == 0)
{
/* add more here */
KFileRelease (bfile);
}
else
{
pLOGERR (klogErr, rc, "Failure to initiate buffer $(F)", PLOG_S(F), self->path);
KFileRelease (mfile);
}
}
else
pLOGERR (klogErr, rc, "Failure to initiate MD5 summing $(F)", PLOG_S(F), self->path);
return rc;
}
rc_t vds_diff( const char * f1, const char * f2 )
{
KDirectory * dir;
rc_t rc = KDirectoryNativeDir( &dir );
if ( rc != 0 )
KOutMsg( "KDirectoryNativeDir() failed\n" );
else
{
const KFile * kf1;
rc = KDirectoryOpenFileRead ( dir, &kf1, "%s", f1 );
if ( rc != 0 )
KOutMsg( "cannot open file '%s'\n", f1 );
else
{
const KFile * kf2;
rc = KDirectoryOpenFileRead ( dir, &kf2, "%s", f2 );
if ( rc != 0 )
KOutMsg( "cannot open file '%s'\n", f2 );
else
{
rc = vds_diff_files( kf1, kf2 );
KFileRelease( kf2 );
}
KFileRelease( kf1 );
}
KDirectoryRelease( dir );
}
clear_recorded_errors();
return rc;
}
static
rc_t KLoaderFile_Open(KLoaderFile* self)
{
rc_t rc = 0;
DBG(("%s opening %s\n", __func__, self->realname));
if( (rc = KDirectoryOpenFileRead(self->dir, &self->kfile, "%s", self->realname)) == 0 ) {
if( self->has_md5 ) {
const KFile *md5File = NULL;
DBG(("%s opening as md5 wrapped %s\n", __func__, self->realname));
if( (rc = KFileMakeMD5Read(&md5File, self->file, self->md5_digest)) == 0) {
self->file = md5File;
}
}
if( rc == 0 ) {
const KFile *z = NULL;
switch(self->compress_type) {
case compress_none:
break;
case compress_gzip:
DBG(("%s opening as gzip wrapped %s\n", __func__, self->realname));
if( (rc = KFileMakeGzipForRead(&z, self->file)) == 0 ) {
KFileRelease(self->file);
self->file = z;
}
break;
case compress_bzip2:
DBG(("%s opening as bzip2 wrapped %s\n", __func__, self->realname));
if( (rc = KFileMakeBzip2ForRead(&z, self->file)) == 0 ) {
KFileRelease(self->file);
self->file = z;
}
break;
default:
rc = RC(rcApp, rcFile, rcOpening, rcType, rcUnexpected);
break;
}
#if ! WINDOWS
if( rc == 0 && self->ahead ) {
const KFile *z = NULL;
if( (rc = KQueueFileMakeRead(&z, self->pos, self->file,
self->buffer_size * 10, self->buffer_size, 0)) == 0 ) {
KFileRelease(self->file);
self->file = z;
}
}
#endif
}
}
if( rc != 0 ) {
PLOGERR(klogErr, (klogErr, rc, "opening $(file)", PLOG_S(file), self->filename));
KFileRelease(self->file);
}
return rc;
}
rc_t make_lookup_reader( const KDirectory *dir, const struct index_reader * index,
struct lookup_reader ** reader, size_t buf_size, const char * fmt, ... )
{
rc_t rc;
const struct KFile * f = NULL;
va_list args;
va_start ( args, fmt );
rc = KDirectoryVOpenFileRead( dir, &f, fmt, args );
if ( rc != 0 )
{
char tmp[ 4096 ];
size_t num_writ;
rc_t rc1 = string_vprintf( tmp, sizeof tmp, &num_writ, fmt, args );
if ( rc1 != 0 )
ErrMsg( "make_lookup_reader.KDirectoryVOpenFileRead( '?' ) -> %R", rc );
else
ErrMsg( "make_lookup_reader.KDirectoryVOpenFileRead( '%s' ) -> %R", tmp, rc );
}
else
{
const struct KFile * temp_file = NULL;
rc = KBufFileMakeRead( &temp_file, f, buf_size );
KFileRelease( f );
if ( rc != 0 )
{
ErrMsg( "make_lookup_reader.KBufFileMakeRead() -> %R", rc );
}
else
{
lookup_reader * r = calloc( 1, sizeof * r );
if ( r == NULL )
{
KFileRelease( temp_file );
rc = RC( rcVDB, rcNoTarg, rcConstructing, rcMemory, rcExhausted );
ErrMsg( "make_lookup_reader.calloc( %d ) -> %R", ( sizeof * r ), rc );
}
else
{
r->f = temp_file;
r->index = index;
rc = make_SBuffer( &r->buf, 4096 );
if ( rc == 0 )
*reader = r;
else
release_lookup_reader( r );
}
}
}
va_end ( args );
return rc;
}
rc_t ArchiveAndEncrypt(KDirectory* wd, const char* inpath, const char* outpath, const char* passwd)
{
const KDirectory* d;
rc_t rc = KDirectoryOpenDirRead (wd, &d, false, "%s", inpath);
if (rc == 0)
{
const KFile* infile;
rc_t rc2;
rc = KDirectoryOpenTocFileRead (d, &infile, 4, NULL, NULL, NULL);
if (rc == 0)
{
KFile* outfile;
/* if the file exists, add write access */
KDirectorySetAccess( wd, false, 0600, 0777, "%s", outpath );
rc = KDirectoryCreateFile(wd, &outfile, false, 0600, kcmCreate|kcmInit, "%s", outpath);
if ( rc == 0 )
{
KFile* enc_outfile;
KKey key;
rc = KKeyInitRead(&key, kkeyAES256, passwd, string_measure(passwd, NULL));
if ( rc == 0 )
rc = KEncFileMakeWrite(&enc_outfile, outfile, &key);
if (rc == 0)
rc = copy_file(infile, enc_outfile);
rc2 = KFileRelease(outfile);
if (rc == 0)
rc = rc2;
/* remove write access */
rc2 = KDirectorySetAccess( wd, false, 0400, 0777, "%s", outpath );
if (rc == 0)
rc = rc2;
rc2 = KFileRelease(enc_outfile);
if (rc == 0)
rc = rc2;
}
rc2 = KFileRelease(infile);
if (rc == 0)
rc = rc2;
}
rc2 = KDirectoryRelease(d);
if (rc == 0)
rc = rc2;
}
return rc;
}
struct rna_splice_log * make_rna_splice_log( const char * filename, const char * toolname )
{
struct rna_splice_log * res = NULL;
KDirectory * dir;
rc_t rc = KDirectoryNativeDir ( &dir );
if ( rc == 0 )
{
KFile * f;
rc = KDirectoryCreateFile ( dir, &f, false, 0664, kcmInit, "%s", filename );
if ( rc == 0 )
{
res = calloc( 1, sizeof * res );
if ( res != NULL )
{
res->log_file = f;
if ( toolname != NULL )
res->tool_name = string_dup_measure ( toolname, NULL );
}
else
KFileRelease ( f );
}
KDirectoryRelease ( dir );
}
return res;
}
/* Whack
*/
static
rc_t KQueueFileWhackRead ( KQueueFile *self )
{
void *b;
/* no more reading */
QFMSG ( "%s: sealing queue\n", __func__ );
KQueueSeal ( self -> q );
/* flush the queue */
QFMSG ( "%s: popping queue\n", __func__ );
while ( KQueuePop ( self -> q, & b, NULL ) == 0 )
{
QFMSG ( "%s: dousing a buffer\n", __func__ );
free ( b );
}
/* wait for thread to exit */
QFMSG ( "%s: waiting for bg thread to exit\n", __func__ );
KThreadWait ( self -> t, NULL );
/* tear it down */
QFMSG ( "%s: freeing object\n", __func__ );
free ( self -> b );
KThreadRelease ( self -> t );
KQueueRelease ( self -> q );
KFileRelease ( self -> f );
free ( self );
return 0;
}
LIB_EXPORT rc_t CC WriteNamelistToFileByName( const VNamelist * namelist, const char * filename,
const char * delim )
{
rc_t rc;
if ( namelist == NULL || filename == NULL || delim == NULL )
rc = RC( rcFS, rcFile, rcValidating, rcParam, rcNull );
else
{
KDirectory * dir;
rc = KDirectoryNativeDir ( &dir );
if ( rc == 0 )
{
KFile * f;
rc = KDirectoryCreateFile ( dir, &f, true, 0664, kcmCreate, filename );
if ( rc == 0 )
{
if ( rc == 0 )
rc = SaveToFile( f, namelist, delim );
KFileRelease ( f );
}
KDirectoryRelease ( dir );
}
}
return rc;
}
LIB_EXPORT rc_t CC LoadFileByNameToNameList( VNamelist * namelist, const char * filename )
{
rc_t rc;
if ( namelist == NULL || filename == NULL )
rc = RC( rcFS, rcFile, rcValidating, rcParam, rcNull );
else
{
KDirectory * dir;
rc = KDirectoryNativeDir ( &dir );
if ( rc == 0 )
{
KFile const * f;
rc = KDirectoryOpenFileRead ( dir, &f, "%s", filename );
if ( rc == 0 )
{
if ( rc == 0 )
rc = LoadFromFile( f, namelist );
KFileRelease ( f );
}
KDirectoryRelease ( dir );
}
}
return rc;
}
static rc_t SpotIteratorDestroy(struct SpotIterator* self)
{
assert(self);
KDirectoryRelease(__SpotIteratorDirectory);
__SpotIteratorDirectory = NULL;
return KFileRelease(self->m_file);
}
/* Whack
*/
static
void KMemBankWhack ( KMemBank *self )
{
freeColdStorage(self->coldStorage, 0);
KFileRelease(self->pf);
free(self);
}
/* Open
*/
rc_t KColumnDataOpenRead ( KColumnData *self,
const KDirectory *dir, uint64_t eof, size_t pgsize )
{
rc_t rc = KDirectoryVOpenFileRead ( dir,
& self -> f, "data", NULL );
#if DATA_READ_FILE_BUFFER
if ( rc == 0 )
{
const KFile * orig = self -> f;
rc = KBufFileMakeRead ( & self -> f, self -> f, DATA_READ_FILE_BUFFER );
if ( rc == 0 )
{
KFileRelease ( orig );
}
else
{
self -> f = orig;
rc = 0;
}
}
#endif
if ( rc == 0 )
rc = KColumnDataInit ( self, eof, pgsize );
return rc;
}
static rc_t prepare_decompress( const compress_context * ctx,
KDirectory *dir, const KFile **src, KFile **dst )
{
const KFile *temp = NULL;
rc_t rc = KDirectoryCreateFile ( dir, dst, false, 0664, kcmInit, ctx->dst_file );
DISP_RC( rc, "KDirectoryCreateFile() failed" );
if ( rc != 0 ) return rc;
rc = KDirectoryOpenFileRead ( dir, &temp, ctx->src_file );
DISP_RC( rc, "KDirectoryOpenFileRead() failed" );
if ( rc == 0 )
switch( ctx->method )
{
case KC_GZIP : rc = KFileMakeGzipForRead ( src, temp );
DISP_RC( rc, "KFileMakeGzipForRead() failed" );
break;
case KC_BZIP : rc = KFileMakeBzip2ForRead ( src, temp );
DISP_RC( rc, "KFileMakeBzip2ForRead() failed" );
break;
case KC_SZIP : /* rc = KFileMakeSzipForRead ( src, temp ); */
rc = RC( rcExe, rcFile, rcPacking, rcFormat, rcUnknown );
DISP_RC( rc, "KFileMakeSzip2ForRead() failed" );
break;
}
KFileRelease ( temp );
return rc;
}
/* Init
*/
static
rc_t KColumnIdx2Init ( KColumnIdx2 *self, uint64_t idx2_eof )
{
rc_t rc;
#if 0
memset(&self->cstorage,0,sizeof(self->cstorage));
self->cstorage.elem_bits = sizeof(KColumnIdx2BlockCache)*8;
self->last = 0;
#endif
rc = KFileSize ( self -> f, & self -> eof );
if ( rc == 0 )
{
if ( self -> eof < idx2_eof )
rc = RC ( rcDB, rcColumn, rcConstructing, rcIndex, rcCorrupt );
else
{
self -> eof = idx2_eof;
return 0;
}
}
KFileRelease ( self -> f );
self -> f = NULL;
return rc;
}
/* ----------------------------------------------------------------------
* Destroy
*
*/
static
rc_t CC CCFileDestroy (CCFile *self)
{
rc_t rc = KFileRelease (self->original);
free (self);
return rc;
}
/* Whack
*/
rc_t KColumnDataWhack ( KColumnData *self )
{
rc_t rc = KFileRelease ( self -> f );
if ( rc == 0 )
self -> f = NULL;
return rc;
}
static void whack_lane( lane * l )
{
/* KFileRelease( l->mappings ); */
KFileRelease( l->reads );
StringWhack ( l->name );
free( l );
}
static
rc_t CC
_DocFile_close_v1 ( const struct XFSFileEditor * self )
{
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 ) {
RCt = KFileRelease ( Editor -> file );
Editor -> file = NULL;
}
return RCt;
} /* _DocFile_close_v1 () */
void txt2kdb_release (void)
{
KDirectoryRelease (G.dir);
KFileRelease (G.txt);
KDBManagerRelease (G.mgr);
KColumnRelease (G.col);
}
/* Open
*/
rc_t KColumnIdx2OpenRead ( KColumnIdx2 *self,
const KDirectory *dir, uint64_t eof )
{
rc_t rc = KDirectoryOpenFileRead ( dir,
( const KFile** ) & self -> f, "idx2" );
#if IDX2_READ_FILE_BUFFER
if ( rc == 0 )
{
KFile * orig = self -> f;
rc = KBufFileMakeRead ( ( const KFile** ) & self -> f, self -> f, eof + 1 );
if ( rc == 0 )
{
KFileRelease ( orig );
}
else
{
self -> f = orig;
rc = 0;
}
}
#endif
if ( rc == 0 )
rc = KColumnIdx2Init ( self, eof );
return rc;
}
rc_t SRAFastqFile_Open(const KFile** cself, const SRAListNode* sra, const FileOptions* opt)
{
rc_t rc = 0;
SRAFastqFile* self;
CALLOC( self, 1, sizeof( *self ) );
if( self == NULL )
{
rc = RC( rcExe, rcFile, rcConstructing, rcMemory, rcExhausted );
}
else
{
if ( ( rc = KFileInit( &self->dad, (const KFile_vt*)&SRAFastqFile_vtbl, "SRAFastqFile", "no-name", true, false ) ) == 0 )
{
if ( ( rc = SRAListNode_TableOpen( sra, &self->stbl ) ) == 0 )
{
if ( ( rc = SRATableGetKTableRead( self->stbl, &self->ktbl ) ) == 0 )
{
if ( ( rc = KTableOpenIndexRead( self->ktbl, &self->kidx, opt->index ) ) == 0 )
{
if ( ( rc = KLockMake( &self->lock ) ) == 0 )
{
MALLOC( self->buf, opt->buffer_sz * ( opt->f.fastq.gzip ? 2 : 1 ) );
if ( self->buf == NULL )
{
rc = RC( rcExe, rcFile, rcOpening, rcMemory, rcExhausted );
}
else
{
self->file_sz = opt->file_sz;
self->buffer_sz = opt->buffer_sz;
if ( opt->f.fastq.gzip )
{
self->gzipped = &self->buf[ opt->buffer_sz ];
}
self->from = ~0; /* reset position beyond file end */
rc = FastqReaderMake( &self->reader, self->stbl,
opt->f.fastq.accession, opt->f.fastq.colorSpace,
opt->f.fastq.origFormat, false, opt->f.fastq.printLabel,
opt->f.fastq.printReadId, !opt->f.fastq.clipQuality, false,
opt->f.fastq.minReadLen, opt->f.fastq.qualityOffset,
opt->f.fastq.colorSpaceKey,
opt->f.fastq.minSpotId, opt->f.fastq.maxSpotId );
}
}
}
}
}
if ( rc == 0 )
{
*cself = &self->dad;
}
else
{
KFileRelease( &self->dad );
}
}
}
return rc;
}
/* ----------------------------------------------------------------------
* Destroy
*
*/
static
rc_t CC KSubFileDestroy (KSubFile *self)
{
assert (self != NULL);
KFileRelease (self->original);
free (self);
return 0;
}
static
rc_t CC KBufWriteFileDestroy ( KBufWriteFile *self )
{
rc_t rc = KFileRelease ( self -> f );
if ( rc == 0 )
free ( self );
return rc;
}
rc_t CC KMain (int argc, char * argv[])
{
rc_t rc = 0;
KDirectory* wd;
KLogLevelSet(klogInfo);
LogMsg ( klogInfo, "KeyringServer: starting");
rc = KDirectoryNativeDir (&wd);
if (rc == 0)
{
KFile* lockedFile;
const char* dataDir;
char lockFileName[MAX_PATH];
if (argc < 2 || argv[1] == NULL)
dataDir = KeyRingDefaultDataDir;
else
dataDir = argv[1];
rc = string_printf(lockFileName, sizeof(lockFileName)-1, NULL, "%s/keyring_lock", dataDir);
if (rc == 0)
{
rc = KDirectoryCreateExclusiveAccessFile(wd, &lockedFile, true, 0600, kcmOpen, "%s", lockFileName);
if (rc == 0)
{
KNSManager* mgr;
rc = KNSManagerMake(&mgr);
if (rc == 0)
{
rc = string_printf(keyRingFileName, sizeof(keyRingFileName)-1, NULL, "%s/keyring", dataDir);
if (rc == 0)
rc = Server(mgr);
KNSManagerRelease(mgr);
}
else
LogErr(klogErr, rc, "KeyringServer: KNSManagerMake failed");
KFileRelease(lockedFile);
LogMsg ( klogInfo, "KeyringServer: removing lock file.");
KDirectoryRemove(wd, true, "%s", lockFileName);
}
else
{ /*TODO: check for stale lock file*/
LogMsg ( klogInfo, "KeyringServer: another instance appears to be running.");
rc = 0;
}
}
else
LogErr ( klogErr, rc, "KeyringServer: failed to build the lock file name" );
KDirectoryRelease(wd);
}
else
LogErr(klogErr, rc, "KeyringServer: KDirectoryNativeDir failed");
LogMsg ( klogInfo, "KeyringServer: finishing");
return rc;
}
rc_t CopierDoOne (Copier * self)
{
rc_t rc = 0;
const Buffer * b;
LOGMSG (klogDebug10, "CopierDoOne");
rc = Quitting();
if (rc == 0)
{
LOGMSG (klogDebug10, "call BufferQPopBuffer");
rc = BufferQPopBuffer (self->q, &b, NULL);
if (rc == 0)
{
size_t w;
size_t z;
LOGMSG (klogDebug10, "call BufferContentGetSize");
z = BufferContentGetSize (b);
rc = KFileWrite (self->f, self->o, b, z, &w);
self->o += w;
if (w != z)
rc = RC (rcExe, rcFile, rcWriting, rcTransfer, rcIncomplete);
else
rc = BufferRelease (b);
}
/* ow this is ugly! */
/* is the rc a "exhausted" on a timeout? */
else if ((GetRCObject(rc) == rcTimeout) && (GetRCState(rc) == rcExhausted))
{
rc = 0;
LOGMSG (klogDebug10, "CopierDoOne timeout");
/* if so is the queue also sealed? */
if (BufferQSealed (self->q) == true)
{
LOGMSG (klogDebug10, "CopierDoOne sealed");
/* if both then we are done and so signal */
rc = KFileRelease (self->f);
PLOGMSG (klogDebug10, "CopierDoOne back from KFileRelease $(rc)",PLOG_U32(rc),rc);
if (rc == 0)
{
self->f = NULL;
rc = BufferQRelease (self->q);
if (rc == 0)
{
self->q = NULL;
rc = RC (rcExe, rcNoTarg, rcCopying, rcNoTarg, rcDone );
}
}
}
}
else
LOGMSG (klogDebug10, "CopierDoOne pop failure");
}
else
LOGMSG (klogDebug10, "CopierDoOne: quitting");
return rc;
}
void release_out_redir( out_redir * self )
{
KFileRelease( self->kfile );
if( self->org_writer != NULL )
{
KOutHandlerSet( self->org_writer, self->org_data );
}
self->org_writer = NULL;
}
void release_lookup_reader( struct lookup_reader * reader )
{
if ( reader != NULL )
{
if ( reader->f != NULL ) KFileRelease( reader->f );
release_SBuffer( &reader->buf );
free( ( void * ) reader );
}
}
void free_rna_splice_log( struct rna_splice_log * sl )
{
if ( sl != NULL )
{
KFileRelease ( sl->log_file );
if ( sl->tool_name != NULL ) free( ( void * )sl->tool_name );
free( ( void * ) sl );
}
}
/* CreateLockFile
* attempts to create a KLockFile
*
* "lock" [ OUT ] - return parameter for newly created lock file
*
* "path" [ IN ] - NUL terminated string in directory-native
* character set denoting lock file
*/
LIB_EXPORT rc_t CC KDirectoryVCreateLockFile ( KDirectory *self,
KLockFile **lock, const char *path, va_list args )
{
rc_t rc;
if ( lock == NULL )
rc = RC ( rcFS, rcFile, rcLocking, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcFS, rcFile, rcLocking, rcSelf, rcNull );
else if ( path == NULL )
rc = RC ( rcFS, rcFile, rcLocking, rcPath, rcNull );
else if ( path [ 0 ] == 0 )
rc = RC ( rcFS, rcFile, rcLocking, rcPath, rcEmpty );
else
{
char full [ 4096 ];
rc = KDirectoryVResolvePath ( self, false, full, sizeof full, path, args );
if ( rc == 0 )
{
KFile *lock_file;
rc = KDirectoryCreateFile ( self, & lock_file, false, 0600, kcmCreate | kcmParents, "%s", full );
if ( rc == 0 )
{
rc_t rc2;
/* no longer need the file - not going to write to it anyway */
KFileRelease ( lock_file );
/* we have the lock */
rc = KLockFileMake ( lock, self, full );
if ( rc == 0 )
return 0;
/* must unlink lockfile */
rc2 = KDirectoryRemove ( self, true, "%s", full );
if ( rc2 != 0 )
/* issue a report */;
}
else if ( GetRCState ( rc ) == rcExists )
{
/* map the rc to kproc type values */
rc = RC ( rcFS, rcFile, rcLocking, rcLocking, rcBusy );
}
else
{
rc = ResetRCContext ( rc, rcFS, rcFile, rcLocking );
}
}
}
* lock = NULL;
}
return rc;
}
/* ----------------------------------------------------------------------
* CCNodeSraDirDestroy
*/
static rc_t CC CCNodeSraDirDestroy (CCNodeSraDir *self)
{
if (self)
{
KFileRelease (self->file);
free (self);
}
return 0;
}