#import "common.h"

#if !defined (__GNU_LIBOBJC__)

# include <objc/encoding.h>

#endif

#import "GNUstepBase/GSObjCRuntime.h"

#import "Foundation/NSByteOrder.h"

#import "Foundation/NSCoder.h"

#import "Foundation/NSData.h"

#import "Foundation/NSException.h"

#import "Foundation/NSFileManager.h"

#import "Foundation/NSPathUtilities.h"

#import "Foundation/NSRange.h"

#import "Foundation/NSURL.h"

#import "Foundation/NSValue.h"

#import "GSPrivate.h"

#include <stdio.h>

#ifdef HAVE_MMAP

#include <sys/mman.h>

#if defined(HAVE_SYS_FCNTL_H)

# include <sys/fcntl.h>

#elif defined(HAVE_FCNTL_H)

# include <fcntl.h>

#endif

#ifndef MAP_FAILED

#define MAP_FAILED ((void*)-1) /* Failure address. */

#endif

@class NSDataMappedFile;

#endif

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#ifdef HAVE_SHMCTL

#include <sys/ipc.h>

#include <sys/shm.h>

#define VM_RDONLY 0644 /* self read/write - other readonly */

#define VM_ACCESS 0666 /* read/write access for all */

@class NSDataShared;

@class NSMutableDataShared;

#endif

@class NSDataMalloc;

@class NSDataStatic;

@class NSMutableDataMalloc;

static Class dataStatic;

static Class dataMalloc;

static Class mutableDataMalloc;

static Class dataBlock;

static Class mutableDataBlock;

static Class NSDataAbstract;

static Class NSMutableDataAbstract;

static SEL appendSel;

static IMP appendImp;

static inline void

decodebase64(unsigned char *dst, const unsigned char *src)

{

dst[0] = (src[0] << 2) | ((src[1] & 0x30) >> 4);

dst[1] = ((src[1] & 0x0F) << 4) | ((src[2] & 0x3C) >> 2);

dst[2] = ((src[2] & 0x03) << 6) | (src[3] & 0x3F);

}

static char b64[]

= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static const int crlf64 = NSDataBase64EncodingEndLineWithCarriageReturn

| NSDataBase64EncodingEndLineWithLineFeed;

static NSUInteger

encodebase64(unsigned char **dstRef,

const unsigned char *src,

NSUInteger length,

NSDataBase64EncodingOptions options)

{

unsigned char *dst;

NSUInteger dIndex = 0;

NSUInteger dIndexNoNewLines = 0;

NSUInteger sIndex;

NSUInteger lineLength;

NSUInteger destLen;

lineLength = 0;

if (options & NSDataBase64Encoding64CharacterLineLength)

lineLength = 64;

else if (options & NSDataBase64Encoding76CharacterLineLength)

lineLength = 76;

/* if no EndLine options are set but a line length is given,

if (lineLength && !(options & crlf64))

{

options |= crlf64;

}

/* estimate destination length */

destLen = 4 * ((length + 2) / 3);

/* we need to take in account line-endings */

if (lineLength)

{

if ((options & crlf64) == crlf64)

destLen += (destLen / lineLength)*2; // CR and LF

else

destLen += (destLen / lineLength); // CR or LF

}

dst = NSZoneMalloc(NSDefaultMallocZone(), destLen);

for (sIndex = 0; sIndex < length; sIndex += 3)

{

int c0 = src[sIndex];

int c1 = (sIndex+1 < length) ? src[sIndex+1] : 0;

int c2 = (sIndex+2 < length) ? src[sIndex+2] : 0;

dst[dIndex++] = b64[(c0 >> 2) & 077];

dst[dIndex++] = b64[((c0 << 4) & 060) | ((c1 >> 4) & 017)];

dst[dIndex++] = b64[((c1 << 2) & 074) | ((c2 >> 6) & 03)];

dst[dIndex++] = b64[c2 & 077];

dIndexNoNewLines += 4;

if (lineLength && !(dIndexNoNewLines % lineLength) )

{

if (options & NSDataBase64EncodingEndLineWithCarriageReturn)

dst[dIndex++] = '\r';

if (options & NSDataBase64EncodingEndLineWithLineFeed)

dst[dIndex++] = '\n';

}

}

/* If len was not a multiple of 3, then we have encoded too

if (sIndex == length + 1)

{

/* There were only 2 bytes in that last group */

dst[dIndex - 1] = '=';

}

else if (sIndex == length + 2)

{

/* There was only 1 byte in that last group */

dst[dIndex - 1] = '=';

dst[dIndex - 2] = '=';

}

*dstRef = dst;

return dIndex;

}

static BOOL

readContentsOfFile(NSString *path, void **buf, off_t *len, NSZone *zone)

{

NSFileManager *mgr = [NSFileManager defaultManager];

NSDictionary *att;

#if defined(_WIN32)

const unichar *thePath = 0;

#else

const char *thePath = 0;

#endif

FILE *theFile = 0;

void *tmp = 0;

int c;

off_t fileLength;

#ifdef __ANDROID__

// Android: try using asset manager if path is in main bundle resources

AAsset *asset = [NSBundle assetForPath: path withMode: AASSET_MODE_BUFFER];

if (asset)

{

fileLength = AAsset_getLength(asset);

tmp = NSZoneMalloc(zone, fileLength);

if (tmp == 0)

{

NSLog(@"Malloc failed for file (%@) of length %jd - %@", path,

(intmax_t)fileLength, [NSError _last]);

AAsset_close(asset);

goto failure;

}

int result = AAsset_read(asset, tmp, fileLength);

AAsset_close(asset);

if (result < 0)

{

NSWarnFLog(@"read of file (%@) contents failed - %@", path,

[NSError errorWithDomain: NSPOSIXErrorDomain

code: result

userInfo: nil]);

goto failure;

}

*buf = tmp;

*len = fileLength;

return YES;

}

#endif /* __ANDROID__ */

#if defined(_WIN32)

thePath = (const unichar*)[path fileSystemRepresentation];

#else

thePath = [path fileSystemRepresentation];

#endif

if (thePath == 0)

{

NSWarnFLog(@"Open (%@) attempt failed - bad path", path);

return NO;

}

att = [mgr fileAttributesAtPath: path traverseLink: YES];

if (nil == att)

{

return NO; // No such file ... fail quietly

}

if ([att fileType] != NSFileTypeRegular)

{

NSWarnFLog(@"Open (%@) attempt failed - not a regular file", path);

return NO;

}

#if defined(_WIN32)

theFile = _wfopen(thePath, L"rb");

#else

theFile = fopen(thePath, "rb");

#endif

if (theFile == 0) /* We failed to open the file. */

{

NSDebugFLog(@"Open (%@) attempt failed - %@", path, [NSError _last]);

goto failure;

}

/*

c = fseeko(theFile, 0, SEEK_END);

if (c != 0)

{

NSWarnFLog(@"Seek to end of file (%@) failed - %@", path,

[NSError _last]);

goto failure;

}

/*

fileLength = ftello(theFile);

if (fileLength == (off_t)-1)

{

NSWarnFLog(@"Ftell on %@ failed - %@", path, [NSError _last]);

goto failure;

}

if (fileLength >= 2147483647)

{

fileLength = 0;

}

/*

c = fseeko(theFile, 0, SEEK_SET);

if (c != 0)

{

NSWarnFLog(@"Fseek to start of file (%@) failed - %@", path,

[NSError _last]);

goto failure;

}

clearerr(theFile);

if (fileLength == 0)

{

unsigned char buf[BUFSIZ];

/*

while ((c = fread(buf, 1, BUFSIZ, theFile)) != 0)

{

if (tmp == 0)

{

tmp = NSZoneMalloc(zone, c);

}

else

{

tmp = NSZoneRealloc(zone, tmp, fileLength + c);

}

if (tmp == 0)

{

NSLog(@"Malloc failed for file (%@) of length %jd - %@", path,

(intmax_t)fileLength + c, [NSError _last]);

goto failure;

}

memcpy(tmp + fileLength, buf, c);

fileLength += c;

}

}

else

{

off_t offset = 0;

tmp = NSZoneMalloc(zone, fileLength);

if (tmp == 0)

{

NSLog(@"Malloc failed for file (%@) of length %jd - %@", path,

(intmax_t)fileLength, [NSError _last]);

goto failure;

}

while (offset < fileLength

&& (c = fread(tmp + offset, 1, fileLength - offset, theFile)) != 0)

{

offset += c;

}

if (offset < fileLength)

{

fileLength = offset;

tmp = NSZoneRealloc(zone, tmp, fileLength);

}

}

if (ferror(theFile))

{

NSWarnFLog(@"read of file (%@) contents failed - %@", path,

[NSError _last]);

goto failure;

}

*buf = tmp;

*len = fileLength;

fclose(theFile);

return YES;

/*

failure:

{

NSZoneFree(zone, tmp);

}

if (theFile != 0)

{

fclose(theFile);

}

return NO;

}

@interface NSDataStatic : NSData

{

NSUInteger length;

__strong void *bytes;

/**

id deallocator;

}

@interface NSDataEmpty: NSDataStatic

@interface NSDataMalloc : NSDataStatic

@interface NSDataWithDeallocatorBlock : NSDataMalloc

@interface NSMutableDataMalloc : NSMutableData

{

NSUInteger length;

__strong void *bytes;

/**

id deallocator;

NSZone *zone;

NSUInteger capacity;

NSUInteger growth;

}

- (void) _grow: (NSUInteger)minimum;

@interface NSMutableDataWithDeallocatorBlock : NSMutableDataMalloc

#ifdef HAVE_MMAP

@interface NSDataMappedFile : NSDataMalloc

#endif

#ifdef HAVE_SHMCTL

@interface NSDataShared : NSDataMalloc

{

int shmid;

}

- (id) initWithShmID: (int)anId length: (NSUInteger)bufferSize;

@interface NSMutableDataShared : NSMutableDataMalloc

{

int shmid;

}

- (id) initWithShmID: (int)anId length: (NSUInteger)bufferSize;

#endif



@implementation NSData

- (NSUInteger) sizeOfContentExcluding: (NSHashTable*)exclude

{

return [self length];

}

+ (void) initialize

{

if (self == [NSData class])

{

NSDataAbstract = self;

NSMutableDataAbstract = [NSMutableData class];

dataStatic = [NSDataStatic class];

dataMalloc = [NSDataMalloc class];

dataBlock = [NSDataWithDeallocatorBlock class];

mutableDataMalloc = [NSMutableDataMalloc class];

mutableDataBlock = [NSMutableDataWithDeallocatorBlock class];

appendSel = @selector(appendBytes:length:);

appendImp = [mutableDataMalloc instanceMethodForSelector: appendSel];

}

}

+ (id) allocWithZone: (NSZone*)z

{

if (self == NSDataAbstract)

{

return NSAllocateObject(dataMalloc, 0, z);

}

else

{

return NSAllocateObject(self, 0, z);

}

}

+ (id) data

{

static NSData *empty = nil;

if (empty == nil)

{

empty = [dataStatic allocWithZone: NSDefaultMallocZone()];

empty = [empty initWithBytesNoCopy: 0 length: 0 freeWhenDone: NO];

}

return empty;

}

+ (id) dataWithBytes: (const void*)bytes

length: (NSUInteger)length

{

NSData *d;

d = [dataMalloc allocWithZone: NSDefaultMallocZone()];

d = [d initWithBytes: bytes length: length];

return AUTORELEASE(d);

}

+ (id) dataWithBytesNoCopy: (void*)bytes

length: (NSUInteger)length

{

NSData *d;

d = [dataMalloc allocWithZone: NSDefaultMallocZone()];

d = [d initWithBytesNoCopy: bytes length: length freeWhenDone: YES];

return AUTORELEASE(d);

}

+ (id) dataWithBytesNoCopy: (void*)aBuffer

length: (NSUInteger)bufferSize

freeWhenDone: (BOOL)shouldFree

{

NSData *d;

if (shouldFree == YES)

{

d = [dataMalloc allocWithZone: NSDefaultMallocZone()];

}

else

{

d = [dataStatic allocWithZone: NSDefaultMallocZone()];

}

d = [d initWithBytesNoCopy: aBuffer

length: bufferSize

freeWhenDone: shouldFree];

return AUTORELEASE(d);

}

+ (id) dataWithContentsOfFile: (NSString*)path

{

NSData *d;

d = [dataMalloc allocWithZone: NSDefaultMallocZone()];

d = [d initWithContentsOfFile: path];

return AUTORELEASE(d);

}

+ (id) dataWithContentsOfMappedFile: (NSString*)path

{

NSData *d;

#ifdef HAVE_MMAP

d = [NSDataMappedFile allocWithZone: NSDefaultMallocZone()];

d = [d initWithContentsOfMappedFile: path];

#else

d = [dataMalloc allocWithZone: NSDefaultMallocZone()];

d = [d initWithContentsOfMappedFile: path];

#endif

return AUTORELEASE(d);

}

+ (id) dataWithContentsOfURL: (NSURL*)url

{

NSData *d;

d = [url resourceDataUsingCache: YES];

return d;

}

+ (id) dataWithData: (NSData*)data

{

NSData *d;

d = [dataMalloc allocWithZone: NSDefaultMallocZone()];

d = [d initWithBytes: [data bytes] length: [data length]];

return AUTORELEASE(d);

}

+ (id) new

{

NSData *d;

d = [dataMalloc allocWithZone: NSDefaultMallocZone()];

d = [d initWithBytesNoCopy: 0 length: 0 freeWhenDone: YES];

return d;

}

- (id) init

{

return [self initWithBytesNoCopy: 0 length: 0 freeWhenDone: YES];

}

- (id) initWithBase64EncodedData: (NSData*)base64Data

options: (NSDataBase64DecodingOptions)options

{

NSUInteger length;

NSUInteger declen;

const unsigned char *src;

const unsigned char *end;

unsigned char *result;

unsigned char *dst;

unsigned char buf[4];

unsigned pos = 0;

NSZone *zone = [self zone];

if (nil == base64Data)

{

AUTORELEASE(self);

[NSException raise: NSInvalidArgumentException

format: @"[%@-initWithBase64EncodedData:options:] called with "

@"nil data", NSStringFromClass([self class])];

return nil;

}

length = [base64Data length];

if (length == 0)

{

return [self initWithBytesNoCopy: 0 length: 0 freeWhenDone: YES];

}

declen = ((length + 3) * 3)/4;

src = (const unsigned char*)[base64Data bytes];

end = &src[length];

result = NSZoneMalloc(zone, declen);

dst = result;

while (src != end)

{

int c = *src++;

if (isupper(c))

{

c -= 'A';

}

else if (islower(c))

{

c = c - 'a' + 26;

}

else if (isdigit(c))

{

c = c - '0' + 52;

}

else if (c == '/')

{

c = 63;

}

else if (c == '+')

{

c = 62;

}

else if (c == '=')

{

/* Only legal as padding at end of string */

while (src != end)

{

c = *src++;

if (c != '=')

{

if (options & NSDataBase64DecodingIgnoreUnknownCharacters)

{

if (!isupper(c) && !islower(c) && !isdigit(c)

&& c != '/' && c != '+')

{

continue; // An unknown character

}

}

free(result);

DESTROY(self);

return nil;

}

}

/* For OSX compatibility, if we have unnecessary padding at the

if (0 == pos)

{

*dst++ = '\0';

}

c = -1;

}

else if (options & NSDataBase64DecodingIgnoreUnknownCharacters)

{

c = -1; /* ignore */

}

else

{

free(result);

DESTROY(self);

return nil;

}

if (c >= 0)

{

buf[pos++] = c;

if (pos == 4)

{

pos = 0;

decodebase64(dst, buf);

dst += 3;

}

}

}

if (pos > 0)

{

unsigned i;

for (i = pos; i < 4; i++)

{

buf[i] = '\0';

}

pos--;

if (pos > 0)

{

unsigned char tail[3];

decodebase64(tail, buf);

memcpy(dst, tail, pos);

dst += pos;

}

}

length = dst - result;

if (options & NSDataBase64DecodingIgnoreUnknownCharacters)

{

/* If the decoded length is a lot shorter than expected (because we

if ((((declen - length) * 100) / declen) > 5)

{

result = NSZoneRealloc(zone, result, length);

}

}

return [self initWithBytesNoCopy: result length: length freeWhenDone: YES];

}

- (id) initWithBase64EncodedString: (NSString*)base64String

options: (NSDataBase64DecodingOptions)options

{

NSData *data;

if (nil == base64String)

{

AUTORELEASE(self);

[NSException raise: NSInvalidArgumentException

format: @"[%@-initWithBase64EncodedString:options:] called with "

@"nil string", NSStringFromClass([self class])];

return nil;

}

data = [base64String dataUsingEncoding: NSUTF8StringEncoding];

return [self initWithBase64EncodedData: data options: options];

}

- (id) initWithBytes: (const void*)aBuffer

length: (NSUInteger)bufferSize

{

void *ptr = 0;

if (bufferSize > 0)

{

if (aBuffer == 0)

{

[NSException raise: NSInvalidArgumentException

format: @"[%@-initWithBytes:length:] called with "

@"length but null bytes", NSStringFromClass([self class])];

}

ptr = NSAllocateCollectable(bufferSize, 0);

if (ptr == 0)

{

DESTROY(self);

return nil;

}

memcpy(ptr, aBuffer, bufferSize);

}

return [self initWithBytesNoCopy: ptr

length: bufferSize

freeWhenDone: YES];

}

- (id) initWithBytesNoCopy: (void*)aBuffer

length: (NSUInteger)bufferSize

{

return [self initWithBytesNoCopy: aBuffer

length: bufferSize

freeWhenDone: YES];

}

- (id) initWithBytesNoCopy: (void*)aBuffer

length: (NSUInteger)bufferSize

freeWhenDone: (BOOL)shouldFree

{

[self subclassResponsibility: _cmd];

return nil;

}

- (instancetype) initWithBytesNoCopy: (void*)bytes

length: (NSUInteger)length

deallocator: (GSDataDeallocatorBlock)deallocator

{

[self subclassResponsibility: _cmd];

return nil;

}

- (id) initWithContentsOfFile: (NSString*)path

{

void *fileBytes;

off_t fileLength;

if (readContentsOfFile(path, &fileBytes, &fileLength, [self zone]) == NO)

{

DESTROY(self);

return nil;

}

self = [self initWithBytesNoCopy: fileBytes

length: (NSUInteger)fileLength

freeWhenDone: YES];

return self;

}

- (id) initWithContentsOfMappedFile: (NSString *)path

{

#ifdef HAVE_MMAP

NSZone *z = [self zone];

DESTROY(self);

self = [NSDataMappedFile allocWithZone: z];

return [self initWithContentsOfMappedFile: path];

#else

return [self initWithContentsOfFile: path];

#endif

}

- (id) initWithContentsOfURL: (NSURL*)url

{

NSData *data = [url resourceDataUsingCache: YES];

return [self initWithData: data];

}

- (id) initWithData: (NSData*)data

{

if (data == nil)

{

return [self initWithBytesNoCopy: 0 length: 0 freeWhenDone: YES];

}

if ([data isKindOfClass: [NSData class]] == NO)

{

NSLog(@"-initWithData: passed a non-data object");

DESTROY(self);

return nil;

}

return [self initWithBytes: [data bytes] length: [data length]];

}

- (const void*) bytes

{

[self subclassResponsibility: _cmd];

return 0;

}

- (NSString*) description

{

extern void GSPropertyListMake(id,NSDictionary*,BOOL,BOOL,unsigned,id*);

NSMutableString *result = nil;