/* ---------------------------------------------------------------------- */ 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; }