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