static rc_t CC scan_mod_dir(const KDirectory* dir,
uint32_t type, const char* name, void* data)
{
rc_t rc = 0;
const char ext[] = SHLX;
assert(data);
if (strlen(name) > strlen(ext) + 1 &&
name[strlen(name) - strlen(ext) - 1] == '.')
{
char buf[PATH_MAX + 1];
rc = KDirectoryResolvePath
(dir, true, buf, sizeof buf, "%s/%s", data, name);
while (rc == 0) {
uint32_t type = KDirectoryPathType(dir, buf);
if (type & kptAlias) {
rc = KDirectoryResolveAlias
(dir, true, buf, sizeof buf, buf);
DISP_RC(rc, name);
}
else if (rc == 0) {
if (type == kptNotFound || type == kptBadPath) {
OUTMSG(("%s: %s\n", buf,
type == kptNotFound ? "not found" : "bad path"));
}
else { OUTMSG(("%s\n", buf)); }
break;
}
}
}
return rc;
}
static rc_t pacbio_check_sourcefile( context *ctx, ld_context *lctx )
{
rc_t rc = 0;
uint32_t src_path_type = KDirectoryPathType ( lctx->wd, ctx->src_path );
if ( ( src_path_type & kptFile ) == 0 )
{
rc = RC ( rcExe, rcFile, rcValidating, rcItem, rcNotFound );
LOGERR( klogErr, rc, "source-file not found" );
}
else
{
if ( ( src_path_type & kptAlias ) != 0 )
{
char resolved[ 2048 ];
rc = KDirectoryResolveAlias ( lctx->wd, true, resolved,
2084, ctx->src_path );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot resolve srcfile-link" );
}
else
{
free( ctx->src_path );
ctx->src_path = string_dup_measure ( resolved, NULL );
}
}
}
return rc;
}
/* IsAlias
* returns true if object name is an alias
* returns path to fundamental name if it was aliased
*
* "type" [ IN ] - a KDBPathType
* valid values are kptIndex and kptColumn
*
* "resolved" [ OUT ] and "rsize" [ IN ] - optional output buffer
* for fundamenta object name if "alias" is not a fundamental name,
*
* "name" [ IN ] - NUL terminated object name
*/
LIB_EXPORT bool CC KTableIsAlias ( const KTable *self, uint32_t type,
char *resolved, size_t rsize, const char *name )
{
if ( self != NULL && name != NULL && name [ 0 ] != 0 )
{
rc_t rc;
const char *ns;
char path [ 256 ];
switch ( type )
{
case kptIndex:
ns = "idx";
break;
case kptColumn:
ns = "col";
break;
default:
return false;
}
rc = KDBMakeSubPath ( self -> dir, path, sizeof path, ns, 3, name );
if ( rc == 0 )
{
switch ( KDirectoryPathType ( self -> dir, "%s", path ) )
{
case kptFile | kptAlias:
case kptDir | kptAlias:
if ( resolved != NULL && rsize != 0 )
{
const KDirectory *sub;
rc = KDirectoryOpenDirRead ( self -> dir, & sub, false, "%s", ns );
* resolved = 0;
if ( rc != 0 )
PLOGERR ( klogWarn, ( klogWarn, rc, "failed to open subdirectory '$(sub)'", "sub=%s", ns ) );
else
{
rc = KDirectoryResolveAlias ( sub, false, resolved, rsize, "%s", name );
KDirectoryRelease ( sub );
if ( rc != 0 )
PLOGERR ( klogWarn, ( klogWarn, rc, "failed to resolve alias '$(alias)'", "alias=%s", name ) );
}
}
return true;
}
}
}
if ( resolved != NULL && rsize != 0 )
* resolved = 0;
return false;
}
static
rc_t ReportAlias(const ReportFuncs *f, uint32_t indent, const char* alias, const KDirectory* dir)
{
char resolved[PATH_MAX + 1];
rc_t rc
= KDirectoryResolveAlias(dir, false, resolved, sizeof resolved, "%s", alias);
if (rc == 0) {
const char tag[] = "Alias";
uint32_t type = KDirectoryPathType(dir, "%s", resolved);
if (type & kptAlias) {
reportOpen(indent, tag, 1, "resolved", 's', resolved);
rc = ReportAlias(f, indent + 1, resolved, dir);
reportClose(indent, tag);
}
else
{ report(indent, tag, 1, "resolved", 's', resolved); }
}
return rc;
}
/* ----------------------------------------------------------------------
*/
static
void CC build_vpath_one (void * item, void * data)
{
const char * path;
rc_data * prc;
path = item;
prc = data;
if (prc->rc == 0)
{
static const char ccid [] = "copycat-id:";
const size_t cz = sizeof (ccid) - 1;
size_t pz;
const char * hier;
const char * ppath;
VPath * vpath;
rc_t rc;
char vbuff [8193];
rc = 0;
ppath = path;
pz = string_size (path);
hier = string_chr (path, pz, ':');
if ((hier != NULL) &&
(0 == string_cmp (path, (hier+1) - path, ccid, cz /*sizeof (ccid) - 1*/, cz)))
{
static const char nfile[] = "ncbi-file:";
char * qmark;
size_t s, r/*, q */;
char ibuff [8192];
char rbuff [8192];
++hier;
s = hier - path;
r = string_copy (ibuff, sizeof (ibuff), hier, pz - s);
qmark = string_chr (ibuff, r, '?');
if (qmark == NULL) /* this is more future with parts */
qmark = string_chr (ibuff, r, '#');
if (qmark != NULL)
*qmark = '\0';
rc = KDirectoryResolveAlias (options.root, true, rbuff, sizeof (rbuff), "%s", ibuff);
if (rc)
PLOGERR (klogErr, (klogErr, rc, "error resolving file id '$(I)", "I=%s", ibuff));
else
{
char * slash;
size_t z;
slash = string_chr (rbuff+1, sizeof (rbuff), '/');
if (slash == NULL)
/* we won't extract the root */
return;
++slash;
z = string_size (slash);
if (z == 0)
return;
if (qmark)
{
s = string_copy (vbuff, sizeof (vbuff), nfile, sizeof (nfile));
r = string_copy (vbuff + s, sizeof (vbuff) - s, slash, z);
/*q = */string_copy (vbuff + s + r, (sizeof (vbuff) - s) - r, qmark, pz - (qmark - path));
}
else
{
s = string_copy (vbuff, sizeof (vbuff), slash, z);
}
ppath = vbuff;
}
}
if (rc == 0)
{
rc = VFSManagerMakePath (options.vfsmgr, &vpath, "%s", ppath);
if (rc)
;
else
{
rc = VectorAppend (&options.pathvpath, NULL, vpath);
if (rc)
{
VPathRelease (vpath);
}
}
}
prc->rc = 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;
}
}
