bool ConfigXml::writeConfigFile(const QString fileName)
{
QXmlStreamWriter writer;
QFile configFile(fileName);
if (!configFile.open(QFile::Truncate | QFile::WriteOnly | QFile::Text)) {
qDebug() << "Error: Cannot write file " << qPrintable(fileName) <<
": " << qPrintable(configFile.errorString());
return false;
}
writer.setDevice(&configFile);
writer.setAutoFormatting(true);
writer.writeStartDocument();
writer.writeStartElement("config");
writeEntries(&writer);
writer.writeEndDocument();
configFile.close();
if (configFile.error()) {
qDebug() << "Error: Cannot write file " << qPrintable(fileName) <<
": " << qPrintable(configFile.errorString());
return false;
}
return true;
}
void KConfigRawBackEnd::sync(bool bMerge)
{
// write-sync is only necessary if there are dirty entries
if ( !pConfig->isDirty() || pConfig->isReadOnly() ) return;
_file.reset();
KEntryMap aTempMap;
getEntryMap(aTempMap, false, bMerge ? &_file : 0);
if ( _stream==0 ) {
_stream = fdopen(_fd, "w");
if ( _stream==0 ) return;
}
ftruncate(_fd, 0);
writeEntries(_stream, aTempMap);
fflush(_stream);
}
void Foam::TableBase<Type>::writeData(Ostream& os) const
{
os << nl << indent << table_ << token::END_STATEMENT << nl;
writeEntries(os);
}
/* antlarr: KDE 4.0: make the first parameter "const QString &" */
bool KConfigINIBackEnd::writeConfigFile(QString filename, bool bGlobal, bool bMerge)
{
// is the config object read-only?
if(pConfig->isReadOnly())
return true; // pretend we wrote it
KEntryMap aTempMap;
QFile *mergeFile = (bMerge ? new QFile(filename) : 0);
bool bEntriesLeft = getEntryMap(aTempMap, bGlobal, mergeFile);
delete mergeFile;
if(bFileImmutable)
return true; // pretend we wrote it
// OK now the temporary map should be full of ALL entries.
// write it out to disk.
// Check if file exists:
int fileMode = -1;
bool createNew = true;
KDE_struct_stat buf;
if(KDE_stat(QFile::encodeName(filename), &buf) == 0)
{
if(buf.st_uid == getuid())
{
// Preserve file mode if file exists and is owned by user.
fileMode = buf.st_mode & 0777;
}
else
{
// File is not owned by user:
// Don't create new file but write to existing file instead.
createNew = false;
}
}
KSaveFile *pConfigFile = 0;
FILE *pStream = 0;
if(createNew)
{
pConfigFile = new KSaveFile(filename, 0600);
if(pConfigFile->status() != 0)
{
delete pConfigFile;
return bEntriesLeft;
}
if(!bGlobal && (fileMode == -1))
fileMode = mFileMode;
if(fileMode != -1)
{
fchmod(pConfigFile->handle(), fileMode);
}
pStream = pConfigFile->fstream();
}
else
{
// Open existing file.
// We use open() to ensure that we call without O_CREAT.
int fd = KDE_open(QFile::encodeName(filename), O_WRONLY | O_TRUNC);
if(fd < 0)
{
return bEntriesLeft;
}
pStream = KDE_fdopen(fd, "w");
if(!pStream)
{
close(fd);
return bEntriesLeft;
}
}
writeEntries(pStream, aTempMap);
if(pConfigFile)
{
bool bEmptyFile = (ftell(pStream) == 0);
if(bEmptyFile && ((fileMode == -1) || (fileMode == 0600)))
{
// File is empty and doesn't have special permissions: delete it.
::unlink(QFile::encodeName(filename));
pConfigFile->abort();
}
else
{
// Normal case: Close the file
pConfigFile->close();
}
delete pConfigFile;
}
else
{
fclose(pStream);
}
return bEntriesLeft;
}
int
main(int argc, char *argv[]) {
int in;
struct stat sb;
uint8 *buf;
index_header *h;
struct options opts;
char outnbuf[512];
parse_arguments(argc, argv, &opts);
in = open(opts.infile, O_RDONLY);
if (in == -1) {
fprintf(stderr, "Error: Could not open file %s: %s\n", opts.infile,
strerror(errno));
return EXIT_FAILURE;
}
if (fstat(in, &sb) == -1) {
perror("stat() failed");
return EXIT_FAILURE;
}
buf = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, in, 0);
if (buf == MAP_FAILED) {
perror("mmap() failed");
return EXIT_FAILURE;
}
close(in);
if (opts.sound && !opts.outfile) {
char *pdot = strrchr(opts.infile, '.');
opts.outfile = outnbuf;
strcpy(outnbuf, opts.infile);
if (pdot)
outnbuf[pdot - opts.infile] = 0;
}
h = readIndex(buf);
if (opts.print)
printIndex(h, buf, stdout);
if (opts.list) {
listEntries(h, buf, stdout);
}
if (opts.sound && opts.outfile) {
writeSoundEntries(h, buf, opts.outfile);
} else if (opts.outfile) {
FILE *out;
out = fopen(opts.outfile, "wb+");
if (out == NULL) {
fprintf(stderr, "Could not open output file '%s': %s\n",
opts.outfile, strerror(errno));
exit(EXIT_FAILURE);
}
writeEntries(h, buf, out);
fclose(out);
}
// freeIndex(h);
munmap(buf, sb.st_size);
return EXIT_SUCCESS;
}
//
// writes the specified flash variable with the specified value
//
bool writeFlashVar( char const *name,
char const *value )
{
bool worked = false ;
readVars_t rv ;
char const *devName = GetFlashDev();
debugPrint( "opening flash device %s\n", devName );
if( rv.worked() )
{
unsigned const nameLen = strlen( name );
unsigned const dataLen = strlen( value );
unsigned const avail = rv.maxSize() - rv.bytesUsed();
unsigned int bDevice = IsDevice(devName);
if (bDevice && ( avail > nameLen + dataLen + 2 ))
{
int fd = open( devName, O_WRONLY );
if( 0 <= fd )
{
mtd_info_t meminfo;
if( ioctl( fd, MEMGETINFO, (unsigned long)&meminfo) == 0)
{
if( meminfo.erasesize == rv.maxSize() )
{
unsigned offset = meminfo.size-meminfo.erasesize+ rv.bytesUsed();
if( offset == (unsigned)lseek( fd, offset, SEEK_SET ) )
{
//
// build memory image of new entry
//
char *entryStart = (char *)rv.startChar() + rv.bytesUsed();
memcpy( entryStart, name, nameLen );
char *upd = entryStart + nameLen ;
*upd++ = '=' ;
memcpy( upd, value, dataLen );
upd += dataLen ;
*upd++ = '\n' ;
unsigned const entryLen = upd-entryStart ;
int const numWrote = write( fd, entryStart, entryLen );
if( (unsigned)numWrote == entryLen )
{
// printf( "wrote %u bytes of new entry\n", numWrote );
}
else
perror( "write" );
}
else
perror( "lseek2" );
}
else
fprintf( stderr, "erase size mismatch: rv %u, mi %u\n", rv.maxSize(), meminfo.erasesize );
}
else {
perror( "MEMGETINFO" );
}
close( fd );
}
else
perror(devName);
}
else
{
fprintf( stderr, "Collapse vars\n" );
//
// first, find number of entries by searching for newlines
//
unsigned maxEntries = 0 ;
unsigned spaceLeft = rv.bytesUsed();
char const *next = rv.startChar();
while( 0 < spaceLeft )
{
void const *nl = memchr( next, '\n', spaceLeft );
if( nl )
{
maxEntries++ ;
unsigned offs = (char *)nl - next + 1 ;
next += offs ;
spaceLeft -= offs ;
}
else
break;
}
if ( 1 )
{
printf( "%u entries in list\n", maxEntries+1 );
unsigned numUnique = 0 ;
unsigned uniqueSize = 0 ;
entry_t * const entries = (entry_t *)malloc(sizeof(entry_t)*(maxEntries+1) );
memset( entries, 0, maxEntries*sizeof(entry_t) );
varIter_t it( rv );
entry_t nextEntry ;
while( it.next( nextEntry.name, nextEntry.nameLen, nextEntry.data, nextEntry.dataLen ) )
{
unsigned i ;
for( i = 0 ; i < numUnique ; i++ )
{
if( ( entries[i].nameLen == nextEntry.nameLen )
&&
( 0 == memcmp( entries[i].name, nextEntry.name, nextEntry.nameLen ) ) )
{
break;
}
}
if( i < numUnique )
{
uniqueSize -= entries[i].dataLen ;
uniqueSize += nextEntry.dataLen ;
entries[i].data = nextEntry.data ;
entries[i].dataLen = nextEntry.dataLen ;
} // duplicate
else
{
entries[numUnique++] = nextEntry ;
uniqueSize += nextEntry.nameLen ;
uniqueSize += nextEntry.dataLen ;
} // first timer
} // for each entry in flash
//
// now add original entry (remember why we're here)
//
unsigned i ;
for( i = 0 ; i < numUnique ; i++ )
{
if( ( entries[i].nameLen == nameLen )
&&
( 0 == memcmp( entries[i].name, name, nameLen ) ) )
{
break;
}
}
if( i < numUnique )
{
uniqueSize -= entries[i].dataLen ;
uniqueSize += dataLen ;
entries[i].data = value ;
entries[i].dataLen = dataLen ;
} // duplicate
else
{
entries[i].name = name ;
entries[i].nameLen = nameLen ;
entries[i].data = value ;
entries[i].dataLen = dataLen ;
uniqueSize += nameLen ;
uniqueSize += dataLen ;
numUnique++ ;
} // new entry
uniqueSize += 2*numUnique ;
printf( "%u unique entries, %u bytes\n", numUnique, uniqueSize );
if( uniqueSize < rv.maxSize() )
{
printf( "saving %u bytes\n", uniqueSize );
int fd = open( devName, O_WRONLY );
if( 0 <= fd )
{
if (bDevice) {
mtd_info_t meminfo;
if( 0 == ioctl( fd, MEMGETINFO, (unsigned long)&meminfo) )
{
if( meminfo.erasesize == rv.maxSize() )
{
unsigned offset = meminfo.size-meminfo.erasesize ;
erase_info_t erase;
erase.start = offset ;
erase.length = meminfo.erasesize;
if( 0 == ioctl( fd, MEMERASE, (unsigned long)&erase) )
{
if( offset == (unsigned)lseek( fd, offset, SEEK_SET ) )
{
writeEntries(fd, entries,numUnique,uniqueSize);
worked = true ;
}
else
perror( "lseek3" );
}
else
fprintf( stderr, "erase error %m\n" );
}
else
fprintf( stderr, "erase size mismatch: rv %u, mi %u\n", rv.maxSize(), meminfo.erasesize );
}
else
perror( "MEMGETINFO" );
} else {
writeEntries(fd, entries,numUnique,uniqueSize);
worked = true ;
}
close( fd );
}
else
perror(devName);
}
else
fprintf( stderr, "Flash parameter area is full!\n" );
free( entries );
}
else
fprintf( stderr, "Error counting entries: why is size so big?\n" );
}
}
return worked ;
}
