static
rc_t KDBManagerMakeDBUpdate ( KDBManager *self,
KDatabase **dbp, KDirectory *wd, const char *path, KMD5SumFmt *md5 )
{
rc_t rc;
KDirectory *dir;
rc = KDirectoryOpenDirUpdate ( wd, & dir, false, "%s", path );
if ( rc == 0 )
{
KDatabase *db;
/* Make the base object */
rc = KDatabaseMake ( & db, dir, path, md5, false );
if ( rc == 0 )
{
rc = KDBManagerInsertDatabase ( self, db );
if ( rc == 0 )
{
* dbp = db;
return 0; /* successful exit */
}
rc = RC ( rcDB, rcMgr, rcOpening, rcDatabase, rcBusy );
free ( db );
}
KDirectoryRelease ( dir );
}
return rc;
}
static rc_t cg_dump_prepare_output( cg_dump_opts * opts, cg_dump_ctx * cg_ctx )
{
rc_t rc = 0;
uint32_t pt = ( KDirectoryPathType ( cg_ctx->dir, "%s", cg_ctx->dst ) & ~ kptAlias );
switch ( pt )
{
case kptNotFound : rc = cg_dump_create_output_dir( cg_ctx ); break;
case kptDir : rc = cg_dump_clear_output_dir( opts, cg_ctx ); break;
case kptFile : rc = cg_dump_remove_file( opts, cg_ctx );
if ( rc == 0 )
rc = cg_dump_create_output_dir( cg_ctx );
break;
default : rc = RC( rcExe, rcNoTarg, rcReading, rcParam, rcInvalid );
(void)PLOGERR( klogErr, ( klogErr, rc, "invalid output-directory-type '$(dt)'",
"dt=%s", pathtype_2_pchar( pt ) ) );
break;
}
if ( rc == 0 )
{
rc = KDirectoryOpenDirUpdate ( cg_ctx->dir, &cg_ctx->out_dir, false, "%s", cg_ctx->dst );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot open output-directory for update" );
}
else
{
BSTreeInit( &cg_ctx->lanes );
}
}
return rc;
}
static rc_t KDBOpenPathTypeReadInt ( const KDBManager * mgr, const KDirectory * dir, const char * path,
const KDirectory ** pdir, int * type,
int pathtype, uint32_t rcobj, bool try_srapath )
{
VFSManager * vmgr = mgr->vfsmgr;
const KDirectory * ldir = NULL;
rc_t rc = 0;
/* object relative opens can be done using KFS - we hacked in VFS after all */
if (! try_srapath)
{
rc = KDirectoryOpenDirUpdate ((KDirectory*)dir, (KDirectory**)pdir, false, path);
if ((rc) && (GetRCState(rc) != rcNotFound))
rc = KDirectoryOpenDirRead (dir, pdir, false, path);
}
else
{
VPath * vpath;
/*
* We've got to decide if the path coming in is a full or relative
* path and if relative make it relative to dir or possibly its a srapath
* accession
*
*/
rc = VPathMakeDirectoryRelative ( &vpath, dir, path );
if ( rc == 0 )
{
rc = VFSManagerOpenDirectoryReadDirectoryRelativeDecrypt ( vmgr, dir, &ldir, vpath );
if ( rc == 0 )
{
*type = (~kptAlias) & KDBPathType ( ldir, NULL, "." );
/* just a directory, not a kdb type */
if ( *type == kptDir )
rc = RC (rcDB, rcMgr, rcOpening, rcPath, rcIncorrect);
else if ( *type != pathtype )
{
KDirectoryRelease( ldir );
rc = RC ( rcDB, rcMgr, rcOpening, rcobj, rcIncorrect );
}
else
{
if ( pdir != NULL )
*pdir = ldir;
else
KDirectoryRelease( ldir );
}
}
VPathRelease ( vpath );
}
}
return rc;
}
static rc_t copy2_main( Args * args )
{
const char * source_path;
rc_t rc = ArgsParamValue( args, 0, &source_path );
if ( rc != 0 )
LOGERR( klogInt, rc, "ArgsParamValue( 0 ) failed" );
else
{
const char * dest_path;
rc = ArgsParamValue( args, 1, &dest_path );
if ( rc != 0 )
LOGERR( klogInt, rc, "ArgsParamValue( 1 ) failed" );
else
{
KDirectory *dir, *dest_dir;
const KDirectory *source_dir;
rc = KDirectoryNativeDir ( &dir );
if ( rc != 0 )
LOGERR( klogInt, rc, "KDirectoryNativeDir() failed" );
else
{
rc = KDirectoryOpenDirRead( dir, &source_dir, false,
source_path );
if ( rc != 0 )
LOGERR( klogInt, rc, "KDirectoryOpenDirRead() failed" );
else
{
rc = KDirectoryOpenDirUpdate( dir, &dest_dir, false,
dest_path );
if ( rc != 0 )
LOGERR( klogInt, rc,
"KDirectoryOpenDirUpdate() failed" );
else
{
rc = KDirectoryCopy( source_dir, dest_dir, true,
source_path, dest_path );
if ( rc != 0 )
LOGERR( klogInt, rc, "copy_dirs() failed" );
else
OUTMSG(( "copy successful!\n" ));
KDirectoryRelease ( dest_dir );
}
KDirectoryRelease ( source_dir );
}
KDirectoryRelease ( dir );
}
}
}
return rc;
}
/*
* copies top/inname (a directory)
* to targettop/outname, i.e. creates outname as a copy of that directory.
*/
rc_t CopyDirectoryToExistingDirectory( const KDirectory *top, const char *inname, KDirectory *targettop, const char *outname )
{
rc_t rc;
uint32_t mode;
const KDirectory *source;
KDirectory *dest;
rc = KDirectoryOpenDirRead(top, &source, true, "%s", (const char *)inname);
if (rc != 0)
{
LOGERR ( klogInt, rc, "can't open input directory" );
return rc;
}
mode = DEFAULT_DIR_MODE;
rc = KDirectoryAccess( top, &mode, "%s", inname);
if (rc != 0)
{
LOGERR ( klogInt, rc, inname );
return rc;
}
rc = KDirectoryCreateDir( targettop, mode, kcmOpen, "%s", outname );
if (rc != 0)
{
LOGERR ( klogInt, rc, "can't create output directory" );
return rc;
}
if (clobber_protections) {
KDirectorySetAccess( targettop, false, mode, 0777, "%s", outname);
}
rc = KDirectoryOpenDirUpdate(targettop, &dest, true, "%s", outname);
if (rc != 0)
{
LOGERR ( klogInt, rc, "can't open directory for write" );
return rc;
}
CopyDirectoryFiles(source, dest);
CopyDirectoryDirectories( source, dest );
KDirectoryRelease( dest );
KDirectoryRelease( source );
return 0;
}
static rc_t CreateConfig(char* argv0) {
const KFile* std_in = NULL;
KDirectory* native = NULL;
KDirectory* dir = NULL;
rc_t rc = 0;
char* location = NULL;
char* mod = NULL;
char* wmod = NULL;
char* refseq = NULL;
if (rc == 0) {
rc = KDirectoryNativeDir(&native);
}
if (rc == 0) {
const char* def = NULL;
char cwd[PATH_MAX + 1] = "";
const char* home = getenv("HOME");
if (home)
{ def = home; }
else {
rc = VPathGetCWD(cwd, sizeof cwd);
if (rc == 0 && cwd[0])
{ def = cwd; }
else
{ def = "."; }
}
while (rc == 0) {
char buffer[PATH_MAX + 1];
rc = In("Specify configuration files directory", def, &location);
if (rc == 0) {
rc = KDirectoryOpenDirUpdate(native, &dir, false, location);
if (rc == 0) {
rc = KDirectoryVVisit
(dir, false, scan_config_dir, buffer, ".", NULL);
if (rc != 0) {
if (rc ==
RC(rcExe, rcDirectory, rcListing, rcFile, rcExists)
&& buffer[0])
{
PLOGERR(klogErr, (klogErr, rc,
"Configuration file found: $(dir)/$(name)",
"dir=%s,name=%s", location, buffer));
rc = 0;
buffer[0] = '\0';
continue;
}
else {
PLOGERR(klogErr, (klogErr, rc, "$(dir)/$(name)",
"dir=%s,name=%s", location, buffer));
}
}
break;
}
else if (GetRCObject(rc) == rcPath &&
(GetRCState(rc) == rcIncorrect || GetRCState(rc) == rcNotFound))
{
PLOGERR(klogErr,
(klogErr, rc, "$(path)", "path=%s", location));
rc = 0;
}
else { DISP_RC(rc, location); }
}
}
}
while (rc == 0) {
const KDirectory* dir = NULL;
rc = In("Specify refseq installation directory", NULL, &refseq);
if (rc != 0)
{ break; }
rc = KDirectoryOpenDirRead(native, &dir, false, refseq);
if (rc == 0) {
RELEASE(KDirectory, dir);
break;
}
else if (GetRCObject(rc) == rcPath
&& GetRCState(rc) == rcIncorrect)
{
PLOGERR(klogErr,
(klogErr, rc, "$(path)", "path=%s", refseq));
rc = 0;
}
DISP_RC(rc, refseq);
}
if (rc == 0) {
char buffer[512];
const char path[] = "vdb-config.kfg";
uint64_t pos = 0;
KFile* f = NULL;
rc = KDirectoryCreateFile(dir, &f, false, 0664, kcmCreate, path);
DISP_RC(rc, path);
if (rc == 0) {
int n = snprintf(buffer, sizeof buffer,
"refseq/servers = \"%s\"\n", refseq);
if (n >= sizeof buffer) {
rc = RC(rcExe, rcFile, rcWriting, rcBuffer, rcInsufficient);
}
else {
size_t num_writ = 0;
rc = KFileWrite(f, pos, buffer, strlen(buffer), &num_writ);
pos += num_writ;
}
}
if (rc == 0) {
const char buffer[] = "refseq/volumes = \".\"\n";
size_t num_writ = 0;
rc = KFileWrite(f, pos, buffer, strlen(buffer), &num_writ);
pos += num_writ;
}
if (rc == 0 && mod && mod[0]) {
int n = snprintf(buffer, sizeof buffer,
"vdb/module/paths = \"%s\"\n", mod);
if (n >= sizeof buffer) {
rc = RC(rcExe, rcFile, rcWriting, rcBuffer, rcInsufficient);
}
else {
size_t num_writ = 0;
rc = KFileWrite(f, pos, buffer, strlen(buffer), &num_writ);
pos += num_writ;
}
}
if (rc == 0 && wmod && wmod[0]) {
int n = snprintf(buffer, sizeof buffer,
"vdb/wmodule/paths = \"%s\"\n", wmod);
if (n >= sizeof buffer) {
rc = RC(rcExe, rcFile, rcWriting, rcBuffer, rcInsufficient);
}
else {
size_t num_writ = 0;
rc = KFileWrite(f, pos, buffer, strlen(buffer), &num_writ);
pos += num_writ;
}
}
RELEASE(KFile, f);
}
free(mod);
free(wmod);
free(refseq);
free(location);
RELEASE(KDirectory, dir);
RELEASE(KDirectory, native);
RELEASE(KFile, std_in);
DestroyStdin();
return rc;
}
static
rc_t Start (KDirectory * cwd, const char * src, const char * dst)
{
KPathType dtype;
KPathType stype;
char dpath [MY_MAX_PATH];
char spath [MY_MAX_PATH];
rc_t rc;
bool using_stdin, using_stdout, try_rename;
/* limited anti oops checks */
try_rename = (dst == NULL);
if (!try_rename)
{
/* try to prevent file to file clash */
if (strcmp (src,dst) == 0)
dst = NULL;
/* try to prevent file to dir clash */
else
{
size_t s,d;
s = string_size (src);
d = string_size (dst);
if (s > d)
{
if (string_cmp (src, s, dst, d, d) == 0)
{
if ((strchr (src+d+1, '/') == NULL) &&
((src[d] == '/') ||
(src[d-1] == '/')))
{
try_rename = true;
dst = NULL;
}
}
}
}
}
/*
* This is a quick fix "hack"
* A fully built out VFS should replace the KFS in use and eliminate this
*/
using_stdin = (strcmp (src, "/dev/stdin") == 0);
if (using_stdin)
{
if (dst == NULL)
{
rc = RC (rcExe, rcArgv, rcParsing, rcParam, rcNull);
LOGERR (klogErr, rc, "Unable to handle stdin in place");
return rc;
}
stype = kptFile;
strcpy (spath, src);
UseStdin = true;
STSMSG (1, ("reading console / stdin as input"));
goto stdin_shortcut;
}
rc = KDirectoryResolvePath (cwd, false, spath, sizeof spath, "%s", src);
if (rc)
{
LOGERR (klogErr, rc, "can't resolve source");
return rc;
}
stype = KDirectoryPathType (cwd, spath);
switch (stype)
{
case kptNotFound:
rc = RC (rcExe, rcArgv, rcResolving, rcPath, rcNotFound);
break;
default:
case kptBadPath:
rc = RC (rcExe, rcArgv, rcResolving, rcPath, rcInvalid);
break;
case kptCharDev:
case kptBlockDev:
case kptFIFO:
case kptZombieFile:
case kptDataset:
case kptDatatype:
rc = RC (rcExe, rcArgv, rcResolving, rcPath, rcIncorrect);
break;
case kptFile:
case kptDir:
break;
}
if (rc)
{
PLOGERR (klogErr, (klogErr, rc, "can not use source '$(S)'", "S=%s", src));
return rc;
}
/*
* In Place Operation
*/
if (dst == NULL)
{
/*
* Input is a file
*/
if (stype == kptFile)
{
KDirectory * ndir;
char * pc;
pc = strrchr (spath, '/');
if (pc == NULL)
{
pc = spath;
ndir = cwd;
rc = KDirectoryAddRef (cwd);
}
else if (pc == spath)
{
++pc;
ndir = cwd;
rc = KDirectoryAddRef (cwd);
}
else
{
*pc++ = '\0';
rc = KDirectoryOpenDirUpdate (cwd, &ndir, false, spath);
}
if (rc == 0)
{
rc = FileInPlace (ndir, pc, try_rename);
KDirectoryRelease (ndir);
}
}
/*
* Input is a directory
*/
else
{
KDirectory * ndir;
rc = KDirectoryOpenDirUpdate (cwd, &ndir, false, spath);
if (rc)
;
else
{
STSMSG (1, ("%scrypting directory %s", De, spath));
rc = DoDir (ndir, ndir);
STSMSG (1, ("done with directory %s", spath));
KDirectoryRelease (ndir);
}
}
}
/*
* 'Copy' Operation
*/
else
{
stdin_shortcut:
using_stdout = (strcmp (dst, "/dev/stdout") == 0);
if (using_stdout == true)
{
dtype = kptFile;
strcpy (dpath, dst);
UseStdout = true;
STSMSG (1, ("writing console / stdout as output"));
goto do_file;
}
rc = KDirectoryResolvePath (cwd, false, dpath, sizeof dpath, "%s", dst);
if (rc)
{
LOGERR (klogErr, rc, "can't resolve destination");
return rc;
}
dtype = KDirectoryPathType (cwd, dpath);
switch (dtype)
{
default:
case kptBadPath:
rc = RC (rcExe, rcArgv, rcResolving, rcPath, rcInvalid);
PLOGERR (klogErr, (klogErr, rc, "can not use destination '$(S)'", "S=%s", dst));
break;
case kptCharDev:
case kptBlockDev:
case kptFIFO:
case kptZombieFile:
case kptDataset:
case kptDatatype:
rc = RC (rcExe, rcArgv, rcResolving, rcPath, rcIncorrect);
PLOGERR (klogErr, (klogErr, rc, "can not use destination parameter '$(S)'", "S=%s", dst));
break;
case kptNotFound:
{
size_t z;
z = strlen (dst) - 1;
if ((dst[z] == '/') || (stype == kptDir))
goto do_dir;
else
goto do_file;
}
case kptFile:
if (!ForceFlag)
{
rc = RC (rcExe, rcArgv, rcParsing, rcFile, rcExists);
PLOGERR (klogErr, (klogErr, rc, "can not over-write '$(F)' without --force",
"F=%s", dpath));
break;
}
do_file:
if (stype == kptFile)
{
rc = FileToFile (cwd, spath, cwd, dpath, try_rename, NULL);
}
else
{
rc = RC (rcExe, rcArgv, rcResolving, rcPath, rcIncorrect);
LOGERR (klogErr, rc, "Can't do directory to file");
}
break;
do_dir:
case kptDir:
/*
* Input is a directory
*/
if (stype == kptDir)
{
#if DIRECTORY_TO_DIRECTORY_SUPPORTED
const KDirectory * sdir;
KDirectory * ddir;
rc = KDirectoryOpenDirRead (cwd, &sdir, false, spath);
if (rc)
;
else
{
if (dtype == kptNotFound)
{
STSMSG (1, ("creating output directory %s", dpath));
rc = KDirectoryCreateDir (cwd, 0775, kcmCreate|kcmParents,
"%s", dpath);
}
if (rc == 0)
{
rc = KDirectoryOpenDirUpdate (cwd, &ddir, false, dpath);
if (rc)
;
else
{
STSMSG (1, ("%scrypting directory %s to %s", De, spath, dpath));
rc = DoDir (sdir, ddir);
STSMSG (1, ("done with directory %s to %s", spath, dpath));
KDirectoryRelease (ddir);
}
}
KDirectoryRelease (sdir);
}
#else
rc = RC (rcExe, rcArgv, rcResolving, rcPath, rcIncorrect);
LOGERR (klogErr, rc, "Can't do directory to directory");
#endif
}
/*
* Input is a file
*/
else
{
KDirectory * ndir;
const char * pc;
if (dtype == kptNotFound)
{
STSMSG (1, ("creating output directory %s", dpath));
rc = KDirectoryCreateDir (cwd, 0775, kcmCreate|kcmParents,
"%s", dpath);
}
if (rc == 0)
{
STSMSG (1, ("opening output directory %s", dpath));
rc = KDirectoryOpenDirUpdate (cwd, &ndir, false, dpath);
if (rc)
;
else
{
pc = strrchr (spath, '/');
if (pc == NULL)
pc = spath;
else
++pc;
rc = FileToFile (cwd, spath, ndir, pc, true, dpath);
KDirectoryRelease (ndir);
}
}
}
break;
}
}
return rc;
}
static
rc_t DoDir (const KDirectory * sd, KDirectory * dd)
{
KNamelist * names;
rc_t rc;
rc = KDirectoryList (sd, &names, NULL, NULL, ".");
if (rc)
;
else
{
uint32_t count;
rc = KNamelistCount (names, &count);
if (rc)
;
else
{
uint32_t idx;
for (idx = 0; idx < count; ++idx)
{
const char * name;
rc = KNamelistGet (names, idx, &name);
if (rc)
;
else
{
const KDirectory * nsd;
KDirectory * ndd;
KPathType kpt;
kpt = KDirectoryPathType (sd, name);
switch (kpt)
{
default:
break;
case kptFile:
if (sd == dd)
rc = FileInPlace (dd, name, true);
else
rc = FileToFile (sd, name, dd, name, true, NULL);
break;
case kptDir:
if (sd == dd)
{
rc = KDirectoryOpenDirUpdate (dd, &ndd, false, "%s", name);
if (rc)
;
else
{
/* RECURSION */
STSMSG (1, ("%scrypting directory %s", De, name));
rc = DoDir (ndd, ndd);
STSMSG (1, ("done with directory %s", name));
KDirectoryRelease (ndd);
}
}
else
{
rc = KDirectoryOpenDirRead (sd, &nsd, false, name);
if (rc)
;
else
{
rc = KDirectoryCreateDir (dd, 0600, kcmOpen, "%s", name);
if (rc)
;
else
{
rc = KDirectoryOpenDirUpdate (dd, &ndd, false, "%s", name);
if (rc)
;
else
{
/* RECURSION */
STSMSG (1, ("%scrypting directory %s", De, name));
rc = DoDir (nsd, ndd);
STSMSG (1, ("done with directory %s", name));
KDirectoryRelease (ndd);
}
}
KDirectoryRelease (nsd);
}
}
break;
}
}
}
}
KNamelistRelease (names);
}
return rc;
}
rc_t run (Args * args)
{
rc_t rc;
do
{
const char * outname;
const char * source;
uint32_t pathtype;
KDirectory *top;
KDirectory *targettop;
uint32_t pcount;
uint32_t ix;
char sourcename [1024];
rc = KDirectoryNativeDir (&top);
if (rc)
break;
rc = ArgsParamCount (args, &pcount);
if (rc)
break;
if (pcount < 2)
{
MiniUsage (args);
rc = RC (rcExe, rcArgv, rcParsing, rcParam, rcInsufficient);
break;
}
rc = ArgsParamValue (args, 0, (const void **)&outname);
if (rc)
break;
pathtype = KDirectoryPathType (top, "%s", outname);
if ((pathtype & ~kptAlias) == kptDir)
{
/*
* Copying things into an existing directory.
*/
rc = KDirectoryOpenDirUpdate( top, &targettop, true, outname);
if (rc)
{
LOGERR (klogFatal, rc, outname);
break;
}
for (ix = 1; ix < pcount; ++ix)
{
rc = ArgsParamValue (args, ix, (const void **)&source);
if (rc)
break;
JustTheName (source, sourcename);
pathtype = KDirectoryPathType (top, "%s", sourcename);
if ((pathtype & ~kptAlias) == kptFile)
{
CopyFileToFile (top, source, targettop, sourcename);
}
else if ((pathtype & ~kptAlias) == kptDir)
{
if (!recurse)
{
STSMSG (0, ("Skipping directory %s\n", source));
continue;
}
CopyDirectoryToExistingDirectory (top, source, targettop, sourcename);
}
}
if (rc)
break;
rc = KDirectoryRelease (targettop);
/* this looks wrong */
if (rc)
LOGERR (klogInt, rc, outname);
}
else if ((pathtype * ~kptAlias) == kptFile)
{
if (!force)
{
STSMSG (0, ("File exists -- %s\n", outname));
break;
}
if (pcount > 2)
{
STSMSG (0, ("Target %s is a file. Too many parameters/\n", outname));
break;
}
rc = ArgsParamValue (args, 1, (const void **)&source);
if (rc)
break;
pathtype = KDirectoryPathType (top, "%s", source);
if ((pathtype & ~kptAlias) == kptDir)
{
STSMSG (0, ("Cannot overwrite file with directory %s\n", source));
break;
}
if ((pathtype & ~kptAlias) == kptFile)
{
CopyFileToFile (top, source, top, outname);
}
}
else if ((pathtype & ~kptAlias) == kptNotFound)
{
if (pcount > 2)
{
STSMSG (0, ("Directory %s does not exist.\n", outname));
break;
}
rc = ArgsParamValue (args, 1, (const void **)&source);
if (rc)
break;
pathtype = KDirectoryPathType (top, "%s", source);
if ((pathtype & ~kptAlias) == kptFile)
{
CopyFileToFile (top, source, top, outname);
}
else if ((pathtype & ~kptAlias) == kptDir)
{
if (!recurse)
{
STSMSG (0, ("Skipping directory %s\n", source));
break;
}
CopyDirectoryToExistingDirectory (top, source, top, outname);
}
}
} while (0);
return rc;
}
