/* local fill the buffer with block or more */ static rc_t KWGAEncFileReadInt (KWGAEncFile * self, uint64_t pos, size_t bsize) { uint64_t adjpos; size_t tot_read; size_t num_read; rc_t rc = 0; assert (self); assert (bsize); assert (bsize <= 32 * 1024); assert (128%16 == 0); memset (self->buffer.data, 0, sizeof self->buffer.data); tot_read = num_read = 0; adjpos = pos + sizeof (KWGAEncFileHeader); #if 0 do { rc = KFileRead (self->encrypted, adjpos + tot_read, self->buffer.data + tot_read, bsize - tot_read, &num_read); if (rc) return rc; tot_read += num_read; } while ((tot_read < bsize) && (num_read > 0)); #else rc = KFileReadAll (self->encrypted, adjpos, self->buffer.data, bsize, &tot_read); #endif self->buffer.offset = pos; self->buffer.valid = tot_read; if (tot_read & 15) rc = RC (rcKrypto, rcFile, rcReading, rcSize, rcInsufficient); else if (tot_read > 0) { #if 1 #if RETAINED_COMPATIBILTY_WITH_ERROR KCipherDecryptECB (self->cipher, self->buffer.data, self->buffer.data, (tot_read / ECB_BYTES)); #else /* Well this is wrong for even being wrong now */ KCipherDecryptECB (self->cipher, self->buffer.data, self->buffer.data, tot_read); #endif #else uint32_t count; uint32_t ix; /* this loop can be replaced by the KCipherDecryptECB * with care taken to match the error in the original * C++ */ #if RETAINED_COMPATIBILTY_WITH_ERROR count = tot_read / ECB_BYTES; #else /* do all full 16 byte blocks plus a last partial block */ count = (tot_read + (ECB_BYTES-1)) / ECB_BYTES; #endif for (ix = 0; ix < count; ++ix) { uint8_t * pb = self->buffer.data + (ix * ECB_BYTES); rc = KCipherDecrypt (self->cipher, pb, pb); if (rc) break; } #endif } return rc; }
/* MakeSet * load a dynamic library * * "set" [ OUT ] - return parameter for lib set */ LIB_EXPORT rc_t CC KDyldMakeSet ( const KDyld *self, KDlset **setp ) { rc_t rc = 0; if ( setp == NULL ) rc = RC ( rcFS, rcDylib, rcConstructing, rcParam, rcNull ); else { if ( self == NULL ) rc = RC ( rcFS, rcDylib, rcConstructing, rcSelf, rcNull ); else { KDlset *set = malloc ( sizeof * set ); if ( set == NULL ) rc = RC ( rcFS, rcDylib, rcConstructing, rcMemory, rcExhausted ); else { set -> dl = KDyldAttach ( self ); VectorInit ( & set -> name, 0, 16 ); VectorInit ( & set -> ord, 0, 16 ); KRefcountInit ( & set -> refcount, 1, "KDlset", "make", "dlset" ); #if ! ALWAYS_ADD_EXE { KDylib *jni; const char* libname = LIBNAME(LIBPREFIX, "vdb_jni.", SHLIBEXT); if ( KDyldLoadLib ( ( KDyld* ) self, & jni, libname ) == 0 ) { rc = KDlsetAddLib ( set, jni ); KDylibRelease ( jni ); } if (rc == 0) { * setp = set; return 0; } } #else { KDylib *exe; rc = KDyldLoadLib ( ( KDyld* ) self, & exe, NULL ); if ( rc == 0 ) { rc = KDlsetAddLib ( set, exe ); KDylibRelease ( exe ); if ( rc == 0 ) { * setp = set; return 0; } } } #endif KDlsetRelease ( set ); } } * setp = NULL; } return rc; }
rc_t matcher_execute( matcher* self, const p_matcher_input in ) { VSchema * dflt_schema; const VTable * src_table; rc_t rc; if ( self == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcSelf, rcNull ); if ( in->manager == NULL || in->add_schemas == NULL || in->cfg == NULL || in->columns == NULL || in->src_path == NULL || in->dst_path == NULL || in->dst_tabname == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcParam, rcNull ); rc = matcher_build_column_vector( self, in->columns ); if ( rc != 0 ) return rc; rc = matcher_exclude_columns( self, in->excluded_columns ); if ( rc != 0 ) return rc; rc = helper_parse_schema( in->manager, &dflt_schema, in->add_schemas ); if ( rc != 0 ) return rc; rc = VDBManagerOpenTableRead( in->manager, &src_table, dflt_schema, "%s", in->src_path ); if ( rc == 0 ) { const VSchema * src_schema; rc = VTableOpenSchema ( src_table, &src_schema ); if ( rc == 0 ) { rc = matcher_read_src_types( self, src_table, src_schema ); if ( rc == 0 ) { if ( in->legacy_schema != NULL ) rc = VSchemaParseFile ( dflt_schema, "%s", in->legacy_schema ); if ( rc == 0 ) { VTable * dst_table; KCreateMode cmode = kcmParents; const VSchema * dst_schema = src_schema; if ( in->legacy_schema != NULL ) dst_schema = dflt_schema; if ( in->force_unlock ) VDBManagerUnlock ( in->manager, "%s", in->dst_path ); if ( in->force_kcmInit ) cmode |= kcmInit; else cmode |= kcmCreate; rc = VDBManagerCreateTable( in->manager, &dst_table, dst_schema, in->dst_tabname, cmode, "%s", in->dst_path ); if ( rc == 0 ) { rc = matcher_read_dst_types( self, dst_table, dst_schema ); if ( rc == 0 ) { rc = matcher_make_type_matrix( self ); if ( rc == 0 ) rc = matcher_match_matrix( self, src_schema, in->cfg ); } VTableRelease( dst_table ); if ( !(in->force_kcmInit) ) KDirectoryRemove ( in->dir, true, "%s", in->dst_path ); } } } VSchemaRelease( src_schema ); } VTableRelease( src_table ); } VSchemaRelease( dflt_schema ); return rc; }
static rc_t MakeIndexes(const SRATable* stbl, KTable* ktbl, KMetadata* meta) { rc_t rc = 0; int i; char* buffer = NULL; size_t buffer_sz = g_file_block_sz * 100; SIndexObj idx[] = { /* meta, file, format, index, func, file_size, buffer_sz, minSpotId, maxSpotId */ {NULL, "fastq", "fastq", "fuse-fastq", Fastq_Idx, 0, 0, 0, 0}, {NULL, "sff", "SFF", "fuse-sff", SFF_Idx, 0, 0, 0, 0}, {NULL, "fastq.gz", "fastq-gzip", "fuse-fastq-gz", FastqGzip_Idx, 0, 0, 0, 0}, {NULL, "sff.gz", "SFF-gzip", "fuse-sff-gz", SFFGzip_Idx, 0, 0, 0, 0} }; for(i = 0; rc == 0 && i < sizeof(idx) / sizeof(idx[0]); i++) { KMDataNode* parent = NULL; if( (rc = KMetadataOpenNodeUpdate(meta, &parent, "/FUSE")) == 0 ) { KMDataNodeDropChild(parent, "root"); /* drop old stuff */ if( g_ungzip || strcmp(&idx[i].file[strlen(idx[i].file) - 3], ".gz") == 0 ) { STSMSG(0, ("Preparing index %s", idx[i].index)); MD5StateInit(&idx[i].md5); SLListInit(&idx[i].li); KMDataNodeDropChild(parent, "%s.tmp", idx[i].file); if( (rc = KMDataNodeOpenNodeUpdate(parent, &idx[i].meta, "%s.tmp", idx[i].file)) == 0 ) { if( idx[i].func != NULL ) { if( buffer == NULL ) { if( (buffer = malloc(buffer_sz)) == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); break; } } rc = idx[i].func(stbl, &idx[i], buffer, buffer_sz); if( rc == 0 ) { MD5StateFinish(&idx[i].md5, idx[i].md5_digest); rc = CommitIndex(ktbl, idx[i].index, &idx[i].li); } } if( rc == 0 ) { rc = WriteFileMeta(&idx[i]); } KMDataNodeRelease(idx[i].meta); } if( GetRCState(rc) == rcUnsupported ) { KMDataNodeDropChild(parent, "%s", idx[i].file); PLOGERR(klogWarn, (klogWarn, rc, "Index $(i) is not supported for this table", PLOG_S(i), idx[i].index)); rc = 0; } else if( rc == 0 ) { char f[4096]; strcpy(f, idx[i].file); strcat(f, ".tmp"); KMDataNodeDropChild(parent, "%s", idx[i].file); rc = KMDataNodeRenameChild(parent, f, idx[i].file); } } else if( !g_ungzip ) { KTableDropIndex(ktbl, idx[i].index); KMDataNodeDropChild(parent, "%s", idx[i].file); } KMDataNodeDropChild(parent, "%s.tmp", idx[i].file); KMDataNodeRelease(parent); } SLListWhack(&idx[i].li, WhackIndexData, NULL); } free(buffer); return rc; }
/* HomeDirectory * returns a KDirectory where the binary for a given function is located * * "dir" [ OUT ] - return parameter for home directory ( read-only ), if found * * "func" [ IN ] - function pointer within binary to be located */ LIB_EXPORT rc_t CC KDyldHomeDirectory ( const KDyld *self, const KDirectory **dir, fptr_t func ) { rc_t rc; if ( dir == NULL ) rc = RC ( rcFS, rcDylib, rcSearching, rcParam, rcNull ); else { * dir = NULL; if ( self == NULL ) rc = RC ( rcFS, rcDylib, rcSearching, rcSelf, rcNull ); else if ( func == NULL ) rc = RC ( rcFS, rcDylib, rcSearching, rcFunction, rcNull ); else { Dl_info info; memset ( & info, 0, sizeof info ); if ( dladdr ( ( void* ) func, & info ) == 0 ) rc = RC ( rcFS, rcDylib, rcSearching, rcFunction, rcNotFound ); else { KDirectory *wd; rc = KDirectoryNativeDir ( & wd ); if ( rc == 0 ) { /* turn this into a real path */ const KSysDir *sdir = KDirectoryGetSysDir ( wd ); if ( sdir == NULL ) rc = RC ( rcFS, rcDylib, rcSearching, rcDirectory, rcIncorrect ); else { /* "dladdr" will return a simple name rather than a path when the address is within the application itself and the application was found using PATH. this is brilliant design at its best. */ char thanks_for_brilliant_APIs [ PATH_MAX ]; const char *dli_fname = info . dli_fname; /* check for a path rather than a name */ const char *last_slash = strrchr ( info . dli_fname, '/' ); if ( last_slash == NULL ) { /* simple name - get PATH */ const char *PATH = getenv ( "PATH" ); rc = RC ( rcFS, rcDylib, rcSearching, rcPath, rcNotFound ); if ( PATH != NULL ) { /* loop over PATH */ const char *path_start, *path_end; for ( path_start = PATH;; path_start = path_end + 1 ) { /* look for non-empty directory */ path_end = strchr ( path_start, ':' ); if ( path_start != path_end && path_start [ 0 ] != 0 ) { rc_t rc2; uint32_t path_type; /* handle last element in list */ if ( path_end == NULL ) last_slash = path_start + strlen ( path_start ); else for ( last_slash = path_end; last_slash > path_start; -- last_slash ) { if ( last_slash [ -1 ] != '/' ) break; } /* create possible path, using up to ':' */ rc2 = string_printf ( thanks_for_brilliant_APIs, sizeof thanks_for_brilliant_APIs, NULL, "%.*s/%s", ( int ) ( last_slash - path_start ), path_start, dli_fname ); /* if failed to create path string */ if ( rc2 != 0 ) break; /* check path against working directory */ path_type = KDirectoryPathType ( wd, thanks_for_brilliant_APIs ); if ( ( path_type & ~ kptAlias ) == kptFile ) { uint32_t access = 0; rc = KDirectoryAccess ( wd, & access, thanks_for_brilliant_APIs ); if ( rc != 0 ) break; /* try to do a quick check that the file can be executed. but it could fail to do the right guess. */ if ( access & 0100 || access & 0010 || access & 0001 ) { /* this is a file, which can be assumed to be an executable */ dli_fname = thanks_for_brilliant_APIs; last_slash = & thanks_for_brilliant_APIs [ last_slash - path_start ]; rc = 0; break; } } } /* exit if no more paths */ if ( path_end == NULL ) break; } } } if ( rc == 0 ) { char real [ PATH_MAX ]; rc = KSysDirRealPath ( sdir, real, sizeof real, "%.*s" , ( int ) ( last_slash - dli_fname ), dli_fname ); if ( rc == 0 ) rc = KDirectoryOpenDirRead ( wd, dir, false, real ); DBGMSG(DBG_KFS, DBG_FLAG(DBG_KFS_DIR), ("%s: %R path is '%s'\n", __func__, rc, real)); } } KDirectoryRelease ( wd ); } } } } return rc; }
static rc_t SFF_Idx(const SRATable* sratbl, SIndexObj* obj, char* buffer, const size_t buffer_sz) { rc_t rc = 0; const SFFReader* reader = NULL; if( (rc = SFFReaderMake(&reader, sratbl, g_accession, obj->minSpotId, obj->maxSpotId)) != 0 ) { return rc; } else { size_t written = 0; uint32_t blk = 0; SIndexNode* inode = NULL; while( rc == 0 ) { rc = SFFReader_GetNextSpotData(reader, buffer, buffer_sz, &written); if( blk >= g_file_block_sz || (GetRCObject(rc) == rcRow && GetRCState(rc) == rcExhausted) ) { inode->key_size = blk; SLListPushTail(&obj->li, &inode->n); DEBUG_MSG(5, ("SFF index closed spots %lu, offset %lu, block size %lu\n", inode->id_qty, inode->key, inode->key_size)); inode = NULL; if( blk > obj->buffer_sz ) { obj->buffer_sz = blk; } blk = 0; } if( GetRCObject(rc) == rcRow && GetRCState(rc) == rcExhausted ) { rc = 0; break; } if( inode == NULL ) { spotid_t spotid = 0; if( (rc = SFFReaderCurrentSpot(reader, &spotid)) != 0 ) { break; } inode = malloc(sizeof(SIndexNode)); if( inode == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); break; } inode->key = obj->file_size; inode->key_size = 0; inode->id = spotid; inode->id_qty = 0; DEBUG_MSG(5, ("SFF index opened spot %ld, offset %lu\n", inode->id, inode->key)); if( spotid == 1 ) { char hd[10240]; size_t hd_sz = 0; if( (rc = SFFReaderHeader(reader, 0, hd, sizeof(hd), &hd_sz)) == 0 ) { obj->file_size += hd_sz; blk += hd_sz; MD5StateAppend(&obj->md5, hd, hd_sz); if( g_dump ) { fwrite(hd, hd_sz, 1, stderr); } } } } obj->file_size += written; blk += written; inode->id_qty++; MD5StateAppend(&obj->md5, buffer, written); if( g_dump ) { fwrite(buffer, written, 1, stderr); } } rc = rc ? rc : Quitting(); if( rc != 0 ) { spotid_t spot = 0; SFFReaderCurrentSpot(reader, &spot); PLOGERR(klogErr, (klogErr, rc, "spot $(s)", PLOG_U32(s), spot)); } } SFFReaderWhack(reader); return rc; }
static rc_t Fastq_Idx(const SRATable* sratbl, SIndexObj* obj, char* buffer, const size_t buffer_sz) { rc_t rc = 0; const FastqReader* reader = NULL; uint8_t colorSpace = false; char* colorSpaceKey = "\0"; uint8_t origFormat = false; uint8_t printLabel = true; uint8_t printReadId = true; uint8_t clipQuality = true; uint32_t minReadLen = 0; uint16_t qualityOffset = 0; {{ const SRAColumn* c = NULL; const uint8_t *platform = SRA_PLATFORM_UNDEFINED; bitsz_t o, z; if( (rc = SRATableOpenColumnRead(sratbl, &c, "PLATFORM", sra_platform_id_t)) != 0 ) { return rc; } if( (rc = SRAColumnRead(c, 1, (const void **)&platform, &o, &z)) != 0 ) { return rc; } if( *platform == SRA_PLATFORM_ABSOLID ) { colorSpace = true; } SRAColumnRelease(c); }} if( (rc = FastqReaderMake(&reader, sratbl, g_accession, colorSpace, origFormat, false, printLabel, printReadId, !clipQuality, minReadLen, qualityOffset, colorSpaceKey[0], obj->minSpotId, obj->maxSpotId)) != 0 ) { return rc; } else { KMDataNode* opt = NULL, *nd = NULL; if( (rc = KMDataNodeOpenNodeUpdate(obj->meta, &opt, "Format/Options")) != 0 ) { return rc; } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "colorSpace")) == 0 ) { rc = KMDataNodeWriteB8(nd, &colorSpace); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "colorSpaceKey")) == 0 ) { rc = KMDataNodeWrite(nd, colorSpaceKey, 1); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "origFormat")) == 0 ) { rc = KMDataNodeWriteB8(nd, &origFormat); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "printLabel")) == 0 ) { rc = KMDataNodeWriteB8(nd, &printLabel); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "printReadId")) == 0 ) { rc = KMDataNodeWriteB8(nd, &printReadId); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "clipQuality")) == 0 ) { rc = KMDataNodeWriteB8(nd, &clipQuality); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "minReadLen")) == 0 ) { rc = KMDataNodeWriteB32(nd, &minReadLen); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "qualityOffset")) == 0 ) { rc = KMDataNodeWriteB16(nd, &qualityOffset); KMDataNodeRelease(nd); } KMDataNodeRelease(opt); } if( rc == 0 ) { size_t written = 0; uint32_t blk = 0; SIndexNode* inode = NULL; while( rc == 0 ) { rc = FastqReader_GetNextSpotSplitData(reader, buffer, buffer_sz, &written); if( blk >= g_file_block_sz || (GetRCObject(rc) == rcRow && GetRCState(rc) == rcExhausted) ) { inode->key_size = blk; SLListPushTail(&obj->li, &inode->n); DEBUG_MSG(5, ("Fastq index closed spots %lu, offset %lu, block size %lu\n", inode->id_qty, inode->key, inode->key_size)); inode = NULL; if( blk > obj->buffer_sz ) { obj->buffer_sz = blk; } blk = 0; } if( GetRCObject(rc) == rcRow && GetRCState(rc) == rcExhausted ) { rc = 0; break; } if( inode == NULL ) { spotid_t spotid = 0; if( (rc = FastqReaderCurrentSpot(reader, &spotid)) != 0 ) { break; } inode = malloc(sizeof(SIndexNode)); if( inode == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); break; } inode->key = obj->file_size; inode->key_size = 0; inode->id = spotid; inode->id_qty = 0; DEBUG_MSG(5, ("Fastq index opened spot %ld, offset %lu\n", inode->id, inode->key)); } inode->id_qty++; obj->file_size += written; blk += written; MD5StateAppend(&obj->md5, buffer, written); if( g_dump ) { fwrite(buffer, written, 1, stderr); } } rc = rc ? rc : Quitting(); if( rc != 0 ) { spotid_t spot = 0; FastqReaderCurrentSpot(reader, &spot); PLOGERR(klogErr, (klogErr, rc, "spot $(s)", PLOG_U32(s), spot)); } } FastqReaderWhack(reader); return rc; }
rc_t FastqReaderFileGetRecord ( const FastqReaderFile *f, const Record** result ) { rc_t rc; FastqReaderFile* self = (FastqReaderFile*) f; if (self->pb.fatalError) return 0; self->pb.record = (FastqRecord*)malloc(sizeof(FastqRecord)); if (self->pb.record == NULL) { rc = RC ( RC_MODULE, rcData, rcAllocating, rcMemory, rcExhausted ); return 0; } rc = FastqRecordInit(self->pb.record); if (rc != 0) return rc; FASTQ_ParseBlockInit( & self->pb ); if ( FASTQ_parse( & self->pb ) == 0 && self->pb.record->rej == 0 ) { /* normal end of input */ RecordRelease((const Record*)self->pb.record); *result = 0; return 0; } /*TODO: remove? compensate for an artificially inserted trailing \n */ if ( self->eolInserted ) { -- self->pb.length; self->eolInserted = false; } if (self->pb.record->rej != 0) /* had error(s) */ { /* save the complete raw source in the Rejected object */ StringInit(& self->pb.record->rej->source, string_dup(self->recordStart, self->pb.length), self->pb.length, (uint32_t)self->pb.length); self->pb.record->rej->fatal = self->pb.fatalError; } if (rc == 0 && self->reader != 0) { /* advance the record start pointer beyond the last token */ size_t length; rc = KLoaderFile_Read( self->reader, self->pb.length, 0, (const void**)& self->recordStart, & length); if (rc != 0) LogErr(klogErr, rc, "FastqReaderFileGetRecord failed"); self->curPos -= self->pb.length; } StringInit( & self->pb.record->seq.spotname, (const char*)self->pb.record->source.base + self->pb.spotNameOffset, self->pb.spotNameLength, (uint32_t)self->pb.spotNameLength); StringInit( & self->pb.record->seq.spotgroup, (const char*)self->pb.record->source.base + self->pb.spotGroupOffset, self->pb.spotGroupLength, (uint32_t)self->pb.spotGroupLength); StringInit( & self->pb.record->seq.read, (const char*)self->pb.record->source.base + self->pb.readOffset, self->pb.readLength, (uint32_t)self->pb.readLength); StringInit( & self->pb.record->seq.quality, (const char*)self->pb.record->source.base + self->pb.qualityOffset, self->pb.qualityLength, (uint32_t)self->pb.qualityLength); self->pb.record->seq.qualityFormat = self->pb.qualityFormat; self->pb.record->seq.qualityAsciiOffset = self->pb.qualityAsciiOffset; if (self->pb.record->seq.readnumber == 0) self->pb.record->seq.readnumber = self->pb.defaultReadNumber; *result = (const Record*) self->pb.record; return rc; }
static rc_t populate_stype_tbl ( BSTree *stype_tbl, const VSchema *schema ) { rc_t rc; uint32_t i; static struct { const char *typename; const char *redact_value; } sensitive_types [] = { /* original SRA types */ { "INSDC:fasta", "N" }, { "INSDC:csfasta", "." }, { "NCBI:2na", "\x00" }, { "NCBI:2cs", "\x00" }, { "NCBI:4na", "\xFF" }, { "NCBI:qual1", "\x00" }, { "NCBI:qual4", "\xFB\xFB\xFB\xFB" }, { "NCBI:isamp1", "\x00\x00\x00" }, { "NCBI:isamp4", "\x00\x00\x00" }, { "NCBI:fsamp1", "\x00\x00\x00" }, { "NCBI:fsamp4", "\x00\x00\x00" }, { "INSDC:dna:text", "N" }, { "INSDC:dna:bin", "\x04" }, { "INSDC:dna:4na", "\xFF" }, { "INSDC:dna:2na", "\x00" }, { "INSDC:color:text", "." }, { "INSDC:color:bin", "\x04" }, { "INSDC:color:2cs", "\x00" }, { "INSDC:quality:phred", "\x00" }, { "INSDC:quality:log_odds", "\x00\x00\x00" } /* signal types TBD */ }; BSTreeInit ( stype_tbl ); for ( rc = 0, i = 0; i < sizeof sensitive_types / sizeof sensitive_types [ 0 ]; ++ i ) { VTypedecl td; const char *decl = sensitive_types [ i ] . typename; rc = VSchemaResolveTypedecl ( schema, & td, decl ); if ( rc == 0 ) { stype_id *n; BSTNode *exist; VTypedesc desc; rc = VSchemaDescribeTypedecl ( schema, & desc, & td ); if ( rc != 0 ) { PLOGERR ( klogInt, (klogInt, rc, "failed to describe type '$(type)'", "type=%s", decl )); break; } n = malloc ( sizeof * n ); if ( n == NULL ) { rc = RC ( rcExe, rcNode, rcAllocating, rcMemory, rcExhausted ); LOGERR ( klogInt, rc, "failed to record sensitive data type" ); break; } n -> redact_value = sensitive_types [ i ] . redact_value; n -> type_id = td . type_id; n -> elem_size = VTypedescSizeof ( & desc ); rc = BSTreeInsertUnique ( stype_tbl, & n -> n, & exist, stype_id_sort ); if ( rc != 0 ) { free ( n ); if ( GetRCState ( rc ) != rcExists ) { LOGERR ( klogInt, rc, "failed to record sensitive data type" ); break; } rc = 0; } } else if ( GetRCState ( rc ) == rcNotFound ) { rc = 0; } else { break; } } return rc; }
static __inline__ rc_t WGAEncValidateHeader (const KWGAEncFileHeader * header, size_t header_size) { rc_t rc = 0; unsigned ix; if (header_size != sizeof * header) { rc = RC (rcKrypto, rcFile, rcValidating, rcHeader, rcInsufficient); LOGERR (klogErr, rc, "incomplete header"); return rc; } if (memcmp (header, &header_const, sizeof header->magic) != 0) { rc = RC (rcKrypto, rcFile, rcValidating, rcHeader, rcInvalid); LOGERR (klogErr, rc, "bad signature in encrypted file header"); return rc; } #if 0 /* check block_size */ do { for (ix = 0; isspace(header->block_sz[ix]); ++ix) ; if (ix >= sizeof (header->block_sz)) break; if (header->block_sz[ix] == '+') ++ix; if (ix >= sizeof (header->block_sz)) break; for (; (ix < sizeof header->block_sz); ++ix) { if (isdigit (header->block_sz[ix])) ; else if ((header->block_sz[ix] >= 'a') && (header->block_sz[ix] <= 'w')) ; else if ((header->block_sz[ix] >= 'A') && (header->block_sz[ix] <= 'W')) ; else break; } for (; (ix < sizeof header->block_sz); ++ix) { if (header->block_sz[ix] == '\0') ; else break; } if (rc) for (ix = 0; ix < sizeof header->block_size; ++ix) { if () ; } ; else if (header->block_sz[ix] == '-') ; else ; }while (0);
* neither. * * This list should probably be more configurable, and more than * likely on a per-realm basis, so locally-defined services can be * added, or not. */ static const struct krb_convert sconv_list[] = { /* Realm conversion, Change service name */ #define RC(V5NAME,V4NAME) { V5NAME, V4NAME, DO_REALM_CONVERSION, sizeof(V5NAME)-1 } /* Realm conversion */ #define R(NAME) { NAME, NAME, DO_REALM_CONVERSION, sizeof(NAME)-1 } /* No Realm conversion */ #define NR(NAME) { NAME, NAME, 0, sizeof(NAME)-1 } NR("kadmin"), RC("rcmd", "host"), R("discuss"), R("rvdsrv"), R("sample"), R("olc"), R("pop"), R("sis"), R("rfs"), R("imap"), R("ftp"), R("ecat"), R("daemon"), R("gnats"), R("moira"), R("prms"), R("mandarin"),
/* read only version for decrypting of existing files */ KRYPTO_EXTERN rc_t CC KFileMakeWGAEncRead (const struct KFile ** pself, const struct KFile * encrypted, const char * key, size_t key_size) { rc_t rc; if (pself == NULL) { rc = RC (rcFS, rcFile, rcConstructing, rcSelf, rcNull); LOGERR (klogErr, rc, "key parameter for WGA encrypted file is empty"); return rc; } *pself = NULL; if ((encrypted == NULL)||(key == NULL)) { rc = RC (rcFS, rcFile, rcConstructing, rcParam, rcNull); LOGERR (klogErr, rc, "missing WGA encrypted file passed in to constructor"); } else if (key_size == 0) { rc = RC (rcFS, rcFile, rcConstructing, rcParam, rcInvalid); LOGERR (klogErr, rc, "missing WGA encrypted file passed in to constructor"); } else if (encrypted->read_enabled == 0) { rc = RC (rcFS, rcFile, rcConstructing, rcParam, rcIncorrect); LOGERR (klogErr, rc, "encrypted file not readable"); } else { KCipherManager * cipher_mgr; rc = KCipherManagerMake (&cipher_mgr); if (rc == 0) { KCipher * cipher; rc = KCipherManagerMakeCipher (cipher_mgr, &cipher, kcipher_AES); if (rc == 0) { size_t z; rc = KCipherBlockSize (cipher, &z); if (rc) { LOGERR (klogErr, rc, "unable to get block size for WGA " "encrypted file cipher passed in to constructor"); } else { if (z != ECB_BYTES) { rc = RC (rcFS, rcFile, rcConstructing, rcParam, rcInvalid); LOGERR (klogErr, rc, "wrong block size for WGA " "encrypted file cipher passed in to " "constructor"); } else { KWGAEncFile * self; self = calloc (sizeof (*self), sizeof (uint8_t)); if (self == NULL) { rc = RC (rcFS, rcFile, rcConstructing, rcMemory, rcExhausted); LOGERR (klogErr, rc, "out of memory while " "constructing decryptor"); } else { rc = KFileAddRef (encrypted); if (rc) LOGERR (klogErr, rc, "unable to add reference " "to encrypted file"); else { /* cast to strip const */ self->encrypted = encrypted; self->cipher = cipher; /* read the header of the encrypted file for * details about the decrypted file */ DEBUG_STS(("%s: calling KWGAEncFileHeaderRead\n", __func__)); rc = KWGAEncFileHeaderRead (self); if (rc == 0) { /* using the file header's stored encoding * key build a key from the parameter key */ DEBUG_STS(("%s: calling " "KWGAEncFileHeaderRead\n", __func__)); rc = KWGAEncFileKeyInit (self, key, key_size); } if (rc == 0) { rc = KFileInit (&self->dad, (const KFile_vt*) &vtKWGAEncFileRead, "KWGAEncFile", "no-name", true, false); if (rc) LOGERR (klogInt, rc, "Failed to initialize decrypting file"); else { *pself = &self->dad; self->buffer.offset = 0; self->buffer.valid = 0; KCipherManagerRelease (cipher_mgr); return 0; } } /* release of encrypted handled in destroy() */ } KWGAEncFileDestroyRead (self); } } } KCipherRelease (cipher); } } } return rc; }
static rc_t KWGAEncFileHeaderRead (KWGAEncFile * self) { KWGAEncFileHeader header; uint8_t * pb; size_t num_read; size_t tot_read; rc_t rc; assert (self); assert (sizeof (KWGAEncFileHeader) == 128); DEBUG_STS (("s: Enter '%p'\n", __func__, self)); pb = (void*)&header; for (num_read = tot_read = 0; tot_read < sizeof header; ) { rc = KFileRead (self->encrypted, (uint64_t)tot_read, pb, sizeof (header) - tot_read, &num_read); if (rc) { LOGERR (klogErr, rc, "Error reading the header for an encrypted file"); return rc; } if (num_read == 0) { rc = RC (rcFS, rcFile, rcReading, rcFile, rcInsufficient); LOGERR (klogErr, rc, "Header incomplete for an encrypted file"); return rc; } tot_read += num_read; pb += num_read; } KWGAEncFileHeaderDecrypt (&header); if (memcmp (header.magic, ncbi_crypt_magic, sizeof ncbi_crypt_magic) != 0) { rc = RC (rcFS, rcFile, rcReading, rcHeader, rcCorrupt); LOGERR (klogErr, rc, "Header's magic bad for encrypted file"); return rc; } /* so far unknown legal range */ self->block_size = strtou32 (header.block_sz, NULL, KWGA_ENC_FILE_HEADER_RADIX); self->file_size = strtou64 (header.file_sz, NULL, KWGA_ENC_FILE_HEADER_RADIX); /* file format has limiting feature of a 32 bit timestamp */ self->mtime = (KTime_t)strtol (header.mtime, NULL, KWGA_ENC_FILE_HEADER_RADIX); switch ((FER_ENCODING)header.fer_enc) { default: rc = RC (rcFS, rcFile, rcReading, rcHeader, rcOutofrange); LOGERR (klogErr, rc, "Enryption type code out of range"); return rc; case fer_encDES: case fer_encBLF: rc = RC (rcFS, rcFile, rcReading, rcHeader, rcIncorrect); LOGERR (klogErr, rc, "Enryption type code not supported"); return rc; case fer_encAES: break; } self->md5_here = (header.md5_here != 0); if (self->md5_here) memcpy (self->md5, header.md5, sizeof (self->md5)); memcpy (self->md51, header.md51, sizeof (self->md51)); return 0; /* yeah not really checking later errors am i? */ }
static rc_t CC KWGAEncFileRead (const KWGAEncFile *cself, uint64_t pos, void *buffer, size_t bsize, size_t *num_read) { KWGAEncFile * self = (KWGAEncFile *)cself; /* mutable values */ rc_t rc = 0; assert (cself); assert (buffer); assert (num_read); *num_read = 0; /* are we even within the file? If not just say no. Drugs are bad Mmmkay */ if (pos >= self->file_size) {} /* are we not reading from out what is already in the decrypted buffer space? */ else { if ((self->buffer.valid == 0) || (pos < self->buffer.offset) || (pos >= (self->buffer.offset + self->buffer.valid))) { if (pos < self->block_size) /* we'll be reading from the first 'block' */ { rc = KWGAEncFileReadInt (self, 0, self->block_size); if (rc) { LOGERR (klogErr, rc, "error reading first data block of" " encrypted file"); return rc; } if (self->buffer.valid > self->block_size) { rc = RC (rcFS, rcFile, rcReading, rcBuffer, rcTooBig); LOGERR (klogInt, rc, "read wrong amount for first block"); return rc; } else { size_t md5_size; size_t nudge = 0; char md51_comp [32]; if (self->buffer.valid & (ECB_BYTES-1)) nudge = ECB_BYTES - (self->buffer.valid & (ECB_BYTES-1)); if (nudge) memset (self->buffer.data + self->buffer.valid, 0, nudge); md5_size = self->buffer.valid + nudge; CalcMD5 (self->buffer.data, md5_size, md51_comp); #if 1 if (strcase_cmp (self->md51, string_size(self->md51), md51_comp, string_size(md51_comp), 32) != 0) #else if (strncasecmp (self->md51, md51_comp, 32) != 0) #endif { rc = RC (rcFS, rcFile, rcReading, rcConstraint, rcCorrupt); LOGERR (klogErr, rc, "MD5 does not match in decryption"); return rc; } } } else /* if (pos >= self->block_size) */ { rc = KWGAEncFileReadInt (self, (pos & ~(16-1)), DEFAULT_BUFF_SIZE); if (rc) { LOGERR (klogErr, rc, "error reading data block of" " encrypted file"); return rc; } } /* if (pos < self->block_size) */ } /* if ((self->buffer.valid == 0) || etc. */ /* if here we have a valid buffer and it contains the start pos requested */ /* assert (pos >= self->buffer.offset); */ /* assert (pos < (self->buffer.offset +self->buffer.valid)); */ { size_t start; size_t limit; /* find offset of start for copy within the buffer */ start = (size_t)(pos - self->buffer.offset); /* how many bytes available starting here */ limit = self->buffer.valid - start; if (pos + limit > self->file_size) limit = self->file_size - pos; /* are we asking to read more than we have? is so trim the request */ if (limit < bsize) bsize = limit; memmove (buffer, self->buffer.data + start, bsize); *num_read = bsize; } } return 0; }
static rc_t align_info(const Params* prm) { rc_t rc = 0; const VDatabase* db = NULL; const VDBManager* mgr = NULL; const KDBManager *kmgr = NULL; VSchema* schema = NULL; bool is_db = false; if (prm == NULL) { return RC(rcExe, rcQuery, rcExecuting, rcParam, rcNull); } if (rc == 0) { rc = VDBManagerMakeRead(&mgr, NULL); DISP_RC(rc, "while calling VDBManagerMakeRead"); } if (rc == 0) { rc = VDBManagerOpenKDBManagerRead(mgr, &kmgr); DISP_RC(rc, "while calling VDBManagerOpenKDBManagerRead"); } if (rc == 0) { rc = VDBManagerMakeSRASchema(mgr, &schema); DISP_RC(rc, "while calling VDBManagerMakeSRASchema"); } if (rc == 0) { rc = VDBManagerOpenDBRead(mgr, &db, schema, prm->dbPath); if (rc == 0) { is_db = true; } else if (rc == SILENT_RC(rcDB, rcMgr, rcOpening, rcDatabase, rcIncorrect)) { PLOGMSG(klogWarn, (klogWarn, "'$(path)' is not a database", "path=%s", prm->dbPath)); rc = 0; } else { PLOGERR(klogErr, (klogErr, rc, "$(path)", "path=%s", prm->dbPath)); } } if (is_db) { if (rc == 0) { if (prm->paramRef) { const VDBDependencies* dep = NULL; uint32_t count = 0; int i = 0; if (prm->paramHeaders) { OUTMSG(("Alignments:\n")); } rc = VDatabaseListDependencies(db, &dep, false); DISP_RC2(rc, prm->dbPath, "while calling VDatabaseListDependencies"); if (rc == 0) { rc = VDBDependenciesCount(dep, &count); DISP_RC2(rc, prm->dbPath, "while calling VDBDependenciesCount"); } for (i = 0; i < count && rc == 0; ++i) { bool circular = false; const char* name = NULL; const char* path = NULL; const char* remote = NULL; bool local = false; const char* seqId = NULL; rc = VDBDependenciesCircular(dep, &circular, i); if (rc != 0) { DISP_RC2(rc, prm->dbPath, "while calling VDBDependenciesCircular"); break; } rc = VDBDependenciesName(dep, &name, i); if (rc != 0) { DISP_RC2(rc, prm->dbPath, "while calling VDBDependenciesName"); break; } rc = VDBDependenciesPath(dep, &path, i); if (rc != 0) { DISP_RC2(rc, prm->dbPath, "while calling VDBDependenciesPath"); break; } rc = VDBDependenciesLocal(dep, &local, i); if (rc != 0) { DISP_RC2(rc, prm->dbPath, "while calling VDBDependenciesLocal"); break; } rc = VDBDependenciesSeqId(dep, &seqId, i); if (rc != 0) { DISP_RC2(rc, prm->dbPath, "while calling VDBDependenciesSeqId"); break; } rc = VDBDependenciesPathRemote(dep, &remote, i); if (rc != 0) { DISP_RC2(rc, prm->dbPath, "while calling VDBDependenciesRemote"); break; } OUTMSG(("%s,%s,%s,%s", seqId, name, (circular ? "true" : "false"), (local ? "local" : "remote"))); if (path && path[0]) { OUTMSG((":%s", path)); } else if (remote && remote[0]) { OUTMSG(("::%s", remote)); } OUTMSG(("\n")); } DESTRUCT(VDBDependencies, dep); if (prm->paramHeaders) { OUTMSG(("\n")); } } if (prm->paramBamHeader) { rc_t rc3 = bam_header(db); if (rc3 != 0 && rc == 0) { rc = rc3; } } if (prm->paramQuality) { rc_t rc3 = qual_stats(prm, db); if (rc3 != 0 && rc == 0) { rc = rc3; } } } } DESTRUCT(VSchema, schema); DESTRUCT(KDBManager, kmgr); DESTRUCT(VDBManager, mgr); DESTRUCT(VDatabase, db); return rc; }
static rc_t populate_cursors ( VTable *dtbl, VCursor *dcurs, const VCursor *scurs, vtblcp_column_map *cm, const Vector *v, uint32_t *rd_filt ) { uint32_t end = VectorLength ( v ); uint32_t i = VectorStart ( v ); BSTree stype_tbl, rftype_tbl; const VSchema *schema; rc_t rc = VTableOpenSchema ( dtbl, & schema ); if ( rc != 0 ) { LOGERR ( klogInt, rc, "failed to open destination table schema" ); return rc; } /* populate sensitive type table */ rc = populate_stype_tbl ( & stype_tbl, schema ); if ( rc != 0 ) { VSchemaRelease ( schema ); return rc; } /* populate read filter type table */ rc = populate_rdfilt_tbl ( & rftype_tbl, schema ); if ( rc != 0 ) { BSTreeWhack ( & stype_tbl, stype_id_whack, NULL ); VSchemaRelease ( schema ); return rc; } for ( end += i, rc = 0, * rd_filt = 0; i < end; ++ i ) { VTypedecl td; char typedecl [ 128 ]; const char *spec = ( const void* ) VectorGet ( v, i ); /* request column in destination */ rc = VCursorAddColumn ( dcurs, & cm [ i ] . wr, spec ); if ( rc != 0 ) { PLOGERR ( klogErr, (klogErr, rc, "failed to add '$(spec)' to destination cursor", "spec=%s", spec )); break; } /* always retrieve data type */ rc = VCursorDatatype ( dcurs, cm [ i ] . wr, & td, NULL ); if ( rc != 0 ) { PLOGERR ( klogInt, (klogInt, rc, "failed to determine datatype of destination column '$(name)'", "name=%s", spec )); break; } /* mark column as sensitive or not */ rc = mark_type_sensitivity ( & stype_tbl, schema, & td, & cm [ i ] ); if ( rc != 0 ) break; /* if spec is already typed, request it in source */ if ( spec [ 0 ] == '(' ) { rc = VCursorAddColumn ( scurs, & cm [ i ] . rd, spec ); if ( rc != 0 ) { PLOGERR ( klogErr, (klogErr, rc, "failed to add '$(spec)' to source cursor", "spec=%s", spec )); break; } } else { rc = VTypedeclToText ( & td, schema, typedecl, sizeof typedecl ); if ( rc != 0 ) { PLOGERR ( klogInt, (klogInt, rc, "failed to print datatype of destination column '$(name)'", "name=%s", spec )); break; } rc = VCursorAddColumn ( scurs, & cm [ i ] . rd, "(%s)%s", typedecl, spec ); if ( rc != 0 ) { PLOGERR ( klogErr, (klogErr, rc, "failed to add '$(spec)' to source cursor", "spec=(%s)%s", typedecl, spec )); break; } } /* check if column is a read filter */ cm [ i ] . rd_filter = false; if ( ! cm [ i ] . sensitive ) { if ( BSTreeFind ( & rftype_tbl, & td, stype_id_cmp ) != NULL ) { if ( * rd_filt != 0 ) { rc = RC ( rcExe, rcColumn, rcOpening, rcColumn, rcExists ); PLOGERR ( klogInt, (klogInt, rc, "can't use column '$(name)' as read filter", "name=%s", spec )); break; } * rd_filt = cm [ i ] . rd; cm [ i ] . rd_filter = true; } } } BSTreeWhack ( & rftype_tbl, stype_id_whack, NULL ); BSTreeWhack ( & stype_tbl, stype_id_whack, NULL ); VSchemaRelease ( schema ); /* add read filter to input if not already there in some way */ if ( * rd_filt == 0 ) { rc = VCursorAddColumn ( scurs, rd_filt, "RD_FILTER" ); if ( rc != 0 && GetRCState ( rc ) == rcNotFound ) rc = 0; } return rc; }
rc_t CC KMain(int argc, char* argv[]) { rc_t rc = 0; Args* args = NULL; Params prm; memset(&prm, 0, sizeof prm); do { uint32_t pcount = 0; rc = ArgsMakeAndHandle(&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if (rc) { LOGERR(klogErr, rc, "While calling ArgsMakeAndHandle"); break; } rc = ArgsParamCount(args, &pcount); if (rc) { LOGERR(klogErr, rc, "While calling ArgsParamCount"); break; } if (pcount < 1) { MiniUsage(args); DESTRUCT(Args, args); exit(1); break; } if (pcount > 1) { rc = RC(rcExe, rcArgv, rcParsing, rcParam, rcAmbiguous); LOGERR(klogErr, rc, "Too many database parameters"); break; } rc = ArgsParamValue(args, 0, &prm.dbPath); if (rc) { LOGERR(klogErr, rc, "Failure retrieving database name"); break; } rc = ArgsOptionCount (args, OPTION_ALL, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_ALL "' argument"); break; } if (pcount) { prm.paramBamHeader = prm.paramQuality = prm.paramRef = true; } rc = ArgsOptionCount (args, OPTION_BAM, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_BAM "' argument"); break; } if (pcount) { prm.paramBamHeader = true; } rc = ArgsOptionCount (args, OPTION_QUA, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_QUA "' argument"); break; } if (pcount) { prm.paramQuality = true; } rc = ArgsOptionCount (args, OPTION_REF, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_REF "' argument"); break; } if (pcount) { prm.paramRef = true; } if (!prm.paramBamHeader && !prm.paramQuality && !prm.paramRef) { prm.paramRef = true; } rc = ArgsOptionCount (args, OPTION_HEA, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_HEA "' argument"); break; } if (pcount) { prm.paramHeaders = true; } } while (false); if (rc == 0) { rc = align_info(&prm); } DESTRUCT(Args, args); return rc; }
/* KMain */ rc_t CC KMain ( int argc, char *argv [] ) { int i; rc_t rc; /* expect paths and schema types */ vtblcp_parms pb; memset ( & pb, 0, sizeof pb ); pb . columns = ( const char** ) & argv [ 1 ]; /* parse arguments */ for ( rc = 0, i = 1; i < argc; ++ i ) { const char *arg = argv [ i ]; if ( arg [ 0 ] != '-' ) { if ( pb . src_path == NULL ) pb . src_path = arg; else if ( pb . dst_path == NULL ) pb . dst_path = NULL; else { /* capture column name/spec */ pb . columns [ pb . column_cnt ++ ] = arg; } } else do switch ( ( ++ arg ) [ 0 ] ) { case 'K': pb . schema_src = NextArg ( & arg, & i, argc, argv, NULL, NULL ); break; case 'T': pb . dst_type = NextArg ( & arg, & i, argc, argv, NULL, NULL ); break; case 'h': case '?': s_Usage ( argv [ 0 ] ); return 0; default: fprintf ( stderr, "unrecognized switch: '%s'\n", argv [ i ] ); MiniUsage ( argv [ 0 ] ); return RC ( rcExe, rcArgv, rcReading, rcParam, rcInvalid ); } while ( arg [ 1 ] != 0 ); } /* check arguments */ if ( pb . src_path == NULL ) { fprintf ( stderr, "missing source table path\n" ); MiniUsage ( argv [ 0 ] ); return RC ( rcExe, rcArgv, rcReading, rcParam, rcNotFound ); } if ( pb . dst_path == NULL ) { fprintf ( stderr, "missing destination table path\n" ); MiniUsage ( argv [ 0 ] ); return RC ( rcExe, rcArgv, rcReading, rcParam, rcNotFound ); } if ( pb . schema_src == NULL ) { fprintf ( stderr, "missing schema source file\n" ); MiniUsage ( argv [ 0 ] ); return RC ( rcExe, rcArgv, rcReading, rcParam, rcNotFound ); } if ( pb . dst_type == NULL ) { fprintf ( stderr, "missing destination table type description\n" ); MiniUsage ( argv [ 0 ] ); return RC ( rcExe, rcArgv, rcReading, rcParam, rcNotFound ); } /* run tool */ return run ( & pb ); }
static rc_t SFFGzip_Idx(const SRATable* sratbl, SIndexObj* obj, char* buffer, const size_t buffer_sz) { rc_t rc = 0; uint16_t zlib_ver = ZLIB_VERNUM; const SFFReader* reader = NULL; if( (rc = SFFReaderMake(&reader, sratbl, g_accession, obj->minSpotId, obj->maxSpotId)) != 0 ) { return rc; } else { size_t written = 0; uint32_t blk = 0, spots_per_block = 0, proj_id_qty = 0; SIndexNode* inode = NULL; size_t z_blk = 0; size_t spots_buf_sz = g_file_block_sz * 100; size_t zbuf_sz = spots_buf_sz + 100; char* zbuf = malloc(zbuf_sz); char* spots_buf = malloc(spots_buf_sz); bool eof = false; if( zbuf == NULL || spots_buf == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); } while( rc == 0 ) { if( (rc = SFFReader_GetNextSpotData(reader, buffer, buffer_sz, &written)) == 0 ) { if( inode == NULL ) { spotid_t spotid = 0; if( (rc = SFFReaderCurrentSpot(reader, &spotid)) != 0 ) { break; } inode = malloc(sizeof(SIndexNode)); if( inode == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); break; } inode->key = obj->file_size; inode->key_size = 0; inode->id = spotid; inode->id_qty = 0; DEBUG_MSG(5, ("%s open key: spot %ld, offset %lu\n", obj->index, inode->id, inode->key)); if( spotid == 1 ) { char hd[10240]; size_t hd_sz = 0; if( (rc = SFFReaderHeader(reader, 0, hd, sizeof(hd), &hd_sz)) == 0 ) { if( hd_sz + written > spots_buf_sz ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcInsufficient); break; } memmove(&spots_buf[blk], hd, hd_sz); blk += hd_sz; if( g_dump ) { fwrite(hd, hd_sz, 1, stderr); } } } } if( blk + written > spots_buf_sz ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcInsufficient); break; } inode->id_qty++; memmove(&spots_buf[blk], buffer, written); blk += written; if( g_dump ) { fwrite(buffer, written, 1, stderr); } } if( (eof = (GetRCObject(rc) == rcRow && GetRCState(rc) == rcExhausted)) ) { rc = 0; if( inode == NULL ) { break; } } if( rc == 0 && (eof || (proj_id_qty == 0 && inode->id_qty > (spots_per_block * 0.95)) || (proj_id_qty > 0 && inode->id_qty >= proj_id_qty) ) ) { rc = ZLib_DeflateBlock(spots_buf, blk, zbuf, zbuf_sz, &z_blk); if( z_blk < g_file_block_sz ) { /* project needed id_qty */ proj_id_qty = g_file_block_sz * inode->id_qty / z_blk * 1.05; DEBUG_MSG(5, ("%s: project id qty %lu\n", obj->index, proj_id_qty)); } else { DEBUG_MSG(10, ("%s: no projection %lu > %lu\n", obj->index, z_blk, g_file_block_sz)); } } if( rc == 0 && (eof || z_blk >= g_file_block_sz) ) { obj->file_size += z_blk; MD5StateAppend(&obj->md5, zbuf, z_blk); inode->key_size = z_blk; SLListPushTail(&obj->li, &inode->n); DEBUG_MSG(5, ("%s close key: spots %lu, size %lu, ratio %hu%%, raw %lu\n", obj->index, inode->id_qty, inode->key_size, (uint16_t)(((float)(blk - z_blk)/blk)*100), blk)); spots_per_block = inode->id_qty; inode = NULL; if( blk > obj->buffer_sz ) { obj->buffer_sz = blk; } blk = 0; z_blk = 0; proj_id_qty = 0; } if( eof ) { break; } } rc = rc ? rc : Quitting(); if( rc != 0 ) { spotid_t spot = 0; SFFReaderCurrentSpot(reader, &spot); PLOGERR(klogErr, (klogErr, rc, "spot $(s)", PLOG_U32(s), spot)); } free(zbuf); free(spots_buf); } if( rc == 0 ) { KMDataNode* opt = NULL, *nd = NULL; if( (rc = KMDataNodeOpenNodeUpdate(obj->meta, &opt, "Format/Options")) != 0 ) { return rc; } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "ZlibVersion")) == 0 ) { rc = KMDataNodeWriteB16(nd, &zlib_ver); KMDataNodeRelease(nd); } KMDataNodeRelease(opt); } SFFReaderWhack(reader); return rc; }
/* InitDNSEndpoint * initialize the endpoint with a DNS name and a port number * * "ep" [ OUT ] - address of endpoint block to be intialized * * "dns" [ IN ] - textual DNS address. * * "port" [ IN, DEFAULT 0 ] - binary port number in native integer byte order. * if the special port number 0 is given, it represents any available port. */ LIB_EXPORT rc_t CC KNSManagerInitDNSEndpoint ( struct KNSManager const *self, KEndPoint *ep, struct String const *dns, uint16_t port ) { rc_t rc = 0; if ( ep == NULL ) rc = RC (rcNS, rcNoTarg, rcInitializing, rcParam, rcNull ); else { if ( self == NULL ) rc = RC ( rcNS, rcNoTarg, rcInitializing, rcSelf, rcNull ); else if ( dns == NULL ) rc = RC ( rcNS, rcNoTarg, rcInitializing, rcParam, rcNull ); else if ( dns -> size == 0 ) rc = RC ( rcNS, rcNoTarg, rcInitializing, rcSelf, rcInsufficient ); else { KDataBuffer b; char buffer [ 4096 ], * hostname = buffer; size_t buff_size = sizeof buffer; if ( dns -> size >= sizeof buffer ) { rc = KDataBufferMakeBytes ( & b, dns -> size + 1 ); if ( rc == 0 ) { hostname = b . base; buff_size = ( size_t ) b . elem_count; } } if ( rc == 0 ) { size_t size; rc = string_printf ( hostname, buff_size, & size, "%S", dns ); assert ( rc == 0 ); assert ( size < buff_size ); assert ( hostname [ size ] == 0 ); if ( rc == 0 ) { int lerrno; struct hostent *remote = gethostbyname ( hostname ); if ( remote != NULL ) { ep -> type = epIPV4; memcpy ( & ep -> u . ipv4 . addr, remote -> h_addr_list [ 0 ], sizeof ep -> u . ipv4 . addr ); ep -> u . ipv4 . addr = htonl ( ep -> u . ipv4 . addr ); ep -> u . ipv4 . port = ( uint16_t ) port; } else switch ( lerrno = WSAGetLastError () ) { case WSANOTINITIALISED: /* Must have WSAStartup call */ rc = RC ( rcNS, rcNoTarg, rcInitializing, rcEnvironment, rcUndefined ); break; case WSAENETDOWN:/* network subsystem failed */ rc = RC ( rcNS, rcNoTarg, rcInitializing, rcNoObj, rcFailed ); break; case WSAHOST_NOT_FOUND: /* Answer host not found */ rc = RC ( rcNS, rcNoTarg, rcValidating, rcConnection, rcNotFound ); break; case WSATRY_AGAIN: /* host not found or server failure */ rc = RC ( rcNS, rcNoTarg, rcValidating, rcConnection, rcBusy ); break; case WSANO_RECOVERY: /* non-recoverable error */ rc = RC ( rcNS, rcNoTarg, rcValidating, rcConnection, rcError ); break; case WSANO_DATA: /* name is valid but no data */ rc = RC ( rcNS, rcNoTarg, rcValidating, rcConnection, rcEmpty ); break; case WSAEINPROGRESS: /* call is in progress */ rc = RC ( rcNS, rcNoTarg, rcReading, rcId, rcUndefined ); break; case WSAEFAULT: /* name paremeter is not valid part of addr space */ rc = RC ( rcNS, rcNoTarg, rcReading, rcMemory, rcOutofrange ); break; case WSAEINTR: /* socket call was calanceled */ rc = RC ( rcNS, rcNoTarg, rcReading, rcConnection, rcCanceled ); break; default: rc = RC ( rcNS, rcNoTarg, rcReading, rcNoObj, rcError ); } } } if ( hostname != buffer ) KDataBufferWhack ( & b ); } if ( rc != 0 ) memset ( ep, 0, sizeof * ep ); } return rc; }
static rc_t FastqGzip_Idx(const SRATable* sratbl, SIndexObj* obj, char* buffer, const size_t buffer_sz) { rc_t rc = 0; const FastqReader* reader = NULL; uint16_t zlib_ver = ZLIB_VERNUM; uint8_t colorSpace = false; char* colorSpaceKey = "\0"; uint8_t origFormat = false; uint8_t printLabel = true; uint8_t printReadId = true; uint8_t clipQuality = true; uint32_t minReadLen = 0; uint16_t qualityOffset = 0; {{ const SRAColumn* c = NULL; const uint8_t *platform = SRA_PLATFORM_UNDEFINED; bitsz_t o, z; if( (rc = SRATableOpenColumnRead(sratbl, &c, "PLATFORM", sra_platform_id_t)) != 0 ) { return rc; } if( (rc = SRAColumnRead(c, 1, (const void **)&platform, &o, &z)) != 0 ) { return rc; } if( *platform == SRA_PLATFORM_ABSOLID ) { colorSpace = true; } SRAColumnRelease(c); }} if( (rc = FastqReaderMake(&reader, sratbl, g_accession, colorSpace, origFormat, false, printLabel, printReadId, !clipQuality, minReadLen, qualityOffset, colorSpaceKey[0], obj->minSpotId, obj->maxSpotId)) != 0 ) { return rc; } else { size_t written = 0; uint32_t blk = 0, spots_per_block = 0, proj_id_qty = 0; SIndexNode* inode = NULL; size_t z_blk = 0; size_t spots_buf_sz = g_file_block_sz * 100; size_t zbuf_sz = spots_buf_sz + 100; char* zbuf = malloc(zbuf_sz); char* spots_buf = malloc(spots_buf_sz); bool eof = false; if( zbuf == NULL || spots_buf == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); } while( rc == 0 ) { if( (rc = FastqReader_GetNextSpotSplitData(reader, buffer, buffer_sz, &written)) == 0 ) { if( inode == NULL ) { spotid_t spotid = 0; if( (rc = FastqReaderCurrentSpot(reader, &spotid)) != 0 ) { break; } inode = malloc(sizeof(SIndexNode)); if( inode == NULL ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted); break; } inode->key = obj->file_size; inode->key_size = 0; inode->id = spotid; inode->id_qty = 0; DEBUG_MSG(5, ("%s open key: spot %ld, offset %lu\n", obj->index, inode->id, inode->key)); } if( blk + written > spots_buf_sz ) { rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcInsufficient); break; } inode->id_qty++; memmove(&spots_buf[blk], buffer, written); blk += written; if( g_dump ) { fwrite(buffer, written, 1, stderr); } } if( (eof = (GetRCObject(rc) == rcRow && GetRCState(rc) == rcExhausted)) ) { rc = 0; if( inode == NULL ) { break; } } if( rc == 0 && (eof || (proj_id_qty == 0 && inode->id_qty > (spots_per_block * 0.95)) || (proj_id_qty > 0 && inode->id_qty >= proj_id_qty) ) ) { rc = ZLib_DeflateBlock(spots_buf, blk, zbuf, zbuf_sz, &z_blk); if( z_blk < g_file_block_sz ) { /* project needed id_qty */ proj_id_qty = g_file_block_sz * inode->id_qty / z_blk * 1.05; DEBUG_MSG(5, ("%s: project id qty %u\n", obj->index, proj_id_qty)); } else { DEBUG_MSG(10, ("%s: no projection %u > %u\n", obj->index, z_blk, g_file_block_sz)); } } if( rc == 0 && (eof || z_blk >= g_file_block_sz) ) { obj->file_size += z_blk; MD5StateAppend(&obj->md5, zbuf, z_blk); inode->key_size = z_blk; SLListPushTail(&obj->li, &inode->n); DEBUG_MSG(5, ("%s close key: spots %lu, size %lu, ratio %hu%%, raw %u\n", obj->index, inode->id_qty, inode->key_size, (uint16_t)(((float)(blk - z_blk)/blk)*100), blk )); spots_per_block = inode->id_qty; inode = NULL; if( blk > obj->buffer_sz ) { obj->buffer_sz = blk; } blk = 0; z_blk = 0; proj_id_qty = 0; } if( eof ) { break; } } rc = rc ? rc : Quitting(); if( rc != 0 ) { spotid_t spot = 0; FastqReaderCurrentSpot(reader, &spot); PLOGERR(klogErr, (klogErr, rc, "spot $(s)", PLOG_U32(s), spot)); } free(zbuf); free(spots_buf); } if( rc == 0 ) { KMDataNode* opt = NULL, *nd = NULL; if( (rc = KMDataNodeOpenNodeUpdate(obj->meta, &opt, "Format/Options")) != 0 ) { return rc; } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "ZlibVersion")) == 0 ) { rc = KMDataNodeWriteB16(nd, &zlib_ver); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "colorSpace")) == 0 ) { rc = KMDataNodeWriteB8(nd, &colorSpace); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "colorSpaceKey")) == 0 ) { rc = KMDataNodeWrite(nd, colorSpaceKey, 1); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "origFormat")) == 0 ) { rc = KMDataNodeWriteB8(nd, &origFormat); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "printLabel")) == 0 ) { rc = KMDataNodeWriteB8(nd, &printLabel); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "printReadId")) == 0 ) { rc = KMDataNodeWriteB8(nd, &printReadId); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "clipQuality")) == 0 ) { rc = KMDataNodeWriteB8(nd, &clipQuality); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "minReadLen")) == 0 ) { rc = KMDataNodeWriteB32(nd, &minReadLen); KMDataNodeRelease(nd); } if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &nd, "qualityOffset")) == 0 ) { rc = KMDataNodeWriteB16(nd, &qualityOffset); KMDataNodeRelease(nd); } KMDataNodeRelease(opt); } FastqReaderWhack(reader); return rc; }
static rc_t ReadFilterSplitter_GetKeySet( const SRASplitter* cself, const SRASplitter_Keys** key, uint32_t* keys, spotid_t spot, const readmask_t* readmask ) { rc_t rc = 0; ReadFilterSplitter* self = ( ReadFilterSplitter* )cself; if ( self == NULL || key == NULL ) { rc = RC( rcSRA, rcNode, rcExecuting, rcParam, rcNull ); } else { const INSDC_SRA_read_filter* rdf; bitsz_t o = 0, sz = 0; *keys = 0; if ( self->col_rdf != NULL ) { rc = SRAColumnRead( self->col_rdf, spot, (const void **)&rdf, &o, &sz ); if ( rc == 0 ) { int32_t j, i = sz / sizeof( INSDC_SRA_read_filter ) / 8; *key = self->keys; *keys = sizeof( self->keys ) / sizeof( self->keys[ 0 ] ); for ( j = 0; j < *keys; j++ ) { clear_readmask( self->keys[ j ].readmask ); } while ( i > 0 ) { i--; if ( self->read_filter != 0xFF && self->read_filter != rdf[i] ) { /* skip by filter value != to command line */ } else if ( rdf[ i ] == SRA_READ_FILTER_PASS ) { set_readmask( self->keys[ EReadFilterSplitter_pass ].readmask, i ); } else if ( rdf[ i ] == SRA_READ_FILTER_REJECT ) { set_readmask( self->keys[ EReadFilterSplitter_reject ].readmask, i ); } else if( rdf[ i ] == SRA_READ_FILTER_CRITERIA ) { set_readmask( self->keys[ EReadFilterSplitter_criteria ].readmask, i ); } else if( rdf[ i ] == SRA_READ_FILTER_REDACTED ) { set_readmask( self->keys[ EReadFilterSplitter_redacted ].readmask, i ); } else { set_readmask( self->keys[ EReadFilterSplitter_unknown ].readmask, i ); PLOGMSG( klogWarn, ( klogWarn, "unknown READ_FILTER value $(value) at spot id $(row)", PLOG_2( PLOG_U8( value ), PLOG_I64( row ) ), rdf[ i ], spot ) ); } } } } } return rc; }
rc_t KMain(int argc, char *argv[]) { rc_t rc = 0; Args* args = NULL; const char* errmsg = NULL, *table_dir = NULL; char accn[1024]; if( (rc = ArgsMakeAndHandle(&args, argc, argv, 1, MainArgs, MainArgsQty)) == 0 ) { const char* blksz = NULL; uint32_t count, dump = 0, gzip = 0; if( (rc = ArgsParamCount(args, &count)) != 0 || count != 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, count > 1 ? rcExcessive : rcInsufficient); errmsg = "table"; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_BlockSize].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_BlockSize].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_BlockSize].name, 0, (const void **)&blksz)) != 0 ) { errmsg = MainArgs[eopt_BlockSize].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_Accession].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_Accession].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_Accession].name, 0, (const void **)&g_accession)) != 0 ) { errmsg = MainArgs[eopt_Accession].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_DumpIndex].name, &dump)) != 0 ) { errmsg = MainArgs[eopt_DumpIndex].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_noGzip].name, &gzip)) != 0 ) { errmsg = MainArgs[eopt_noGzip].name; } while( rc == 0 ) { long val = 0; char* end = NULL; if( blksz != NULL ) { errno = 0; val = strtol(blksz, &end, 10); if( errno != 0 || blksz == end || *end != '\0' || val <= 0 ) { rc = RC(rcExe, rcArgv, rcReading, rcParam, rcInvalid); errmsg = MainArgs[eopt_BlockSize].name; break; } else if( val <= 128 || val > (1024 * 1024 * 1024) ) { rc = RC(rcExe, rcArgv, rcValidating, rcParam, rcEmpty); errmsg = "block size invalid"; break; } g_file_block_sz = val; } if( (rc = ArgsParamValue(args, 0, (const void **)&table_dir)) != 0 ) { errmsg = "table"; break; } if( g_accession == NULL ) { const char* p = strchr(table_dir, '/'); size_t l = 0; g_accession = accn; if( p == NULL ) { p = strchr(table_dir, '\\'); } strncpy(accn, p == NULL ? table_dir : p + 1, sizeof(accn) - 1); if( accn[0] == '\0' ) { rc = RC(rcExe, rcArgv, rcValidating, rcParam, rcEmpty); errmsg = "accession"; } l = strlen(accn); if( accn[l - 1] == '/' || accn[l - 1] == '\\') { accn[--l] = '\0'; } if( strncmp(&accn[l - 9], ".lite.sra", 9) == 0 ) { accn[l - 9] = '\0'; } else if( strncmp(&accn[l - 4], ".sra", 4) == 0 ) { accn[l - 4] = '\0'; } } g_dump = dump > 0; g_ungzip = gzip > 0; break; } } if( rc == 0 ) { SRAMgr* smgr = NULL; KDBManager* kmgr = NULL; DEBUG_MSG(5, ("table %s, accession %s\n", table_dir, g_accession)); if( (rc = SRAMgrMakeUpdate(&smgr, NULL)) == 0 ) { if( (rc = KDBManagerMakeUpdate(&kmgr, NULL)) == 0 ) { bool relock = true; if( (rc = KDBManagerUnlock(kmgr, table_dir)) != 0 ) { relock = false; rc = GetRCState(rc) == rcUnlocked ? 0 : rc; } else { PLOGMSG(klogInfo, (klogInfo, "Table $(p) locked, unlocking", PLOG_S(p), table_dir)); } if( rc == 0 ) { KTable* ktbl = NULL; if( (rc = KDBManagerOpenTableUpdate(kmgr, &ktbl, table_dir)) == 0 ) { KMetadata* meta = NULL; if( (rc = KTableOpenMetadataUpdate(ktbl, &meta)) == 0 ) { const SRATable* stbl = NULL; if( (rc = SRAMgrOpenTableRead(smgr, &stbl, table_dir)) == 0 ) { rc = MakeIndexes(stbl, ktbl, meta); SRATableRelease(stbl); } } KMetadataRelease(meta); } KTableRelease(ktbl); } if( rc == 0 && relock ) { rc = KDBManagerLock(kmgr, table_dir); } KDBManagerRelease(kmgr); } SRAMgrRelease(smgr); } } if( rc != 0 && rc != KLogLastErrorCode() ) { if( errmsg ) { Usage(args); } LOGERR(klogErr, rc, errmsg ? errmsg : "stop"); } ArgsWhack(args); return rc; }
bool CC SRADumper_GetArg( const SRADumperFmt* fmt, char const* const abbr, char const* const full, int* i, int argc, char *argv[], const char** value ) { rc_t rc = 0; const char* arg = argv[*i]; while ( *arg == '-' && *arg != '\0') { arg++; } if ( abbr != NULL && strcmp(arg, abbr) == 0 ) { SRA_DUMP_DBG( 9, ( "GetArg key: '%s'\n", arg ) ); arg = arg + strlen( abbr ); if ( value != NULL && arg[0] == '\0' && (*i + 1) < argc ) { arg = NULL; if ( argv[ *i + 1 ][ 0 ] != '-' ) { /* advance only if next is not an option with '-' */ *i = *i + 1; arg = argv[ *i ]; } } else { arg = NULL; } } else if ( full != NULL && strcmp( arg, full ) == 0 ) { SRA_DUMP_DBG( 9, ( "GetArg key: '%s'\n", arg ) ); arg = NULL; if ( value != NULL && ( *i + 1 ) < argc ) { if ( argv[ *i + 1 ][ 0 ] != '-' ) { /* advance only if next is not an option with '-' */ *i = *i + 1; arg = argv[ *i ]; } } } else { return false; } SRA_DUMP_DBG( 9, ( "GetArg val: '%s'\n", arg ) ); if ( value == NULL && arg != NULL ) { rc = RC( rcApp, rcArgv, rcAccessing, rcParam, rcUnexpected ); } else if ( value != NULL ) { if ( arg == NULL && *value == '\0' ) { rc = RC( rcApp, rcArgv, rcAccessing, rcParam, rcNotFound ); } else if ( arg != NULL && arg[0] != '\0' ) { *value = arg; } } if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "$(a0)$(a1)$(a2)$(f0)$(f1): $(v)", PLOG_3(PLOG_S(a0),PLOG_S(a1),PLOG_S(a2))","PLOG_3(PLOG_S(f0),PLOG_S(f1),PLOG_S(v)), abbr ? "-": "", abbr ? abbr : "", abbr ? ", " : "", full ? "--" : "", full ? full : "", arg)); CoreUsage( argv[ 0 ], fmt, true, EXIT_FAILURE ); } return rc == 0 ? true : false; }
LIB_EXPORT rc_t CC KDyldVLoadLib ( KDyld *self, KDylib **lib, const char *path, va_list args ) { rc_t rc; if ( lib == NULL ) rc = RC ( rcFS, rcDylib, rcLoading, rcParam, rcNull ); else { if ( self == NULL ) rc = RC ( rcFS, rcDylib, rcLoading, rcSelf, rcNull ); else if ( path == NULL || path [ 0 ] == 0 ) { String pstr; CONST_STRING ( & pstr, "" ); rc = KDylibMake ( lib, & pstr ); if ( rc == 0 ) { rc = KDyldLoad ( self, * lib, NULL ); if ( rc == 0 ) return 0; free ( * lib ); } } else { uint32_t i = VectorStart ( & self -> search ); uint32_t end = i + VectorLength ( & self -> search ); if ( i == end ) { char name [ 4096 ]; int len = vsnprintf ( name, sizeof name, path, args ); if ( len < 0 || len >= sizeof name ) rc = RC ( rcFS, rcDylib, rcLoading, rcPath, rcExcessive ); else { String pstr; StringInit ( & pstr, name, len, string_len ( name, len ) ); rc = KDylibMake ( lib, & pstr ); if ( rc == 0 ) { rc = KDyldLoad ( self, * lib, name ); if ( rc == 0 ) return 0; free ( * lib ); } } } else { for ( * lib = NULL; i < end; ++ i ) { const KDirectory *dir; va_list cpy; va_copy ( cpy, args ); dir = ( const void* ) VectorGet ( & self -> search, i ); rc = KDyldVTryLoadLib ( self, lib, dir, path, cpy ); va_end ( cpy ); if ( rc == 0 || GetRCState ( rc ) != rcNotFound ) return rc; } rc = RC ( rcFS, rcDylib, rcLoading, rcPath, rcNotFound ); } } * lib = NULL; } return rc; }
/******************************************************************************* * KMain - defined for use with kapp library *******************************************************************************/ rc_t CC KMain ( int argc, char* argv[] ) { rc_t rc = 0; int i; const char* arg; uint64_t total_spots = 0; const SRAMgr* sraMGR = NULL; SRADumperFmt fmt; bool to_stdout = false, do_gzip = false, do_bzip2 = false; char const* outdir = NULL; spotid_t minSpotId = 1; spotid_t maxSpotId = ~0; bool sub_dir = false; bool keep_empty = false; const char* table_path[10240]; int table_path_qty = 0; char const* D_option = NULL; char const* P_option = NULL; char P_option_buffer[4096]; const char* accession = NULL; const char* table_name = NULL; bool spot_group_on = false; int spot_groups = 0; char* spot_group[128] = {NULL}; bool read_filter_on = false; SRAReadFilter read_filter = 0xFF; bool failed_to_open = false; /* for the fasta-ouput of fastq-dump: branch out completely of 'common' code */ if ( fasta_dump_requested( argc, argv ) ) { return fasta_dump( argc, argv ); } /* Prepare for the worst: report this information after disaster */ ReportBuildDate ( __DATE__ ); memset( &fmt, 0, sizeof( fmt ) ); rc = SRADumper_Init( &fmt ); if ( rc != 0 ) { LOGERR(klogErr, rc, "formatter initialization"); return 100; } else if ( fmt.get_factory == NULL ) { rc = RC( rcExe, rcFormatter, rcValidating, rcInterface, rcNull ); LOGERR( klogErr, rc, "formatter factory" ); return 101; } else { rc = SRADumper_ArgsValidate( argv[0], &fmt ); if ( rc != 0 ) { LOGERR( klogErr, rc, "formatter args list" ); return 102; } } if ( argc < 2 ) { CoreUsage( argv[0], &fmt, true, EXIT_FAILURE ); return 0; } for ( i = 1; i < argc; i++ ) { arg = argv[ i ]; if ( arg[ 0 ] != '-' ) { uint32_t k; for ( k = 0; k < table_path_qty; k++ ) { if ( strcmp( arg, table_path[ k ] ) == 0 ) { break; } } if ( k >= table_path_qty ) { if ( ( table_path_qty + 1 ) >= ( sizeof( table_path ) / sizeof( table_path[ 0 ] ) ) ) { rc = RC( rcExe, rcArgv, rcReading, rcBuffer, rcInsufficient ); goto Catch; } table_path[ table_path_qty++ ] = arg; } continue; } arg = NULL; if ( SRADumper_GetArg( &fmt, "L", "log-level", &i, argc, argv, &arg ) ) { rc = LogLevelSet( arg ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "log level $(lvl)", PLOG_S( lvl ), arg ) ); goto Catch; } } else if ( SRADumper_GetArg( &fmt, NULL, OPTION_REPORT, &i, argc, argv, &arg ) ) { } else if ( SRADumper_GetArg( &fmt, "+", "debug", &i, argc, argv, &arg ) ) { #if _DEBUGGING rc = KDbgSetString( arg ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "debug level $(lvl)", PLOG_S( lvl ), arg ) ); goto Catch; } #endif } else if ( SRADumper_GetArg( &fmt, "H", "help", &i, argc, argv, NULL ) || SRADumper_GetArg( &fmt, "?", "h", &i, argc, argv, NULL ) ) { CoreUsage( argv[ 0 ], &fmt, false, EXIT_SUCCESS ); } else if ( SRADumper_GetArg( &fmt, "V", "version", &i, argc, argv, NULL ) ) { HelpVersion ( argv[ 0 ], KAppVersion() ); return 0; } else if ( SRADumper_GetArg( &fmt, "v", NULL, &i, argc, argv, NULL ) ) { KStsLevelAdjust( 1 ); } else if ( SRADumper_GetArg( &fmt, "D", "table-path", &i, argc, argv, &D_option ) ) { LOGMSG( klogErr, "option -D is deprecated, see --help" ); } else if ( SRADumper_GetArg( &fmt, "P", "path", &i, argc, argv, &P_option ) ) { LOGMSG( klogErr, "option -P is deprecated, see --help" ); } else if ( SRADumper_GetArg( &fmt, "A", "accession", &i, argc, argv, &accession ) ) { } else if ( SRADumper_GetArg( &fmt, "O", "outdir", &i, argc, argv, &outdir ) ) { } else if ( SRADumper_GetArg( &fmt, "Z", "stdout", &i, argc, argv, NULL ) ) { to_stdout = true; } else if ( fmt.gzip && SRADumper_GetArg( &fmt, NULL, "gzip", &i, argc, argv, NULL ) ) { do_gzip = true; } else if ( fmt.bzip2 && SRADumper_GetArg( &fmt, NULL, "bzip2", &i, argc, argv, NULL ) ) { do_bzip2 = true; } else if ( SRADumper_GetArg( &fmt, NULL, "table", &i, argc, argv, &table_name ) ) { } else if ( SRADumper_GetArg( &fmt, "N", "minSpotId", &i, argc, argv, &arg ) ) { minSpotId = AsciiToU32( arg, NULL, NULL ); } else if ( SRADumper_GetArg( &fmt, "X", "maxSpotId", &i, argc, argv, &arg ) ) { maxSpotId = AsciiToU32( arg, NULL, NULL ); } else if ( SRADumper_GetArg( &fmt, "G", "spot-group", &i, argc, argv, NULL ) ) { spot_group_on = true; } else if ( SRADumper_GetArg( &fmt, NULL, "spot-groups", &i, argc, argv, NULL ) ) { if ( i + 1 < argc && argv[ i + 1 ][ 0 ] != '-' ) { int f = 0, t = 0; i++; while ( argv[ i ][ t ] != '\0' ) { if ( argv[ i ][ t ] == ',' ) { if ( t - f > 0 ) { spot_group[ spot_groups++ ] = strndup( &argv[ i ][ f ], t - f ); } f = t + 1; } t++; } if ( t - f > 0 ) { spot_group[ spot_groups++ ] = strndup( &argv[ i ][ f ], t - f ); } if ( spot_groups < 1 ) { rc = RC( rcApp, rcArgv, rcReading, rcParam, rcEmpty ); PLOGERR( klogErr, ( klogErr, rc, "$(p)", PLOG_S( p ), argv[ i - 1 ] ) ); CoreUsage( argv[ 0 ], &fmt, false, EXIT_FAILURE ); } spot_group[ spot_groups ] = NULL; } } else if ( SRADumper_GetArg( &fmt, "R", "read-filter", &i, argc, argv, NULL ) ) { read_filter_on = true; if ( i + 1 < argc && argv[ i + 1 ][ 0 ] != '-' ) { i++; if ( read_filter != 0xFF ) { rc = RC( rcApp, rcArgv, rcReading, rcParam, rcDuplicate ); PLOGERR( klogErr, ( klogErr, rc, "$(p): $(o)", PLOG_2( PLOG_S( p ),PLOG_S( o ) ), argv[ i - 1 ], argv[ i ] ) ); CoreUsage( argv[ 0 ], &fmt, false, EXIT_FAILURE ); } if ( strcasecmp( argv[ i ], "pass" ) == 0 ) { read_filter = SRA_READ_FILTER_PASS; } else if ( strcasecmp( argv[ i ], "reject" ) == 0 ) { read_filter = SRA_READ_FILTER_REJECT; } else if ( strcasecmp( argv[ i ], "criteria" ) == 0 ) { read_filter = SRA_READ_FILTER_CRITERIA; } else if ( strcasecmp( argv[ i ], "redacted" ) == 0 ) { read_filter = SRA_READ_FILTER_REDACTED; } else { /* must be accession */ i--; } } } else if ( SRADumper_GetArg( &fmt, "T", "group-in-dirs", &i, argc, argv, NULL ) ) { sub_dir = true; } else if ( SRADumper_GetArg( &fmt, "K", "keep-empty-files", &i, argc, argv, NULL ) ) { keep_empty = true; } else if ( SRADumper_GetArg( &fmt, NULL, "no-user-settings", &i, argc, argv, NULL ) ) { KConfigDisableUserSettings (); } else if ( fmt.add_arg && fmt.add_arg( &fmt, SRADumper_GetArg, &i, argc, argv ) ) { } else { rc = RC( rcApp, rcArgv, rcReading, rcParam, rcIncorrect ); PLOGERR( klogErr, ( klogErr, rc, "$(p)", PLOG_S( p ), argv[ i ] ) ); CoreUsage( argv[ 0 ], &fmt, false, EXIT_FAILURE ); } } if ( to_stdout ) { if ( outdir != NULL || sub_dir || keep_empty || spot_group_on || ( read_filter_on && read_filter == 0xFF ) ) { LOGMSG( klogWarn, "stdout mode is set, some options are ignored" ); spot_group_on = false; if ( read_filter == 0xFF ) { read_filter_on = false; } } KOutHandlerSetStdErr(); KStsHandlerSetStdErr(); KLogHandlerSetStdErr(); ( void ) KDbgHandlerSetStdErr(); } if ( do_gzip && do_bzip2 ) { rc = RC( rcApp, rcArgv, rcReading, rcParam, rcAmbiguous ); LOGERR( klogErr, rc, "output compression method" ); CoreUsage( argv[ 0 ], &fmt, false, EXIT_FAILURE ); } if ( minSpotId > maxSpotId ) { spotid_t temp = maxSpotId; maxSpotId = minSpotId; minSpotId = temp; } if ( table_path_qty == 0 ) { if ( D_option != NULL && D_option[ 0 ] != '\0' ) { /* support deprecated '-D' option */ table_path[ table_path_qty++ ] = D_option; } else if ( accession == NULL || accession[ 0 ] == '\0' ) { /* must have accession to proceed */ rc = RC( rcExe, rcArgv, rcValidating, rcParam, rcEmpty ); LOGERR( klogErr, rc, "expected accession" ); goto Catch; } else if ( P_option != NULL && P_option[ 0 ] != '\0' ) { /* support deprecated '-P' option */ i = snprintf( P_option_buffer, sizeof( P_option_buffer ), "%s/%s", P_option, accession ); if ( i < 0 || i >= sizeof( P_option_buffer ) ) { rc = RC( rcExe, rcArgv, rcValidating, rcParam, rcExcessive ); LOGERR( klogErr, rc, "path too long" ); goto Catch; } table_path[ table_path_qty++ ] = P_option_buffer; } else { table_path[ table_path_qty++ ] = accession; } } rc = SRAMgrMakeRead( &sraMGR ); if ( rc != 0 ) { LOGERR( klogErr, rc, "failed to open SRA manager" ); goto Catch; } else { rc = SRASplitterFactory_FilerInit( to_stdout, do_gzip, do_bzip2, sub_dir, keep_empty, outdir ); if ( rc != 0 ) { LOGERR( klogErr, rc, "failed to initialize files" ); goto Catch; } } { const VDBManager* vmgr = NULL; rc_t rc2 = SRAMgrGetVDBManagerRead( sraMGR, &vmgr ); if ( rc2 != 0 ) { LOGERR( klogErr, rc2, "while calling SRAMgrGetVDBManagerRead" ); } rc2 = ReportSetVDBManager( vmgr ); VDBManagerRelease( vmgr ); } /* loop tables */ for ( i = 0; i < table_path_qty; i++ ) { const SRASplitterFactory* fact_head = NULL; spotid_t smax, smin; SRA_DUMP_DBG( 5, ( "table path '%s', name '%s'\n", table_path[ i ], table_name ) ); if ( table_name != NULL ) { rc = SRAMgrOpenAltTableRead( sraMGR, &fmt.table, table_name, table_path[ i ] ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "failed to open '$(path):$(table)'", "path=%s,table=%s", table_path[ i ], table_name ) ); continue; } } ReportResetObject( table_path[ i ] ); if ( fmt.table == NULL ) { rc = SRAMgrOpenTableRead( sraMGR, &fmt.table, table_path[ i ] ); if ( rc != 0 ) { if ( UIError( rc, NULL, NULL ) ) { UITableLOGError( rc, NULL, true ); } else { PLOGERR( klogErr, ( klogErr, rc, "failed to open '$(path)'", "path=%s", table_path[ i ] ) ); if (GetRCState(rc) == rcNotFound) { failed_to_open = true; } } continue; } } /* infer accession from table_path if missing or more than one table */ fmt.accession = table_path_qty > 1 ? NULL : accession; if ( fmt.accession == NULL || fmt.accession[ 0 ] == 0 ) { char * basename; char *ext; size_t l; bool is_url = false; strcpy( P_option_buffer, table_path[ i ] ); basename = strchr ( P_option_buffer, ':' ); if ( basename ) { ++basename; if ( basename [0] == '\0' ) basename = P_option_buffer; else is_url = true; } else basename = P_option_buffer; if ( is_url ) { ext = strchr ( basename, '#' ); if ( ext ) ext[ 0 ] = '\0'; ext = strchr ( basename, '?' ); if ( ext ) ext[ 0 ] = '\0'; } l = strlen( basename ); while ( strchr( "\\/", basename[ l - 1 ] ) != NULL ) { basename[ --l ] = '\0'; } fmt.accession = strrchr( basename, '/' ); if ( fmt.accession++ == NULL ) { fmt.accession = basename; } /* cut off [.lite].[c]sra[.nenc||.ncbi_enc] if any */ ext = strrchr( fmt.accession, '.' ); if ( ext != NULL ) { if ( strcasecmp( ext, ".nenc" ) == 0 || strcasecmp( ext, ",ncbi_enc" ) == 0 ) { *ext = '\0'; ext = strrchr( fmt.accession, '.' ); } if ( ext != NULL && ( strcasecmp( ext, ".sra" ) == 0 || strcasecmp( ext, ".csra" ) == 0 ) ) { *ext = '\0'; ext = strrchr( fmt.accession, '.' ); if ( ext != NULL && strcasecmp( ext, ".lite" ) == 0 ) { *ext = '\0'; } } } } SRA_DUMP_DBG( 5, ( "accession: '%s'\n", fmt.accession ) ); rc = SRASplitterFactory_FilerPrefix( accession ? accession : fmt.accession ); while ( rc == 0 ) { /* sort out the spot id range */ if ( ( rc = SRATableMaxSpotId( fmt.table, &smax ) ) != 0 || ( rc = SRATableMinSpotId( fmt.table, &smin ) ) != 0 ) { break; } { const struct VTable* tbl = NULL; rc_t rc2 = SRATableGetVTableRead( fmt.table, &tbl ); if ( rc == 0 ) { rc = rc2; } rc2 = ReportResetTable( table_path[i], tbl ); if ( rc == 0 ) { rc = rc2; } VTableRelease( tbl ); /* SRATableGetVTableRead adds Reference to tbl! */ } /* test if we have to dump anything... */ if ( smax < minSpotId || smin > maxSpotId ) { break; } if ( smax > maxSpotId ) { smax = maxSpotId; } if ( smin < minSpotId ) { smin = minSpotId; } /* hack to reduce looping in AddSpot: needs redesign to pass nreads along through tree */ if ( true ) /* ??? */ { const SRAColumn* c = NULL; nreads_max = NREADS_MAX; rc = SRATableOpenColumnRead( fmt.table, &c, "PLATFORM", sra_platform_id_t ); if ( rc == 0 ) { const INSDC_SRA_platform_id *platform; bitsz_t o, z; rc = SRAColumnRead( c, 1, (const void **)&platform, &o, &z ); if ( rc == 0 && platform != NULL ) { if ( *platform != SRA_PLATFORM_PACBIO_SMRT ) { nreads_max = 32; } } SRAColumnRelease( c ); } else if ( GetRCState( rc ) == rcNotFound && GetRCObject( rc ) == rcColumn ) { rc = 0; } } /* table dependent */ rc = fmt.get_factory( &fmt, &fact_head ); if ( rc != 0 ) { break; } if ( fact_head == NULL ) { rc = RC( rcExe, rcFormatter, rcResolving, rcInterface, rcNull ); break; } if ( rc == 0 && ( spot_group_on || spot_groups > 0 ) ) { const SRASplitterFactory* f = NULL; rc = SpotGroupSplitterFactory_Make( &f, fmt.table, spot_group_on, spot_group ); if ( rc == 0 ) { rc = SRASplitterFactory_AddNext( f, fact_head ); if ( rc == 0 ) { fact_head = f; } else { SRASplitterFactory_Release( f ); } } } if ( rc == 0 && read_filter_on ) { const SRASplitterFactory* f = NULL; rc = ReadFilterSplitterFactory_Make( &f, fmt.table, read_filter ); if ( rc == 0 ) { rc = SRASplitterFactory_AddNext( f, fact_head ); if ( rc == 0 ) { fact_head = f; } else { SRASplitterFactory_Release( f ); } } } if ( rc == 0 ) { /* this filter takes over head of chain to be first and kill off bad NREADS */ const SRASplitterFactory* f = NULL; rc = MaxNReadsValidatorFactory_Make( &f, fmt.table ); if ( rc == 0 ) { rc = SRASplitterFactory_AddNext( f, fact_head ); if ( rc == 0 ) { fact_head = f; } else { SRASplitterFactory_Release( f ); } } } rc = SRASplitterFactory_Init( fact_head ); if ( rc == 0 ) { /* ********************************************************** */ rc = SRADumper_DumpRun( fmt.table, smin, smax, fact_head ); /* ********************************************************** */ if ( rc == 0 ) { uint64_t total = 0, file = 0; SRASplitterFactory_FilerReport( &total, &file ); OUTMSG(( "Written %lu spots for %s\n", total - total_spots, table_path[ i ] )); if ( to_stdout && total > 0 ) { PLOGMSG( klogInfo, ( klogInfo, "$(t) biggest file has $(n) spots", PLOG_2( PLOG_S( t ), PLOG_U64( n ) ), table_path[ i ], file )); } total_spots = total; } } break; } SRASplitterFactory_Release( fact_head ); SRATableRelease( fmt.table ); fmt.table = NULL; if ( rc == 0 ) { PLOGMSG( klogInfo, ( klogInfo, "$(path)$(dot)$(table) $(spots) spots", PLOG_4(PLOG_S(path),PLOG_S(dot),PLOG_S(table),PLOG_U32(spots)), table_path[ i ], table_name ? ":" : "", table_name ? table_name : "", smax - smin + 1 ) ); } else if ( !reportToUser( rc, argv [0 ] ) ) { PLOGERR( klogErr, ( klogErr, rc, "failed $(path)$(dot)$(table)", PLOG_3(PLOG_S(path),PLOG_S(dot),PLOG_S(table)), table_path[ i ], table_name ? ":" : "", table_name ? table_name : "" ) ); } } Catch: if ( fmt.release ) { rc_t rr = fmt.release( &fmt ); if ( rr != 0 ) { SRA_DUMP_DBG( 1, ( "formatter release error %R\n", rr ) ); } } for ( i = 0; i < spot_groups; i++ ) { free( spot_group[ i ] ); } SRASplitterFiler_Release(); SRAMgrRelease( sraMGR ); OUTMSG(( "Written %lu spots total\n", total_spots )); if (failed_to_open) { ReportSilence(); } { /* Report execution environment if necessary */ rc_t rc2 = ReportFinalize( rc ); if ( rc == 0 ) { rc = rc2; } } return rc; }
rc_t extract_statistic_from_row(statistic *self, row_input const *data) { rc_t rc = 0; spotgrp *sg; char const *spotgrp_base; uint32_t spotgrp_len; unsigned i; uint8_t lb = 4; unsigned hpr = 0; unsigned gcc = 0; if (data == NULL) { return RC(rcXF, rcFunction, rcExecuting, rcParam, rcNull); } if (self == NULL) { return RC(rcXF, rcFunction, rcExecuting, rcSelf, rcNull); } rc = validate_row_data(self, data); if (rc) return rc; spotgrp_base = data->spotgroup; spotgrp_len = data->spotgroup_len; if (spotgrp_base == NULL || spotgrp_len == 0) { spotgrp_base = ""; spotgrp_len = 0; } sg = find_spotgroup( self, spotgrp_base, spotgrp_len ); if ( sg == NULL ) { sg = make_spotgrp( spotgrp_base, spotgrp_len ); if ( sg == NULL ) { return RC( rcXF, rcFunction, rcExecuting, rcMemory, rcExhausted ); } else { rc = BSTreeInsert ( &self->spotgroups, (BSTNode *)sg, spotgroup_sort ); if (rc) return rc; } } for (i = 0; i < data->read_len && rc == 0; ++i) { unsigned const base = data->read[i]; unsigned dimer; if (base > 3) { dimer = 16; hpr = 0; } else { dimer = (lb > 3) ? 16 : ((lb << 2) | base); if (lb == base) ++hpr; else hpr = 0; } if (i > 0) rc = spotgroup_enter_values(sg, data->quality[i], dimer, gcc, hpr, data->base_pos_offset + i, CASE_MATCH); if (base == 1 || base == 2) ++gcc; if (i >= self->gc_window) { unsigned const out = data->read[i - self->gc_window]; if (out == 1 || out == 2) --gcc; } lb = base; } return rc; }
static rc_t qual_stats(const Params* prm, const VDatabase* db) { rc_t rc = 0; const char tblName[] = "SEQUENCE"; const VTable* tbl = NULL; const KMetadata* meta = NULL; const KMDataNode* node = NULL; assert(prm && db); if (rc == 0) { rc = VDatabaseOpenTableRead(db, &tbl, tblName); DISP_RC2(rc, tblName, "while calling VDatabaseOpenTableRead"); } if (rc == 0) { rc = VTableOpenMetadataRead(tbl, &meta); DISP_RC2(rc, tblName, "while calling VTableOpenMetadataRead"); } if (rc == 0) { bool found = false; const char path[] = "STATS/QUALITY"; rc = KMetadataOpenNodeRead(meta, &node, path); if (rc == 0) { found = true; } else if (GetRCState(rc) == rcNotFound) { rc = 0; } DISP_RC2(rc, path, "while calling KMetadataOpenNodeRead"); if (found) { uint32_t i = 0; int nbr = 0; uint32_t count = 0; KNamelist* names = NULL; int* quals = NULL; if (rc == 0) { rc = KMDataNodeListChild(node, &names); DISP_RC2(rc, path, "while calling KMDataNodeListChild"); } if (rc == 0) { rc = KNamelistCount(names, &count); DISP_RC2(rc, path, "while calling KNamelistCount"); if (rc == 0 && count > 0) { quals = calloc(count, sizeof *quals); if (quals == NULL) { rc = RC(rcExe, rcStorage, rcAllocating, rcMemory, rcExhausted); } } } for (i = 0; i < count && rc == 0; ++i) { /* uint64_t u = 0; const KMDataNode* n = NULL; */ const char* nodeName = NULL; const char* name = NULL; rc = KNamelistGet(names, i, &nodeName); DISP_RC2(rc, path, "while calling KNamelistGet"); if (rc) { break; } name = nodeName; /* rc = KMDataNodeOpenNodeRead(node, &n, name); DISP_RC(rc, name); if (rc == 0) { rc = KMDataNodeReadAsU64(n, &u); DISP_RC(rc, name); } */ if (rc == 0) { char* c = strchr(name, '_'); if (c != NULL && *(c + 1) != '\0') { name = c + 1; if (sscanf(name, "%d", &quals[i]) != 1) { rc = RC(rcExe, rcNode, rcParsing, rcName, rcUnexpected); PLOGERR(klogInt, (klogInt, rc, "$(name)", "name=%s", nodeName)); } } /* OUTMSG(("QUALITY %s %lu\n", name, u)); */ } /* DESTRUCT(KMDataNode, n); */ } if (rc == 0 && count > 0) { ksort(quals, count, sizeof *quals, sort_callback, NULL); } if (rc == 0) { if (prm->paramHeaders) { OUTMSG(("Quality statistics - rows per value\n")); OUTMSG(("Quality values:")); for (i = 0; i <= 40; ++i) { OUTMSG(("\t%d", i)); } OUTMSG(("\n")); } OUTMSG(("%s", prm->dbPath)); } for (i = 0, nbr = 0; i < count && rc == 0; ++i, ++nbr) { uint64_t u = 0; char name[64]; const KMDataNode* n = NULL; sprintf(name, "PHRED_%d", quals[i]); rc = KMDataNodeOpenNodeRead(node, &n, name); DISP_RC(rc, name); if (rc == 0) { rc = KMDataNodeReadAsU64(n, &u); DISP_RC(rc, name); if (rc == 0) { while (nbr < quals[i]) { OUTMSG(("\t0")); ++nbr; } OUTMSG(("\t%lu", u)); /* OUTMSG(("QUALITY %d %lu\n", quals[i], u)); */ } } DESTRUCT(KMDataNode, n); } while (rc == 0 && nbr <= 40) { OUTMSG(("\t0")); nbr++; } if (rc == 0) { OUTMSG(("\n")); } DESTRUCT(KNamelist, names); } } DESTRUCT(KMDataNode, node); DESTRUCT(KMetadata, meta); DESTRUCT(VTable, tbl); return rc; }
/* alter cursor * 'alter <cursor> add column [ ( <typedecl> ) ] NAME;' * * all data after the 'column' keyword are gathered into * ( typedecl, name ) pairs. we are going to allow comma * separation, but otherwise just gather everything up to * the semi-colon. */ static rc_t kqsh_alter_cursor_add_column ( KSymTable *tbl, KTokenSource *src, KToken *t, KSymbol *cursor ) { rc_t rc; do { size_t i; uint32_t idx; char coldecl [ 256 ]; for ( i = 0; i < sizeof coldecl - 1; ) { /* end of column */ if ( t -> id == eSemiColon || t -> id == eComma ) break; /* accumulate */ i += string_copy ( & coldecl [ i ], sizeof coldecl - i, t -> str . addr, t -> str . size ); next_token ( tbl, src, t ); } /* the name needs to fit in our buffer */ if ( i == sizeof coldecl - 1 ) { rc = RC ( rcExe, rcCursor, rcUpdating, rcName, rcExcessive ); if ( interactive ) { kqsh_printf ( "this is really hard to believe, but you managed to request\n" "a column with a %u byte expression. please stop trying to abuse me.\n", ( unsigned int ) i ); } else { LOGERR ( klogErr, rc, "failed to add column to cursor" ); } return rc; } /* perform the task */ rc = _VCursorAddColumn ( cursor -> u . obj, & idx, coldecl ); if ( rc != 0 ) { PLOGERR ( klogErr, (klogErr, rc, "cannot add column '$(expr)' to cursor '$(curs)'", "expr=%s,curs=%.*s" , coldecl , ( int ) cursor -> name . size, cursor -> name . addr)); } else if ( interactive ) { kqsh_printf ( "added column '%s' ( idx %u ) to cursor '%N' ( %p )\n" , coldecl , idx , cursor , cursor -> u . obj ); } } while ( t -> id == eComma ); if ( t -> id != eSemiColon ) return expected ( t, klogErr, ";" ); return 0; }
static rc_t TextFile_Write(TextFile *self, uint64_t pos, const void *buffer, size_t size, size_t *num_writ) { return RC(rcExe, rcFile, rcWriting, rcInterface, rcUnsupported); }