Created
April 29, 2011 06:13
-
-
Save zbowling/947928 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// | |
// NSData+MWExtras.h | |
// MagicWall | |
// | |
// Created by Zac Bowling on 2/10/11. | |
// Copyright 2011 i'mhello. All rights reserved. | |
// | |
#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(NSData_MWExtras) | |
- (NSString*)stringWithHexBytes; | |
+ (NSData *)dataFromBase64String:(NSString *)aString; | |
- (NSString *)base64EncodedString; | |
@end |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// | |
// NSData+MWExtras.m | |
// MagicWall | |
// | |
// Created by Zac Bowling on 2/10/11. | |
// Copyright 2011 i'mhello. All rights reserved. | |
// | |
#import "NSData+MWExtras.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-1) / 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,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 2 | |
// | |
// 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(NSData_MWExtras) | |
-(NSString*) stringWithHexBytes { | |
static const char hexdigits[] = "0123456789ABCDEF"; | |
const size_t numBytes = [self length]; | |
const unsigned char* bytes = [self bytes]; | |
char *strbuf = (char *)malloc(numBytes * 2 + 1); | |
char *hex = strbuf; | |
NSString *hexBytes = nil; | |
for (int i = 0; i<numBytes; ++i) { | |
const unsigned char c = *bytes++; | |
*hex++ = hexdigits[(c >> 4) & 0xF]; | |
*hex++ = hexdigits[(c ) & 0xF]; | |
} | |
*hex = 0; | |
hexBytes = [NSString stringWithUTF8String:strbuf]; | |
free(strbuf); | |
return hexBytes; | |
} | |
// | |
// 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 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment