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