/* KMain - EXTERN * executable entrypoint "main" is implemented by * an OS-specific wrapper that takes care of establishing * signal handlers, logging, etc. * * in turn, OS-specific "main" will invoke "KMain" as * platform independent main entrypoint. * * "argc" [ IN ] - the number of textual parameters in "argv" * should never be < 0, but has been left as a signed int * for reasons of tradition. * * "argv" [ IN ] - array of NUL terminated strings expected * to be in the shell-native character set: ASCII or UTF-8 * element 0 is expected to be executable identity or path. */ rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; default_log_level = KLogLevelGet(); rc = ArgsMakeAndHandle (&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if (rc == 0) { do { srakar_parms pb; KDirectory * pwd; const char * name; uint32_t pcount; char archive_name [256]; rc = KDirectoryNativeDir (&pwd); if (rc) break; pb.lite = false; pb.force = false; pb.dir = pwd; rc = ArgsOptionCount (args, OPTION_LITE, &pcount); if (rc) break; if (pcount == 1) { STSMSG (1, ("Using lite option")); pb.lite = true; } #if USE_FORCE rc = ArgsOptionCount (args, OPTION_FORCE, &pcount); if (rc) break; if (pcount == 1) { STSMSG (1, ("Using force option")); pb.force = true; } #endif rc = ArgsParamCount (args, &pcount); if (rc) break; if (pcount == 0) { KOutMsg ("missing source table\n"); MiniUsage (args); rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcInsufficient); break; } else if (pcount > 2) { KOutMsg ("Too many parameters\n"); MiniUsage (args); rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcExcessive); break; } rc = ArgsParamValue (args, 0, (const void **)&pb.src_path); if (rc) { KOutMsg ("failure to get source path/name\n"); break; } pb.dst_path = archive_name; name = string_rchr (pb.src_path, string_size (pb.src_path), '/'); if (name == NULL) name = pb.src_path; if (pcount == 1) { size_t size; rc = string_printf (archive_name, sizeof (archive_name), & size, "%s%s", name, pb.lite ? ".lite.sra" : ".sra"); if ( rc != 0 ) { rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcInsufficient); PLOGERR (klogFatal, (klogFatal, rc, "Failure building archive name $(P)", "P=%s", archive_name)); break; } } else { rc = ArgsParamValue (args, 1, (const void **)&pb.dst_path); if (rc) { LOGERR (klogInt, rc, "failure to get destination path"); break; } } if (rc == 0) { KPathType kpt; kpt = KDirectoryPathType (pwd, "%s", pb.dst_path); switch (kpt & ~kptAlias) { case kptNotFound: /* found nothing so assume its a valid new file name * not gonna tweak extensions at this point but that can be upgraded */ break; case kptFile: /* got a file name, use it - would need force... */ if (pb.force == false) { rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcBusy); PLOGERR (klogFatal, (klogFatal, rc, "Output file already exists $(P)", "P=%s", archive_name)); } break; case kptDir: { size_t size; rc = string_printf (archive_name, sizeof (archive_name), & size, "%s/%s%s", pb.dst_path, name, pb.lite ? ".lite.sra" : ".sra"); if ( rc != 0 ) { rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcInsufficient); PLOGERR (klogFatal, (klogFatal, rc, "Failure building archive name $(P)", "P=%s", archive_name)); break; } pb.dst_path = archive_name; break; } default: rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcInvalid); break; } if (rc == 0) { STSMSG (1,("Creating archive (%s) from table (%s)\n", pb.dst_path, pb.src_path)); rc = run (&pb); STSMSG (5, ("Run exits with %d %R\n", rc, rc)); } } } while (0); } STSMSG (1, ("Exit status %u %R", rc, rc)); return rc; }
rc_t KNSProxiesVSetHTTPProxyPath ( KNSProxies * self, const char * fmt, va_list args, bool clear ) { rc_t rc = 0; if ( clear ) rc = KNSProxiesHttpProxyClear ( self ); if ( rc == 0 && fmt != NULL && fmt [ 0 ] != 0 ) { size_t psize; char path [ 4096 * 2 ]; const char * p = path; rc = string_vprintf ( path, sizeof path, & psize, fmt, args ); if ( rc == 0 ) { while ( psize != 0 ) { size_t s = psize; uint16_t proxy_port = 0; const char * colon = NULL; const char * comma = string_chr ( p, psize, ',' ); if ( comma != NULL ) { #ifdef MULTIPLE_PROXIES s = comma - p; #else rc = RC ( rcNS, rcMgr, rcUpdating, rcPath, rcInvalid ); break; #endif } colon = string_chr ( p, s, ':' ); if ( colon != NULL ) { char * end = NULL; const char * port_spec = NULL; long port_num = 0; int have = colon - p; int remains = s - have; if ( remains > 2 ) { assert ( colon [ 0 ] == ':' ); if ( colon [ 1 ] == '/' && colon [ 2 ] == '/' ) { /* strip off the scheme from proxy specification: it is ignored now */ psize -= have + 3; p = colon + 3; if ( psize == 0 ) return RC ( rcNS, rcMgr, rcUpdating, rcPath, rcInvalid ); continue; } } port_spec = colon + 1; /* it is true that some day we might read symbolic port names... */ port_num = strtol ( port_spec, & end, 10 ); if ( port_num <= 0 || port_num >= 0x10000) { PLOGERR ( klogErr, ( klogErr, rc, "Proxy '$(proxy)' was ignored", "proxy=%.*s", ( int ) s, p ) ); rc = RC ( rcNS, rcMgr, rcUpdating, rcPath, rcInvalid ); } else if ( end [ 0 ] != 0 && comma == NULL ) { if ( * end != '/' && * end != '?' ) { /* skip everyting after '/' or '?' */ PLOGERR ( klogErr, ( klogErr, rc, "Proxy '$(proxy)' was ignored", "proxy=%.*s", ( int ) s, p ) ); rc = RC ( rcNS, rcMgr, rcUpdating, rcPath, rcInvalid ); } } if ( rc == 0 ) { proxy_port = ( uint16_t ) port_num; s = colon - p; } } if ( rc == 0 ) rc = KNSProxiesAddHttpProxyPath ( self, p, s, proxy_port ); if ( comma == NULL) psize = 0; else { s = comma - p + 1; if ( s > psize ) psize = 0; else { psize -= s; p += s; } } } } } return rc; }
static rc_t read_from_ref_node( ref_node * node, int32_t ref_offset, uint32_t ref_len, uint8_t *exclude_vector, uint32_t *active ) { rc_t rc = 0; uint64_t row_id = ( ref_offset / node->read_len ) + 1; uint8_t *dst = exclude_vector; uint32_t remaining = ref_len; uint32_t src_ofs = ref_offset % node->read_len; while ( remaining > 0 && rc == 0 ) { uint32_t elem_bits, boff, rlen; const uint8_t *src; rc = VCursorCellDataDirect ( node->cur, row_id, node->hits_idx, &elem_bits, (const void**)&src, &boff, &rlen ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to read $(col_name) from 1st row in table $(db_name).$(tab_name)", "col_name=%s,db_name=%S,tab_name=%s", HITS_COLUMN, node->name, HITMAP_TAB ) ); } else { if ( src_ofs >= rlen ) { rc = RC( rcApp, rcNoTarg, rcReading, rcParam, rcInvalid ); PLOGERR( klogInt, ( klogInt, rc, "error: try to read more data than are in var-loc $(tab_name)", "tab_name=%S", node->name ) ); } else { uint32_t to_copy = ( rlen - src_ofs ); if ( to_copy > remaining ) { to_copy = remaining; } src += src_ofs; memmove( dst, src, to_copy ); dst += to_copy; remaining -= to_copy; src_ofs = 0; row_id ++; node->bytes_requested += to_copy; } } } *active = 0; if ( rc == 0 ) { for ( src_ofs = 0; src_ofs < ref_len; ++src_ofs ) { if ( exclude_vector[ src_ofs ] > 0 ) { ( *active )++; } } } return rc; }
static rc_t run ( srakar_parms *pb ) { KFile * outfile; rc_t rc; const SRAMgr *mgr; rc = SRAMgrMakeRead ( & mgr ); if ( rc != 0 ) LOGERR ( klogInt, rc, "failed to open SRAMgr" ); else { const SRATable *tbl; rc = SRAMgrOpenTableRead ( mgr, & tbl, "%s", pb -> src_path ); if ( rc != 0 ) PLOGERR ( klogInt, (klogInt, rc, "failed to open SRATable '$(spec)'", "spec=%s", pb -> src_path )); else { rc = KDirectoryCreateFile (pb->dir, &outfile, false, 0446, kcmParents | ( pb->force ? kcmInit : kcmCreate) , "%s", pb->dst_path); if (rc == 0) { const KFile * archive; rc = SRATableMakeSingleFileArchive (tbl, &archive, pb->lite, NULL); if (rc == 0) { rc = copy_file (archive, outfile); KFileRelease (archive); } KFileRelease (outfile); } SRATableRelease ( tbl ); } SRAMgrRelease (mgr); } /* rc = KDirectoryCreateFile (pb->dir, &outfile, false, 0446, kcmParents | ( pb->force ? kcmInit : kcmCreate) , "%s", pb->dst_path); if (rc == 0) { const SRAMgr *mgr; rc = SRAMgrMakeRead ( & mgr ); if ( rc != 0 ) LOGERR ( klogInt, rc, "failed to open SRAMgr" ); else { const SRATable *tbl; rc = SRAMgrOpenTableRead ( mgr, & tbl, "%s", pb -> src_path ); if ( rc != 0 ) PLOGERR ( klogInt, (klogInt, rc, "failed to open SRATable '$(spec)'", "spec=%s", pb -> src_path )); else { const KFile * archive; rc = SRATableMakeSingleFileArchive (tbl, &archive, pb->lite, NULL); if (rc == 0) { rc = copy_file (archive, outfile); KFileRelease (archive); } SRATableRelease ( tbl ); } SRAMgrRelease (mgr); } KFileRelease (outfile); } */ return rc; }
static rc_t detect_read_len( ref_node *node ) { const VCursor *temp_cursor; rc_t rc = VTableCreateCursorRead ( node->tab, &temp_cursor ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to create cursor on table $(tab_name)", "tab_name=%S", node->name ) ); } else { uint32_t idx; rc = VCursorAddColumn ( temp_cursor, &idx, MAXLEN_COLUMN ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to add column $(col_name) to cursor for table $(db_name).$(tab_name)", "col_name=%s,db_name=%S,tab_name=%s", MAXLEN_COLUMN, node->name, HITMAP_TAB ) ); } else { rc = VCursorOpen( temp_cursor ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to open cursor for table $(db_name).$(tab_name to read $(col_name)", "col_name=%s,db_name=%S,tab_name=%s", MAXLEN_COLUMN, node->name, HITMAP_TAB ) ); } else { uint32_t elem_bits, boff, row_len; const void *base; rc = VCursorCellDataDirect ( temp_cursor, 1, idx, &elem_bits, &base, &boff, &row_len ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to read $(col_name) from 1st row in table $(db_name).$(tab_name)", "col_name=%s,db_name=%S,tab_name=%s", MAXLEN_COLUMN, node->name, HITMAP_TAB ) ); } else { node->read_len = *((uint32_t *)base); if ( node->read_len == 0 ) { rc = RC( rcApp, rcNoTarg, rcReading, rcParam, rcInvalid ); PLOGERR( klogInt, ( klogInt, rc, "$(col_name) == 0 discoverd in table $(db_name).$(tab_name)", "col_name=%s,db_name=%S,tab_name=%s", MAXLEN_COLUMN, node->name, HITMAP_TAB ) ); } } } } VCursorRelease( temp_cursor ); } return rc; }
static ref_node * make_ref_node( ref_exclude *exclude, const String * s ) { ref_node * res = calloc( 1, sizeof * res ); if ( res != NULL ) { if ( StringCopy ( &res->name, s ) != 0 ) { free( res ); res = NULL; } } if ( res != NULL && exclude->path != NULL ) { char buf[ 1024 ]; size_t num_writ; rc_t rc = string_printf ( buf, sizeof buf, &num_writ, "%s/%S", exclude->path, s ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to assemble path to exclude-table $(tab_name)", "tab_name=%S", s ) ); } else { rc = VDBManagerOpenDBRead ( exclude->mgr, &res->db, NULL, "%s", buf ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to open exclude-table $(db_name)", "db_name=%s", buf ) ); /* it can be OK if the database/table cannot be found! */ rc = 0; } else { rc = VDatabaseOpenTableRead ( res->db, &res->tab, "HITMAP" ); if ( rc != 0 ) { PLOGERR( klogInt, ( klogInt, rc, "error to open exclude-table 'HITMAP' in $(db_name)", "db_name=%s", buf ) ); /* it can be OK if the database/table cannot be found! */ rc = 0; } else { rc = detect_read_len( res ); if ( rc == 0 ) { rc = prepare_ref_node( res ); } } } } } return res; }
static rc_t nenctool (const char * srcstr, const char * dststr, bool force) { VFSManager * mgr; rc_t rc; rc = VFSManagerMake (&mgr); if (rc) LOGERR (klogInt, rc, "failed to create file system manager"); else { VPath * srcpath; rc = VFSManagerMakePath (mgr, &srcpath, "%s", srcstr); if (rc) PLOGERR (klogErr, (klogErr, rc, "Failed to parse source path '$(path)'", "path=%s", srcstr)); else { VPath * dstpath; rc = VFSManagerMakePath (mgr, &dstpath, "%s", dststr); if (rc) PLOGERR (klogErr, (klogErr, rc, "Failed to parse destination path '$(path)'", "path=%s", dststr)); else { const KFile * srcfile; rc = VFSManagerOpenFileRead (mgr, &srcfile, srcpath); if (rc) PLOGERR (klogErr, (klogErr, rc, "Failed to open source path '$(path)'", "path=%s", srcstr)); else { KFile * dstfile; rc = VFSManagerCreateFile (mgr, &dstfile, false, 0666, kcmParents | (force ? kcmInit : kcmCreate), dstpath); if (rc) PLOGERR (klogErr, (klogErr, rc, "failed to open destination path '$(path)'", "path=%s", dststr)); else { rc = copy_file (srcstr, dststr, srcfile, dstfile); if (rc) { PLOGERR (klogErr, (klogErr, rc, "failed to copy '$(S)' to '$(D)'", "S=%s,D=%s", srcstr, dststr)); VFSManagerRemove (mgr, true, dstpath); } KFileRelease (dstfile); } KFileRelease (srcfile); } VPathRelease (dstpath); } VPathRelease (srcpath); } VFSManagerRelease (mgr); } return rc; }
static rc_t VCursorFlushPageInt ( VCursor *self ) { rc_t rc; if ( self == NULL ) rc = RC ( rcVDB, rcCursor, rcFlushing, rcSelf, rcNull ); else if ( self -> read_only ) rc = RC ( rcVDB, rcCursor, rcFlushing, rcCursor, rcReadonly ); else { int64_t end_id; #if ! VCURSOR_FLUSH_THREAD run_trigger_prod_data pb; #endif switch ( self -> state ) { case vcConstruct: rc = RC ( rcVDB, rcCursor, rcFlushing, rcCursor, rcNotOpen ); break; case vcFailed: rc = RC ( rcVDB, rcCursor, rcFlushing, rcCursor, rcInvalid ); break; case vcRowOpen: rc = RC ( rcVDB, rcCursor, rcFlushing, rcCursor, rcBusy ); break; default: /* ignore request if there is no page to commit */ if ( self -> start_id == self -> end_id ) { /* the cursor should be in unwritten state, where the row_id can be reset but drags along the other markers. */ assert ( self -> end_id == self -> row_id ); return 0; } #if VCURSOR_FLUSH_THREAD MTCURSOR_DBG (( "VCursorFlushPageInt: going to acquire lock\n" )); /* get lock */ rc = KLockAcquire ( self -> flush_lock ); if ( rc != 0 ) return rc; MTCURSOR_DBG (( "VCursorFlushPageInt: have lock\n" )); /* make sure that background thread is ready */ while ( self -> flush_state == vfBusy ) { MTCURSOR_DBG (( "VCursorFlushPageInt: waiting for background thread\n" )); rc = KConditionWait ( self -> flush_cond, self -> flush_lock ); if ( rc != 0 ) { LOGERR ( klogSys, rc, "VCursorFlushPageInt: wait failed - exiting" ); KLockUnlock ( self -> flush_lock ); return rc; } } if ( self -> flush_state != vfReady ) { if ( self -> flush_state != vfBgErr ) rc = RC ( rcVDB, rcCursor, rcFlushing, rcCursor, rcInconsistent ); else { rc_t rc2; MTCURSOR_DBG (( "VCursorFlushPageInt: waiting on thread to exit\n" )); rc = KThreadWait ( self -> flush_thread, & rc2 ); if ( rc == 0 ) { rc = rc2; MTCURSOR_DBG (( "VCursorFlushPageInt: releasing thread\n" )); KThreadRelease ( self -> flush_thread ); self -> flush_thread = NULL; } } PLOGERR ( klogInt, (klogInt, rc, "VCursorFlushPageInt: not in ready state[$(state)] - exiting","state=%hu",self -> flush_state )); KLockUnlock ( self -> flush_lock ); return rc; } MTCURSOR_DBG (( "VCursorFlushPageInt: running buffer page\n" )); #endif /* first, tell all columns to bundle up their pages into buffers */ end_id = self -> end_id; rc = RC ( rcVDB, rcCursor, rcFlushing, rcMemory, rcExhausted ); if ( VectorDoUntil ( & self -> row, false, WColumnBufferPage, & end_id ) ) { VectorForEach ( & self -> row, false, WColumnDropPage, NULL ); self -> flush_state = vfFgErr; } else { /* supposed to be constant */ assert ( end_id == self -> end_id ); #if VCURSOR_FLUSH_THREAD MTCURSOR_DBG (( "VCursorFlushPageInt: pages buffered - capturing id and count\n" )); self -> flush_id = self -> start_id; self -> flush_cnt = self -> end_id - self -> start_id; self -> start_id = self -> end_id; self -> end_id = self -> row_id + 1; self -> state = vcReady; MTCURSOR_DBG (( "VCursorFlushPageInt: state set to busy - signaling bg thread\n" )); self -> flush_state = vfBusy; rc = KConditionSignal ( self -> flush_cond ); if ( rc != 0 ) LOGERR ( klogSys, rc, "VCursorFlushPageInt: condition returned error on signal" ); #else /* run all validation and trigger productions */ pb . id = self -> start_id; pb . cnt = self -> end_id - self -> start_id; pb . rc = 0; if ( ! VectorDoUntil ( & self -> trig, false, run_trigger_prods, & pb ) ) { self -> start_id = self -> end_id; self -> end_id = self -> row_id + 1; self -> state = vcReady; } rc = pb . rc; /* drop page buffers */ VectorForEach ( & self -> row, false, WColumnDropPage, NULL ); #endif } #if VCURSOR_FLUSH_THREAD MTCURSOR_DBG (( "VCursorFlushPageInt: unlocking\n" )); KLockUnlock ( self -> flush_lock ); #endif } } return rc; }
static rc_t copy_file (const char * src, const char * dst, const KFile * fin, KFile *fout) { rc_t rc; uint8_t buff [64 * 1024]; size_t num_read; uint64_t inpos; uint64_t outpos; assert (src); assert (dst); assert (fin); assert (fout); inpos = 0; outpos = 0; #if 1 for (inpos = 0; ; inpos += num_read) { rc = Quitting (); if (rc) { LOGMSG (klogFatal, "Received quit"); break; } else { rc = KFileReadAll (fin, inpos, buff, sizeof (buff), &num_read); if (rc) { PLOGERR (klogErr, (klogErr, rc, "Failed to read from file $(F) at $(P)", "F=%s,P=%lu", src, inpos)); break; } else if (num_read) { size_t num_writ; rc = KFileWriteAll (fout, inpos, buff, num_read, &num_writ); if (rc) { PLOGERR (klogErr, (klogErr, rc, "Failed to write to file $(F) at $(P)", "F=%s,P=%lu", dst, outpos)); break; } else if (num_writ != num_read) { rc = RC (rcExe, rcFile, rcWriting, rcFile, rcInsufficient); PLOGERR (klogErr, (klogErr, rc, "Failed to write all to file $(F) at $(P)", "F=%s,P=%lu", dst, outpos)); break; } } else break; } } #else do { rc = Quitting (); if (rc) { LOGMSG (klogFatal, "Received quit"); break; } rc = KFileRead (fin, inpos, buff, sizeof (buff), &num_read); if (rc) { PLOGERR (klogErr, (klogErr, rc, "Failed to read from file $(F) at $(P)", "F=%s,P=%lu", src, inpos)); break; } else if (num_read > 0) { size_t to_write; inpos += (uint64_t)num_read; STSMSG (2, ("Read %zu bytes to %lu", num_read, inpos)); to_write = num_read; while (to_write > 0) { size_t num_writ; rc = KFileWrite (fout, outpos, buff, num_read, &num_writ); if (rc) { PLOGERR (klogErr, (klogErr, rc, "Failed to write to file $(F) at $(P)", "F=%s,P=%lu", dst, outpos)); break; } outpos += num_writ; to_write -= num_writ; } } if (rc) break; } while (num_read != 0); #endif return rc; }
rc_t CC VPathTransformSysPath (VPath * self) { char * pc; size_t lim; size_t ix; rc_t rc = 0; pc = (char *)(self->path.addr); lim = StringSize (&self->path); if (lim == 0) return 0; /* ----- * toss out windows/dos device names */ for (ix = 0; reserved_device_names[ix] != NULL; ++ix) if (strcmp (reserved_device_names[ix], pc) == 0) return RC (rcFS, rcPath, rcConstructing, rcPath, rcIncorrect); /* ----- * look for for mingw and cygwin full paths and make them windowish * NOTE we could screw things up here with bad strings like * /cygdrive/haha/fooled-you */ if (pc[0] == '/') { static const char cygdrive [] = "/cygdrive/"; if (strncmp (pc, cygdrive, sizeof cygdrive - 1) == 0) { pc += sizeof cygdrive - 2; lim -= sizeof cygdrive - 2; /* NOTE: if the macro changes this could fail! */ StringInit (&self->path, pc, StringSize(&self->path) - sizeof cygdrive - 2, StringLength(&self->path) - sizeof cygdrive - 2); } /* if here we had a mingw or cygwin specification */ if (isalpha (pc[1]) && (pc[2] == '/')) { /* change it back to a windows specification */ pc[0] = pc[1]; pc[1] = ':'; } } /* change from Windows '/' to posix '/' segment dividers */ for (ix = 0; ix < lim; ++ix) if (pc [ix] == '\\') pc [ix] = '/'; /* look for stray ':' characters */ for (ix = 0; ix < lim; ++ix) { if (pc[ix] == ':') { rc = RC (rcFS, rcPath, rcConstructing, rcPath, rcInvalid); PLOGERR (klogErr, (klogErr, rc, "incorrect use of ':' in path '$(path)'", "path=%s", pc)); return rc; } if (ix == 0) ++ix; } if ((lim > 1) && (pc[1] == ':')) { if (!isalpha (pc[0])) { rc = RC (rcFS, rcPath, rcConstructing, rcPath, rcInvalid); PLOGERR (klogErr, (klogErr, rc, "invalid character as drive letter '$(c)' ($(d)) in path '$(S)'", "c=%c,d=%d,s=%s",pc[0],pc[0],pc)); return rc; } /* we don't support drive relative addressing at this point * we should correct this in the future */ if (pc[2] != '/') { rc = RC (rcFS, rcPath, rcConstructing, rcPath, rcIncorrect); PLOGERR (klogErr, (klogErr, rc, "drive relative addressing not currently supported '$(path)'", "path=%s", pc)); return rc; } } if ((pc[0] == '/') && (pc[1] == '/')) /* UNC form */ { if (pc[2] == '.') /* device space name - we don't handle these */ return RC (rcFS, rcPath, rcConstructing, rcPath, rcIncorrect); if (pc[2] == '?') /* special space name - we don't handle these */ return RC (rcFS, rcPath, rcConstructing, rcPath, rcIncorrect); } /* possible future stuff? */ #if DO_MORE_STUFF_TO_VALIDATE_PATH /* ----- * this size thing is turned off to allow paths into archives */ ix = string_size (ipc = inpath); if (ix > MAX_PATH) return RC (rcFS, rcPath, rcConstructing, rcPath, rcTooLong); { DWORD insize = ilen; DWORD outlen; outlen = GetFullPathNameA (ipc, (DWORD)sizeof (temp), temp, NULL); if (outlen == 0) return RC (rcFS, rcPath, rcConstructing, rcPath, rcInvalid); if (outlen > sizeof temp) return RC (rcFS, rcPath, rcConstructing, rcPath, rcTooShort); ipc = temp; opc[0] = '/'; opc[1] = ipc [0]; ix = jx = 2; } do { switch (ipc[ix]) { case '\0': normalize_done = true; /* fall through */ default: opc[jx++] = ipc[ix++]; break; case '\\': opc[jx++] = '/'; ++ix; break; case '\x1': /* never allowed */ case '\x2': case '\x3': case '\x4': case '\x5': case '\x6': case '\x7': case '\x8': case '\x9': case '\xA': case '\xB': case '\xC': case '\xD': case '\xE': case '\xF': case '\x10': case '\x11': case '\x12': case '\x13': case '\x14': case '\x15': case '\x16': case '\x17': case '\x18': case '\x19': case '\x1A': case '\x1B': case '\x1C': case '\x1D': case '\x1E': case '\x1F': case ':': case '<': case '>': case '"': case '|': case '*': case '?': rc = RC (rcFS, rcPath, rcConstructing, rcPath, rcInvalid); PLOGERR (klogErr, (klogErr, rc, "invalid character '$(c)' ($(d)) in path '$(s)'", "c=%c,d=%d,s=%s",ipc[ix],ipc[ix],ipc)); return rc; } } while (!normalize_done); self->asciz_size = ix - 1; #endif /* put drive based paths (back?) into our form */ if ((lim > 1) && (pc[1] == ':')) { pc[1] = pc[0]; pc[0] = '/'; self->scheme = vpuri_ncbi_vfs; } return 0; }
rc_t CC KMain(int argc, char* argv[]) { const char table[] = "/home/klymenka/REDACT-IN"; const char name[] = "READ_FILTER"; rc_t rc = 0; bool locked = false; VDBManager* mgr; VTable *tbl; const VCursor *rCursor = NULL; int i; LogLevelSet("info"); for (i = 1; i < argc; ++i) { if (!strcmp(argv[i], "-+")) { if (++i <= argc) { #if _DEBUGGING KDbgSetString(argv[i]); #endif } } } /*KDbgSetString("VDB");*/ if (rc == 0) { /* +01: ManagerMake */ LOGMSG(klogInfo, "VDBManagerMakeUpdate"); rc = VDBManagerMakeUpdate(&mgr, NULL); DISP_RC_INT(rc, "while calling VDBManagerMakeUpdate"); } if (rc == 0) { rc = VDBManagerWritable(mgr, "%s", table); if (GetRCState(rc) == rcLocked) { LOGMSG(klogInfo, "VDBManagerUnlock"); rc = VDBManagerUnlock(mgr, "%s", table); DISP_RC_INT(rc, "while calling VDBManagerUnlock"); locked = true; } } if (rc == 0) { /* +02: OpenTable */ PLOGMSG(klogInfo, (klogInfo, "VDBManagerOpenTableUpdate(\"$(t)\")", "t=%s", table)); rc = VDBManagerOpenTableUpdate (mgr, &tbl, NULL, "%s", table); if (rc != 0) { PLOGERR(klogErr, (klogErr, rc, "while opening VTable '$(path)'", "path=%s", table)); } } if (rc == 0) { /* +03: CreateCursorRead */ LOGMSG(klogInfo, "VDBManagerUnlock"); rc = VTableCreateCursorRead(tbl, &rCursor); DISP_RC_INT(rc, "while creating read cursor"); #if 1 if (rc == 0) { uint32_t idx; PLOGMSG(klogInfo, (klogInfo, "VCursorAddColumn(read cursor, \"$(n)\")", "n=%s", name)); rc = VCursorAddColumn(rCursor, &idx, "%s", name); if (rc != 0) { PLOGERR(klogErr, (klogErr, rc, "while adding $(name) to read cursor", "name=%s", name)); } } #endif if (rc == 0) { LOGMSG(klogInfo, "VCursorOpen(read cursor)"); rc = VCursorOpen(rCursor); DISP_RC_INT(rc, "while opening read cursor"); } } if (rc == 0) { VCursor *cursor; uint32_t idx; /* +04: CreateCursorWrite */ LOGMSG(klogInfo, "VTableCreateCursorWrite"); rc = VTableCreateCursorWrite(tbl, &cursor, kcmInsert); DISP_RC_INT(rc, "while creating write cursor"); if (rc == 0) { PLOGMSG(klogInfo, (klogInfo, "VCursorAddColumn(write cursor, \"$(n)\")", "n=%s", name)); rc = VCursorAddColumn(cursor, &idx, "%s", name); if (rc != 0) { PLOGERR(klogErr, (klogErr, rc, "while adding $(name) to write cursor", "name=%s", name)); } } if (rc == 0) { LOGMSG(klogInfo, "VCursorOpen(write cursor)"); rc = VCursorOpen(cursor); DISP_RC_INT(rc, "while opening write cursor"); } #if 1 for (i = 0; i < 3 && rc == 0; ++i) { if (rc == 0) { PLOGMSG(klogInfo, (klogInfo, "VCursorOpenRow(write cursor) $(i)", "i=%d", i)); rc = VCursorOpenRow(cursor); DISP_RC_INT(rc, "while opening row to write"); } if (rc == 0) { char buffer[1]; char b; switch (i) { case 0: buffer[0] = SRA_READ_FILTER_CRITERIA; buffer[0] = SRA_READ_FILTER_REJECT; break; case 1: buffer[0] = SRA_READ_FILTER_REJECT; buffer[0] = SRA_READ_FILTER_CRITERIA; break; case 2: buffer[0] = SRA_READ_FILTER_REDACTED; break; } buffer[0] = SRA_READ_FILTER_PASS; b = buffer[0]; PLOGMSG(klogInfo, (klogInfo, "VCursorWrite('$(v)') $(i)", "v=%s,i=%d", b == SRA_READ_FILTER_REDACTED ? "SRA_READ_FILTER_REDACTED" : "?", i)); rc = VCursorWrite(cursor, idx, 8, buffer, 0, 1); DISP_RC_INT(rc, "while writing"); } if (rc == 0) { PLOGMSG(klogInfo, (klogInfo, "VCursorCommitRow(write cursor) $(i)", "i=%d", i)); rc = VCursorCommitRow(cursor); DISP_RC_INT(rc, "while committing row"); } PLOGMSG(klogInfo, (klogInfo, "VCursorCloseRow(write cursor) $(i)", "i=%d", i)); { rc_t rc2 = VCursorCloseRow(cursor); DISP_RC_INT(rc2, "while closing row"); if (rc == 0) { rc = rc2; } } } #endif LOGMSG(klogInfo, "VCursorRelease(read cursor)"); /* -03: CreateCursorRead */ VCursorRelease(rCursor); if (rc == 0) { LOGMSG(klogInfo, "VCursorCommit(write cursor)"); rc = VCursorCommit(cursor); DISP_RC_INT(rc, "while committing cursor"); } LOGMSG(klogInfo, "VCursorRelease(write cursor)"); /* -04: CreateCursorWrite */ VCursorRelease(cursor); } LOGMSG(klogInfo, "VTableRelease"); /* -02: OpenTable */ VTableRelease(tbl); LOGMSG(klogInfo, "VDBManagerLock"); if (locked) { rc_t rc2 = VDBManagerLock(mgr, "%s", table); DISP_RC_INT(rc2, "while VDBManagerLock"); } /* -01: ManagerMake */ LOGMSG(klogInfo, "VDBManagerRelease"); VDBManagerRelease(mgr); if (rc == 0) { LOGMSG(klogInfo, "SUCCESS"); } else { LOGMSG(klogInfo, "FAILURE"); } return rc; }
static rc_t run() { KRng * rng; rc_t rc; rc = KCSPRngMake (&rng); if (rc) LOGERR (klogErr, rc, "failed to make RNG"); else { uint32_t ix; OUTMSG (("KCSPRng with no seed\n")); for (ix = 0; ix < 10; ++ix) { uint8_t buff [8]; uint32_t num_read; rc = KRngRead (rng, buff, sizeof (buff), &num_read); if (rc) PLOGERR (klogErr, (klogErr, rc, "error in read '$u' from KRng", "u=%lu", ix)); else { OUTMSG (( "%4.4d: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n", ix, buff[0], buff[1], buff[2], buff[3], buff[4], buff[5], buff[6], buff[7])); } } KRngRelease (rng); rc = KCSPRngMake (&rng); if (rc) LOGERR (klogErr, rc, "failed to make RNG"); else { uint32_t ix; /* this is using system seed from us */ rc = KRngSeed (rng); if (rc) LOGERR (klogErr, rc, "error running KRngSeed"); else { OUTMSG (("KCSPRng with seed\n")); for (ix = 0; ix < 10; ++ix) { uint8_t buff [8]; uint32_t num_read; rc = KRngRead (rng, buff, sizeof (buff), &num_read); if (rc) PLOGERR (klogErr, (klogErr, rc, "error in read '$u' from KRng", "u=%lu", ix)); else { OUTMSG (( "%4.4d: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n", ix, buff[0], buff[1], buff[2], buff[3], buff[4], buff[5], buff[6], buff[7])); } } { uint8_t reseed [1024]; reseed[0] = 0xAA; for (ix = 1; ix < sizeof (reseed); ++ix) reseed[ix] = reseed[ix-1] ^ (uint8_t)ix; /* this is using reseed from us */ rc = KRngReseed (rng, reseed, sizeof (reseed)); if (rc) LOGERR (klogErr, rc, "error running KRngReseed"); else { OUTMSG (("KCSPRng with reseed\n")); for (ix = 0; ix < 10; ++ix) { uint8_t buff [8]; uint32_t num_read; rc = KRngRead (rng, buff, sizeof (buff), &num_read); if (rc) PLOGERR (klogErr, (klogErr, rc, "error in read '$u' from KRng", "u=%lu", ix)); else { OUTMSG (( "%4.4d: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n", ix, buff[0], buff[1], buff[2], buff[3], buff[4], buff[5], buff[6], buff[7])); } } } } } KRngRelease (rng); } } return 0; }
static rc_t KBZipFileReadInt (KBZipFile * self, void * buffer, size_t bsize, size_t * pnumread) { bz_stream temp; /* store some values here during a reinit after stream end */ bz_stream * strm; /* alias for the object's bzip stream object */ size_t bleft = bsize; size_t num_read; size_t tot_read = 0; rc_t rc = 0; BZIP_DEBUG (("---------------\n%s: Enter requesting bsize %lu\n", __func__, bsize)); strm = &self->strm; for (tot_read = 0; tot_read < bsize ; ) { char * this_out; size_t src_read; int zret; bool bin; bool bout; bool end; bin = (strm->avail_in != 0); BZIP_DEBUG (("%s: loop start tot_read %zu\n", __func__, tot_read)); strm->next_out = this_out = (char*)buffer + tot_read; strm->avail_out = bsize - tot_read; BZIP_DEBUG(("%s: call Decompress\n", __func__)); BZIP_DBGSTREAM (strm, "before BZ2_bzDecompress"); zret = BZ2_bzDecompress(strm); BZIP_DBGSTREAM (strm, "after BZ2_bzDecompress"); switch (zret) { /* unexpected error returns from zlib */ default: BZIP_DEBUG (("%s: undocumented error return in bzip Decompress\n", __func__)); rc = RC (rcFS, rcFile, rcReading, rcFile, rcUnknown); PLOGERR (klogErr, (klogErr, rc, "unknown error decompressing BZip2 file " "error code '$(EC)'", "EC=%d", zret)); return rc; /* known unfixable errors */ case BZ_PARAM_ERROR: BZIP_DEBUG (("%s: internal programming error - bad parameters\n", __func__)); rc = RC (rcFS, rcFile, rcReading, rcSelf, rcInvalid); if (strm == NULL) BZIP_DEBUG (("%s: strm is NULL\n", __func__)); else { if (strm->state == NULL) BZIP_DEBUG (("%s: strm->state is NULL\n", __func__)); if (strm->avail_out < 1) BZIP_DEBUG (("%s: strm->avail_out < 1\n", __func__)); } LOGERR (klogInt, rc, "bzip strm structure bad"); return rc; case BZ_DATA_ERROR: BZIP_DEBUG (("%s: data integrity error in bzip stream\n", __func__)); rc = RC (rcFS, rcFile, rcReading, rcData, rcCorrupt); LOGERR (klogErr, rc, "bzip stream data error"); return rc; case BZ_DATA_ERROR_MAGIC: BZIP_DEBUG (("%s: data magic bytes error in bzip stream\n", __func__)); rc = RC (rcFS, rcFile, rcReading, rcData, rcIncorrect); LOGERR (klogErr, rc, "bzip stream not a bzip stream"); return rc; case BZ_MEM_ERROR: BZIP_DEBUG (("%s: memory exhausted during BZip decompress\n", __func__)); rc = RC (rcFS, rcFile, rcReading, rcMemory, rcExhausted); LOGERR (klogErr, rc, "not enough memory available during bzip decompress"); return rc; case BZ_STREAM_END: BZIP_DEBUG (("%s: BZ_STREAM_END\n", __func__)); end = true; num_read = strm->next_out - this_out; bout = (num_read != 0); BZIP_DEBUG (("%s: num_read %zu\n", __func__, num_read)); self->completed = true; BZIP_DBGSTREAM (strm, "before BZ2_bzDecompressEnd"); zret = BZ2_bzDecompressEnd(strm); BZIP_DBGSTREAM (strm, "after BZ2_bzDecompressEnd"); if (zret == BZ_OK) { temp = *strm; memset (strm, 0, sizeof *strm); zret = BZ2_bzDecompressInit (strm, 1, 0); BZIP_DBGSTREAM (strm, "after BZ2_bzDecompressInit"); strm->next_in = temp.next_in; strm->avail_in = temp.avail_in; /* strm->next_out = temp.next_out; */ /* strm->avail_out = temp.avail_out; */ strm->total_in_lo32 = temp.total_in_lo32; strm->total_in_hi32 = temp.total_in_hi32; strm->total_out_lo32 = temp.total_out_lo32; strm->total_out_hi32 = temp.total_out_hi32; BZIP_DBGSTREAM (strm, "after restore"); } switch (zret) { case BZ_OK: break; default: return RC (rcFS, rcFile, rcReading, rcFile, rcUnknown); } goto read_more; case BZ_OK: BZIP_DEBUG (("%s: BZ_OK\n", __func__)); end = false; num_read = strm->next_out - this_out; bout = (num_read != 0); BZIP_DEBUG (("%s: num_read %zu\n", __func__, num_read)); read_more: /* if we wanted more on this read, read some more compressed */ tot_read += num_read; if (strm->avail_in == 0) { rc = KFileRead (self->file, self->filePosition, self->buff, sizeof self->buff, &src_read); if (rc) return rc; BZIP_DEBUG (("%s: KFileRead read %u\n", __func__, src_read)); if (src_read == 0) { BZIP_DEBUG (("%s: end %u in %u out %u\n", __func__, end, bin, bout)); if (!end && bin && !bout) rc = RC (rcFS, rcFile, rcReading, rcData, rcInsufficient); goto done; } strm->avail_in = src_read; self->filePosition += src_read; strm->next_in = self->buff; /* if src_read == 0 but we are not at BZ_STREAM_END * we have an error */ if (src_read == 0) bleft = 0; } break; } if (rc) break; BZIP_DEBUG (("%s: loop end tot_read %zu\n", __func__, tot_read)); } done: BZIP_DEBUG (("%s: returning tot_read %zu\n\n\n", __func__, tot_read)); *pnumread = tot_read; return rc; }