/* ----------------------------------------------------------------------
*/
static
int64_t CC extnode_sort (const BSTNode * item, const BSTNode * n)
{
const extnode * l;
const extnode * r;
int64_t ii;
l = (const extnode *)item;
r = (const extnode *)n;
if (l->offset < r->offset)
ii = -1;
else if (l->offset > r->offset)
ii = 1;
else
{
size_t lz;
size_t rz;
char lbuff [8192];
char rbuff [8192];
rc_t lrc;
rc_t rrc;
lrc = VPathReadPath (l->path, lbuff, sizeof (lbuff), &lz);
if (lrc)
{
LOGERR (klogInt, lrc, "failed to etract item path");
lz = 0;
}
rrc = VPathReadPath (r->path, rbuff, sizeof (rbuff), &rz);
if (lrc)
{
LOGERR (klogInt, rrc, "failed to etract node path");
rz = 0;
}
ii = string_cmp (lbuff, lz, rbuff, rz, lz + rz);
}
return ii;
}
static rc_t report_deletes_spec( const VDBManager *vdb_mgr,
VFSManager * vfs_mgr,
const char * spec,
uint32_t min_len )
{
rc_t rc = KOutMsg( "\nreporting deletes of '%s'\n", spec );
if ( rc == 0 )
{
VPath * path = NULL;
const VPath * local_cache = NULL;
const KFile * remote_file = NULL;
rc = VFSManagerResolveSpec ( vfs_mgr, spec, &path, &remote_file, &local_cache, true );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot resolve spec via VFSManager" );
}
else
{
char buffer[ 4096 ];
size_t num_read;
rc = VPathReadPath ( path, buffer, sizeof buffer, &num_read );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot read path from vpath" );
}
else
{
int path_type = ( VDBManagerPathType ( vdb_mgr, "%s", buffer ) & ~ kptAlias );
switch( path_type )
{
case kptDatabase : rc = report_deletes_db( vdb_mgr, buffer, min_len ); break;
case kptTable : KOutMsg( "cannot report deletes on a table-object\n" );
rc = RC ( rcApp, rcNoTarg, rcAccessing, rcParam, rcInvalid );
(void)LOGERR( klogErr, rc, "cannot report references on a table-object" );
break;
default : KOutMsg( "the given object is not a vdb-database\n" );
rc = RC ( rcApp, rcNoTarg, rcAccessing, rcParam, rcInvalid );
(void)LOGERR( klogErr, rc, "the given object is not a vdb-database" );
break;
}
}
KFileRelease( remote_file );
VPathRelease ( local_cache );
VPathRelease ( path );
}
}
return rc;
}
static rc_t report_references( const VDBManager *vdb_mgr, VFSManager * vfs_mgr, const char * spec,
bool extended )
{
rc_t rc = KOutMsg( "\nreporting references of '%s'\n", spec );
if ( rc == 0 )
{
VPath * path = NULL;
const VPath * local_cache = NULL;
const KFile * remote_file = NULL;
rc = VFSManagerResolveSpec ( vfs_mgr, spec, &path, &remote_file, &local_cache, true );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot resolve spec via VFSManager" );
}
else
{
char buffer[ 4096 ];
size_t num_read;
rc = VPathReadPath ( path, buffer, sizeof buffer, &num_read );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot read path from vpath" );
}
else
{
rc = KOutMsg( "resolved into '%s'\n", buffer );
if ( rc == 0 )
{
int path_type = ( VDBManagerPathType ( vdb_mgr, "%s", buffer ) & ~ kptAlias );
switch( path_type )
{
case kptDatabase : rc = report_ref_database( vdb_mgr, vfs_mgr, buffer, extended );
break;
case kptTable : rc = KOutMsg( "cannot report references on a table-object\n" );
break;
default : rc = KOutMsg( "the given object is not a vdb-database\n" );
break;
}
}
}
KFileRelease( remote_file );
VPathRelease ( local_cache );
VPathRelease ( path );
}
}
return rc;
}
static rc_t ref_walker_prepare_1_src( struct ref_walker * self, const char * name )
{
VPath * path = NULL;
const VPath * local_cache = NULL;
const KFile * remote_file = NULL;
rc_t rc = VFSManagerResolveSpec ( self->vfs_mgr, name, &path, &remote_file, &local_cache, true );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "cannot resolve '$(n)' via VFSManager", "n=%s", name ) );
}
else
{
char buffer[ 4096 ];
size_t num_read;
rc = VPathReadPath ( path, buffer, sizeof buffer, &num_read );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "cannot read path from vpath for '$(n)'", "n=%s", name ) );
}
else
{
if ( rc == 0 )
{
int path_type = ( VDBManagerPathType ( self->vmgr, "%s", buffer ) & ~ kptAlias );
if ( path_type == kptDatabase )
{
const ReferenceList * reflist;
uint32_t options = ( ereferencelist_usePrimaryIds |
ereferencelist_useSecondaryIds |
ereferencelist_useEvidenceIds );
rc = ReferenceList_MakePath( &reflist, self->vmgr, name, options, 0, NULL, 0 );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "cannot create ReferenceList for '$(n)'", "n=%s", name ) );
}
else
{
uint32_t count;
rc = ReferenceList_Count( reflist, &count );
if ( rc != 0 )
{
PLOGERR( klogErr, ( klogErr, rc, "ReferenceList_Count() for '$(n)' failed", "n=%s", name ) );
}
else
{
uint32_t idx;
for ( idx = 0; idx < count && rc == 0; ++idx )
{
const ReferenceObj * refobj;
rc = ReferenceList_Get( reflist, &refobj, idx );
if ( rc != 0 )
{
LOGERR( klogInt, rc, "ReferenceList_Get() failed" );
}
else
{
const char * seqid;
rc = ReferenceObj_SeqId( refobj, &seqid );
if ( rc == 0 )
{
INSDC_coord_len seqlen;
rc = ReferenceObj_SeqLength( refobj, &seqlen );
if ( rc == 0 )
{
rc = add_region( &self->regions, seqid, 0, seqlen - 1 );
}
}
ReferenceObj_Release( refobj );
}
}
}
ReferenceList_Release( reflist );
}
}
}
}
KFileRelease( remote_file );
VPathRelease ( local_cache );
VPathRelease ( path );
}
return rc;
}
/* ----------------------------------------------------------------------
* signature is because this is called by VectorDoUntil
*/
static
void CC handle_path (void * item_, void * data_)
{
if ((item_ != NULL) && (data_ != NULL))
{
VPath * vpath = item_;
rc_data * data = data_;
size_t z;
rc_t rc;
char pbuff [8193];
/* char tbuff [8193]; */
if (data->rc)
return;
/* -1 saves room for a guaranteed NUL */
rc = VPathReadPath (vpath, pbuff, sizeof (pbuff) - 1, &z);
if (rc)
LOGERR (klogErr, rc, "failed to pull path out of VPath");
else if (z)
{
KPathType kpt;
/* force a NUL just in case: we saved room for it */
pbuff[z] = '\0';
/* what type of path is this? */
kpt = KDirectoryPathType (options.base, "%s", pbuff);
#if 0
/* ain't doing this now, and may never because of the root versus base problems */
/* dereference links until we're done */
while (kpt & kptAlias)
{
rc = KDirectoryResolveAlias (options.base, true,
tbuff, sizeof tbuff, "%s", pbuff);
if (rc)
{
PLOGERR (klogErr,
(klogErr, rc, "error resolving path '$(P)'",
"P=%s", pbuff));
break;
}
else
{
memcpy (tbuff, pbuff, sizeof pbuff);
z = string_size (pbuff);
kpt = KDirectoryPathType (options.root, "%s", pbuff);
}
}
#endif
/* if we didn't crash this path dereferecing it. */
if (rc == 0)
{
if (kpt & kptAlias)
kpt = kptAlias;
switch (kpt)
{
default:
rc = RC (rcExe, rcPath, rcAccessing, rcPath, rcInvalid);
PLOGERR (klogErr,
(klogErr, rc, "unknown problem with path '$(P)'",
"P=%s", pbuff));
break;
case kptNotFound:
PLOGERR (klogErr,
(klogErr, rc, "path is a not found in archive '$(P)'",
"P=%s", pbuff));
break;
case kptZombieFile:
rc = RC (rcExe, rcPath, rcAccessing, rcPath, rcNotFound);
PLOGERR (klogErr,
(klogErr, rc, "path is a not in archive but should be '$(P)'",
"P=%s", pbuff));
break;
case kptBadPath:
rc = RC (rcExe, rcPath, rcAccessing, rcPath, rcInvalid);
PLOGERR (klogErr,
(klogErr, rc, "unusable path form '$(P)'",
"P=%s", pbuff));
break;
case kptFile:
{
uint64_t offset = 0;
rc = walk_path_file (pbuff, z, &offset, kptFile);
if (rc)
PLOGERR (klogErr,
(klogErr, rc, "couldn't walk path '$(P)'",
"P=%s", pbuff));
else
{
rc = insert_path (vpath, offset);
if (rc)
PLOGERR (klogErr,
(klogErr, rc, "couldn't sort path '$(P)'",
"P=%s", pbuff));
}
break;
}
case kptDir:
rc = walk_path_tree (pbuff, z);
break;
case kptCharDev:
case kptBlockDev:
case kptFIFO:
case kptAlias:
rc = RC (rcExe, rcPath, rcAccessing, rcPath, rcIncorrect);
PLOGERR (klogErr,
(klogErr, rc, "unusable path target type '$(P)'",
"P=%s", pbuff));
break;
}
}
}
data->rc = rc;
}
}
static
int CC sort_pathpath_cmp (const void ** litem, const void ** ritem, void * data)
{
uint64_t lloc, rloc;
{
const VPath * lpath;
size_t z;
rc_t rc;
char pbuff [8192];
lpath = *litem;
rc = VPathReadPath (lpath, pbuff, sizeof pbuff, &z);
if (rc == 0)
{
switch (KDirectoryPathType (options.base, "%s", pbuff))
{
default:
lloc = 0;
break;
case kptFile:
rc = KDirectoryFileLocator (options.base, &lloc, "%s", pbuff);
break;
}
if (rc == 0)
{
const VPath * rpath;
rpath = *ritem;
rc = VPathReadPath (rpath, pbuff, sizeof pbuff, &z);
if (rc == 0)
{
switch (KDirectoryPathType (options.base, "%s", pbuff))
{
default:
rloc = 0;
break;
case kptFile:
rc = KDirectoryFileLocator (options.base, &rloc, "%s", pbuff);
break;
}
}
}
}
if (rc) /* surrender */
lloc = rloc = 0;
}
{
int cmp;
if (lloc < rloc)
cmp = -1;
else if (lloc > rloc)
cmp = 1;
else
{
assert (lloc == rloc);
cmp = 0;
};
return cmp;
}
}
/* ----------------------------------------------------------------------
*/
static
bool CC extract_one (BSTNode * n, void * data_)
{
extnode * node;
rc_data * data = data_;
rc_t rc;
size_t z;
char buff [8193];
assert (n);
assert (data);
node = (extnode*)n;
rc = VPathReadPath (node->path, buff, sizeof (buff) - 1, &z);
if (rc)
LOGERR (klogErr, rc, "error pulling path for an extraction");
else
{
const KFile * sfile;
buff[z] = '\0';
/*
* use base unless we have to revert to root.
* base allows more control over options like password where the outside
* archive might have a different password than an inner file
*/
#if 1
rc = VFSManagerOpenFileReadDirectoryRelative (options.vfsmgr, options.base,
&sfile, node->path);
#else
rc = VFSManagerOpenFileReadDirectoryRelative (options.vfsmgr, options.root,
&sfile, node->path);
#endif
if (rc)
LOGERR (klogErr, rc, "error opening file within the archive");
else
{
KFile * dfile;
/* KOutMsg ("%s: %s %x\n", __func__, node->path, options.cm); */
rc = KDirectoryCreateFile (options.dir, &dfile, false, 0640, options.cm, "%s", buff);
if (rc)
PLOGERR (klogErr, (klogErr, rc, "failed to create file '$(P)'", "P=%s", buff));
else
{
const KFile * teefile;
rc = KFileMakeTeeRead (&teefile, sfile, dfile);
if (rc)
PLOGERR (klogErr, (klogErr, rc, "failed pipefitting file '$(P)'", "P=%s", buff));
else
{
KFileAddRef (sfile);
KFileAddRef (dfile);
rc = KFileRelease (teefile);
if (rc)
PLOGERR (klogErr, (klogErr, rc, "failed copying file '$(P)'", "P=%s", buff));
}
}
KFileRelease (sfile);
}
KFileRelease (sfile);
}
data->rc = rc;
return (rc != 0);
}
/* ResolveTablePath
* takes either an accession or path
* substitutes any arguments
* resolves via SRAPath mgr if present
*/
rc_t ResolveTablePath ( const SRAMgr *mgr,
char *path, size_t psize, const char *spec, va_list args )
{
#if OLD_SRAPATH_MGR
int len;
char tblpath [ 4096 ];
const SRAPath *pmgr = mgr -> _pmgr;
/* if no path manager or if the spec string has embedded path separators,
then this can't be an accession - just print it out */
if ( mgr -> _pmgr == NULL || strchr( spec, '/' ) != NULL )
{
len = vsnprintf ( path, psize, spec, args );
if ( len < 0 || ( size_t ) len >= psize )
return RC ( rcSRA, rcTable, rcOpening, rcPath, rcExcessive );
return 0;
}
/* create a copy - not likely to be too large */
len = vsnprintf ( tblpath, sizeof tblpath, spec, args );
if ( len < 0 || ( size_t ) len >= sizeof tblpath )
return RC ( rcSRA, rcTable, rcOpening, rcPath, rcExcessive );
/* test if the path exists in current directory, i.e. with assumed dot */
if ( ! SRAPathTest ( pmgr, tblpath ) )
{
rc_t rc = SRAPathFind ( pmgr, tblpath, path, psize );
if ( rc == 0 )
return 0;
}
/* use the path given */
if ( ( size_t ) len >= psize )
return RC ( rcSRA, rcTable, rcOpening, rcBuffer, rcInsufficient );
strcpy ( path, tblpath );
return 0;
#else
VFSManager *vfs;
rc_t rc = VFSManagerMake ( & vfs );
if ( rc == 0 )
{
VPath *accession;
const VPath *tblpath = NULL;
rc = VFSManagerVMakePath ( vfs, & accession, spec, args );
if ( rc == 0 )
{
rc = VResolverLocal ( ( const VResolver* ) mgr -> _pmgr, accession, & tblpath );
if ( rc == 0 )
{
size_t size;
rc = VPathReadPath ( tblpath, path, psize, & size );
VPathRelease ( tblpath );
}
VPathRelease ( accession );
}
VFSManagerRelease ( vfs );
}
return rc;
#endif
}
static
rc_t run ()
{
const KFile * in;
rc_t rc = 0;
do {
uint64_t in_pos = 0;
size_t num_read;
char buffer [8 * 1024];
rc = KFileMakeStdIn (&in);
if (rc) break;
for ( ;; )
{
VPath * path;
rc = KOutMsg ("Enter a system specific path: ");
if (rc) break;
memset (buffer, 0, sizeof buffer);
rc = KFileRead (in, in_pos, buffer, sizeof buffer, &num_read);
if (rc)
{
LOGERR (klogFatal, rc, "error with KFileRead");
break;
}
if (num_read == 0) break;
in_pos += num_read;
if (buffer[num_read-1] == '\n')
buffer[num_read-1] = '\0';
if (buffer[num_read-2] == '\r')
buffer[num_read-2] = '\0';
rc = VPathMakeSysPath (&path, buffer);
if (rc)
{
LOGERR (klogErr, rc, "error with MakeSysPath");
break;
}
memset (buffer, 0, sizeof buffer);
rc = VPathReadPath (path, buffer, sizeof buffer, &num_read);
if (rc)
{
LOGERR (klogErr, rc, "error wth ReadPath");
break;
}
rc = KOutMsg ("VPath path is '%s' size '%zu'\n\n", buffer, num_read);
if (rc)
{
LOGERR (klogErr, rc, "error with KOuMsg");
break;
}
}
} while (0);
return rc;
}
