예제 #1
0
파일: utils.c 프로젝트: azuwis/cview
static void extract_zip_file_into_loader(GdkPixbufLoader * loader,
        const char *archname,
        const char *archpath)
{
    if (loader == NULL)
        return;
    ZZIP_DIR *dir = zzip_dir_open(archname, 0);
    ZZIP_FILE *fp = zzip_file_open(dir, archpath, 0);
    if (fp) {
        guchar buf[ZIPBUFSIZE];
        GError *error = NULL;
        zzip_ssize_t len;
        while ((len = zzip_file_read(fp, buf, ZIPBUFSIZE))) {
            gdk_pixbuf_loader_write(loader, buf, len, &error);
            if (error != NULL) {
                g_warning("load image in zip failed: %s\n",
                          error->message);
                g_error_free(error);
                zzip_dir_close(dir);
                return;
            }
        }
        zzip_file_close(fp);
    }
    zzip_dir_close(dir);
}
예제 #2
0
int
main(int argc, char** argv)
{
  static const char map_path[] = "tmp/map.xcm";

  ZZIP_DIR *dir = zzip_dir_open(map_path, nullptr);
  if (dir == nullptr) {
    fprintf(stderr, "Failed to open %s\n", map_path);
    return EXIT_FAILURE;
  }

  RasterMap map;

  NullOperationEnvironment operation;
  if (!LoadTerrainOverview(dir, map.GetTileCache(), operation)) {
    fprintf(stderr, "failed to load map\n");
    zzip_dir_close(dir);
    return EXIT_FAILURE;
  }

  map.UpdateProjection();

  SharedMutex mutex;
  do {
    UpdateTerrainTiles(dir, map.GetTileCache(), mutex,
                       map.GetProjection(),
                       map.GetMapCenter(), 100000);
  } while (map.IsDirty());
  zzip_dir_close(dir);

  plan_tests(4 + NUM_SOL);
  ok(test_route(28, map), "route 28", 0);
  return exit_status();
}
void ResourceManager::ShutDown()
{
#ifdef _CACH_PARSED_DATA_
	for (std::map<const char*, ModelFileParser*>::iterator it = mModelFileParsers.begin(); it != mModelFileParsers.end(); it++)
	{
		delete it->second;
	}
	for (std::map<const char*, SoundData*>::iterator it = mSoundResource.begin(); it != mSoundResource.end(); it++)
	{
		delete it->second;
	}
	mModelFileParsers.clear();
	mSoundResource.clear();
#endif

	switch ( mAssetPacketExtension )
	{
		case PACA:
			mPacaReader.Close();
		break;

		case ZIP:
			zzip_dir_close( mDir );
		break;
	}

    mThreadPool.Destroy();
}
예제 #4
0
int main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "Usage: %s PATH\n", argv[0]);
        return 1;
    }

    const char *path = argv[1];

    ZZIP_DIR *dir = zzip_dir_open(path, NULL);
    if (dir == NULL) {
        fprintf(stderr, "Failed to open %s\n", (const char *)path);
        return EXIT_FAILURE;
    }

    ZipLineReaderA reader(dir, "topology.tpl");
    if (reader.error()) {
        fprintf(stderr, "Failed to open %s\n", (const char *)path);
        return EXIT_FAILURE;
    }

    TopographyStore topography;
    NullOperationEnvironment operation;
    topography.Load(operation, reader, NULL, dir);
    zzip_dir_close(dir);

    TestProjection projection;

    topography.ScanVisibility(projection);

    return EXIT_SUCCESS;
}
예제 #5
0
파일: zzip-file.c 프로젝트: brock7/TianLong
/**
 * the direct function of => zzip_close(fp). it will cleanup the
 * inflate-portion of => zlib and free the structure given.
 * 
 * it is called quite from the error-cleanup parts
 * of the various => _open functions. 
 * 
 * the .refcount is decreased and if zero the fp->dir is closed just as well.
 */
int 
zzip_file_close(ZZIP_FILE * fp)
{
    ZZIP_DIR * dir = fp->dir;
    
    if (fp->method)

        inflateEnd(&fp->d_stream); /* inflateEnd() can be called many times */

    if (fp->buf32k)
    {
        if (dir->cache.buf32k == NULL) dir->cache.buf32k = fp->buf32k;
        else free(fp->buf32k);
    }

    if (dir->currentfp == fp)
        dir->currentfp = NULL;
  
    dir->refcount--;
    /* ease to notice possible dangling reference errors */
    memset(fp, 0, sizeof(*fp)); 

    if (dir->cache.fp == NULL) dir->cache.fp = fp;
    else free(fp);
    
    if (! dir->refcount) return zzip_dir_close(dir); else return 0;
}
예제 #6
0
bool
WaypointGlue::LoadWaypoints(Waypoints &way_points,
                            const RasterTerrain *terrain,
                            OperationEnvironment &operation)
{
  LogFormat("ReadWaypoints");
  operation.SetText(_("Loading Waypoints..."));

  bool found = false;

  // Delete old waypoints
  way_points.Clear();

  TCHAR path[MAX_PATH];

  LoadWaypointFile(way_points, LocalPath(path, _T("user.cup")),
                   WaypointFileType::SEEYOU,
                   WaypointOrigin::USER, terrain, operation);

  // ### FIRST FILE ###
  if (Profile::GetPath(ProfileKeys::WaypointFile, path))
    found |= LoadWaypointFile(way_points, path, WaypointOrigin::PRIMARY,
                              terrain, operation);

  // ### SECOND FILE ###
  if (Profile::GetPath(ProfileKeys::AdditionalWaypointFile, path))
    found |= LoadWaypointFile(way_points, path, WaypointOrigin::ADDITIONAL,
                              terrain, operation);

  // ### WATCHED WAYPOINT/THIRD FILE ###
  if (Profile::GetPath(ProfileKeys::WatchedWaypointFile, path))
    found |= LoadWaypointFile(way_points, path, WaypointOrigin::WATCHED,
                              terrain, operation);

  // ### MAP/FOURTH FILE ###

  // If no waypoint file found yet
  if (!found) {
    auto dir = OpenMapFile();
    if (dir != nullptr) {
      found |= LoadWaypointFile(way_points, dir, "waypoints.xcw",
                                WaypointFileType::WINPILOT,
                                WaypointOrigin::MAP,
                                terrain, operation);

      found |= LoadWaypointFile(way_points, dir, "waypoints.cup",
                                WaypointFileType::SEEYOU,
                                WaypointOrigin::MAP,
                                terrain, operation);

      zzip_dir_close(dir);
    }
  }

  // Optimise the waypoint list after attaching new waypoints
  way_points.Optimise();

  // Return whether waypoints have been loaded into the waypoint list
  return found;
}
예제 #7
0
int main(int argc, char **argv)
{
  Args args(argc, argv, "PATH");
  const char *path = args.ExpectNext();
  args.ExpectEnd();

  ZZIP_DIR *dir = zzip_dir_open(path, NULL);
  if (dir == NULL) {
    fprintf(stderr, "Failed to open %s\n", (const char *)path);
    return EXIT_FAILURE;
  }

  ZipLineReaderA reader(dir, "topology.tpl");
  if (reader.error()) {
    fprintf(stderr, "Failed to open %s\n", (const char *)path);
    return EXIT_FAILURE;
  }

  TopographyStore topography;
  NullOperationEnvironment operation;
  topography.Load(operation, reader, NULL, dir);
  zzip_dir_close(dir);

  topography.LoadAll();

#ifdef ENABLE_OPENGL
  TriangulateAll(topography);
#endif

  return EXIT_SUCCESS;
}
예제 #8
0
파일: read_odf.c 프로젝트: skm42/opendias
size_t getEntry(const char *name, char *contentFile, char **ptr) {

  size_t size=0;
  ZZIP_DIR *dir;
  ZZIP_DIRENT entry;
  ZZIP_FILE *file;
  char *buf;

  dir = zzip_dir_open(name, 0);
  if (!dir) {
    fprintf(stderr, "failed to open %s\n", name);
    return 0;
  }

  zzip_dir_read(dir, &entry);

  file = zzip_file_open(dir, contentFile, 0);

  (void)zzip_seek(file, 0, SEEK_END);
  size = zzip_tell(file);
  (void)zzip_seek(file, 0, SEEK_SET);
  buf = (char *)malloc(size+1);
  (void)zzip_read(file, buf, size);
  buf[size] = '\0';
  *ptr = buf;

  zzip_file_close(file);
  zzip_dir_close(dir);

  return size;
}
예제 #9
0
void ZipWorker::Close()
{
    if (archive_)
    {
        zzip_dir_close(archive_);
        archive_ = 0;
    }
}
예제 #10
0
void ZipAssetBundle::Close()
{
    if (archive_)
    {
        zzip_dir_close(archive_);
        archive_ = 0;
    }
}
예제 #11
0
/** 卸载ZIP文件包
*/
void FZipFilePack::Unload(void)
{
    if( m_pZipDir )
    {
        zzip_dir_close( m_pZipDir );
        m_pZipDir = NULL;
        m_FileInfos.clear();
    }
}
예제 #12
0
bool ArchiveZip::close()
{
	ZZIP_DIR* zip = (ZZIP_DIR*) handle;
	if (!isValid)
		return true;

	int ret = zzip_dir_close(zip);
	return ret == ZZIP_NO_ERROR ;
}
예제 #13
0
/**
 * Load topography from the map file (ZIP), load the other files from
 * the same ZIP file.
 */
static bool
LoadConfiguredTopographyZip(TopographyStore &store,
                            OperationEnvironment &operation)
{
  auto dir = OpenMapFile();
  if (dir == nullptr)
    return false;

  ZipLineReaderA reader(dir, "topology.tpl", IgnoreError());
  if (reader.error()) {
    zzip_dir_close(dir);
    LogFormat(_T("No topography in map file"));
    return false;
  }

  store.Load(operation, reader, nullptr, dir);
  zzip_dir_close(dir);
  return true;
}
예제 #14
0
파일: OgreZip.cpp 프로젝트: brock7/TianLong
 //-----------------------------------------------------------------------
 void ZipArchive::unload()
 {
     if (mZzipDir)
     {
         zzip_dir_close(mZzipDir);
         mZzipDir = 0;
         mFileList.clear();
     }
 
 }
예제 #15
0
int main(int argc, char** argv) {
  static const char hc_path[] = "tmp/map.xcm";
  const char *map_path;
  if ((argc<2) || !strlen(argv[0])) {
    map_path = hc_path;
  } else {
    map_path = argv[0];
  }

  ZZIP_DIR *dir = zzip_dir_open(map_path, nullptr);
  if (dir == nullptr) {
    fprintf(stderr, "Failed to open %s\n", map_path);
    return EXIT_FAILURE;
  }

  RasterMap map;

  NullOperationEnvironment operation;
  if (!LoadTerrainOverview(dir, map.GetTileCache(),
                           operation)) {
    fprintf(stderr, "failed to load map\n");
    zzip_dir_close(dir);
    return EXIT_FAILURE;
  }

  map.UpdateProjection();

  SharedMutex mutex;
  do {
    UpdateTerrainTiles(dir, map.GetTileCache(), mutex,
                       map.GetProjection(),
                       map.GetMapCenter(), 100000);
  } while (map.IsDirty());
  zzip_dir_close(dir);

  plan_tests(16*3);
  test_troute(map, 0, 0.1, 10000);
  test_troute(map, 0, 0, 10000);
  test_troute(map, 5.0, 1, 10000);

  return exit_status();
}
예제 #16
0
파일: OgreZip.cpp 프로젝트: wjwwood/ogre
 //-----------------------------------------------------------------------
 void ZipArchive::unload()
 {
     OGRE_LOCK_AUTO_MUTEX;
     if (mZzipDir)
     {
         zzip_dir_close(mZzipDir);
         mZzipDir = 0;
         mFileList.clear();
     }
 
 }
예제 #17
0
파일: luazip.c 프로젝트: msva/luazip
static int zip_close (lua_State *L) {
  ZZIP_DIR* f = tofile(L, 1);
  if (zzip_dir_close(f) == 0)
  {
    *(ZZIP_DIR**)lua_touserdata(L, 1) = NULL; /* mark file as close */
    lua_pushboolean(L, 1);
  }
  else
    lua_pushboolean(L, 0);
  return 1;
}
예제 #18
0
void CZipArchive::unloadArchive()
{
//	for(int i=0;i<m_files.size();++i){
//		GCPtr<IStream>file=m_files[i].fileData;
//	}
	m_files.clear();

	if(m_zipDir){
		zzip_dir_close(m_zipDir);
		m_zipDir=0;
	}
}
예제 #19
0
Updater::~Updater()
{
	//关闭打开的zip文件
	PATCHFILE_MAP::iterator it;
	for(it=m_mapPatchFile.begin(); it!=m_mapPatchFile.end(); it++)
	{
		ZZIP_DIR* mZzipDir = (ZZIP_DIR*)(it->second);
		if(mZzipDir)
		{
			zzip_dir_close(mZzipDir);
			mZzipDir = 0;
		}
	}
	m_mapPatchFile.clear();
}
예제 #20
0
int main(int argc, char **argv)
{
  Args args(argc, argv, "PATH");
  const auto map_path = args.ExpectNext();
  args.ExpectEnd();

  ZZIP_DIR *dir = zzip_dir_open(map_path, nullptr);
  if (dir == nullptr) {
    fprintf(stderr, "Failed to open %s\n", map_path);
    return EXIT_FAILURE;
  }

  NullOperationEnvironment operation;
  RasterTileCache rtc;
  if (!LoadTerrainOverview(dir, rtc, operation)) {
    fprintf(stderr, "LoadOverview failed\n");
    zzip_dir_close(dir);
    return EXIT_FAILURE;
  }

  GeoBounds bounds = rtc.GetBounds();
  printf("bounds = %f|%f - %f|%f\n",
         (double)bounds.GetWest().Degrees(),
         (double)bounds.GetNorth().Degrees(),
         (double)bounds.GetEast().Degrees(),
         (double)bounds.GetSouth().Degrees());

  SharedMutex mutex;
  do {
    UpdateTerrainTiles(dir, rtc, mutex,
                       rtc.GetWidth() / 2, rtc.GetHeight() / 2, 1000);
  } while (rtc.IsDirty());
  zzip_dir_close(dir);

  return EXIT_SUCCESS;
}
예제 #21
0
void ZipResourceManager::populate() {
	zzip_error_t zzipError;
    ZZIP_DIR* zzipDir = zzip_dir_open(resourcePath.c_str(), &zzipError);
    checkZzipError(zzipError);

    ZZIP_DIRENT zzipEntry;
    while (zzip_dir_read(zzipDir, &zzipEntry))
    {
        int compressedSize = zzipEntry.d_csize;
        int uncompressedSize = zzipEntry.st_size;

		std::string name = std::string(zzipEntry.d_name);
		files[name] = SDL_RWFromZZIP((resourcePath + "/" + name).c_str(), "rb");
    }

	zzip_dir_close(zzipDir);
}
예제 #22
0
파일: zzip-dir.c 프로젝트: gkalab/cb2pgn
/**
 * This function is the equivalent of => closedir(3) for a realdir or zipfile.
 * <p>
 * This function is magic - if the given arg-ZZIP_DIR
 * is a real directory, it will call the real => closedir(3) and then
 * free the wrapping ZZIP_DIR structure. Otherwise it will divert 
 * to => zzip_dir_close which will free the ZZIP_DIR structure.
 */
int
zzip_closedir(ZZIP_DIR* dir)
{
    if (! dir) { errno = EBADF; return -1; }

    if (USE_DIRENT && dir->realdir)
    {
        _zzip_closedir(dir->realdir);
        free(dir->realname);
        free(dir);
        return 0;
    }else
    {
        zzip_dir_close(dir);
        return 0;
    }
}
예제 #23
0
/**
 * This function is the equivalent of => closedir(3) for a realdir or zipfile.
 * 
 * This function is magic - if the given arg-ZZIP_DIR
 * is a real directory, it will call the real => closedir(3) and then
 * free the wrapping ZZIP_DIR structure. Otherwise it will divert 
 * to => zzip_dir_close which will free the ZZIP_DIR structure.
 */
int
zzip_closedir(ZZIP_DIR * dir)
{
    if (! dir)
        { kdSetError ( KD_EBADF ); return -1; }
/*
    if (USE_DIRENT && dir->realdir)
    {
        _zzip_closedir(dir->realdir);
        free(dir->realname);
        free(dir);
        return 0;
    } else
*/ 
    {
        zzip_dir_close(dir);
        return 0;
    }
}
예제 #24
0
bool PluginLoader::ParseDirectory(FileSpecifier& dir)
{
  std::vector<dir_entry> de;
  if (!dir.ReadDirectory(de)) {
    return false;
  }

  for (std::vector<dir_entry>::const_iterator it = de.begin(); it != de.end();
       ++it) {
    FileSpecifier file = dir + it->name;
    if (it->name == "Plugin.xml") {
      ParsePlugin(file);
    }
    else if (it->is_directory && it->name[0] != '.') {
      ParseDirectory(file);
    }
#ifdef HAVE_ZZIP
    else if (algo::ends_with(it->name,
                             ".zip") || algo::ends_with(it->name, ".ZIP")) {
      // search it for a Plugin.xml file
      ZZIP_DIR* zzipdir = zzip_dir_open(file.GetPath(), 0);
      if (zzipdir) {
        ZZIP_DIRENT dirent;
        while (zzip_dir_read(zzipdir, &dirent))
        {
          if (algo::ends_with(dirent.d_name, "Plugin.xml")) {
            std::string archive = file.GetPath();
            FileSpecifier file_name =
              FileSpecifier(archive.substr(0,
                                           archive.find_last_of('.'))) +
              dirent.d_name;
            ParsePlugin(file_name);
          }
        }
        zzip_dir_close(zzipdir);
      }
    }
#endif
  }

  return true;
}
예제 #25
0
파일: utils.c 프로젝트: azuwis/cview
GList *get_filelist_from_zip(const char *archname, GtkFileFilter * filter)
{
    GList *filelist = NULL;
    gchar *filename = NULL;

    ZZIP_DIR *dir = zzip_dir_open(archname, 0);
    if (dir) {
        ZZIP_DIRENT dirent;
        while (zzip_dir_read(dir, &dirent) != 0) {
            filename = g_strdup(dirent.d_name);
            if ((filter != NULL
                    && gtk_filename_filter(filename, filter))
                    || filter == NULL)
                filelist = g_list_append(filelist, filename);
        }
        zzip_dir_close(dir);
    }
    return filelist;

}
예제 #26
0
/**
 * Load topology from the map file (ZIP), load the other files from
 * the same ZIP file.
 */
static bool
LoadConfiguredTopologyZip(TopologyStore &store)
{
  TCHAR path[MAX_PATH];
  if (!Profile::GetPath(szProfileMapFile, path))
    return false;

  ZZIP_DIR *dir = zzip_dir_open(NarrowPathName(path), NULL);
  if (dir == NULL)
    return false;

  ZipLineReaderA reader(dir, "topology.tpl");
  if (reader.error()) {
    LogStartUp(_T("No topology in map file: %s"), path);
    return false;
  }

  store.Load(reader, NULL, dir);
  zzip_dir_close(dir);
  return true;
}
예제 #27
0
size_t getEntry(const char *name, char *contentFile, char **ptr) {

  size_t size=0;
  ZZIP_DIR *dir;
  ZZIP_DIRENT entry;
  ZZIP_FILE *file;
  zzip_error_t error;
  char *buf;

  o_log(DEBUGM, "opening %s", name);

  dir = zzip_dir_open(name, &error);
  if (!dir) {
    o_log(ERROR, "failed to open %s", name);
    return 0;
  }

  while(zzip_dir_read(dir, &entry)) {

    if( 0 == strcmp(entry.d_name, contentFile) ) {

      file = zzip_file_open(dir, contentFile, O_RDONLY);

      (void)zzip_seek(file, 0, SEEK_END);
      size = zzip_tell(file);
      (void)zzip_seek(file, 0, SEEK_SET);

      buf = (char *)malloc(size+1);
      (void)zzip_read(file, buf, size);
      buf[size] = '\0';
      *ptr = buf;

      zzip_file_close(file);
    }
  }
  zzip_dir_close(dir);

  return size;
}
예제 #28
0
void
RasterWeather::ScanAll(const GeoPoint &location)
{
  /* not holding the lock here, because this method is only called
     during startup, when the other threads aren't running yet */

  TCHAR fname[MAX_PATH];
  LocalPath(fname, _T("xcsoar-rasp.dat"));

  ZZIP_DIR *dir = zzip_dir_open(NarrowPathName(fname), NULL);
  if (dir == NULL)
    return;

  ProgressGlue::SetRange(MAX_WEATHER_TIMES);
  for (unsigned i = 0; i < MAX_WEATHER_TIMES; i++) {
    ProgressGlue::SetValue(i);
    weather_available[i] = ExistsItem(dir, _T("wstar"), i) ||
      ExistsItem(dir, _T("wstar_bsratio"), i);
  }

  zzip_dir_close(dir);
}
예제 #29
0
static TLineReader *
OpenMapTextFile(const char *in_map_file, Charset cs)
{
  assert(in_map_file != nullptr);

  auto dir = OpenMapFile();
  if (dir == nullptr)
    return nullptr;

  Error error;
  ZipLineReader *reader = new ZipLineReader(dir, in_map_file, error, cs);
  zzip_dir_close(dir);
  if (reader == nullptr) {
    LogError(error);
    return nullptr;
  }

  if (reader->error()) {
    delete reader;
    return nullptr;
  }

  return reader;
}
예제 #30
0
static int zipread_showlist(request_rec *r, const char *filter)
{
    const char *filename = r->filename;
    const char *pathinfo = r->path_info;
    unsigned int len_filter = filter ? strlen(filter) : 0;

    ZZIP_DIRENT dirent;
    int pi_start;
    char *ppdir;
    apr_array_header_t * arr = apr_array_make(r->pool, 0, sizeof(char *));

    // open the zip file
    ZZIP_DIR *dir = zzip_dir_open(filename, 0);
    if (!dir) return HTTP_NOT_FOUND;

    r->content_type = "text/html";
    zipread_showheader(r, r->uri);

    if (filter && *filter == '/') {
	filter++;
	len_filter--;
    }

    // figure out the parent directory
    ppdir = apr_pstrdup(r->pool, "");
    if (pathinfo && strlen(pathinfo) >= 2)
    {
	int i;
	for (i = strlen(pathinfo)-2 ; i >= 1 ; i--)
	{
	    if (pathinfo[i] == '/')
	    {
		ppdir = apr_pstrndup(r->pool, pathinfo, i);
		break;
	    }
	}
    }
    else
    {
	// the parent dir is outside of the zip file.
	ppdir = "/..";
    }

    // find the start of pathinfo in r->uri
    if (pathinfo)
	pi_start = ap_find_path_info(r->uri, r->path_info);
    else
	pi_start = strlen(r->uri);

    ap_rprintf(r,"<img src=\"/icons/back.gif\" alt=\"[BCK]\" /><a href=\"%s%s/\">%s</a>\n",
	       apr_pstrndup(r->pool, r->uri, pi_start), ppdir, "Parent Directory");

    while ( zzip_dir_read(dir, &dirent) )
    {
	if (!filter || strncmp(dirent.d_name, filter, len_filter) == 0)
	{
	    char **n = apr_array_push(arr);
	    *n = apr_pstrdup(r->pool, dirent.d_name);
	}
    }

    {
	char **list = (char **)arr->elts;
	char *old = "";
	int i;

	// Sort the list of files we contructed
	qsort((void *)list, arr->nelts, sizeof(char *), zipread_cmp);

	// Show the list of files: get first path part and remove the duplicates
	if (1 && filter)
	{
	    for (i = 0; i < arr->nelts; i++)
	    {
		int dir_found = 0;
		char *p1;

		// cut off anything after the first /
		if ((p1 = strchr(list[i] + len_filter, '/')))
		{
		    dir_found = 1;
		    *(p1+1) = '\0';
		}

		if (strcmp(list[i], old) != 0)
		{
		    if (list[i][strlen(list[i])-1] == '/')
		    {
			dir_found = 1;

			// skip the base filter directory entry
			if (strcmp(list[i], filter) == 0) continue;
		    }

		    zipread_showentry(r, list[i], list[i] + len_filter, dir_found, pi_start);

		    old = apr_pstrdup(r->pool, list[i]);
		}
	    }
	}
	else
	{
	    // just list all paths unfiltered
	    for (i = 0; i < arr->nelts; i++)
	    {
		int dir_found = 0;

		if (list[i][strlen(list[i])-1] == '/')
		{
		    dir_found = 1;
		}

		zipread_showentry(r, list[i], list[i], dir_found, pi_start);
	    }
	}
    }

    ap_rputs("<hr /></pre>mod_zipread on Apache 2.0 (built on "__DATE__ " " __TIME__ ")\n</body></html>", r);
    zzip_dir_close (dir);

    return OK;
}