void SelectResourceImage::listDirectory(QDir dir, QStandardItem *parentItem, const QString& pathPrefix)
{
QStringList dirs=dir.entryList(QDir::AllDirs|QDir::NoDotAndDotDot,QDir::Name);
QStringList filters;
filters<<"*.png"<<"*.jpg"<<"*.bmp"<<"*.svg"<<"*.tif";
QStringList files=dir.entryList(filters,QDir::Files,QDir::Name);
for (int i = 0; i < dirs.size(); ++i) {
QStandardItem *item = new QStandardItem(dirs[i]);
item->setData(dir.absolutePath()+"/"+dirs[i]+"/");
item->setData(false, Qt::UserRole+2);
item->setIcon(QIcon(":/lib/file_opendir.png"));
parentItem->appendRow(item);
QDir d=dir;
d.cd(dirs[i]);
if (pathPrefix.isEmpty()) {
listDirectory(d, item, "");
} else {
listDirectory(d, item, pathPrefix+dirs[i]+"/");
}
}
for (int i = 0; i < files.size(); ++i) {
QString abspath=dir.absoluteFilePath(files[i]);
QStandardItem *item = new QStandardItem(QIcon(abspath), files[i]);
item->setData(true, Qt::UserRole+2);
if (pathPrefix.isEmpty()) {
item->setData(abspath);
} else {
item->setData(pathPrefix+files[i]);
}
parentItem->appendRow(item);
}
}
boolean get_handler(AtMegaWebServer& web_server){
const char* filename = web_server.get_path();
#if DEBUG
Serial << F("file_handler path: ") << filename << '\n';
#endif
if (!filename) {
web_server.sendHttpResult(404);
#if DEBUG
Serial << F("Could not parse URL");
#endif
return true;
}
if(filename[0] == '/' && filename[1] == 0){ // root dir, file.open() will fail
listDirectory(web_server, SdBaseFile::cwd());
return true;
}
SdFile file;
if(file.open(filename, O_READ)){
#if DEBUG
Serial << "file isOpen: " << filename << '\n';
#endif
if (file.isDir())
{
listDirectory(web_server, &file);
}
else
{
AtMegaWebServer::MimeType mime_type
= AtMegaWebServer::get_mime_type_from_filename(filename);
// If you want to send a file with a non-supported MimeType you can:
// web_server.sendHttpResult(200, 0, "Content-Type: image/tiff" CRLF);
web_server.sendHttpResult(200, mime_type);
#if DEBUG
Serial << F("Read file ");
Serial.println(filename);
#endif
web_server.send_file(file);
}
file.close();
}else{
web_server.sendHttpResult(404);
}
return true;
}
void LocalStorageDatabaseTracker::updateTrackerDatabaseFromLocalStorageDatabaseFiles()
{
Vector<String> paths = listDirectory(m_localStorageDirectory, "*.localstorage");
HashSet<String> origins(m_origins);
HashSet<String> originsFromLocalStorageDatabaseFiles;
for (size_t i = 0; i < paths.size(); ++i) {
const String& path = paths[i];
if (!path.endsWith(".localstorage"))
continue;
String filename = pathGetFileName(path);
String originIdentifier = filename.substring(0, filename.length() - strlen(".localstorage"));
if (!m_origins.contains(originIdentifier))
addDatabaseWithOriginIdentifier(originIdentifier, path);
originsFromLocalStorageDatabaseFiles.add(originIdentifier);
}
for (auto it = origins.begin(), end = origins.end(); it != end; ++it) {
const String& originIdentifier = *it;
if (origins.contains(originIdentifier))
continue;
removeDatabaseWithOriginIdentifier(originIdentifier);
}
}
static void removeAllDatabasesForOriginPath(const String& originPath, double startDate, double endDate)
{
// FIXME: We should also close/invalidate any live handles to the database files we are about to delete.
// Right now:
// - For read-only operations, they will continue functioning as normal on the unlinked file.
// - For write operations, they will start producing errors as SQLite notices the missing backing store.
// This is tracked by https://bugs.webkit.org/show_bug.cgi?id=135347
Vector<String> databasePaths = listDirectory(originPath, "*");
for (auto& databasePath : databasePaths) {
String databaseFile = pathByAppendingComponent(databasePath, "IndexedDB.sqlite3");
if (!fileExists(databaseFile))
continue;
time_t modTime;
getFileModificationTime(databaseFile, modTime);
if (modTime < startDate || modTime > endDate)
continue;
deleteFile(databaseFile);
deleteEmptyDirectory(databasePath);
}
deleteEmptyDirectory(originPath);
}
static void removeAllDatabasesForOriginPath(const String& originPath, std::chrono::system_clock::time_point modifiedSince)
{
Vector<String> databasePaths = listDirectory(originPath, "*");
for (auto& databasePath : databasePaths) {
String databaseFile = pathByAppendingComponent(databasePath, "IndexedDB.sqlite3");
if (!fileExists(databaseFile))
continue;
if (modifiedSince > std::chrono::system_clock::time_point::min()) {
time_t modificationTime;
if (!getFileModificationTime(databaseFile, modificationTime))
continue;
if (std::chrono::system_clock::from_time_t(modificationTime) < modifiedSince)
continue;
}
SQLiteFileSystem::deleteDatabaseFile(databaseFile);
deleteEmptyDirectory(databasePath);
}
deleteEmptyDirectory(originPath);
}
void Particles::init(){
/// collect textures
std::vector<std::string> &&images = listDirectory("../res/textures/CGI256"s);
ResourceLoader loader;
Global::main.commonResources.textureAtlas["Cgi256"] = loader.loadAtlas(images, "../res/textures/CGI256"s);
createBuffer();
}
void RemoteBrowserDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 data) {
switch (cmd) {
case kChooseCmd: {
// If nothing is selected in the list widget, choose the current dir.
// Else, choose the dir that is selected.
int selection = _fileList->getSelected();
if (selection >= 0)
_choice = _nodeContent[selection];
else
_choice = _node;
setResult(1);
close();
break;
}
case kGoUpCmd:
goUp();
break;
case kListItemActivatedCmd:
case kListItemDoubleClickedCmd:
if (_nodeContent[data].isDirectory()) {
_rememberedNodeContents[_node.path()] = _nodeContent;
listDirectory(_nodeContent[data]);
}
break;
case kListSelectionChangedCmd:
// We do not allow selecting directories,
// thus we will invalidate the selection
// when the user selects a directory over here.
if (data != (uint32)-1 && !_nodeContent[data].isDirectory())
_fileList->setSelected(-1);
break;
default:
Dialog::handleCommand(sender, cmd, data);
}
}
SelectResourceImage::SelectResourceImage(const QString &directory, QWidget *parent, const QString& pathPrefix) :
QFDialog(parent),
ui(new Ui::SelectResourceImage)
{
ui->setupUi(this);
connect(ui->treeView, SIGNAL(clicked(QModelIndex)), this, SLOT(treeClicked(QModelIndex)));
connect(ui->listView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(listDoubleClicked(QModelIndex)));
QStandardItem *parentItem = model.invisibleRootItem();
listDirectory(QDir(directory), parentItem, pathPrefix);
ui->treeView->setModel(&model);
ui->listView->setModel(&model);
ui->listView->setRootIndex(model.index(0,0));
ui->spinIconSize->setValue(16);
isMulti=false;
ProgramOptions::getConfigWindowGeometry(this, "SelectResourceImage/window");
ProgramOptions::getConfigQSplitter(ui->splitter, "SelectResourceImage/splitter");
ProgramOptions::getConfigQSpinBox(ui->spinIconSize, "SelectResourceImage/spinIconSize");
ProgramOptions::getConfigQToolButton(ui->btnLarge, "SelectResourceImage/btnLarge");
ProgramOptions::getConfigQToolButton(ui->btnList, "SelectResourceImage/btnList");
ProgramOptions::getConfigQToolButton(ui->btnTreeOnly, "SelectResourceImage/btnTreeOnly");
updateView();
setWindowFlags(windowFlags()|Qt::WindowMinMaxButtonsHint);
}
void DU_File::listDirectory(const string &path, vector<string> &files, bool bRecursive)
{
vector<string> tf;
scanDir(path, tf, 0, 0);
for(size_t i = 0; i < tf.size(); i++)
{
if(tf[i] == "." || tf[i] == "..")
continue;
string s = path + "/" + tf[i];
if(isFileExist(s, S_IFDIR))
{
files.push_back(simplifyDirectory(s));
if(bRecursive)
{
listDirectory(s, files, bRecursive);
}
}
else
{
files.push_back(simplifyDirectory(s));
}
}
}
Vector<SecurityOriginData> DatabaseProcess::getIndexedDatabaseOrigins()
{
Vector<SecurityOriginData> results;
if (m_indexedDatabaseDirectory.isEmpty()) {
return results;
}
Vector<String> originPaths = listDirectory(m_indexedDatabaseDirectory, "*");
for (auto& originPath : originPaths) {
URL url;
url.setProtocol(ASCIILiteral("file"));
url.setPath(originPath);
String databaseIdentifier = url.lastPathComponent();
RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::maybeCreateFromDatabaseIdentifier(databaseIdentifier);
if (!securityOrigin)
continue;
results.append(SecurityOriginData::fromSecurityOrigin(securityOrigin.get()));
}
return results;
}
static int _testListInvalidDirectory(void) {
CharString c = newCharStringWithCString("invalid");
LinkedList l = listDirectory(c);
assertIntEquals(linkedListLength(l), 0);
freeLinkedList(l);
freeCharString(c);
return 0;
}
void listDirectory(const std::string& path, Vector<std::string>& list) {
std::vector<std::string> vec;
listDirectory(path, vec);
list.clear();
for (std::string file : vec) {
list.add(file);
}
}
TEST(FileUtils, Listdirectory)
{
std::string directory = "test/zip";
std::vector<std::string> result = listDirectory(directory);
ASSERT_EQ(1, result.size());
}
void DatabaseProcess::deleteIndexedDatabaseEntriesModifiedBetweenDates(double startDate, double endDate)
{
if (m_indexedDatabaseDirectory.isEmpty())
return;
Vector<String> originPaths = listDirectory(m_indexedDatabaseDirectory, "*");
for (auto& originPath : originPaths)
removeAllDatabasesForOriginPath(originPath, startDate, endDate);
}
void DatabaseProcess::deleteAllIndexedDatabaseEntries()
{
if (m_indexedDatabaseDirectory.isEmpty())
return;
Vector<String> originPaths = listDirectory(m_indexedDatabaseDirectory, "*");
for (auto& originPath : originPaths)
removeAllDatabasesForOriginPath(originPath, std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max());
}
void DatabaseProcess::deleteIndexedDatabaseEntriesModifiedSince(std::chrono::system_clock::time_point modifiedSince)
{
if (m_indexedDatabaseDirectory.isEmpty())
return;
Vector<String> originPaths = listDirectory(m_indexedDatabaseDirectory, "*");
for (auto& originPath : originPaths)
removeAllDatabasesForOriginPath(originPath, modifiedSince);
}
void IDBServer::performCloseAndDeleteDatabasesModifiedSince(std::chrono::system_clock::time_point modifiedSince, uint64_t callbackID)
{
if (!m_databaseDirectoryPath.isEmpty()) {
Vector<String> originPaths = listDirectory(m_databaseDirectoryPath, "*");
for (auto& originPath : originPaths)
removeAllDatabasesForOriginPath(originPath, modifiedSince);
}
postDatabaseTaskReply(createCrossThreadTask(*this, &IDBServer::didPerformCloseAndDeleteDatabases, callbackID));
}
static int _testListEmptyDirectory(void) {
CharString tempDir = _fileUtilitiesMakeTempDir();
LinkedList l = listDirectory(tempDir);
assertIntEquals(linkedListLength(l), 0);
removeDirectory(tempDir);
freeCharString(tempDir);
freeLinkedListAndItems(l, (LinkedListFreeItemFunc)freeCharString);
return 0;
}
unsigned long long DatabaseTracker::usageForOrigin(SecurityOrigin* origin)
{
String originPath = this->originPath(origin);
unsigned long long diskUsage = 0;
for (auto& fileName : listDirectory(originPath, ASCIILiteral("*.db"))) {
long long size;
getFileSize(fileName, size);
diskUsage += size;
}
return diskUsage;
}
void FilesPageHandler::handle(Client &client) {
Common::String response =
"<html>" \
"<head><title>ScummVM</title></head>" \
"<body>" \
"<p>{create_directory_desc}</p>" \
"<form action=\"create\">" \
"<input type=\"hidden\" name=\"path\" value=\"{path}\"/>" \
"<input type=\"text\" name=\"directory_name\" value=\"\"/>" \
"<input type=\"submit\" value=\"{create_directory_button}\"/>" \
"</form>" \
"<hr/>" \
"<p>{upload_file_desc}</p>" \
"<form action=\"upload?path={path}\" method=\"post\" enctype=\"multipart/form-data\">" \
"<input type=\"file\" name=\"upload_file-f\" allowdirs multiple/>" \
"<span>{or_upload_directory_desc}</span>" \
"<input type=\"file\" name=\"upload_file-d\" directory webkitdirectory multiple/>" \
"<input type=\"submit\" value=\"{upload_file_button}\"/>" \
"</form>"
"<hr/>" \
"<h1>{index_of_directory}</h1>" \
"<table>{content}</table>" \
"</body>" \
"</html>";
Common::String itemTemplate = "<tr><td><img src=\"icons/{icon}\"/></td><td><a href=\"{link}\">{name}</a></td><td>{size}</td></tr>\n"; //TODO: load this template too?
// load stylish response page from the archive
Common::SeekableReadStream *const stream = HandlerUtils::getArchiveFile(FILES_PAGE_NAME);
if (stream)
response = HandlerUtils::readEverythingFromStream(stream);
Common::String path = client.queryParameter("path");
Common::String content = "";
// show an error message if failed to list directory
if (!listDirectory(path, content, itemTemplate)) {
HandlerUtils::setFilesManagerErrorMessageHandler(client, _("ScummVM couldn't list the directory you specified."));
return;
}
//these occur twice:
replace(response, "{create_directory_button}", _("Create directory"));
replace(response, "{create_directory_button}", _("Create directory"));
replace(response, "{path}", encodeDoubleQuotes(client.queryParameter("path")));
replace(response, "{path}", encodeDoubleQuotes(client.queryParameter("path")));
replace(response, "{upload_files_button}", _("Upload files")); //tab
replace(response, "{upload_file_button}", _("Upload files")); //button in the tab
replace(response, "{create_directory_desc}", _("Type new directory name:"));
replace(response, "{upload_file_desc}", _("Select a file to upload:"));
replace(response, "{or_upload_directory_desc}", _("Or select a directory (works in Chrome only):"));
replace(response, "{index_of_directory}", Common::String::format(_("Index of %s"), encodeHtmlEntities(getDisplayPath(client.queryParameter("path"))).c_str()));
replace(response, "{content}", content);
LocalWebserver::setClientGetHandler(client, response);
}
SelectResourceImage::SelectResourceImage(const QStringList &directories, QWidget *parent, const QStringList &pathPrefixes, const QStringList &baseNodeNames) :
QFDialog(parent),
ui(new Ui::SelectResourceImage)
{
ui->setupUi(this);
connect(ui->treeView, SIGNAL(clicked(QModelIndex)), this, SLOT(treeClicked(QModelIndex)));
connect(ui->listView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(listDoubleClicked(QModelIndex)));
if (baseNodeNames.isEmpty()) {
QStandardItem *parentItem = model.invisibleRootItem();
for (int i=0; i<directories.size(); i++) {
listDirectory(QDir(directories[i]), parentItem, pathPrefixes.value(i, ""));
}
} else {
QStandardItem *inv = model.invisibleRootItem();
for (int i=0; i<directories.size(); i++) {
QStandardItem *parentItem=new QStandardItem(baseNodeNames.value(i, tr("group %1").arg(i+1)));
parentItem->setData(false, Qt::UserRole+2);
parentItem->setData(QDir(directories[i]).absolutePath());
inv->appendRow(parentItem);
listDirectory(QDir(directories[i]), parentItem, pathPrefixes.value(i, ""));
}
}
ui->treeView->setModel(&model);
ui->listView->setModel(&model);
ui->listView->setRootIndex(model.index(0,0));
ui->btnLarge->setChecked(true);
ui->spinIconSize->setValue(64);
isMulti=true;
ProgramOptions::getConfigWindowGeometry(this, "SelectResourceImageMulti/window");
ProgramOptions::getConfigQSplitter(ui->splitter, "SelectResourceImageMulti/splitter");
ProgramOptions::getConfigQSpinBox(ui->spinIconSize, "SelectResourceImageMulti/spinIconSize");
ProgramOptions::getConfigQToolButton(ui->btnLarge, "SelectResourceImageMulti/btnLarge");
ProgramOptions::getConfigQToolButton(ui->btnList, "SelectResourceImageMulti/btnList");
ProgramOptions::getConfigQToolButton(ui->btnTreeOnly, "SelectResourceImageMulti/btnTreeOnly");
updateView();
setWindowFlags(windowFlags()|Qt::WindowMinMaxButtonsHint);
}
/**
* Search and release filter object.
*/
size_t File::list(FileList &result, FileFilter *filter) const
{
try {
size_t s = listDirectory(result, filter);
delete filter;
return s;
}
catch (...) {
delete filter;
throw;
}
}
Iterator newDirectoryIterator(string dir) {
Iterator iterator;
string *names;
int i;
iterator = newListIterator(sizeof (string), NULL);
names = listDirectory(dir);
for (i = 0; names[i] != NULL; i++) {
addToIteratorList(iterator, &names[i]);
}
return iterator;
}
Vector<String> PluginInfoStore::pluginPathsInDirectory(const String& directory)
{
Vector<String> result;
Vector<String> pluginPaths = listDirectory(directory, String("*.so"));
Vector<String>::const_iterator end = pluginPaths.end();
for (Vector<String>::const_iterator it = pluginPaths.begin(); it != end; ++it) {
if (fileExists(*it))
result.append(*it);
}
return result;
}
void StorageTracker::syncFileSystemAndTrackerDatabase()
{
ASSERT(!isMainThread());
SQLiteTransactionInProgressAutoCounter transactionCounter;
ASSERT(m_isActive);
Vector<String> paths;
{
MutexLocker locker(m_databaseMutex);
paths = listDirectory(m_storageDirectoryPath, "*.localstorage");
}
// Use a copy of m_originSet to find expired entries and to schedule their
// deletions from disk and from m_originSet.
OriginSet originSetCopy;
{
MutexLocker locker(m_originSetMutex);
for (OriginSet::const_iterator it = m_originSet.begin(), end = m_originSet.end(); it != end; ++it)
originSetCopy.add((*it).isolatedCopy());
}
// Add missing StorageTracker records.
OriginSet foundOrigins;
String fileExtension = ASCIILiteral(".localstorage");
for (Vector<String>::const_iterator it = paths.begin(), end = paths.end(); it != end; ++it) {
const String& path = *it;
if (path.length() > fileExtension.length() && path.endsWith(fileExtension, true)) {
String file = pathGetFileName(path);
String originIdentifier = file.substring(0, file.length() - fileExtension.length());
if (!originSetCopy.contains(originIdentifier))
syncSetOriginDetails(originIdentifier, path);
foundOrigins.add(originIdentifier);
}
}
// Delete stale StorageTracker records.
for (OriginSet::const_iterator it = originSetCopy.begin(), end = originSetCopy.end(); it != end; ++it) {
const String& originIdentifier = *it;
if (foundOrigins.contains(originIdentifier))
continue;
String originIdentifierCopy = originIdentifier.isolatedCopy();
callOnMainThread([this, originIdentifierCopy] {
deleteOriginWithIdentifier(originIdentifierCopy);
});
}
}
/**
* @brief Recursively lists all directories in the global queue and empties that queue
*/
void list_recursive() {
DIRENTRY* directoryEntry;
unsigned int nextCluster;
while((directoryEntry = dir_pop_front())) {
nextCluster = directoryEntry->firstcluser;
do{
listDirectory(getclusteroffset(nextCluster));
}while((nextCluster = getnextcluster(nextCluster)) < CLUSTER_LAST_MIN);
printf("\n");
}
}
void StorageTracker::syncFileSystemAndTrackerDatabase()
{
ASSERT(!isMainThread());
ASSERT(m_isActive);
m_databaseGuard.lock();
DEFINE_STATIC_LOCAL(const String, fileMatchPattern, ("*.localstorage"));
DEFINE_STATIC_LOCAL(const String, fileExt, (".localstorage"));
DEFINE_STATIC_LOCAL(const unsigned, fileExtLength, (fileExt.length()));
m_databaseGuard.unlock();
Vector<String> paths;
{
MutexLocker lock(m_databaseGuard);
paths = listDirectory(m_storageDirectoryPath, fileMatchPattern);
}
// Use a copy of m_originSet to find expired entries and to schedule their
// deletions from disk and from m_originSet.
OriginSet originSetCopy;
{
MutexLocker lock(m_originSetGuard);
OriginSet::const_iterator end = m_originSet.end();
for (OriginSet::const_iterator it = m_originSet.begin(); it != end; ++it)
originSetCopy.add((*it).threadsafeCopy());
}
// Add missing StorageTracker records.
OriginSet foundOrigins;
Vector<String>::const_iterator end = paths.end();
for (Vector<String>::const_iterator it = paths.begin(); it != end; ++it) {
String path = *it;
if (path.endsWith(fileExt, true) && path.length() > fileExtLength) {
String file = pathGetFileName(path);
String originIdentifier = file.substring(0, file.length() - fileExtLength);
if (!originSetCopy.contains(originIdentifier))
syncSetOriginDetails(originIdentifier, path);
foundOrigins.add(originIdentifier);
}
}
// Delete stale StorageTracker records.
OriginSet::const_iterator setEnd = originSetCopy.end();
for (OriginSet::const_iterator it = originSetCopy.begin(); it != setEnd; ++it) {
if (!foundOrigins.contains(*it)) {
RefPtr<StringImpl> originIdentifier = (*it).threadsafeCopy().impl();
callOnMainThread(deleteOriginOnMainThread, originIdentifier.release().leakRef());
}
}
}
unsigned long long DatabaseTracker::usageForOrigin(SecurityOrigin* origin)
{
String originPath = this->originPath(origin);
unsigned long long diskUsage = 0;
Vector<String> fileNames = listDirectory(originPath, String("*.db"));
Vector<String>::iterator fileName = fileNames.begin();
Vector<String>::iterator lastFileName = fileNames.end();
for (; fileName != lastFileName; ++fileName) {
long long size;
getFileSize(*fileName, size);
diskUsage += size;
}
return diskUsage;
}
void IDBServer::performGetAllDatabaseNames(uint64_t serverConnectionIdentifier, const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID)
{
String directory = IDBDatabaseIdentifier::databaseDirectoryRelativeToRoot(mainFrameOrigin, openingOrigin, m_databaseDirectoryPath);
Vector<String> entries = listDirectory(directory, ASCIILiteral("*"));
Vector<String> databases;
databases.reserveInitialCapacity(entries.size());
for (auto& entry : entries) {
String encodedName = lastComponentOfPathIgnoringTrailingSlash(entry);
databases.uncheckedAppend(SQLiteIDBBackingStore::databaseNameFromEncodedFilename(encodedName));
}
postDatabaseTaskReply(createCrossThreadTask(*this, &IDBServer::didGetAllDatabaseNames, serverConnectionIdentifier, callbackID, databases));
}
static void directoryToHTML(const char* path)
{
LST_HEAD* l;
#if 0
char topDirectory[1024];
char currentDirectory[1024];
char key[1024];
#endif
FILE_ENTRY* f;
char parentPath[1024];
char *c;
strcpy(parentPath, path);
c = parentPath + strlen(parentPath);
while (*(--c) != '/')
;
*c = '\0';
l = LST_Create();
listDirectory(path, &l);
html_header();
html_begin_body_options("File View", "bgcolor=#ffffff");
while ((f = LST_Dequeue(&l)) != NULL) {
if (strcmp(f->fileName, "..") == 0) {
printf("<br><a href=""/cgi-bin/fileview.cgi"
"?submitSearch=FileSelect"
"&Key=%s"
"&CurrentDirectory=%s"
"&>%s</a>\n",
".",
parentPath,
f->fileName);
} else {
printf("<br><a href=""/cgi-bin/fileview.cgi"
"?submitSearch=FileSelect"
"&Key=%s"
"&CurrentDirectory=%s"
"&>%s</a>\n",
f->fileName,
path,
f->fileName);
}
free(f);
}
html_end();
LST_Destroy(&l);
}
