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