WebODF

				CODE_SIGN_IDENTITY = "iPhone Developer";

				PROVISIONING_PROFILE = "";

				CODE_SIGN_IDENTITY = "iPhone Developer";

				PROVISIONING_PROFILE = "";

//

//  NSData+Base64.h

//  base64

//

//  Created by Matt Gallagher on 2009/06/03.

//  Copyright 2009 Matt Gallagher. All rights reserved.

//

//  Permission is given to use this source code file, free of charge, in any

//  project, commercial or otherwise, entirely at your risk, with the condition

//  that any redistribution (in part or whole) of source code must retain

//  this copyright and permission notice. Attribution in compiled projects is

//  appreciated but not required.

//

#import <Foundation/Foundation.h>

void *NewBase64Decode(

	const char *inputBuffer,

	size_t length,

	size_t *outputLength);

char *NewBase64Encode(

	const void *inputBuffer,

	size_t length,

	bool separateLines,

	size_t *outputLength);

@interface NSData (Base64)

+ (NSData *)dataFromBase64String:(NSString *)aString;

- (NSString *)base64EncodedString;

@end

//

//  NSData+Base64.m

//  base64

//

//  Created by Matt Gallagher on 2009/06/03.

//  Copyright 2009 Matt Gallagher. All rights reserved.

//

//  Permission is given to use this source code file, free of charge, in any

//  project, commercial or otherwise, entirely at your risk, with the condition

//  that any redistribution (in part or whole) of source code must retain

//  this copyright and permission notice. Attribution in compiled projects is

//  appreciated but not required.

//

#import "NSData+Base64.h"

//

// Mapping from 6 bit pattern to ASCII character.

//

static unsigned char base64EncodeLookup[65] =

	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

//

// Definition for "masked-out" areas of the base64DecodeLookup mapping

//

#define xx 65

//

// Mapping from ASCII character to 6 bit pattern.

//

static unsigned char base64DecodeLookup[256] =

{

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 62, xx, xx, xx, 63, 

    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, xx, xx, xx, xx, xx, xx, 

    xx,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 

    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, xx, xx, xx, xx, xx, 

    xx, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 

    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 

};

//

// Fundamental sizes of the binary and base64 encode/decode units in bytes

//

#define BINARY_UNIT_SIZE 3

#define BASE64_UNIT_SIZE 4

//

// NewBase64Decode

//

// Decodes the base64 ASCII string in the inputBuffer to a newly malloced

// output buffer.

//

//  inputBuffer - the source ASCII string for the decode

//	length - the length of the string or -1 (to specify strlen should be used)

//	outputLength - if not-NULL, on output will contain the decoded length

//

// returns the decoded buffer. Must be free'd by caller. Length is given by

//	outputLength.

//

void *NewBase64Decode(

	const char *inputBuffer,

	size_t length,

	size_t *outputLength)

{

	if (length == -1)

	{

		length = strlen(inputBuffer);

	}

	size_t outputBufferSize = (length / BASE64_UNIT_SIZE) * BINARY_UNIT_SIZE;

	unsigned char *outputBuffer = (unsigned char *)malloc(outputBufferSize);

	size_t i = 0;

	size_t j = 0;

	while (i < length)

	{

		//

		// Accumulate 4 valid characters (ignore everything else)

		//

		unsigned char accumulated[BASE64_UNIT_SIZE];

		bzero(accumulated, sizeof(unsigned char) * BASE64_UNIT_SIZE);

		size_t accumulateIndex = 0;

		while (i < length)

		{

			unsigned char decode = base64DecodeLookup[inputBuffer[i++]];

			if (decode != xx)

			{

				accumulated[accumulateIndex] = decode;

				accumulateIndex++;

				if (accumulateIndex == BASE64_UNIT_SIZE)

				{

					break;

				}

			}

		}

		//

		// Store the 6 bits from each of the 4 characters as 3 bytes

		//

		outputBuffer[j] = (accumulated[0] << 2) | (accumulated[1] >> 4);

		outputBuffer[j + 1] = (accumulated[1] << 4) | (accumulated[2] >> 2);

		outputBuffer[j + 2] = (accumulated[2] << 6) | accumulated[3];

		j += accumulateIndex - 1;

	}

	if (outputLength)

	{

		*outputLength = j;

	}

	return outputBuffer;

}

//

// NewBase64Decode

//

// Encodes the arbitrary data in the inputBuffer as base64 into a newly malloced

// output buffer.

//

//  inputBuffer - the source data for the encode

//	length - the length of the input in bytes

//  separateLines - if zero, no CR/LF characters will be added. Otherwise

//		a CR/LF pair will be added every 64 encoded chars.

//	outputLength - if not-NULL, on output will contain the encoded length

//		(not including terminating 0 char)

//

// returns the encoded buffer. Must be free'd by caller. Length is given by

//	outputLength.

//

char *NewBase64Encode(

	const void *buffer,

	size_t length,

	bool separateLines,

	size_t *outputLength)

{

	const unsigned char *inputBuffer = (const unsigned char *)buffer;

	#define MAX_NUM_PADDING_CHARS 2

	#define OUTPUT_LINE_LENGTH 64

	#define INPUT_LINE_LENGTH ((OUTPUT_LINE_LENGTH / BASE64_UNIT_SIZE) * BINARY_UNIT_SIZE)

	#define CR_LF_SIZE 0

	//

	// Byte accurate calculation of final buffer size

	//

	size_t outputBufferSize =

			((length / BINARY_UNIT_SIZE)

				+ ((length % BINARY_UNIT_SIZE) ? 1 : 0))

					* BASE64_UNIT_SIZE;

	if (separateLines)

	{

		outputBufferSize +=

			(outputBufferSize / OUTPUT_LINE_LENGTH) * CR_LF_SIZE;

	}

	//

	// Include space for a terminating zero

	//

	outputBufferSize += 1;

	//

	// Allocate the output buffer

	//

	char *outputBuffer = (char *)malloc(outputBufferSize);

	if (!outputBuffer)

	{

		return NULL;

	}

	size_t i = 0;

	size_t j = 0;

	const size_t lineLength = separateLines ? INPUT_LINE_LENGTH : length;

	size_t lineEnd = lineLength;

	while (true)

	{

		if (lineEnd > length)

		{

			lineEnd = length;

		}

		for (; i + BINARY_UNIT_SIZE - 1 < lineEnd; i += BINARY_UNIT_SIZE)

		{

			//

			// Inner loop: turn 48 bytes into 64 base64 characters

			//

			outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];

			outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i] & 0x03) << 4)

				| ((inputBuffer[i + 1] & 0xF0) >> 4)];

			outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i + 1] & 0x0F) << 2)

				| ((inputBuffer[i + 2] & 0xC0) >> 6)];

			outputBuffer[j++] = base64EncodeLookup[inputBuffer[i + 2] & 0x3F];

		}

		if (lineEnd == length)

		{

			break;

		}

		//

		// Add the newline

		//

		//outputBuffer[j++] = '\r';

		//outputBuffer[j++] = '\n';

		lineEnd += lineLength;

	}

	if (i + 1 < length)

	{

		//

		// Handle the single '=' case

		//

		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];

		outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i] & 0x03) << 4)

			| ((inputBuffer[i + 1] & 0xF0) >> 4)];

		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i + 1] & 0x0F) << 2];

		outputBuffer[j++] =	'=';

	}

	else if (i < length)

	{

		//

		// Handle the double '=' case

		//

		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];

		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0x03) << 4];

		outputBuffer[j++] = '=';

		outputBuffer[j++] = '=';

	}

	outputBuffer[j] = 0;

	//

	// Set the output length and return the buffer

	//

	if (outputLength)

	{

		*outputLength = j;

	}

	return outputBuffer;

}

@implementation NSData (Base64)

//

// dataFromBase64String:

//

// Creates an NSData object containing the base64 decoded representation of

// the base64 string 'aString'

//

// Parameters:

//    aString - the base64 string to decode

//

// returns the autoreleased NSData representation of the base64 string

//

+ (NSData *)dataFromBase64String:(NSString *)aString

{

	NSData *data = [aString dataUsingEncoding:NSASCIIStringEncoding];

	size_t outputLength;

	void *outputBuffer = NewBase64Decode([data bytes], [data length], &outputLength);

	NSData *result = [NSData dataWithBytes:outputBuffer length:outputLength];

	free(outputBuffer);

	return result;

}

//

// base64EncodedString

//

// Creates an NSString object that contains the base 64 encoding of the

// receiver's data. Lines are broken at 64 characters long.

//

// returns an autoreleased NSString being the base 64 representation of the

//	receiver.

//

- (NSString *)base64EncodedString

{

	size_t outputLength;

	char *outputBuffer =

		NewBase64Encode([self bytes], [self length], true, &outputLength);

	NSString *result =

		[[[NSString alloc]

			initWithBytes:outputBuffer

			length:outputLength

			encoding:NSASCIIStringEncoding]

		autorelease];

	free(outputBuffer);

	return result;

}

@end

- (void) load:(BOOL)base64 arguments:(NSMutableArray*)arguments withDict:(NSMutableDictionary*)options;

- (void) loadAsDataURL:(NSMutableArray*)arguments withDict:(NSMutableDictionary*)options;

#import "NSData+Base64.h"

-(void) load:(BOOL)base64 arguments:(NSMutableArray*)arguments withDict:(NSMutableDictionary*)options

                        if (base64) {

                            NSData* readData = [NSData dataWithBytes:(const void *)contents length:sizeof(unsigned char)*info.uncompressed_size];

                            jsString = [NSString stringWithFormat:@"data:%@;base64,%@", @"mimetype", [readData base64EncodedString]];

                        } else {                    

                            jsString = [[NSString alloc] initWithUTF8String: contents];

                        }

-(void)loadAsString:(NSMutableArray*)arguments withDict:(NSMutableDictionary*)options  

{

    [self load:FALSE arguments:arguments withDict:options];

}

-(void)loadAsDataURL:(NSMutableArray*)arguments withDict:(NSMutableDictionary*)options  

{

    [self load:TRUE arguments:arguments withDict:options];

}

/* crypt.h -- base code for crypt/uncrypt ZIPfile

   Version 1.01e, February 12th, 2005

   Copyright (C) 1998-2005 Gilles Vollant

   This code is a modified version of crypting code in Infozip distribution

   The encryption/decryption parts of this source code (as opposed to the

   non-echoing password parts) were originally written in Europe.  The

   whole source package can be freely distributed, including from the USA.

   (Prior to January 2000, re-export from the US was a violation of US law.)

   This encryption code is a direct transcription of the algorithm from

   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This

   file (appnote.txt) is distributed with the PKZIP program (even in the

   version without encryption capabilities).

   If you don't need crypting in your application, just define symbols

   NOCRYPT and NOUNCRYPT.

   This code support the "Traditional PKWARE Encryption".

   The new AES encryption added on Zip format by Winzip (see the page

   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong

   Encryption is not supported.

*/

#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))

/***********************************************************************

 * Return the next byte in the pseudo-random sequence

 */

static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)

{

    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an

                     * unpredictable manner on 16-bit systems; not a problem

                     * with any known compiler so far, though */

    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;

    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);

}

/***********************************************************************

 * Update the encryption keys with the next byte of plain text

 */

static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)

{

    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);

    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;

    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;

    {

      register int keyshift = (int)((*(pkeys+1)) >> 24);

      (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);

    }

    return c;

}

/***********************************************************************

 * Initialize the encryption keys and the random header according to

 * the given password.

 */

static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)

{

    *(pkeys+0) = 305419896L;

    *(pkeys+1) = 591751049L;

    *(pkeys+2) = 878082192L;

    while (*passwd != '\0') {

        update_keys(pkeys,pcrc_32_tab,(int)*passwd);

        passwd++;

    }

}

#define zdecode(pkeys,pcrc_32_tab,c) \

    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))

#define zencode(pkeys,pcrc_32_tab,c,t) \

    (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))

#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED

#define RAND_HEAD_LEN  12

   /* "last resort" source for second part of crypt seed pattern */

#  ifndef ZCR_SEED2

#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */

#  endif

static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)

    const char *passwd;         /* password string */

    unsigned char *buf;         /* where to write header */

    int bufSize;

    unsigned long* pkeys;

    const unsigned long* pcrc_32_tab;

    unsigned long crcForCrypting;

{

    int n;                       /* index in random header */

    int t;                       /* temporary */

    int c;                       /* random byte */

    unsigned char header[RAND_HEAD_LEN-2]; /* random header */

    static unsigned calls = 0;   /* ensure different random header each time */

    if (bufSize<RAND_HEAD_LEN)

      return 0;

    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the

     * output of rand() to get less predictability, since rand() is

     * often poorly implemented.

     */

    if (++calls == 1)

    {

        srand((unsigned)(time(NULL) ^ ZCR_SEED2));

    }

    init_keys(passwd, pkeys, pcrc_32_tab);

    for (n = 0; n < RAND_HEAD_LEN-2; n++)

    {

        c = (rand() >> 7) & 0xff;

        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);

    }

    /* Encrypt random header (last two bytes is high word of crc) */

    init_keys(passwd, pkeys, pcrc_32_tab);

    for (n = 0; n < RAND_HEAD_LEN-2; n++)

    {

        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);

    }

    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);

    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);

    return n;

}

#endif

    if (pfile_in_zip_read_info->read_buffer == NULL)

    loadAsString: function(zippath, entrypath, success, fail) {

        return PhoneGap.exec(success, fail, "ZipClass", "loadAsString", [zippath, entrypath]);

    },

    loadAsDataURL: function(zippath, entrypath, success, fail) {

        return PhoneGap.exec(success, fail, "ZipClass", "loadAsDataURL", [zippath, entrypath]);

    },

        //alert(filename);

        callback(null, "");

    this.loadAsDataURL = function (filename, callback) {

        ZipPlugin.loadAsDataURL(url, filename,

            function (content) {

                callback(null, content);

            },

            function (err) { callback(err, null); }

        );

    };