void QuickView::ShowFile(const string& FileName, bool TempFile, PluginHandle* hDirPlugin) { CloseFile(); if (!IsVisible()) return; if (FileName.empty()) { ProcessingPluginCommand++; Show(); ProcessingPluginCommand--; return; } string FileFullName = FileName; if (!hDirPlugin) ConvertNameToFull(FileFullName, FileFullName); bool SameFile = strCurFileName == FileFullName; strCurFileName = FileFullName; size_t pos = strCurFileName.rfind(L'.'); if (pos != string::npos) { string strValue; if (GetShellType(strCurFileName.data()+pos, strValue)) { api::reg::GetValue(HKEY_CLASSES_ROOT, strValue, L"", strCurFileType); } } if (hDirPlugin || api::fs::is_directory(strCurFileName)) { // Не показывать тип файла для каталогов в "Быстром просмотре" strCurFileType.clear(); if (SameFile && !hDirPlugin) { Directory=1; } else if (hDirPlugin) { int ExitCode=GetPluginDirInfo(hDirPlugin,strCurFileName,Data.DirCount, Data.FileCount,Data.FileSize,Data.AllocationSize); Directory = (ExitCode ? 4 : 3); uncomplete_dirscan = (ExitCode == 0); } else { int ExitCode=GetDirInfo(MSG(MQuickViewTitle), strCurFileName, Data, getdirinfo_default_delay, nullptr, GETDIRINFO_ENHBREAK|GETDIRINFO_SCANSYMLINKDEF|GETDIRINFO_NOREDRAW); Directory = (ExitCode == -1 ? 2 : 1); // ExitCode: 1=done; 0=Esc,CtrlBreak; -1=Other uncomplete_dirscan = ExitCode != 1; } } else { if (!strCurFileName.empty()) { QView.reset(new Viewer(GetOwner(), true)); QView->SetRestoreScreenMode(false); QView->SetPosition(m_X1+1,m_Y1+1,m_X2-1,m_Y2-3); QView->SetStatusMode(0); QView->EnableHideCursor(0); OldWrapMode = QView->GetWrapMode(); OldWrapType = QView->GetWrapType(); QView->SetWrapMode(LastWrapMode); QView->SetWrapType(LastWrapType); QView->OpenFile(strCurFileName,FALSE); } } if (this->Destroyed()) return; m_TemporaryFile = TempFile; Redraw(); if (Parent()->ActivePanel() == this) { DynamicUpdateKeyBar(); Parent()->GetKeybar().Redraw(); } }
short file_close(FILEH handle) { CloseFile(handle); return(0); }
stat_record_t process_data(char *wfile, int element_stat, int flow_stat, int sort_flows, printer_t print_header, printer_t print_record, time_t twin_start, time_t twin_end, uint64_t limitflows, int tag, int compress, int do_xstat) { common_record_t *flow_record; master_record_t *master_record; nffile_t *nffile_w, *nffile_r; xstat_t *xstat; stat_record_t stat_record; int done, write_file; #ifdef COMPAT15 int v1_map_done = 0; #endif // time window of all matched flows memset((void *)&stat_record, 0, sizeof(stat_record_t)); stat_record.first_seen = 0x7fffffff; stat_record.msec_first = 999; // Do the logic first // print flows later, when all records are processed and sorted // flow limits apply at that time if ( sort_flows ) { print_record = NULL; limitflows = 0; } // do not print flows when doing any stats if ( flow_stat || element_stat ) { print_record = NULL; limitflows = 0; } // do not write flows to file, when doing any stats // -w may apply for flow_stats later write_file = !(sort_flows || flow_stat || element_stat) && wfile; nffile_r = NULL; nffile_w = NULL; xstat = NULL; // Get the first file handle nffile_r = GetNextFile(NULL, twin_start, twin_end); if ( !nffile_r ) { LogError("GetNextFile() error in %s line %d: %s\n", __FILE__, __LINE__, strerror(errno) ); return stat_record; } if ( nffile_r == EMPTY_LIST ) { LogError("Empty file list. No files to process\n"); return stat_record; } // preset time window of all processed flows to the stat record in first flow file t_first_flow = nffile_r->stat_record->first_seen; t_last_flow = nffile_r->stat_record->last_seen; // store infos away for later use // although multiple files may be processed, it is assumed that all // have the same settings is_anonymized = IP_ANONYMIZED(nffile_r); strncpy(Ident, nffile_r->file_header->ident, IDENTLEN); Ident[IDENTLEN-1] = '\0'; // prepare output file if requested if ( write_file ) { nffile_w = OpenNewFile(wfile, NULL, compress, IP_ANONYMIZED(nffile_r), NULL ); if ( !nffile_w ) { if ( nffile_r ) { CloseFile(nffile_r); DisposeFile(nffile_r); } return stat_record; } if ( do_xstat ) { xstat = InitXStat(nffile_w); if ( !xstat ) { if ( nffile_r ) { CloseFile(nffile_r); DisposeFile(nffile_r); } return stat_record; } } } // setup Filter Engine to point to master_record, as any record read from file // is expanded into this record // Engine->nfrecord = (uint64_t *)master_record; done = 0; while ( !done ) { int i, ret; // get next data block from file ret = ReadBlock(nffile_r); switch (ret) { case NF_CORRUPT: case NF_ERROR: if ( ret == NF_CORRUPT ) LogError("Skip corrupt data file '%s'\n",GetCurrentFilename()); else LogError("Read error in file '%s': %s\n",GetCurrentFilename(), strerror(errno) ); // fall through - get next file in chain case NF_EOF: { nffile_t *next = GetNextFile(nffile_r, twin_start, twin_end); if ( next == EMPTY_LIST ) { done = 1; } else if ( next == NULL ) { done = 1; LogError("Unexpected end of file list\n"); } else { // Update global time span window if ( next->stat_record->first_seen < t_first_flow ) t_first_flow = next->stat_record->first_seen; if ( next->stat_record->last_seen > t_last_flow ) t_last_flow = next->stat_record->last_seen; // continue with next file } continue; } break; // not really needed default: // successfully read block total_bytes += ret; } #ifdef COMPAT15 if ( nffile_r->block_header->id == DATA_BLOCK_TYPE_1 ) { common_record_v1_t *v1_record = (common_record_v1_t *)nffile_r->buff_ptr; // create an extension map for v1 blocks if ( v1_map_done == 0 ) { extension_map_t *map = malloc(sizeof(extension_map_t) + 2 * sizeof(uint16_t) ); if ( ! map ) { LogError("malloc() allocation error in %s line %d: %s\n", __FILE__, __LINE__, strerror(errno) ); exit(255); } map->type = ExtensionMapType; map->size = sizeof(extension_map_t) + 2 * sizeof(uint16_t); if (( map->size & 0x3 ) != 0 ) { map->size += 4 - ( map->size & 0x3 ); } map->map_id = INIT_ID; map->ex_id[0] = EX_IO_SNMP_2; map->ex_id[1] = EX_AS_2; map->ex_id[2] = 0; map->extension_size = 0; map->extension_size += extension_descriptor[EX_IO_SNMP_2].size; map->extension_size += extension_descriptor[EX_AS_2].size; if ( Insert_Extension_Map(extension_map_list,map) && write_file ) { // flush new map AppendToBuffer(nffile_w, (void *)map, map->size); } // else map already known and flushed v1_map_done = 1; } // convert the records to v2 for ( i=0; i < nffile_r->block_header->NumRecords; i++ ) { common_record_t *v2_record = (common_record_t *)v1_record; Convert_v1_to_v2((void *)v1_record); // now we have a v2 record -> use size of v2_record->size v1_record = (common_record_v1_t *)((pointer_addr_t)v1_record + v2_record->size); } nffile_r->block_header->id = DATA_BLOCK_TYPE_2; } #endif if ( nffile_r->block_header->id == Large_BLOCK_Type ) { // skip printf("Xstat block skipped ...\n"); continue; } if ( nffile_r->block_header->id != DATA_BLOCK_TYPE_2 ) { if ( nffile_r->block_header->id == DATA_BLOCK_TYPE_1 ) { LogError("Can't process nfdump 1.5.x block type 1. Add --enable-compat15 to compile compatibility code. Skip block.\n"); } else { LogError("Can't process block type %u. Skip block.\n", nffile_r->block_header->id); } skipped_blocks++; continue; } flow_record = nffile_r->buff_ptr; for ( i=0; i < nffile_r->block_header->NumRecords; i++ ) { switch ( flow_record->type ) { case CommonRecordType: { int match; uint32_t map_id = flow_record->ext_map; generic_exporter_t *exp_info = exporter_list[flow_record->exporter_sysid]; if ( map_id >= MAX_EXTENSION_MAPS ) { LogError("Corrupt data file. Extension map id %u too big.\n", flow_record->ext_map); exit(255); } if ( extension_map_list->slot[map_id] == NULL ) { LogError("Corrupt data file. Missing extension map %u. Skip record.\n", flow_record->ext_map); flow_record = (common_record_t *)((pointer_addr_t)flow_record + flow_record->size); continue; } total_flows++; master_record = &(extension_map_list->slot[map_id]->master_record); Engine->nfrecord = (uint64_t *)master_record; ExpandRecord_v2( flow_record, extension_map_list->slot[map_id], exp_info ? &(exp_info->info) : NULL, master_record); // Time based filter // if no time filter is given, the result is always true match = twin_start && (master_record->first < twin_start || master_record->last > twin_end) ? 0 : 1; match &= limitflows ? stat_record.numflows < limitflows : 1; // filter netflow record with user supplied filter if ( match ) match = (*Engine->FilterEngine)(Engine); if ( match == 0 ) { // record failed to pass all filters // increment pointer by number of bytes for netflow record flow_record = (common_record_t *)((pointer_addr_t)flow_record + flow_record->size); // go to next record continue; } // Records passed filter -> continue record processing // Update statistics UpdateStat(&stat_record, master_record); // update number of flows matching a given map extension_map_list->slot[map_id]->ref_count++; if ( flow_stat ) { AddFlow(flow_record, master_record, extension_map_list->slot[map_id]); if ( element_stat ) { AddStat(flow_record, master_record); } } else if ( element_stat ) { AddStat(flow_record, master_record); } else if ( sort_flows ) { InsertFlow(flow_record, master_record, extension_map_list->slot[map_id]); } else { if ( write_file ) { AppendToBuffer(nffile_w, (void *)flow_record, flow_record->size); if ( xstat ) UpdateXStat(xstat, master_record); } else if ( print_record ) { char *string; // if we need to print out this record print_record(master_record, &string, tag); if ( string ) { if ( limitflows ) { if ( (stat_record.numflows <= limitflows) ) printf("%s\n", string); } else printf("%s\n", string); } } else { // mutually exclusive conditions should prevent executing this code // this is buggy! printf("Bug! - this code should never get executed in file %s line %d\n", __FILE__, __LINE__); } } // sort_flows - else } break; case ExtensionMapType: { extension_map_t *map = (extension_map_t *)flow_record; if ( Insert_Extension_Map(extension_map_list, map) && write_file ) { // flush new map AppendToBuffer(nffile_w, (void *)map, map->size); } // else map already known and flushed } break; case ExporterRecordType: case SamplerRecordype: // Silently skip exporter records break; case ExporterInfoRecordType: { int ret = AddExporterInfo((exporter_info_record_t *)flow_record); if ( ret != 0 ) { if ( write_file && ret == 1 ) AppendToBuffer(nffile_w, (void *)flow_record, flow_record->size); } else { LogError("Failed to add Exporter Record\n"); } } break; case ExporterStatRecordType: AddExporterStat((exporter_stats_record_t *)flow_record); break; case SamplerInfoRecordype: { int ret = AddSamplerInfo((sampler_info_record_t *)flow_record); if ( ret != 0 ) { if ( write_file && ret == 1 ) AppendToBuffer(nffile_w, (void *)flow_record, flow_record->size); } else { LogError("Failed to add Sampler Record\n"); } } break; default: { LogError("Skip unknown record type %i\n", flow_record->type); } } // Advance pointer by number of bytes for netflow record flow_record = (common_record_t *)((pointer_addr_t)flow_record + flow_record->size); } // for all records // check if we are done, due to -c option if ( limitflows ) done = stat_record.numflows >= limitflows; } // while CloseFile(nffile_r); // flush output file if ( write_file ) { // flush current buffer to disc if ( nffile_w->block_header->NumRecords ) { if ( WriteBlock(nffile_w) <= 0 ) { LogError("Failed to write output buffer to disk: '%s'" , strerror(errno)); } } if ( xstat ) { if ( WriteExtraBlock(nffile_w, xstat->block_header ) <= 0 ) { LogError("Failed to write xstat buffer to disk: '%s'" , strerror(errno)); } } /* Stat info */ if ( write_file ) { /* Copy stat info and close file */ memcpy((void *)nffile_w->stat_record, (void *)&stat_record, sizeof(stat_record_t)); CloseUpdateFile(nffile_w, nffile_r->file_header->ident ); nffile_w = DisposeFile(nffile_w); } // else stdout } PackExtensionMapList(extension_map_list); DisposeFile(nffile_r); return stat_record; } // End of process_data
CFileInStream::~CFileInStream() { CloseFile(); }
vtkDCMParser::~vtkDCMParser() { CloseFile(); //delete [] aux_ret; }
AppenderFile::~AppenderFile() { CloseFile(); }
bool RPCFile::ChannelReader::ReadData(void* dest, uint64_t numBytes) { // When an error condition is encountered, m_file is set to NULL. if(!m_file) return false; uint64_t availOut = numBytes; char* writePtr = (char*)dest; uint64_t streamEnd = m_chanInfo->GetDataOffset() + m_chanInfo->GetCompressedSize(); while( (availOut > 0) && (m_readOffset < streamEnd) ) { // We need to position the read pointer each time to notify the file reader that we've // consumed the bytes returned by GetBuffer(). m_file->SetReadPtr(m_readOffset); // Get a pointer to the data present in the reader's cache. uint32_t bufferSize; m_inflateCtx.next_in = (const Bytef*)m_file->GetBuffer(&bufferSize); if(!m_inflateCtx.next_in) { CloseFile(); return false; } // Make sure we don't run past the end of the channel. uint64_t availIn = streamEnd - m_readOffset; if(availIn > bufferSize) availIn = bufferSize; m_inflateCtx.avail_in = (uInt)availIn; // zlib uses 32-bit sizes, so we need to clamp the size in case somebody really wants to // read more than 4 GB in one go. This isn't a problem for availIn because bufferSize is 32-bit. m_inflateCtx.avail_out = (uInt)((availOut < UINT_MAX) ? availOut : UINT_MAX); m_inflateCtx.next_out = (Bytef*)writePtr; int inflateResult = inflate(&m_inflateCtx, Z_NO_FLUSH); if( (inflateResult != Z_OK) && (inflateResult != Z_STREAM_END) ) { CloseFile(); return false; } uint32_t readBytes = (uint32_t)(availIn - m_inflateCtx.avail_in); m_readOffset += readBytes; if( (m_readOffset == streamEnd) && (inflateResult != Z_STREAM_END) ) { // We've reached the end of the compressed data, but zlib doesn't think so. CloseFile(); return false; } if( (inflateResult == Z_STREAM_END) && (m_readOffset != streamEnd) ) { // zlib says the stream ended, but we have more data in the file. CloseFile(); return false; } uint64_t writtenBytes = availOut - m_inflateCtx.avail_out; writePtr += writtenBytes; availOut -= writtenBytes; } if(availOut > 0) { // If we reached the end of the stream without filling up the output buffer, it's // an error on the caller's side. CloseFile(); return false; } return true; }
cElCompileFN::~cElCompileFN() { CloseFile(); delete mNamesLoc; delete mDicSymb; }
void cElCompileFN::MakeFileCpp(std::vector<Fonc_Num> vFoncs,bool SpecFCUV) { SetFile("cpp","h"); int aDimOut = (int)vFoncs.size(); // Constructeur : (*this) << mNameClass << "::" << mNameClass << "():\n"; (*this) << " cElCompiledFonc(" << aDimOut << ")\n"; (*this) << "{\n"; const cMapIncInterv & aMap = mListInterv.Map(); for (tCSetIII itCur = aMap.begin() ; itCur != aMap.end() ; itCur++) { (*this) << " AddIntRef (cIncIntervale(" << "\"" << itCur->Id() << "\"" << "," << itCur->I0Alloc() << "," << itCur->I1Alloc() << "));\n"; } (*this) << " Close(false);\n"; (*this) << "}\n"; (*this) << "\n\n\n"; MakeFonc(vFoncs,0,SpecFCUV); MakeFonc(vFoncs,1,SpecFCUV); MakeFonc(vFoncs,2,SpecFCUV); // Calcul des Fonction SetVar (*this) << "\n"; for (cECFN_SetString::const_iterator it = mNamesLoc->begin(); it!=mNamesLoc->end() ; it++) { (*this) << "void " << mNameClass << "::Set"<< it->Name() << "(double aVal){ " << NameVarLoc(it->Name()) << " = aVal;}\n"; } (*this) << "\n\n\n"; // Fonction AdrVarLocFromString : (*this) << "double * " << mNameClass << "::AdrVarLocFromString(const std::string & aName)\n"; (*this) << "{\n"; { for (cECFN_SetString::const_iterator it = mNamesLoc->begin(); it!=mNamesLoc->end() ; it++) { (*this) << " if (aName == \"" << (it->Name()) << "\") return & " << NameVarLoc(it->Name()) << ";\n"; } } (*this) << " return 0;\n"; (*this) << "}\n\n\n"; (*this) << "cElCompiledFonc::cAutoAddEntry " << mNameClass << "::mTheAuto" << "(\"" << mNameClass << "\"," << mNameClass << "::Alloc);\n\n\n"; (*this) << "cElCompiledFonc * " << mNameClass << "::Alloc()\n"; (*this) << "{"; (*this) << " return new " << mNameClass << "();\n"; (*this) << "}\n\n\n"; CloseFile(); }
WavSplitWriter::~WavSplitWriter() { CloseFile(); }
int reduced_covers (FILE *descendant_file, FILE *covers_file, int k, int ***auts, struct pga_vars *pga, struct pcp_vars *pcp) { int lower_step, upper_step; int nmr_of_covers = 0; int *a, *b; /* arrays needed for orbit calculation */ char *c; /* array needed for stabiliser calculation */ int **perms; /* store all permutations */ int *orbit_length; /* length of orbits */ FILE * LINK_input; /* input file for GAP */ #if defined (GAP_LINK) Logical process_fork = FALSE; /* has GAP process forked? */ #endif Logical soluble_group; /* indicates that orbits and stabilisers may be computed using soluble machinery */ /* calculate the extended automorphisms */ extend_automorphisms (auts, pga->m, pcp); if (pcp->overflow) return 0; if (pga->print_extensions && pga->m != 0) { printf ("\nThe extension%s:\n", pga->m == 1 ? " is" : "s are"); print_auts (pga->m, pcp->lastg, auts, pcp); } /* find range of permitted step sizes */ step_range (k, &lower_step, &upper_step, auts, pga, pcp); /* set up space for definition sets */ store_definition_sets (pga->r, lower_step, upper_step, pga); /* loop over each permitted step size */ for (pga->s = lower_step; pga->s <= upper_step; ++pga->s) { if (pga->trace) trace_details (pga); get_definition_sets (pga); compute_degree (pga); /* establish which automorphisms induce the identity on the relevant subgroup of the p-multiplicator */ strip_identities (auts, pga, pcp); /* if possible, use the more efficient soluble code -- in particular, certain extreme cases can be handled */ soluble_group = (pga->soluble || pga->Degree == 1 || pga->nmr_of_perms == 0); if (!soluble_group) { #if defined (GAP_LINK) if (!process_fork) { start_GAP_file (auts, pga); process_fork = TRUE; } StartGapFile (pga); #else #if defined (GAP_LINK_VIA_FILE) start_GAP_file (&LINK_input, auts, pga, pcp); #endif #endif } perms = permute_subgroups (LINK_input, &a, &b, &c, auts, pga, pcp); if (!pga->space_efficient) { if (soluble_group) compute_orbits (&a, &b, &c, perms, pga); else insoluble_compute_orbits (&a, &b, &c, perms, pga); } orbit_length = find_orbit_reps (a, b, pga); if (pga->print_orbit_summary) orbit_summary (orbit_length, pga); if (soluble_group && pga->print_orbit_arrays) print_orbit_information (a, b, c, pga); pga->final_stage = (pga->q == pga->multiplicator_rank); if (!soluble_group) { #if defined (GAP_LINK_VIA_FILE) CloseFile (LINK_input); #endif } setup_reps (pga->rep, pga->nmr_orbits, orbit_length, perms, a, b, c, auts, descendant_file, covers_file, pga, pcp); if (!pga->final_stage) nmr_of_covers += pga->nmr_orbits; free_space (soluble_group, perms, orbit_length, a, b, c, pga); } #if defined (GAP_LINK) if (process_fork) QuitGap (); #endif free_vector (pga->list, 0); free_vector (pga->available, 0); free_vector (pga->offset, 0); return nmr_of_covers; }
WavWriter::~WavWriter() { CloseFile(); }
int main(int argc,char** argv) { NodesX *OSMNodes; WaysX *OSMWays; RelationsX *OSMRelations; ErrorLogsX *OSMErrorLogs; char *dirname=NULL,*prefix=NULL,*tagging=NULL; int option_keep=1; int option_filenames=0; int arg; printf_program_start(); /* Parse the command line arguments */ for(arg=1;arg<argc;arg++) { if(!strcmp(argv[arg],"--version")) print_usage(-1,NULL,NULL); else if(!strcmp(argv[arg],"--help")) print_usage(1,NULL,NULL); else if(!strncmp(argv[arg],"--dir=",6)) dirname=&argv[arg][6]; else if(!strncmp(argv[arg],"--sort-ram-size=",16)) option_filesort_ramsize=atoi(&argv[arg][16]); #if defined(USE_PTHREADS) && USE_PTHREADS else if(!strncmp(argv[arg],"--sort-threads=",15)) option_filesort_threads=atoi(&argv[arg][15]); #endif else if(!strncmp(argv[arg],"--tmpdir=",9)) option_tmpdirname=&argv[arg][9]; else if(!strncmp(argv[arg],"--tagging=",10)) tagging=&argv[arg][10]; else if(!strcmp(argv[arg],"--loggable")) option_loggable=1; else if(!strcmp(argv[arg],"--logtime")) option_logtime=1; else if(!strcmp(argv[arg],"--logmemory")) option_logmemory=1; else if(argv[arg][0]=='-' && argv[arg][1]=='-') print_usage(0,argv[arg],NULL); else option_filenames++; } /* Check the specified command line options */ if(!option_filesort_ramsize) { #if SLIM option_filesort_ramsize=64*1024*1024; #else option_filesort_ramsize=256*1024*1024; #endif } else option_filesort_ramsize*=1024*1024; if(!option_tmpdirname) { if(!dirname) option_tmpdirname="."; else option_tmpdirname=dirname; } if(tagging) { if(!ExistsFile(tagging)) { fprintf(stderr,"Error: The '--tagging' option specifies a file that does not exist.\n"); exit(EXIT_FAILURE); } } else { tagging=FileName(dirname,prefix,"fixme.xml"); if(!ExistsFile(tagging)) { fprintf(stderr,"Error: The '--tagging' option was not used and the default 'fixme.xml' does not exist.\n"); exit(EXIT_FAILURE); } } if(ParseXMLTaggingRules(tagging)) { fprintf(stderr,"Error: Cannot read the tagging rules in the file '%s'.\n",tagging); exit(EXIT_FAILURE); } /* Create new node, segment, way and relation variables */ OSMNodes=NewNodeList(0,0); OSMWays=NewWayList(0,0); OSMRelations=NewRelationList(0,0); /* Create the error log file */ open_errorlog(FileName(dirname,prefix,"fixme.log"),0,option_keep); /* Parse the file */ for(arg=1;arg<argc;arg++) { int fd; char *filename,*p; if(argv[arg][0]=='-' && argv[arg][1]=='-') continue; filename=strcpy(malloc(strlen(argv[arg])+1),argv[arg]); fd=OpenFile(filename); if((p=strstr(filename,".bz2")) && !strcmp(p,".bz2")) { fd=Uncompress_Bzip2(fd); *p=0; } if((p=strstr(filename,".gz")) && !strcmp(p,".gz")) { fd=Uncompress_Gzip(fd); *p=0; } if((p=strstr(filename,".xz")) && !strcmp(p,".xz")) { fd=Uncompress_Xz(fd); *p=0; } printf("\nParse OSM Data [%s]\n==============\n\n",filename); fflush(stdout); if((p=strstr(filename,".pbf")) && !strcmp(p,".pbf")) { if(ParsePBFFile(fd,OSMNodes,OSMWays,OSMRelations)) exit(EXIT_FAILURE); } else if((p=strstr(filename,".o5m")) && !strcmp(p,".o5m")) { if(ParseO5MFile(fd,OSMNodes,OSMWays,OSMRelations)) exit(EXIT_FAILURE); } else { if(ParseOSMFile(fd,OSMNodes,OSMWays,OSMRelations)) exit(EXIT_FAILURE); } CloseFile(fd); free(filename); } DeleteXMLTaggingRules(); FinishNodeList(OSMNodes); FinishWayList(OSMWays); FinishRelationList(OSMRelations); /* Sort the data */ printf("\nSort OSM Data\n=============\n\n"); fflush(stdout); /* Sort the nodes, ways and relations */ SortNodeList(OSMNodes); SortWayList(OSMWays); SortRelationList(OSMRelations); /* Process the data */ RenameFile(OSMNodes->filename_tmp,OSMNodes->filename); RenameFile(OSMWays->filename_tmp,OSMWays->filename); RenameFile(OSMRelations->rrfilename_tmp,OSMRelations->rrfilename); RenameFile(OSMRelations->trfilename_tmp,OSMRelations->trfilename); close_errorlog(); printf("\nCreate Error Log\n================\n\n"); fflush(stdout); OSMErrorLogs=NewErrorLogList(); ProcessErrorLogs(OSMErrorLogs,OSMNodes,OSMWays,OSMRelations); SortErrorLogsGeographically(OSMErrorLogs); SaveErrorLogs(OSMErrorLogs,FileName(dirname,prefix,"fixme.mem")); FreeErrorLogList(OSMErrorLogs); /* Free the memory (delete the temporary files) */ FreeNodeList(OSMNodes,0); FreeWayList(OSMWays,0); FreeRelationList(OSMRelations,0); printf("\n"); fflush(stdout); printf_program_end(); exit(EXIT_SUCCESS); }
QuickView::~QuickView() { CloseFile(); }
CDummyVideoPlayer::~CDummyVideoPlayer() { CloseFile(); }
BOOL CWriteBitmap::GIFWrite() { GIFHDR hdr; GIFDESC imDesc; GIFMAP ColorMap; int y, i, j, npix, nlin; LPTR lp, lpBuffer, lpImgScanline; BYTE cTerm; int codeSize; RECT rSave; BOOL bEscapable; BOOL compressInit; LPLZW_STUFF lpLZW; LPRGB lpRGBmap; LPFRAME lpFrame; LPOBJECT lpObject; FRMTYPEINFO inType, outType, inTypeLA, outTypeLA; CFrameTypeConvert TypeConvert, LineArtConvert; BOOL fRet = FALSE; CFile theFile; CFile* pTheFile = NULL; if (m_lpObjList) { lpObject = m_lpObjList->lpHead; if (lpObject) lpFrame = ObjGetEditFrame(lpObject); } else { lpFrame = m_lpFrame; lpObject = NULL; } ASSERT(lpFrame); ProgressBegin(1); if ((pTheFile = OpenFile()) == NULL) { ProgressEnd(); return(FALSE); } TRY { lpBuffer = NULL; lpImgScanline = NULL; compressInit = NO; /* full color not supported, force mini color */ if (m_DataType != FDT_GRAYSCALE && m_DataType != FDT_LINEART) m_DataType = FDT_PALETTECOLOR; if (m_fSrcArea) rSave = m_rSrcArea; else { rSave.top = rSave.left = 0; rSave.bottom = FrameYSize(lpFrame)-1; rSave.right = FrameXSize(lpFrame)-1; } inType = FrameTypeInfo(lpFrame); // cause FramePointer never returns line art if (inType.DataType == FDT_LINEART) inType.DataType = FDT_GRAYSCALE; // make sure colormap is inited for outType so we don't free bogus ptr FrameSetTypeInfo(&outType, FDT_NONE); npix = RectWidth(&rSave); nlin = RectHeight(&rSave); /* initialize file header */ hdr.ScnWidth = npix; hdr.ScnHeight = nlin; hdr.Background = 0; hdr.GlobalMap = TRUE; hdr.ColorRes = 8; /* initialize image descriptor */ imDesc.ImLeft = 0; imDesc.ImTop = 0; imDesc.ImWidth = npix; imDesc.ImHeight = nlin; imDesc.Zero = 0; /* determine type of image to create */ if ( m_DataType == FDT_GRAYSCALE ) { /* gray */ hdr.ColorRes = 8; hdr.bpp = 8; codeSize = 8; FrameSetTypeInfo(&outType, FDT_GRAYSCALE); } else if ( m_DataType == FDT_LINEART ) { /* line art or scatter */ hdr.ColorRes = 1; hdr.bpp = 1; codeSize = 2; FrameSetTypeInfo(&outType, FDT_LINEART); } else //if ( m_DataType == FDT_PALETTECOLOR ) { /* mini color */ hdr.ColorRes = 8; hdr.bpp = 8; codeSize = 8; if (inType.DataType == FDT_PALETTECOLOR) outType = inType; else FrameSetTypeInfo(&outType, FDT_PALETTECOLOR); } AllocLines( &lpBuffer, 1, npix, 4 ); // max size is cool AllocLines( &lpImgScanline, 1, npix, 4 ); if ( !lpBuffer || !lpImgScanline ) { SetError(BEC_errMemory); goto Exit; } /* set raw info byte */ hdr.RawImInfo = 0x80 | ((hdr.ColorRes-1) << 4) | (hdr.bpp-1); /* write file header */ pTheFile->Write((LPTR)"GIF87a", 6); pTheFile->Write((LPTR)&hdr.ScnWidth, 2); pTheFile->Write((LPTR)&hdr.ScnHeight, 2); pTheFile->Write((LPTR)&hdr.RawImInfo, 1); pTheFile->Write((LPTR)&hdr.Background, 1); pTheFile->Write((LPTR)"", 1); switch (m_DataType) { case FDT_LINEART: /* initialize the color map */ ColorMap.Length = 2; ColorMap.Map[0].red = ColorMap.Map[0].green = ColorMap.Map[0].blue = 0xFF; ColorMap.Map[1].red = ColorMap.Map[1].green = ColorMap.Map[1].blue = 0x00; /* write image descriptor, color map and code size */ if (gifWriteImDesc (pTheFile, &imDesc, &ColorMap, codeSize)) goto BadWrite; break; case FDT_GRAYSCALE: /* initialize the color map */ ColorMap.Length = 256; for (i = 0; i < 256; i++) { ColorMap.Map[i].red = ColorMap.Map[i].green = ColorMap.Map[i].blue = i; } /* write image descriptor, color map and code size */ if (gifWriteImDesc (pTheFile, &imDesc, &ColorMap, codeSize)) goto BadWrite; break; case FDT_PALETTECOLOR: // see if we need to create a palette if (!outType.ColorMap) { outType.ColorMap = FrameCreateColorMap(); if (!outType.ColorMap) { SetError(BEC_errMemory); goto Exit; } outType.ColorMap->NumEntries = 256; if (!CreateOptimizedPalette(lpObject, lpFrame, outType.ColorMap->RGBData, &outType.ColorMap->NumEntries, TRUE, NULL)) { SetError(BEC_errMemory); goto Exit; } } lpRGBmap = outType.ColorMap->RGBData; /* initialize the color map */ ColorMap.Length = 256; for (i = 0; i < 256; i++) { ColorMap.Map[i].red = lpRGBmap[i].red; ColorMap.Map[i].green = lpRGBmap[i].green; ColorMap.Map[i].blue = lpRGBmap[i].blue; } /* write image descriptor, color map and code size */ if (gifWriteImDesc (pTheFile, &imDesc, &ColorMap, codeSize)) goto BadWrite; break; } // initialize stuff to do the type conversion if (!TypeConvert.Init(inType, outType, npix, m_DitherType)) { SetError(BEC_errMemory); goto Exit; } if (outType.DataType == FDT_LINEART) { FrameSetTypeInfo(&inTypeLA, FDT_LINEART); FrameSetTypeInfo(&outTypeLA, FDT_GRAYSCALE); if (!LineArtConvert.Init(inTypeLA, outTypeLA, npix)) { SetError(BEC_errMemory); goto Exit; } } /* write the image */ if ( !( lpLZW = CompressLZW_GIF (pTheFile, NULL, 0, codeSize, NULL ) ) ) goto BadWrite; compressInit = YES; for (y = rSave.top; y <= rSave.bottom; y++) { if (Progress (y-rSave.top, nlin, bEscapable )) goto Exit; if (lpObject) { if (!ObjGetLine( lpObject, rSave.left, y, npix, lpImgScanline)) goto BadRead; lp = lpImgScanline; } else { if ( !(lp = FramePointer(lpFrame, rSave.left, y, NO)) ) goto BadRead; } // convert the data to the new type TypeConvert.ConvertData(lp, lpBuffer, y, npix); if (outType.DataType == FDT_LINEART) { /* convert back to depth one, but with pixel values of 0 and 1 */ LineArtConvert.ConvertData(lpBuffer, lpImgScanline, y, npix); for (lp = lpImgScanline, j = 0; j < npix; j++, lp++) *lp = (*lp) ? 0 : 1; lp = lpImgScanline; } else lp = lpBuffer; /* compress the data */ if (!(CompressLZW_GIF (pTheFile, lp, npix, codeSize, lpLZW))) goto BadWrite; } if ( compressInit ) CompressLZW_GIF (pTheFile, NULL, 0, codeSize, lpLZW); cTerm = 0; pTheFile->Write((LPTR)&cTerm, 1); cTerm = GIFTerm; pTheFile->Write((LPTR)&cTerm, 1); fRet = TRUE; goto Exit; } CATCH_ALL(e) { goto BadWrite; } END_CATCH_ALL BadWrite: SetError(BEC_errWriteFile); goto Exit; BadRead: SetError(BEC_errFrameRead); Exit: /* clean up */ CloseFile(pTheFile, fRet); compressInit = NO; if (lpBuffer) FreeUp (lpBuffer); if (lpImgScanline) FreeUp ( lpImgScanline ); if (outType.ColorMap && (outType.ColorMap != inType.ColorMap)) FrameDestroyColorMap(outType.ColorMap); ProgressEnd(); return (fRet); }
void AVIDump::Stop() { av_write_trailer(s_format_context); CloseFile(); NOTICE_LOG(VIDEO, "Stopping frame dump"); }
Log::~Log() { CloseFile(); DeleteCriticalSection( &m_criLock ); }
MetaIOID3::~MetaIOID3(void) { CloseFile(); }
void Log::SetFile(LPCTSTR filename, bool append) { if( !filename ) return; CloseFile(); m_tofile = true; // If filename is NULL or invalid we should throw an exception here bool bOverSized = FALSE; if (access(filename, 04) != -1) { //file exist, check size; HANDLE tmpfile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (tmpfile) { DWORD lfSize = GetFileSize(tmpfile, NULL); if (lfSize > 1024*1024) { bOverSized = true; } CloseHandle(tmpfile); } } if (!append || bOverSized) { // Build the backup filename TCHAR backupfilename[MAX_PATH]; lstrcpy(backupfilename, filename ); lstrcat(backupfilename, _TEXT(".bak")); // Attempt the move and replace any existing backup // Note that failure is silent - where would we log a message to? ;) DeleteFile(backupfilename); MoveFile(filename, backupfilename); } hlogfile = CreateFile( filename, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); if (hlogfile == INVALID_HANDLE_VALUE) { // We should throw an exception here m_todebug = true; m_tofile = false; Print(0, _T("Error opening log file %s\n"), filename); return; } if (append) { SetFilePointer( hlogfile, 0, NULL, FILE_END ); } else { SetEndOfFile( hlogfile ); } if (hlogfile) { //print log header this->ReallyPrintLine("\r\n-------------------------------------------------------------------------------------------------------\r\n"); this->ReallyPrintLine("--------------------------------!!!<<new log started>>!!!----------------------------------------------\r\n"); this->ReallyPrintLine("-------------------------------------------------------------------------------------------------------\r\n"); } }
char * ConfigBase::GetConfigLine( ) { static char buf[128]; static char stat=0; char *ptr = NULL; int buflen=128; if (NULL == fp) { if (OpenFile( ) != E_SUCC) { return NULL; } } while (GetLine(buf, buflen) != NULL) { ptr=buf; if (0 == stat) { if (! strcmp(m_sField, "")) { stat=1; } else if (strstr(buf, m_sField)) { stat=1; continue; } } if (0 == stat) { continue; } while (('\t' == *ptr) || (' ' == *ptr)) { // Delete the pre space and tab. ++ptr; } if (*ptr == '[') { // This item end. // r = E_CONFIG_MISS; break; } if ((*ptr == '\0') || (*ptr == '\n') || (*ptr == '\r') || (*ptr == ';') || (*ptr == '#')) { continue; } else { return ptr; } } CloseFile( ); stat = 0; return NULL; }
static void _print_results(void) { /*======================================================*/ LyrIndex lyr; TimeInt pd; GrpIndex g; RealF sum; FILE *fp; fp = OpenFile("testdata.txt","w"); LOG(fp,"===============================================\n"); LOG(fp,"Echoing relative sizes and transpiration values.\n\n"); ForEachGroup(g) { LOG(fp,"%s(%4.3f)\t", RGroup[g]->name, RGroup[g]->relsize); } LOG_NL; ForEachTrPeriod(pd) { LOG(fp,"%d", pd); ForEachTreeTranspLayer(lyr) LOG(fp,"\t%5.4f", SXW.transp[Ilp(lyr,pd)]); LOG_NL; } LOG(fp,"\n===============================================\n"); LOG(fp," Relative rooting distributions.\n\n"); LOG(fp,"Layer"); ForEachGroup(g) LOG(fp,"\t%s", RGroup[g]->name); LOG_NL; ForEachTreeTranspLayer(lyr) { LOG(fp,"%d", lyr); ForEachGroup(g) LOG(fp, "\t%5.4f", _roots_rel[Ilg(lyr,g)]); LOG_NL; } LOG(fp,"\n===============================================\n"); LOG(fp," Relative phenology.\n\n"); LOG(fp,"Group"); ForEachTrPeriod(pd) LOG(fp,"\t%d", pd); LOG_NL; ForEachGroup(g) { LOG(fp,"%s", RGroup[g]->name); ForEachTrPeriod(pd) LOG(fp,"\t%5.4f", _phen_grp_rel[Igp(g,pd)]); LOG_NL; } LOG(fp,"\n===============================================\n"); LOG(fp," Check rel vals for rel phen X rel roots.\n\n"); LOG_NL; ForEachGroup(g) { LOG(fp,"\n ------ %s -------\n", RGroup[g]->name); ForEachTrPeriod(pd) LOG(fp,"\t%d", pd); LOG_NL; ForEachTreeTranspLayer(lyr) { LOG(fp,"%d", lyr); ForEachTrPeriod(pd) LOG(fp,"\t%5.4f", _roots_active[Iglp(g,lyr,pd)]); LOG_NL; } } LOG(fp,"\n===============================================\n"); LOG(fp," Totals for rel roots X rel phen.\n\n"); LOG(fp,"Layer\\Mon"); ForEachTrPeriod(pd) LOG(fp,"\t%d", pd); LOG_NL; ForEachTreeTranspLayer(lyr) { LOG(fp,"%d", lyr); ForEachTrPeriod(pd) LOG(fp,"\t%5.4f", _roots_phen_totals[Ilp(lyr,pd)]); LOG_NL; } LOG(fp,"\n===============================================\n"); LOG(fp," Contribution to period's transpiration by group.\n\n"); LOG(fp,"Group"); ForEachTrPeriod(pd) LOG(fp,"\t%d", pd); LOG_NL; ForEachGroup(g) { LOG(fp,"%s", RGroup[g]->name); ForEachTrPeriod(pd) { sum = 0.; ForEachTreeTranspLayer(lyr) { sum += _roots_active[Iglp(g,lyr,pd)] * SXW.transp[Ilp(lyr,pd)]; } LOG(fp,"\t%5.4f", sum); } LOG_NL; } CloseFile(&fp); }
int main() { int fd; int loopCnt; int byteOffset= 0; char strData[MaxBlockLength]; char fileName[32] = "writeTest.txt"; /*****************************/ /* Initialize the system */ /*****************************/ if( InitReplFs( ReplFsPort, 0, 1 ) < 0 ) { fprintf( stderr, "Error initializing the system\n" ); return( ErrorExit ); } /*****************************/ /* Open the file for writing */ /*****************************/ fd = OpenFile( fileName ); if ( fd < 0 ) { fprintf( stderr, "Error opening file '%s'\n", fileName ); return( ErrorExit ); } /**************************************/ /* Write incrementing numbers to the file */ /**************************************/ for ( loopCnt=0; loopCnt<8; loopCnt++ ) { sprintf( strData, "%d\n", loopCnt ); #ifdef DEBUG printf( "%d: Writing '%s' to file.\n", loopCnt, strData ); #endif if ( WriteBlock( fd, strData, byteOffset, strlen( strData ) ) < 0 ) { printf( "Error writing to file %s [LoopCnt=%d]\n", fileName, loopCnt ); return( ErrorExit ); } byteOffset += strlen( strData ); } /**********************************************/ /* Can we commit the writes to the server(s)? */ /**********************************************/ if ( Commit( fd ) < 0 ) { printf( "Could not commit changes to File '%s'\n", fileName ); return( ErrorExit ); } /**************************************/ /* Close the writes to the server(s) */ /**************************************/ if ( CloseFile( fd ) < 0 ) { printf( "Error Closing File '%s'\n", fileName ); return( ErrorExit ); } printf( "Writes to file '%s' complete.\n", fileName ); return( NormalExit ); }
int textfile_c::CloseTextFile() { delete buffer; CloseFile(); return 0; }
PAPlayer::~PAPlayer() { CloseFile(); delete m_FileItem; }
bool CApplicationPlayer::OpenFile(const CFileItem& item, const CPlayerOptions& options, const CPlayerCoreFactory &factory, const std::string &playerName, IPlayerCallback& callback) { // get player type std::string newPlayer; if (!playerName.empty()) newPlayer = playerName; else newPlayer = factory.GetDefaultPlayer(item); // check if we need to close current player // VideoPlayer can open a new file while playing std::shared_ptr<IPlayer> player = GetInternal(); if (player && player->IsPlaying()) { bool needToClose = false; if (item.IsDiscImage() || item.IsDVDFile()) needToClose = true; if (player->m_name != newPlayer) needToClose = true; if (player->m_type != "video") needToClose = true; if (needToClose) { m_nextItem.pItem = std::make_shared<CFileItem>(item); m_nextItem.options = options; m_nextItem.playerName = newPlayer; m_nextItem.callback = &callback; CloseFile(); if (player->m_name != newPlayer) { CSingleLock lock(m_playerLock); m_pPlayer.reset(); } return true; } } if (!player) { CreatePlayer(factory, newPlayer, callback); player = GetInternal(); if (!player) return false; } bool ret = player->OpenFile(item, options); m_nextItem.pItem.reset(); // reset caching timers m_audioStreamUpdate.SetExpired(); m_videoStreamUpdate.SetExpired(); m_subtitleStreamUpdate.SetExpired(); return ret; }
bool U8NandArchive::SetFile( const char* nandPath ) { if(fst) free(fst); if(name_table) free(name_table); CloseFile(); // open file if( (fd = ISFS_Open( nandPath, ISFS_OPEN_READ ) ) < 0 ) { gprintf( "U8NandArchive: ISFS_Open( \"%s\" ) failed\n", nandPath ); return false; } // get file size fstats stats __attribute__(( aligned( 32 ) )); int ret = ISFS_GetFileStats( fd, &stats ); if( ret < 0 ) { CloseFile(); gprintf( "U8NandArchive: ISFS_GetFileStats( \"%s\" ) failed\n", nandPath ); return false; } // buffer for reading the header and stuff u8* buffer = (u8*)memalign( 32, 0x800 ); if( !buffer ) { CloseFile(); gprintf( "U8NandArchive: enomem\n" ); return false; } // read a chunk big enough that it should contain the U8 header if there is going to be one if( (ret = ISFS_Read( fd, buffer, 0x800 )) != 0x800 ) { free( buffer ); CloseFile(); gprintf( "U8NandArchive: ISFS_Read( 0x800 ) = %i\n", ret ); return false; } // find the start of the U8 data U8Header* tagStart = (U8Header*)FindU8Tag( buffer, ret ); if( !tagStart ) { free( buffer ); CloseFile(); gprintf( "U8NandArchive: didn't see a U8 tag\n" ); return false; } // remember where in the file the U8 starts dataOffset = ( (u8*)tagStart - buffer ); // allocate memory and read the fst if( !(fst = (FstEntry *)memalign( 32, RU( tagStart->dataOffset - dataOffset, 32 ) ) ) || ( ISFS_Seek( fd, dataOffset + tagStart->rootNodeOffset, SEEK_SET ) != (s32)( dataOffset + tagStart->rootNodeOffset ) ) || ( ISFS_Read( fd, fst, tagStart->dataOffset - dataOffset ) != (s32)( tagStart->dataOffset - dataOffset ) ) || ( fst->filelen * 0xC > tagStart->dataOffset ) ) { dataOffset = 0; free( buffer ); if( fst ) free( fst ); CloseFile(); gprintf( "U8NandArchive: error reading fst\n" ); } // set name table pointer u32 name_table_offset = fst->filelen * 0xC; name_table = ((char *)fst) + name_table_offset; free( buffer ); return true; }
/* * Destructor */ BufferedFile::~BufferedFile() { CloseFile(); }
int main( int argc, char **argv ) { struct stat stat_buff; stat_record_t sum_stat; printer_t print_header, print_record; nfprof_t profile_data; char *rfile, *Rfile, *Mdirs, *wfile, *ffile, *filter, *tstring, *stat_type; char *byte_limit_string, *packet_limit_string, *print_format, *record_header; char *print_order, *query_file, *UnCompress_file, *nameserver, *aggr_fmt; int c, ffd, ret, element_stat, fdump; int i, user_format, quiet, flow_stat, topN, aggregate, aggregate_mask, bidir; int print_stat, syntax_only, date_sorted, do_tag, compress, do_xstat; int plain_numbers, GuessDir, pipe_output, csv_output; time_t t_start, t_end; uint16_t Aggregate_Bits; uint32_t limitflows; uint64_t AggregateMasks[AGGR_SIZE]; char Ident[IDENTLEN]; rfile = Rfile = Mdirs = wfile = ffile = filter = tstring = stat_type = NULL; byte_limit_string = packet_limit_string = NULL; fdump = aggregate = 0; aggregate_mask = 0; bidir = 0; t_start = t_end = 0; syntax_only = 0; topN = 10; flow_stat = 0; print_stat = 0; element_stat = 0; do_xstat = 0; limitflows = 0; date_sorted = 0; total_bytes = 0; total_flows = 0; skipped_blocks = 0; do_tag = 0; quiet = 0; user_format = 0; compress = 0; plain_numbers = 0; pipe_output = 0; csv_output = 0; is_anonymized = 0; GuessDir = 0; nameserver = NULL; print_format = NULL; print_header = NULL; print_record = NULL; print_order = NULL; query_file = NULL; UnCompress_file = NULL; aggr_fmt = NULL; record_header = NULL; Aggregate_Bits = 0xFFFF; // set all bits Ident[0] = '\0'; for ( i=0; i<AGGR_SIZE; AggregateMasks[i++] = 0 ) ; while ((c = getopt(argc, argv, "6aA:Bbc:D:E:s:hHn:i:j:f:qzr:v:w:K:M:NImO:R:XZt:TVv:x:l:L:o:")) != EOF) { switch (c) { case 'h': usage(argv[0]); exit(0); break; case 'a': aggregate = 1; break; case 'A': if ( !ParseAggregateMask(optarg, &aggr_fmt ) ) { exit(255); } aggregate_mask = 1; break; case 'B': GuessDir = 1; case 'b': if ( !SetBidirAggregation() ) { exit(255); } bidir = 1; // implies aggregate = 1; break; case 'D': nameserver = optarg; if ( !set_nameserver(nameserver) ) { exit(255); } break; case 'E': query_file = optarg; if ( !InitExporterList() ) { exit(255); } PrintExporters(query_file); exit(0); break; case 'X': fdump = 1; break; case 'Z': syntax_only = 1; break; case 'q': quiet = 1; break; case 'z': compress = 1; break; case 'c': limitflows = atoi(optarg); if ( !limitflows ) { LogError("Option -c needs a number > 0\n"); exit(255); } break; case 's': stat_type = optarg; if ( !SetStat(stat_type, &element_stat, &flow_stat) ) { exit(255); } break; case 'V': { char *e1, *e2; e1 = ""; e2 = ""; #ifdef NSEL e1 = "NSEL-"; #endif #ifdef NEL e2 = "NEL-"; #endif printf("%s: Version: %s%s%s\n",argv[0], e1, e2, nfdump_version); exit(0); } break; case 'l': packet_limit_string = optarg; break; case 'K': LogError("*** Anonymisation moved! Use nfanon to anonymise flows!\n"); exit(255); break; case 'H': do_xstat = 1; break; case 'L': byte_limit_string = optarg; break; case 'N': plain_numbers = 1; break; case 'f': ffile = optarg; break; case 't': tstring = optarg; break; case 'r': rfile = optarg; if ( strcmp(rfile, "-") == 0 ) rfile = NULL; break; case 'm': print_order = "tstart"; Parse_PrintOrder(print_order); date_sorted = 1; LogError("Option -m depricated. Use '-O tstart' instead\n"); break; case 'M': Mdirs = optarg; break; case 'I': print_stat++; break; case 'o': // output mode print_format = optarg; break; case 'O': { // stat order by int ret; print_order = optarg; ret = Parse_PrintOrder(print_order); if ( ret < 0 ) { LogError("Unknown print order '%s'\n", print_order); exit(255); } date_sorted = ret == 6; // index into order_mode } break; case 'R': Rfile = optarg; break; case 'w': wfile = optarg; break; case 'n': topN = atoi(optarg); if ( topN < 0 ) { LogError("TopnN number %i out of range\n", topN); exit(255); } break; case 'T': do_tag = 1; break; case 'i': strncpy(Ident, optarg, IDENT_SIZE); Ident[IDENT_SIZE - 1] = 0; if ( strchr(Ident, ' ') ) { LogError("Ident must not contain spaces\n"); exit(255); } break; case 'j': UnCompress_file = optarg; UnCompressFile(UnCompress_file); exit(0); break; case 'x': query_file = optarg; InitExtensionMaps(NO_EXTENSION_LIST); DumpExMaps(query_file); exit(0); break; case 'v': query_file = optarg; QueryFile(query_file); exit(0); break; case '6': // print long IPv6 addr Setv6Mode(1); break; default: usage(argv[0]); exit(0); } } if (argc - optind > 1) { usage(argv[0]); exit(255); } else { /* user specified a pcap filter */ filter = argv[optind]; FilterFilename = NULL; } // Change Ident only if ( rfile && strlen(Ident) > 0 ) { ChangeIdent(rfile, Ident); exit(0); } if ( (element_stat && !flow_stat) && aggregate_mask ) { LogError("Warning: Aggregation ignored for element statistics\n"); aggregate_mask = 0; } if ( !flow_stat && aggregate_mask ) { aggregate = 1; } if ( rfile && Rfile ) { LogError("-r and -R are mutually exclusive. Plase specify either -r or -R\n"); exit(255); } if ( Mdirs && !(rfile || Rfile) ) { LogError("-M needs either -r or -R to specify the file or file list. Add '-R .' for all files in the directories.\n"); exit(255); } extension_map_list = InitExtensionMaps(NEEDS_EXTENSION_LIST); if ( !InitExporterList() ) { exit(255); } SetupInputFileSequence(Mdirs, rfile, Rfile); if ( print_stat ) { nffile_t *nffile; if ( !rfile && !Rfile && !Mdirs) { LogError("Expect data file(s).\n"); exit(255); } memset((void *)&sum_stat, 0, sizeof(stat_record_t)); sum_stat.first_seen = 0x7fffffff; sum_stat.msec_first = 999; nffile = GetNextFile(NULL, 0, 0); if ( !nffile ) { LogError("Error open file: %s\n", strerror(errno)); exit(250); } while ( nffile && nffile != EMPTY_LIST ) { SumStatRecords(&sum_stat, nffile->stat_record); nffile = GetNextFile(nffile, 0, 0); } PrintStat(&sum_stat); exit(0); } // handle print mode if ( !print_format ) { // automatically select an appropriate output format for custom aggregation // aggr_fmt is compiled by ParseAggregateMask if ( aggr_fmt ) { int len = strlen(AggrPrependFmt) + strlen(aggr_fmt) + strlen(AggrAppendFmt) + 7; // +7 for 'fmt:', 2 spaces and '\0' print_format = malloc(len); if ( !print_format ) { LogError("malloc() error in %s line %d: %s\n", __FILE__, __LINE__, strerror(errno) ); exit(255); } snprintf(print_format, len, "fmt:%s %s %s",AggrPrependFmt, aggr_fmt, AggrAppendFmt ); print_format[len-1] = '\0'; } else if ( bidir ) { print_format = "biline"; } else print_format = DefaultMode; } if ( strncasecmp(print_format, "fmt:", 4) == 0 ) { // special user defined output format char *format = &print_format[4]; if ( strlen(format) ) { if ( !ParseOutputFormat(format, plain_numbers, printmap) ) exit(255); print_record = format_special; record_header = get_record_header(); user_format = 1; } else { LogError("Missing format description for user defined output format!\n"); exit(255); } } else { // predefined output format // Check for long_v6 mode i = strlen(print_format); if ( i > 2 ) { if ( print_format[i-1] == '6' ) { Setv6Mode(1); print_format[i-1] = '\0'; } else Setv6Mode(0); } i = 0; while ( printmap[i].printmode ) { if ( strncasecmp(print_format, printmap[i].printmode, MAXMODELEN) == 0 ) { if ( printmap[i].Format ) { if ( !ParseOutputFormat(printmap[i].Format, plain_numbers, printmap) ) exit(255); // predefined custom format print_record = printmap[i].func; record_header = get_record_header(); user_format = 1; } else { // To support the pipe output format for element stats - check for pipe, and remember this if ( strncasecmp(print_format, "pipe", MAXMODELEN) == 0 ) { pipe_output = 1; } if ( strncasecmp(print_format, "csv", MAXMODELEN) == 0 ) { csv_output = 1; set_record_header(); record_header = get_record_header(); } // predefined static format print_record = printmap[i].func; user_format = 0; } break; } i++; } } if ( !print_record ) { LogError("Unknown output mode '%s'\n", print_format); exit(255); } // this is the only case, where headers are printed. if ( strncasecmp(print_format, "raw", 16) == 0 ) print_header = format_file_block_header; if ( aggregate && (flow_stat || element_stat) ) { aggregate = 0; LogError("Command line switch -s overwrites -a\n"); } if ( !filter && ffile ) { if ( stat(ffile, &stat_buff) ) { LogError("Can't stat filter file '%s': %s\n", ffile, strerror(errno)); exit(255); } filter = (char *)malloc(stat_buff.st_size+1); if ( !filter ) { LogError("malloc() error in %s line %d: %s\n", __FILE__, __LINE__, strerror(errno) ); exit(255); } ffd = open(ffile, O_RDONLY); if ( ffd < 0 ) { LogError("Can't open filter file '%s': %s\n", ffile, strerror(errno)); exit(255); } ret = read(ffd, (void *)filter, stat_buff.st_size); if ( ret < 0 ) { perror("Error reading filter file"); close(ffd); exit(255); } total_bytes += ret; filter[stat_buff.st_size] = 0; close(ffd); FilterFilename = ffile; } // if no filter is given, set the default ip filter which passes through every flow if ( !filter || strlen(filter) == 0 ) filter = "any"; Engine = CompileFilter(filter); if ( !Engine ) exit(254); if ( fdump ) { printf("StartNode: %i Engine: %s\n", Engine->StartNode, Engine->Extended ? "Extended" : "Fast"); DumpList(Engine); exit(0); } if ( syntax_only ) exit(0); if ( print_order && flow_stat ) { printf("-s record and -m are mutually exclusive options\n"); exit(255); } if ((aggregate || flow_stat || print_order) && !Init_FlowTable() ) exit(250); if (element_stat && !Init_StatTable(HashBits, NumPrealloc) ) exit(250); SetLimits(element_stat || aggregate || flow_stat, packet_limit_string, byte_limit_string); if ( tstring ) { if ( !ScanTimeFrame(tstring, &t_start, &t_end) ) exit(255); } if ( !(flow_stat || element_stat || wfile || quiet ) && record_header ) { if ( user_format ) { printf("%s\n", record_header); } else { // static format - no static format with header any more, but keep code anyway if ( Getv6Mode() ) { printf("%s\n", record_header); } else printf("%s\n", record_header); } } nfprof_start(&profile_data); sum_stat = process_data(wfile, element_stat, aggregate || flow_stat, print_order != NULL, print_header, print_record, t_start, t_end, limitflows, do_tag, compress, do_xstat); nfprof_end(&profile_data, total_flows); if ( total_bytes == 0 ) { printf("No matched flows\n"); exit(0); } if (aggregate || print_order) { if ( wfile ) { nffile_t *nffile = OpenNewFile(wfile, NULL, compress, is_anonymized, NULL); if ( !nffile ) exit(255); if ( ExportFlowTable(nffile, aggregate, bidir, date_sorted, extension_map_list) ) { CloseUpdateFile(nffile, Ident ); } else { CloseFile(nffile); unlink(wfile); } DisposeFile(nffile); } else { PrintFlowTable(print_record, limitflows, do_tag, GuessDir, extension_map_list); } } if (flow_stat) { PrintFlowStat(record_header, print_record, topN, do_tag, quiet, csv_output, extension_map_list); #ifdef DEVEL printf("Loopcnt: %u\n", loopcnt); #endif } if (element_stat) { PrintElementStat(&sum_stat, record_header, print_record, topN, do_tag, quiet, pipe_output, csv_output); } if ( !quiet ) { if ( csv_output ) { PrintSummary(&sum_stat, plain_numbers, csv_output); } else if ( !wfile ) { if (is_anonymized) printf("IP addresses anonymised\n"); PrintSummary(&sum_stat, plain_numbers, csv_output); if ( t_last_flow == 0 ) { // in case of a pre 1.6.6 collected and empty flow file printf("Time window: <unknown>\n"); } else { printf("Time window: %s\n", TimeString(t_first_flow, t_last_flow)); } printf("Total flows processed: %u, Blocks skipped: %u, Bytes read: %llu\n", total_flows, skipped_blocks, (unsigned long long)total_bytes); nfprof_print(&profile_data, stdout); } } Dispose_FlowTable(); Dispose_StatTable(); FreeExtensionMaps(extension_map_list); #ifdef DEVEL if ( hash_hit || hash_miss ) printf("Hash hit: %i, miss: %i, skip: %i, ratio: %5.3f\n", hash_hit, hash_miss, hash_skip, (float)hash_hit/((float)(hash_hit+hash_miss))); #endif return 0; }
/** * Read the UnicodeData.txt file. * @returns 0 on success. * @returns !0 on failure. * @param pszBasePath The base path, can be NULL. * @param pszFilename The name of the file. */ static int ReadUnicodeData(const char *pszBasePath, const char *pszFilename) { /* * Open input. */ FILE *pFile = OpenFile(pszBasePath, pszFilename); if (!pFile) return 1; /* * Parse the input and spit out the output. */ char szLine[4096]; RTUNICP i = 0; while (GetLineFromFile(szLine, sizeof(szLine), pFile) != NULL) { if (IsCommentOrBlankLine(szLine)) continue; char *pszCurField; char *pszCodePoint = FirstField(&pszCurField, StripLine(szLine)); /* 0 */ char *pszName = NextField(&pszCurField); /* 1 */ char *pszGeneralCategory = NextField(&pszCurField); /* 2 */ char *pszCanonicalCombiningClass = NextField(&pszCurField); /* 3 */ char *pszBidiClass = NextField(&pszCurField); /* 4 */ char *pszDecompositionType = NextField(&pszCurField); /* 5 */ char *pszDecompositionMapping = SplitDecompField(&pszDecompositionType); char *pszNumericType = NextField(&pszCurField); /* 6 */ char *pszNumericValueD = NextField(&pszCurField); /* 7 */ char *pszNumericValueN = NextField(&pszCurField); /* 8 */ char *pszBidiMirrored = NextField(&pszCurField); /* 9 */ char *pszUnicode1Name = NextField(&pszCurField); /* 10 */ char *pszISOComment = NextField(&pszCurField); /* 11 */ char *pszSimpleUpperCaseMapping = NextField(&pszCurField); /* 12 */ char *pszSimpleLowerCaseMapping = NextField(&pszCurField); /* 13 */ char *pszSimpleTitleCaseMapping = NextField(&pszCurField); /* 14 */ RTUNICP CodePoint = ToNum(pszCodePoint); if (CodePoint >= RT_ELEMENTS(g_aCPInfo)) { ParseError("U+05X is out of range\n", CodePoint); continue; } /* catchup? */ while (i < CodePoint) NullEntry(i++); if (i != CodePoint) { ParseError("i=%d CodePoint=%u\n", i, CodePoint); CloseFile(pFile); return 1; } /* this one */ g_aCPInfo[i].CodePoint = i; g_aCPInfo[i].fNullEntry = 0; g_aCPInfo[i].pszName = DupStr(pszName); g_aCPInfo[i].SimpleUpperCaseMapping = ToNumDefault(pszSimpleUpperCaseMapping, CodePoint); g_aCPInfo[i].SimpleLowerCaseMapping = ToNumDefault(pszSimpleLowerCaseMapping, CodePoint); g_aCPInfo[i].SimpleTitleCaseMapping = ToNumDefault(pszSimpleTitleCaseMapping, CodePoint); g_aCPInfo[i].CanonicalCombiningClass = ToNum(pszCanonicalCombiningClass); g_aCPInfo[i].pszDecompositionType = DupStr(pszDecompositionType); g_aCPInfo[i].paDecompositionMapping = ToMapping(pszDecompositionMapping, &g_aCPInfo[i].cDecompositionMapping, 20); g_aCPInfo[i].pszGeneralCategory = DupStr(pszGeneralCategory); g_aCPInfo[i].pszBidiClass = DupStr(pszBidiClass); g_aCPInfo[i].pszNumericType = DupStr(pszNumericType); g_aCPInfo[i].pszNumericValueD = DupStr(pszNumericValueD); g_aCPInfo[i].pszNumericValueN = DupStr(pszNumericValueN); g_aCPInfo[i].pszBidiMirrored = DupStr(pszBidiMirrored); g_aCPInfo[i].pszUnicode1Name = DupStr(pszUnicode1Name); g_aCPInfo[i].pszISOComment = DupStr(pszISOComment); i++; } /* catchup? */ while (i < RT_ELEMENTS(g_aCPInfo)) NullEntry(i++); CloseFile(pFile); return 0; }