rc_t CCCopyMake (CCCopy ** p, const KDirectory * in, KDirectory * out,
KDirectory * xml, bool force, KMD5SumFmt * md5,
CCFileFormat * ff, CCTree * tree, const char * path)
{
rc_t rc;
size_t pathlen;
CCCopy * self;
char relpath [4096];
assert (in != NULL);
assert (out != NULL);
assert (xml != NULL);
assert (path != NULL);
rc = KDirectoryVResolvePath (in, false, relpath, sizeof relpath, path, NULL);
if (rc != 0)
{
pLOGERR (klogErr, rc, "unable to resolve path $(P)", PLOG_S(P), path);
return rc;
}
if ((relpath[0] == '.') && (relpath[1] == '.') && (relpath[2] == '/'))
{
rc = RC (rcExe, rcDirectory, rcResolving, rcPath, rcOutOfKDirectory);
pLOGERR (klogErr, rc, "Path must resolve to current directory or subdirectories $(P)",
PLOG_S(P), relpath);
return rc;
}
pathlen = strlen(relpath);
self = malloc (sizeof (*self) - sizeof (*self->path) + pathlen + 1);
if (self == NULL)
rc = RC (rcExe, rcNoTarg, rcAllocating, rcMemory, rcExhausted);
else
{
atomic32_set (&self->refcount, 1);
KDirectoryAddRef (in);
KDirectoryAddRef (out);
KDirectoryAddRef (xml);
KMD5SumFmtAddRef (md5);
CCFileFormatAddRef (ff);
self->in = in;
self->out = out;
self->xml = xml;
self->force = force;
self->md5 = md5;
self->ff = ff;
self->tree = tree;
memcpy (self->path, relpath, pathlen+1);
*p = self;
}
return rc;
}
static
rc_t KRemoveLockFileTaskMake ( KTask **task, KDirectory *dir, const char *path )
{
rc_t rc;
size_t path_size = string_size ( path );
KRemoveLockFileTask *t = malloc ( sizeof * t + path_size );
if ( t == NULL )
rc = RC ( rcFS, rcLock, rcConstructing, rcMemory, rcExhausted );
else
{
rc = KTaskInit ( & t -> dad, ( const KTask_vt* ) & KRemoveLockFileTask_vt, "KRemoveLockFileTask", path );
if ( rc == 0 )
{
rc = KDirectoryAddRef ( t -> dir = dir );
if ( rc == 0 )
{
strcpy ( t -> path, path );
* task = & t -> dad;
return 0;
}
}
free ( t );
}
return rc;
}
rc_t ProcessOneMake (ProcessOne ** ppo, const KDirectory * dir, KDirectory * xml,
const KFile * file, KMD5SumFmt *md5, CCFileFormat * ff,
const char * path)
{
ProcessOne * self;
rc_t rc = 0;
size_t pathlen;
PLOGMSG (klogDebug10, "ProcessOneMake $(f)", PLOG_S(f), path);
/* legit seeming inputs? these could be replaced with RC returns */
assert (ppo != NULL);
assert (file != NULL);
assert (path != NULL);
/* allocate the object */
pathlen = strlen (path);
self = malloc (sizeof (*self) - sizeof(self->path) + pathlen + 1);
if (self == NULL)
{
rc = RC (rcExe, rcNoTarg, rcAllocating, rcMemory, rcExhausted);
}
else
{
atomic32_set (&self->refcount, 1);
KDirectoryAddRef (dir);
KDirectoryAddRef (xml);
KMD5SumFmtAddRef (md5);
CCFileFormatAddRef (ff);
KFileAddRef (file);
self->dir = dir;
self->xml = xml;
self->md5 = md5;
self->file = file;
self->ff = ff;
memcpy (self->path, path, pathlen);
self->path[pathlen] = '\0';
rc = 0;
}
*ppo = self;
return rc;
}
/* Make
* create path manager
*
* the path manager should already be configured with
* standard search paths, but can be augmented by using
* the Add*Path messages.
*
* "dir" [ IN, NULL OKAY ] - optional root directory to use
* attaches a new reference
*/
MOD_EXPORT
rc_t CC SRAPathMakeImpl ( SRAPath **pm, const KDirectory *dir )
{
rc_t rc;
if ( pm == NULL )
rc = RC ( rcSRA, rcMgr, rcConstructing, rcParam, rcNull );
else
{
NCBISRAPath *p = (NCBISRAPath *) malloc ( sizeof * p );
if ( p == NULL )
rc = RC ( rcSRA, rcMgr, rcConstructing, rcMemory, rcExhausted );
else
{
p -> dad . vt = ( SRAPath_vt* ) & vtSRAPath;
p -> dir = dir;
if ( dir != NULL )
rc = KDirectoryAddRef ( dir );
else
{
KDirectory *wd;
rc = KDirectoryNativeDir ( & wd );
p -> dir = wd;
}
if ( rc != 0 )
free ( p );
else
{
DLListInit ( & p -> repos );
p -> dflt_repo = NULL;
atomic32_set ( & p -> refcount, 1 );
/* the object is now complete */
rc = SRAPathConfig ( p );
if ( rc == 0 )
{
* pm = & p -> dad;
return 0;
}
SRAPathWhack ( p );
}
}
* pm = NULL;
}
return rc;
}
/* OpenDirectory
* access the directory in use
*/
LIB_EXPORT rc_t CC KDatabaseOpenDirectoryRead ( const KDatabase *self, const KDirectory **dir )
{
rc_t rc;
if ( dir == NULL )
rc = RC ( rcDB, rcDatabase, rcAccessing, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcDB, rcDatabase, rcAccessing, rcSelf, rcNull );
else
{
* dir = self -> dir;
return KDirectoryAddRef ( * dir );
}
* dir = NULL;
}
return rc;
}
LIB_EXPORT rc_t CC KDatabaseOpenDirectoryUpdate ( KDatabase *self, KDirectory **dir )
{
rc_t rc;
if ( dir == NULL )
rc = RC ( rcDB, rcDatabase, rcAccessing, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcDB, rcDatabase, rcAccessing, rcSelf, rcNull );
else if ( self -> dir != NULL && self -> dir -> read_only )
rc = RC ( rcDB, rcDatabase, rcAccessing, rcDirectory, rcReadonly );
else
{
* dir = self -> dir;
return KDirectoryAddRef ( * dir );
}
* dir = NULL;
}
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;
}
LIB_EXPORT rc_t CC KLoaderFile_Make(const KLoaderFile **file, const KDirectory* dir, const char* filename,
const uint8_t* md5_digest, bool read_ahead)
{
rc_t rc = 0;
KLoaderFile* obj = NULL;
if( file == NULL || dir == NULL || filename == NULL ) {
rc = RC(rcApp, rcFile, rcConstructing, rcParam, rcNull);
} else {
*file = NULL;
if( (obj = calloc(1, sizeof(*obj))) == NULL ||
(obj->filename = strdup(filename)) == NULL ) {
rc = RC(rcApp, rcFile, rcConstructing, rcMemory, rcExhausted);
} else {
if( (rc = KDirectoryAddRef(dir)) == 0 ) {
obj->dir = dir;
if( md5_digest != NULL ) {
obj->has_md5 = true;
memcpy(obj->md5_digest, md5_digest, sizeof(obj->md5_digest));
}
if( (rc = KLoaderFile_AllocateBuffer(obj)) == 0 ) {
char resolved[4096];
char* ext = NULL;
strcpy(resolved, filename);
ext = strrchr(resolved, '.');
DBG(("%s adding %s\n", __func__, resolved));
rc = KLoadProgressbar_File(&obj->job, resolved, obj->dir);
if( ext != NULL && strcmp(ext, ".gz") == 0 ) {
obj->compress_type = compress_gzip;
} else if( ext != NULL && strcmp(ext, ".bz2") == 0 ) {
obj->compress_type = compress_bzip2;
}
if( rc != 0 && obj->compress_type != compress_none ) {
*ext = '\0';
DBG(("%s retry adding as %s\n", __func__, resolved));
if( (rc = KLoadProgressbar_File(&obj->job, resolved, obj->dir)) == 0 ) {
obj->has_md5 = false;
obj->compress_type = compress_none;
}
}
if( rc == 0 &&
(rc = KFileInit(&obj->dad, (const KFile_vt*)&KLoaderFile_vtbl, "KLoaderFile", filename, true, false)) == 0 ) {
obj->file = &obj->dad;
#if WINDOWS
obj->ahead = false;
#else
obj->ahead = read_ahead;
#endif
obj->realname = strdup(resolved);
if( obj->realname == NULL ) {
rc = RC(rcApp, rcFile, rcConstructing, rcMemory, rcExhausted);
}
}
}
}
}
}
if( rc == 0 ) {
*file = obj;
} else {
*file = NULL;
KLoaderFile_Release(obj, false);
}
return rc;
}
/* AddRef
* Release
* ignores NULL references
*/
inline rc_t AddRef ( void ) const throw ()
{ return KDirectoryAddRef ( this ); }
