DocFormats/core/src/lib/DFStorage.c - incubator-retired-corinthia - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.

 #include "DFPlatform.h"
 #include <DocFormats/DFStorage.h>
 #include "DFCommon.h"
 #include "DFString.h"
 #include "DFFilesystem.h"
 #include "DFBuffer.h"
 #include "DFZipFile.h"
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 typedef struct DFStorageOps DFStorageOps;

 struct DFStorageOps {
     int (*save)(DFStorage *storage, DFError **error);
     int (*read)(DFStorage *storage, const char *path, void **buf, size_t *nbytes, DFError **error);
     int (*write)(DFStorage *storage, const char *path, void *buf, size_t nbytes, DFError **error);
     int (*exists)(DFStorage *storage, const char *path);
     int (*delete)(DFStorage *storage, const char *path, DFError **error);
     const char **(*list)(DFStorage *storage, DFError **error);
 };

 struct DFStorage {
     size_t retainCount;
     DFFileFormat format;
     char *rootPath;
     char *zipFilename;
     DFHashTable *files;
     const DFStorageOps *ops;
 };

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                                                                                //
 //                                     DFStorage (Filesystem)                                     //
 //                                                                                                //
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 static int fsSave(DFStorage *storage, DFError **error)
 {
     // Nothing to do here; we've already written everything to the filesystem
     // at the time the calls were made.
     return 1;
 }

 static int fsRead(DFStorage *storage, const char *path, void **buf, size_t *nbytes, DFError **error)
 {
     char *fullPath = DFAppendPathComponent(storage->rootPath,path);
     int ok = 0;

     FILE *file = fopen(fullPath,"rb");
     if (file == NULL) {
         DFErrorSetPosix(error,errno);
         goto end;
     }

     size_t balloc = 4096;
     size_t blen = 0;
     char *mem = (char *)xmalloc(balloc);

     size_t r;
     while (0 < (r = fread(&mem[blen],1,4096,file))) {
         balloc += r;
         blen += r;
         mem = (char *)xrealloc(mem,balloc);
     }
     ok = 1;

     *buf = mem;
     *nbytes = blen;

 end:
     if (file != NULL)
         fclose(file);
     free(fullPath);
     return ok;
 }

 static int fsWrite(DFStorage *storage, const char *path, void *buf, size_t nbytes, DFError **error)
 {
     char *fullPath = DFAppendPathComponent(storage->rootPath,path);
     char *parentPath = DFPathDirName(fullPath);
     int r = 0;
     FILE *file = NULL;

     if (!DFFileExists(parentPath) && !DFCreateDirectory(parentPath,1,error))
         goto end;

     file = fopen(fullPath,"wb");
     if (file == NULL) {
         DFErrorSetPosix(error,errno);
         goto end;
     }
     size_t w = fwrite(buf,1,nbytes,file);
     if (w != nbytes) {
         DFErrorFormat(error,"Incomplete write");
         goto end;
     }
     r = 1;

 end:
     if (file != NULL)
         fclose(file);
     free(parentPath);
     free(fullPath);
     return r;
 }

 static int fsExists(DFStorage *storage, const char *path)
 {
     char *fullPath = DFAppendPathComponent(storage->rootPath,path);
     int r = DFFileExists(fullPath);
     free(fullPath);
     return r;
 }

 static int fsDelete(DFStorage *storage, const char *path, DFError **error)
 {
     char *fullPath = DFAppendPathComponent(storage->rootPath,path);
     int r = DFDeleteFile(fullPath,error);
     free(fullPath);
     return r;
 }

 const char **fsList(DFStorage *storage, DFError **error)
 {
     const char **allPaths = DFContentsOfDirectory(storage->rootPath,1,error);
     if (allPaths == NULL)
         return NULL;;

     DFArray *filesOnly = DFArrayNew((DFCopyFunction)xstrdup,(DFFreeFunction)free);
     for (int i = 0; allPaths[i]; i++) {
         const char *relPath = allPaths[i];
         char *absPath = DFAppendPathComponent(storage->rootPath,relPath);
         if (!DFIsDirectory(absPath))
             DFArrayAppend(filesOnly,(void *)relPath);
         free(absPath);
     }

     const char **result = DFStringArrayFlatten(filesOnly);
     DFArrayRelease(filesOnly);
     free(allPaths);
     return result;
 }

 static DFStorageOps fsOps = {
     .save = fsSave,
     .read = fsRead,
     .write = fsWrite,
     .exists = fsExists,
     .delete = fsDelete,
     .list = fsList,
 };

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                                                                                //
 //                                       DFStorage (Memory)                                       //
 //                                                                                                //
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 static int memSave(DFStorage *storage, DFError **error)
 {
     // Nothing to do here; memory-backed storage objects are intended to be temporary, and are never
     // saved to disk
     return 1;
 }

 static int memRead(DFStorage *storage, const char *path, void **buf, size_t *nbytes, DFError **error)
 {
     DFBuffer *buffer = DFHashTableLookup(storage->files,path);
     if (buffer == NULL) {
         DFErrorSetPosix(error,ENOENT);
         return 0;
     }

     *buf = xmalloc(buffer->len);
     memcpy(*buf,buffer->data,buffer->len);
     *nbytes = buffer->len;

     return 1;
 }

 static int memWrite(DFStorage *storage, const char *path, void *buf, size_t nbytes, DFError **error)
 {
     DFBuffer *buffer = DFBufferNew();
     DFBufferAppendData(buffer,buf,nbytes);
     DFHashTableAdd(storage->files,path,buffer);
     DFBufferRelease(buffer);
     return 1;
 }

 static int memExists(DFStorage *storage, const char *path)
 {
     return (DFHashTableLookup(storage->files,path) != NULL);
 }

 static int memDelete(DFStorage *storage, const char *path, DFError **error)
 {
     DFHashTableRemove(storage->files,path);
     return 1;
 }

 static const char **memList(DFStorage *storage, DFError **error)
 {
     return DFHashTableCopyKeys(storage->files);
 }

 static DFStorageOps memOps = {
     .save = memSave,
     .read = memRead,
     .write = memWrite,
     .exists = memExists,
     .delete = memDelete,
     .list = memList,
 };

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                                                                                //
 //                                         DFStorage (Zip)                                        //
 //                                                                                                //
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 // Currently, zip storage objects operate just like memory storage objects, in that they store their
 // contents in a hash table. The only difference is that they extract all the entries from a zip
 // file on creation, and overwrite the zip file on save.
 //
 // Eventually, we should make it so the entries are read on-demand, and also that a new, temporary
 // zip file is written if the storage is modified, and that new version replaces the existing one on
 // save.

 static int zipSave(DFStorage *storage, DFError **error)
 {
     return DFZip(storage->zipFilename,storage,error);
 }

 static int zipRead(DFStorage *storage, const char *path, void **buf, size_t *nbytes, DFError **error)
 {
     DFBuffer *buffer = DFHashTableLookup(storage->files,path);
     if (buffer == NULL) {
         DFErrorSetPosix(error,ENOENT);
         return 0;
     }

     *buf = xmalloc(buffer->len);
     memcpy(*buf,buffer->data,buffer->len);
     *nbytes = buffer->len;

     return 1;
 }

 static int zipWrite(DFStorage *storage, const char *path, void *buf, size_t nbytes, DFError **error)
 {
     DFBuffer *buffer = DFBufferNew();
     DFBufferAppendData(buffer,buf,nbytes);
     DFHashTableAdd(storage->files,path,buffer);
     DFBufferRelease(buffer);
     return 1;
 }

 static int zipExists(DFStorage *storage, const char *path)
 {
     return (DFHashTableLookup(storage->files,path) != NULL);
 }

 static int zipDelete(DFStorage *storage, const char *path, DFError **error)
 {
     DFHashTableRemove(storage->files,path);
     return 1;
 }

 static const char **zipList(DFStorage *storage, DFError **error)
 {
     return DFHashTableCopyKeys(storage->files);
 }

 static DFStorageOps zipOps = {
     .save = zipSave,
     .read = zipRead,
     .write = zipWrite,
     .exists = zipExists,
     .delete = zipDelete,
     .list = zipList,
 };

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                                                                                //
 //                                            DFStorage                                           //
 //                                                                                                //
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 // Normalize the path to remove multiple consecutive / characters, and to remove any trailing /
 // character. This ensures that for implementations which rely on an exact match of the path
 // (specifically, the memory storage object), that any non-essential differences in the supplied
 // path will not matter.

 static char *fixPath(const char *input)
 {
     char *normalized = DFPathNormalize(input);
     char *result;
     if (normalized[0] == '/')
         result = xstrdup(&normalized[1]);
     else
         result = xstrdup(normalized);
     free(normalized);
     return result;
 }

 static DFStorage *DFStorageNew(DFFileFormat format, const DFStorageOps *ops)
 {
     DFStorage *storage = (DFStorage *)xcalloc(1,sizeof(DFStorage));
     storage->retainCount = 1;
     storage->format = format;
     storage->ops = ops;
     return storage;
 }

 DFStorage *DFStorageNewFilesystem(const char *rootPath, DFFileFormat format)
 {
     if ((rootPath == NULL) || (strlen(rootPath) == 0))
         rootPath = ".";;
     DFStorage *storage = DFStorageNew(format,&fsOps);
     storage->rootPath = xstrdup(rootPath);
     return storage;
 }

 DFStorage *DFStorageNewMemory(DFFileFormat format)
 {
     DFStorage *storage = DFStorageNew(format,&memOps);
     storage->files = DFHashTableNew((DFCopyFunction)DFBufferRetain,(DFFreeFunction)DFBufferRelease);
     return storage;
 }

 DFStorage *DFStorageCreateZip(const char *filename, DFError **error)
 {
     // Note that with the current implementation, the file doesn't actually get saved until we do a DFStorageSave.
     if (DFFileExists(filename)) {
         DFErrorFormat(error,"File already exists");
         return NULL;
     }

     DFStorage *storage = DFStorageNew(DFFileFormatFromFilename(filename),&zipOps);
     storage->files = DFHashTableNew((DFCopyFunction)DFBufferRetain,(DFFreeFunction)DFBufferRelease);
     storage->zipFilename = xstrdup(filename);
     return storage;
 }

 DFStorage *DFStorageOpenZip(const char *filename, DFError **error)
 {
     if (!DFFileExists(filename)) {
         DFErrorFormat(error,"File does not exist");
         return NULL;
     }

     DFStorage *storage = DFStorageNew(DFFileFormatFromFilename(filename),&zipOps);
     storage->files = DFHashTableNew((DFCopyFunction)DFBufferRetain,(DFFreeFunction)DFBufferRelease);
     storage->zipFilename = xstrdup(filename);

     if (!DFUnzip(filename,storage,error)) {
         DFStorageRelease(storage);
         return NULL;
     }
     return storage;
 }

 DFStorage *DFStorageRetain(DFStorage *storage)
 {
     if (storage != NULL)
         storage->retainCount++;
     return storage;
 }

 void DFStorageRelease(DFStorage *storage)
 {
     if ((storage == NULL) || (--storage->retainCount > 0))
         return;

     DFHashTableRelease(storage->files);
     free(storage->rootPath);
     free(storage->zipFilename);
     free(storage);
 }

 DFFileFormat DFStorageFormat(DFStorage *storage)
 {
     return storage->format;
 }

 int DFStorageSave(DFStorage *storage, DFError **error)
 {
     return storage->ops->save(storage,error);
 }

 int DFStorageRead(DFStorage *storage, const char *path, void **buf, size_t *nbytes, DFError **error)
 {
     char *fixed = fixPath(path);
     int r = storage->ops->read(storage,fixed,buf,nbytes,error);
     free(fixed);
     return r;
 }

 int DFStorageWrite(DFStorage *storage, const char *path, void *buf, size_t nbytes, DFError **error)
 {
     char *fixed = fixPath(path);
     int r = storage->ops->write(storage,fixed,buf,nbytes,error);
     free(fixed);
     return r;
 }

 int DFStorageExists(DFStorage *storage, const char *path)
 {
     char *fixed = fixPath(path);
     int r = storage->ops->exists(storage,fixed);
     free(fixed);
     return r;
 }

 int DFStorageDelete(DFStorage *storage, const char *path, DFError **error)
 {
     char *fixed = fixPath(path);
     int r = storage->ops->delete(storage,fixed,error);
     free(fixed);
     return r;
 }

 const char **DFStorageList(DFStorage *storage, DFError **error)
 {
     return storage->ops->list(storage,error);
 }
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.

	#include "DFPlatform.h"
	#include <DocFormats/DFStorage.h>
	#include "DFCommon.h"
	#include "DFString.h"
	#include "DFFilesystem.h"
	#include "DFBuffer.h"
	#include "DFZipFile.h"
	#include <errno.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	typedef struct DFStorageOps DFStorageOps;

	struct DFStorageOps {
	int (save)(DFStorage storage, DFError **error);
	int (read)(DFStorage storage, const char path, void buf, size_t nbytes, DFError **error);
	int (write)(DFStorage storage, const char path, void buf, size_t nbytes, DFError **error);
	int (exists)(DFStorage storage, const char *path);
	int (delete)(DFStorage storage, const char path, DFError *error);
	const char *(list)(DFStorage storage, DFError *error);
	};

	struct DFStorage {
	size_t retainCount;
	DFFileFormat format;
	char *rootPath;
	char *zipFilename;
	DFHashTable *files;
	const DFStorageOps *ops;
	};

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// //
	// DFStorage (Filesystem) //
	// //
	////////////////////////////////////////////////////////////////////////////////////////////////////

	static int fsSave(DFStorage storage, DFError *error)
	{
	// Nothing to do here; we've already written everything to the filesystem
	// at the time the calls were made.
	return 1;
	}

	static int fsRead(DFStorage storage, const char path, void *buf, size_t nbytes, DFError **error)
	{
	char *fullPath = DFAppendPathComponent(storage->rootPath,path);
	int ok = 0;

	FILE *file = fopen(fullPath,"rb");
	if (file == NULL) {
	DFErrorSetPosix(error,errno);
	goto end;
	}

	size_t balloc = 4096;
	size_t blen = 0;
	char mem = (char )xmalloc(balloc);

	size_t r;
	while (0 < (r = fread(&mem[blen],1,4096,file))) {
	balloc += r;
	blen += r;
	mem = (char *)xrealloc(mem,balloc);
	}
	ok = 1;

	*buf = mem;
	*nbytes = blen;

	end:
	if (file != NULL)
	fclose(file);
	free(fullPath);
	return ok;
	}

	static int fsWrite(DFStorage storage, const char path, void buf, size_t nbytes, DFError *error)
	{
	char *fullPath = DFAppendPathComponent(storage->rootPath,path);
	char *parentPath = DFPathDirName(fullPath);
	int r = 0;
	FILE *file = NULL;

	if (!DFFileExists(parentPath) && !DFCreateDirectory(parentPath,1,error))
	goto end;

	file = fopen(fullPath,"wb");
	if (file == NULL) {
	DFErrorSetPosix(error,errno);
	goto end;
	}
	size_t w = fwrite(buf,1,nbytes,file);
	if (w != nbytes) {
	DFErrorFormat(error,"Incomplete write");
	goto end;
	}
	r = 1;

	end:
	if (file != NULL)
	fclose(file);
	free(parentPath);
	free(fullPath);
	return r;
	}

	static int fsExists(DFStorage storage, const char path)
	{
	char *fullPath = DFAppendPathComponent(storage->rootPath,path);
	int r = DFFileExists(fullPath);
	free(fullPath);
	return r;
	}

	static int fsDelete(DFStorage storage, const char path, DFError **error)
	{
	char *fullPath = DFAppendPathComponent(storage->rootPath,path);
	int r = DFDeleteFile(fullPath,error);
	free(fullPath);
	return r;
	}

	const char *fsList(DFStorage storage, DFError **error)
	{
	const char **allPaths = DFContentsOfDirectory(storage->rootPath,1,error);
	if (allPaths == NULL)
	return NULL;;

	DFArray *filesOnly = DFArrayNew((DFCopyFunction)xstrdup,(DFFreeFunction)free);
	for (int i = 0; allPaths[i]; i++) {
	const char *relPath = allPaths[i];
	char *absPath = DFAppendPathComponent(storage->rootPath,relPath);
	if (!DFIsDirectory(absPath))
	DFArrayAppend(filesOnly,(void *)relPath);
	free(absPath);
	}

	const char **result = DFStringArrayFlatten(filesOnly);
	DFArrayRelease(filesOnly);
	free(allPaths);
	return result;
	}

	static DFStorageOps fsOps = {
	.save = fsSave,
	.read = fsRead,
	.write = fsWrite,
	.exists = fsExists,
	.delete = fsDelete,
	.list = fsList,
	};

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// //
	// DFStorage (Memory) //
	// //
	////////////////////////////////////////////////////////////////////////////////////////////////////

	static int memSave(DFStorage storage, DFError *error)
	{
	// Nothing to do here; memory-backed storage objects are intended to be temporary, and are never
	// saved to disk
	return 1;
	}

	static int memRead(DFStorage storage, const char path, void *buf, size_t nbytes, DFError **error)
	{
	DFBuffer *buffer = DFHashTableLookup(storage->files,path);
	if (buffer == NULL) {
	DFErrorSetPosix(error,ENOENT);
	return 0;
	}

	*buf = xmalloc(buffer->len);
	memcpy(*buf,buffer->data,buffer->len);
	*nbytes = buffer->len;

	return 1;
	}

	static int memWrite(DFStorage storage, const char path, void buf, size_t nbytes, DFError *error)
	{
	DFBuffer *buffer = DFBufferNew();
	DFBufferAppendData(buffer,buf,nbytes);
	DFHashTableAdd(storage->files,path,buffer);
	DFBufferRelease(buffer);
	return 1;
	}

	static int memExists(DFStorage storage, const char path)
	{
	return (DFHashTableLookup(storage->files,path) != NULL);
	}

	static int memDelete(DFStorage storage, const char path, DFError **error)
	{
	DFHashTableRemove(storage->files,path);
	return 1;
	}

	static const char *memList(DFStorage storage, DFError **error)
	{
	return DFHashTableCopyKeys(storage->files);
	}

	static DFStorageOps memOps = {
	.save = memSave,
	.read = memRead,
	.write = memWrite,
	.exists = memExists,
	.delete = memDelete,
	.list = memList,
	};

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// //
	// DFStorage (Zip) //
	// //
	////////////////////////////////////////////////////////////////////////////////////////////////////

	// Currently, zip storage objects operate just like memory storage objects, in that they store their
	// contents in a hash table. The only difference is that they extract all the entries from a zip
	// file on creation, and overwrite the zip file on save.
	//
	// Eventually, we should make it so the entries are read on-demand, and also that a new, temporary
	// zip file is written if the storage is modified, and that new version replaces the existing one on
	// save.

	static int zipSave(DFStorage storage, DFError *error)
	{
	return DFZip(storage->zipFilename,storage,error);
	}

	static int zipRead(DFStorage storage, const char path, void *buf, size_t nbytes, DFError **error)
	{
	DFBuffer *buffer = DFHashTableLookup(storage->files,path);
	if (buffer == NULL) {
	DFErrorSetPosix(error,ENOENT);
	return 0;
	}

	*buf = xmalloc(buffer->len);
	memcpy(*buf,buffer->data,buffer->len);
	*nbytes = buffer->len;

	return 1;
	}

	static int zipWrite(DFStorage storage, const char path, void buf, size_t nbytes, DFError *error)
	{
	DFBuffer *buffer = DFBufferNew();
	DFBufferAppendData(buffer,buf,nbytes);
	DFHashTableAdd(storage->files,path,buffer);
	DFBufferRelease(buffer);
	return 1;
	}

	static int zipExists(DFStorage storage, const char path)
	{
	return (DFHashTableLookup(storage->files,path) != NULL);
	}

	static int zipDelete(DFStorage storage, const char path, DFError **error)
	{
	DFHashTableRemove(storage->files,path);
	return 1;
	}

	static const char *zipList(DFStorage storage, DFError **error)
	{
	return DFHashTableCopyKeys(storage->files);
	}

	static DFStorageOps zipOps = {
	.save = zipSave,
	.read = zipRead,
	.write = zipWrite,
	.exists = zipExists,
	.delete = zipDelete,
	.list = zipList,
	};

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// //
	// DFStorage //
	// //
	////////////////////////////////////////////////////////////////////////////////////////////////////

	// Normalize the path to remove multiple consecutive / characters, and to remove any trailing /
	// character. This ensures that for implementations which rely on an exact match of the path
	// (specifically, the memory storage object), that any non-essential differences in the supplied
	// path will not matter.

	static char fixPath(const char input)
	{
	char *normalized = DFPathNormalize(input);
	char *result;
	if (normalized[0] == '/')
	result = xstrdup(&normalized[1]);
	else
	result = xstrdup(normalized);
	free(normalized);
	return result;
	}

	static DFStorage DFStorageNew(DFFileFormat format, const DFStorageOps ops)
	{
	DFStorage storage = (DFStorage )xcalloc(1,sizeof(DFStorage));
	storage->retainCount = 1;
	storage->format = format;
	storage->ops = ops;
	return storage;
	}

	DFStorage DFStorageNewFilesystem(const char rootPath, DFFileFormat format)
	{
	if ((rootPath == NULL) \|\| (strlen(rootPath) == 0))
	rootPath = ".";;
	DFStorage *storage = DFStorageNew(format,&fsOps);
	storage->rootPath = xstrdup(rootPath);
	return storage;
	}

	DFStorage *DFStorageNewMemory(DFFileFormat format)
	{
	DFStorage *storage = DFStorageNew(format,&memOps);
	storage->files = DFHashTableNew((DFCopyFunction)DFBufferRetain,(DFFreeFunction)DFBufferRelease);
	return storage;
	}

	DFStorage DFStorageCreateZip(const char filename, DFError **error)
	{
	// Note that with the current implementation, the file doesn't actually get saved until we do a DFStorageSave.
	if (DFFileExists(filename)) {
	DFErrorFormat(error,"File already exists");
	return NULL;
	}

	DFStorage *storage = DFStorageNew(DFFileFormatFromFilename(filename),&zipOps);
	storage->files = DFHashTableNew((DFCopyFunction)DFBufferRetain,(DFFreeFunction)DFBufferRelease);
	storage->zipFilename = xstrdup(filename);
	return storage;
	}

	DFStorage DFStorageOpenZip(const char filename, DFError **error)
	{
	if (!DFFileExists(filename)) {
	DFErrorFormat(error,"File does not exist");
	return NULL;
	}

	DFStorage *storage = DFStorageNew(DFFileFormatFromFilename(filename),&zipOps);
	storage->files = DFHashTableNew((DFCopyFunction)DFBufferRetain,(DFFreeFunction)DFBufferRelease);
	storage->zipFilename = xstrdup(filename);

	if (!DFUnzip(filename,storage,error)) {
	DFStorageRelease(storage);
	return NULL;
	}
	return storage;
	}

	DFStorage DFStorageRetain(DFStorage storage)
	{
	if (storage != NULL)
	storage->retainCount++;
	return storage;
	}

	void DFStorageRelease(DFStorage *storage)
	{
	if ((storage == NULL) \|\| (--storage->retainCount > 0))
	return;

	DFHashTableRelease(storage->files);
	free(storage->rootPath);
	free(storage->zipFilename);
	free(storage);
	}

	DFFileFormat DFStorageFormat(DFStorage *storage)
	{
	return storage->format;
	}

	int DFStorageSave(DFStorage storage, DFError *error)
	{
	return storage->ops->save(storage,error);
	}

	int DFStorageRead(DFStorage storage, const char path, void *buf, size_t nbytes, DFError **error)
	{
	char *fixed = fixPath(path);
	int r = storage->ops->read(storage,fixed,buf,nbytes,error);
	free(fixed);
	return r;
	}

	int DFStorageWrite(DFStorage storage, const char path, void buf, size_t nbytes, DFError *error)
	{
	char *fixed = fixPath(path);
	int r = storage->ops->write(storage,fixed,buf,nbytes,error);
	free(fixed);
	return r;
	}

	int DFStorageExists(DFStorage storage, const char path)
	{
	char *fixed = fixPath(path);
	int r = storage->ops->exists(storage,fixed);
	free(fixed);
	return r;
	}

	int DFStorageDelete(DFStorage storage, const char path, DFError **error)
	{
	char *fixed = fixPath(path);
	int r = storage->ops->delete(storage,fixed,error);
	free(fixed);
	return r;
	}

	const char *DFStorageList(DFStorage storage, DFError **error)
	{
	return storage->ops->list(storage,error);
	}