// Start OTR negotiation if we haven't already done so.
SOSCoderStatus
SOSCoderStart(SOSCoderRef coder, CFErrorRef *error) {
CFMutableStringRef action = CFStringCreateMutable(kCFAllocatorDefault, 0);
CFStringRef beginState = NULL;
SOSCoderStatus result = kSOSCoderFailure;
CFMutableDataRef startPacket = NULL;
require_action_quiet(coder->sessRef, coderFailure, CFStringAppend(action, CFSTR("*** no otr session ***")));
beginState = CFCopyDescription(coder->sessRef);
require_action_quiet(!coder->waitingForDataPacket, negotiatingOut, CFStringAppend(action, CFSTR("waiting for peer to send first data packet")));
require_action_quiet(!SecOTRSGetIsReadyForMessages(coder->sessRef), coderFailure, CFStringAppend(action, CFSTR("otr session ready"));
result = kSOSCoderDataReturned);
require_action_quiet(SecOTRSGetIsIdle(coder->sessRef), negotiatingOut, CFStringAppend(action, CFSTR("otr negotiating already")));
require_action_quiet(startPacket = CFDataCreateMutable(kCFAllocatorDefault, 0), coderFailure, SOSCreateError(kSOSErrorAllocationFailure, CFSTR("alloc failed"), NULL, error));
require_quiet(SOSOTRSAppendStartPacket(coder->sessRef, startPacket, error), coderFailure);
CFRetainAssign(coder->pendingResponse, startPacket);
negotiatingOut:
result = kSOSCoderNegotiating;
coderFailure:
// Uber state log
if (result == kSOSCoderFailure && error && *error)
CFStringAppendFormat(action, NULL, CFSTR(" %@"), *error);
secnotice("coder", "%@ %s %@ %@ returned %s", beginState,
SecOTRPacketTypeString(startPacket), action, coder->sessRef, SOSCoderString(result));
CFReleaseNull(startPacket);
CFReleaseSafe(beginState);
CFRelease(action);
return result;
}
CFStringRef
CFStringCreateByCombiningStrings (CFAllocatorRef alloc, CFArrayRef theArray,
CFStringRef separatorString)
{
CFIndex idx;
CFIndex count;
CFMutableStringRef string;
CFStringRef currentString;
CFStringRef ret;
count = CFArrayGetCount (theArray) - 1;
if (count == 0)
return NULL;
string = CFStringCreateMutable (NULL, 0);
idx = 0;
while (idx < count)
{
currentString = (CFStringRef)CFArrayGetValueAtIndex (theArray, idx++);
CFStringAppend (string, currentString);
CFStringAppend (string, separatorString);
}
currentString = CFArrayGetValueAtIndex (theArray, idx);
CFStringAppend (string, currentString);
ret = CFStringCreateCopy (alloc, string);
CFRelease (string);
return ret;
}
CFStringRef AppendMetaValueStringToDisplayString(CFStringRef metaDataValueString, ByteCount propValueSizeUsed)
{
CFMutableStringRef byteStr = CFStringCreateMutable (kCFAllocatorDefault, 0);
require(byteStr != nil, CANTCREATEMUTABLESTR);
// show count of number of bytes for this piece of data
CFStringRef sizeStr = CFStringCreateWithFormat( kCFAllocatorDefault,
NULL,
CFSTR("(%d bytes) : "),
propValueSizeUsed);
require(sizeStr != nil, CANTCREATESTRWITHFORMAT);
CFStringAppend (byteStr, sizeStr);
CFRelease(sizeStr);
// now append actual data to this string
if (metaDataValueString)
{
CFStringAppend (byteStr, metaDataValueString);
}
CFStringAppend (byteStr, CFSTR(" \n"));
CFStringRef immutableDisplayStr = CFStringCreateCopy (kCFAllocatorDefault, byteStr);
require(immutableDisplayStr != nil, CANTCREATESTRIMMUTABLESTR);
CFRelease(byteStr);
return immutableDisplayStr;
CANTCREATESTRIMMUTABLESTR:
CANTCREATESTRWITHFORMAT:
CFRelease(byteStr);
CANTCREATEMUTABLESTR:
return nil;
}
static CFStringRef __CFDataCopyDescription(CFTypeRef cf) {
CFDataRef data = (CFDataRef)cf;
CFMutableStringRef result;
CFIndex idx;
CFIndex len;
const uint8_t *bytes;
len = __CFDataLength(data);
bytes = CFDataGetBytePtr(data);
result = CFStringCreateMutable(CFGetAllocator(data), 0);
CFStringAppendFormat(result, NULL, CFSTR("<CFData %p [%p]>{length = %u, capacity = %u, bytes = 0x"), cf, CFGetAllocator(data), len, __CFDataCapacity(data));
if (24 < len) {
for (idx = 0; idx < 16; idx += 4) {
CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);
}
CFStringAppend(result, CFSTR(" ... "));
for (idx = len - 8; idx < len; idx += 4) {
CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);
}
} else {
for (idx = 0; idx < len; idx++) {
CFStringAppendFormat(result, NULL, CFSTR("%02x"), bytes[idx]);
}
}
CFStringAppend(result, CFSTR("}"));
return result;
}
/*
* Get the server name out of the URL. CFURLCopyHostName will escape out the
* server name for us. So just convert it to the correct code page encoding.
*
* Note: Currently we put the server name into a c-style string. In the future
* it would be nice to keep this as a CFString.
*/
static int SetServerFromURL(struct smb_ctx *ctx, CFURLRef url)
{
CFIndex maxlen;
CFStringRef serverNameRef = CFURLCopyHostName(url);
char *ipV6Name = NULL;
ipV6Name = CStringCreateWithCFString(serverNameRef);
if (ipV6Name && isIPv6NumericName(ipV6Name)) {
/* CFURLCopyHostName removed the [] so put them back in */
CFMutableStringRef newServer = CFStringCreateMutableCopy(NULL, 1024, CFSTR("["));
if (newServer) {
CFStringAppend(newServer, serverNameRef);
CFStringAppend(newServer, CFSTR("]"));
CFRelease(serverNameRef);
serverNameRef = newServer;
}
}
/* Free up the buffer we allocated */
if (ipV6Name) {
free(ipV6Name);
}
/*
* Every time we parse the URL we end up replacing the server name. In the
* future we should skip replacing the server name if we already have one and
* the one return CFURLCopyHostName matches it.
*
* Not going to make that big of a change in an update, so lets limit to the
* case were we are dealing with using a domain controller.
*/
if (serverNameRef && ctx->serverNameRef && ctx->serverName &&
(ctx->serverIsDomainController) &&
(ctx->ct_flags & SMBCF_CONNECTED) &&
(CFStringCompare(serverNameRef, ctx->serverNameRef, 0) == kCFCompareEqualTo)) {
CFRelease(serverNameRef);
return 0; /* Same name nothing to do here */
}
if (ctx->serverNameRef) {
CFRelease(ctx->serverNameRef);
}
/* The serverNameRef should always contain the URL host name or the Bonjour Name */
ctx->serverNameRef = serverNameRef;
if (ctx->serverNameRef == NULL)
return EINVAL;
DebugLogCFString(ctx->serverNameRef, "Server", __FUNCTION__, __LINE__);
maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(ctx->serverNameRef), kCFStringEncodingUTF8) + 1;
if (ctx->serverName)
free(ctx->serverName);
ctx->serverName = malloc(maxlen);
if (!ctx->serverName) {
CFRelease(ctx->serverNameRef);
ctx->serverNameRef = NULL;
return ENOMEM;
}
CFStringGetCString(ctx->serverNameRef, ctx->serverName, maxlen, kCFStringEncodingUTF8);
return 0;
}
void drawTextWithFeature(CGContextRef context, CTFontDescriptorRef fontDescriptor, CFStringRef feature, int value, CGPoint location)
{
CGFloat fontSize = 25;
CGContextSetTextMatrix(context, CGAffineTransformScale(CGAffineTransformIdentity, 1, 1));
CGContextSetTextPosition(context, location.x, location.y);
CFNumberRef featureValue = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &value);
CFTypeRef featureDictionaryKeys[] = { kCTFontOpenTypeFeatureTag, kCTFontOpenTypeFeatureValue };
CFTypeRef featureDictionaryValues[] = { feature, featureValue };
CFDictionaryRef featureDictionary = CFDictionaryCreate(kCFAllocatorDefault, featureDictionaryKeys, featureDictionaryValues, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFRelease(featureValue);
CFTypeRef featureSettingsValues[] = { featureDictionary };
CFArrayRef fontFeatureSettings = CFArrayCreate(kCFAllocatorDefault, featureSettingsValues, 1, &kCFTypeArrayCallBacks);
CFRelease(featureDictionary);
CFTypeRef fontDescriptorKeys[] = { kCTFontFeatureSettingsAttribute };
CFTypeRef fontDescriptorValues[] = { fontFeatureSettings };
CFDictionaryRef fontDescriptorAttributes = CFDictionaryCreate(kCFAllocatorDefault, fontDescriptorKeys, fontDescriptorValues, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFRelease(fontFeatureSettings);
CTFontDescriptorRef modifiedFontDescriptor = CTFontDescriptorCreateCopyWithAttributes(fontDescriptor, fontDescriptorAttributes);
CFRelease(fontDescriptorAttributes);
CTFontRef font = CTFontCreateWithFontDescriptor(modifiedFontDescriptor, fontSize, nullptr);
CFRelease(modifiedFontDescriptor);
CFMutableStringRef string = CFStringCreateMutable(kCFAllocatorDefault, 0);
CFStringAppend(string, feature);
CFStringAppend(string, value ? CFSTR(" (on)") : CFSTR(" (off)"));
CFStringAppend(string, CFSTR(": ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
CGColorRef red = CGColorCreateGenericRGB(1, 0, 0, 1);
CFTypeRef lineKeys[] = { kCTForegroundColorAttributeName };
CFTypeRef lineValues[] = { red };
CFDictionaryRef lineAttributes = CFDictionaryCreate(kCFAllocatorDefault, lineKeys, lineValues, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CGColorRelease(red);
CFAttributedStringRef attributedString = CFAttributedStringCreate(kCFAllocatorDefault, string, lineAttributes);
CFRelease(lineAttributes);
CFRelease(string);
CFMutableAttributedStringRef mutableAttributedString = CFAttributedStringCreateMutableCopy(kCFAllocatorDefault, 0, attributedString);
CFRelease(attributedString);
CTFontRef monospaceFont = CTFontCreateWithName(CFSTR("Courier"), fontSize, nullptr);
CFAttributedStringSetAttribute(mutableAttributedString, CFRangeMake(0, 12), kCTFontAttributeName, monospaceFont);
CFRelease(monospaceFont);
CFAttributedStringSetAttribute(mutableAttributedString, CFRangeMake(12, 52), kCTFontAttributeName, font);
CFRelease(font);
CTLineRef line = CTLineCreateWithAttributedString(mutableAttributedString);
CFRelease(mutableAttributedString);
CTLineDraw(line, context);
CFRelease(line);
}
void get_device_infos(CFMutableDictionaryRef out) {
CC_SHA1_CTX sha1ctx;
uint8_t udid[20];
char udid1[100];
CFStringRef serial;
CFStringRef imei;
CFStringRef macwifi;
CFStringRef macbt;
CFStringRef hw = copy_hardware_model();
if (hw != NULL)
{
CFDictionaryAddValue(out, CFSTR("hwModel"), hw);
CFRelease(hw);
}
serial = copy_device_serial_number();
imei = copy_device_imei();
macwifi = copy_wifi_mac_address();
macbt = copy_bluetooth_mac_address();
CFMutableStringRef udidInput = CFStringCreateMutable(kCFAllocatorDefault, 0);
if (serial != NULL)
{
CFStringAppend(udidInput, serial);
CFDictionaryAddValue(out, CFSTR("serialNumber"), serial);
CFRelease(serial);
}
if (imei != NULL)
{
CFStringAppend(udidInput, imei);
CFDictionaryAddValue(out, CFSTR("imei"), imei);
CFRelease(imei);
}
if (macwifi != NULL)
{
CFStringAppend(udidInput, macwifi);
CFDictionaryAddValue(out, CFSTR("wifiMac"), macwifi);
CFRelease(macwifi);
}
if (macbt != NULL)
{
CFStringAppend(udidInput, macbt);
CFDictionaryAddValue(out, CFSTR("btMac"), macbt);
CFRelease(macbt);
}
CFStringGetCString(udidInput, udid1, 99, kCFStringEncodingASCII);
CC_SHA1_Init(&sha1ctx);
CC_SHA1_Update(&sha1ctx, udid1, CFStringGetLength(udidInput));
CC_SHA1_Final(udid, &sha1ctx);
CFRelease(udidInput);
addHexaString(out, CFSTR("udid"), udid, 20);
}
static CFDictionaryRef __DAMountMapCreate2( CFAllocatorRef allocator, struct vsdb * vs )
{
CFStringRef idAsString;
CFMutableDictionaryRef map = NULL;
idAsString = CFStringCreateWithCString( kCFAllocatorDefault, vs->vs_spec, kCFStringEncodingUTF8 );
if ( idAsString )
{
CFTypeRef id;
id = _DAFileSystemCreateUUIDFromString( kCFAllocatorDefault, idAsString );
if ( id )
{
map = CFDictionaryCreateMutable( kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
if ( map )
{
CFMutableStringRef options;
options = CFStringCreateMutable( kCFAllocatorDefault, 0 );
if ( options )
{
if ( ( vs->vs_ops & VSDB_PERM ) )
{
CFStringAppend( options, CFSTR( "owners" ) );
CFStringAppend( options, CFSTR( "," ) );
}
else
{
CFStringAppend( options, CFSTR( "noowners" ) );
CFStringAppend( options, CFSTR( "," ) );
}
if ( CFStringGetLength( options ) )
{
CFStringTrim( options, CFSTR( "," ) );
CFDictionarySetValue( map, kDAMountMapMountOptionsKey, options );
}
CFRelease( options );
}
CFDictionarySetValue( map, kDAMountMapProbeIDKey, id );
}
CFRelease( id );
}
CFRelease( idAsString );
}
return map;
}
// ____________________________________________________________________________
// Obtain the name of an endpoint without regard for whether it has connections.
// The result should be released by the caller.
static CFStringRef EndpointName(MIDIEndpointRef endpoint, bool isExternal) {
CFMutableStringRef result = CFStringCreateMutable(NULL, 0);
CFStringRef str;
// begin with the endpoint's name
str = NULL;
MIDIObjectGetStringProperty(endpoint, kMIDIPropertyName, &str);
if (str != NULL) {
CFStringAppend(result, str);
CFRelease(str);
}
MIDIEntityRef entity = NULL;
MIDIEndpointGetEntity(endpoint, &entity);
if (entity == NULL)
// probably virtual
return result;
if (CFStringGetLength(result) == 0) {
// endpoint name has zero length -- try the entity
str = NULL;
MIDIObjectGetStringProperty(entity, kMIDIPropertyName, &str);
if (str != NULL) {
CFStringAppend(result, str);
CFRelease(str);
}
}
// now consider the device's name
MIDIDeviceRef device = NULL;
MIDIEntityGetDevice(entity, &device);
if (device == NULL)
return result;
str = NULL;
MIDIObjectGetStringProperty(device, kMIDIPropertyName, &str);
if (str != NULL) {
// if an external device has only one entity, throw away the endpoint name and just use the device name
if (isExternal && MIDIDeviceGetNumberOfEntities(device) < 2) {
CFRelease(result);
return str;
}
else {
// does the entity name already start with the device name? (some drivers do this though they shouldn't)
// if so, do not prepend
if (CFStringCompareWithOptions(str /* device name */, result /* endpoint name */, CFRangeMake(0, CFStringGetLength(str)), 0) != kCFCompareEqualTo) {
// prepend the device name to the entity name
if (CFStringGetLength(result) > 0)
CFStringInsert(result, 0, CFSTR(" "));
CFStringInsert(result, 0, str);
}
CFRelease(str);
}
}
return result;
}
CFStringRef Resources::getResourcesPathFromBundleId() { //@@TODO
char buffer[PATH_MAX];
CFBundleRef bundle = CFBundleGetBundleWithIdentifier(CFSTR("SuperColldierAU") );
if (bundle == NULL) return NULL;
CFURLRef bundleURL = CFBundleCopyBundleURL(bundle);
CFURLGetFileSystemRepresentation(bundleURL, TRUE, (UInt8*)buffer,PATH_MAX);
CFStringRef bundlePath = CFStringCreateWithCString(NULL,buffer, kCFStringEncodingUTF8);
CFURLRef bundleResourcesURL = CFBundleCopyResourcesDirectoryURL(bundle);
CFStringRef resourcesRelativePath = CFURLGetString(bundleResourcesURL);
CFMutableStringRef resourcesPath = CFStringCreateMutable(NULL,0);
CFStringAppend(resourcesPath,bundlePath);
CFStringAppend(resourcesPath,resourcesRelativePath);
return resourcesPath;
}
// Obtain the name of an endpoint, following connections.
// The result should be released by the caller.
static CFStringRef ConnectedEndpointName(MIDIEndpointRef endpoint) {
CFMutableStringRef result = CFStringCreateMutable(NULL, 0);
CFStringRef str;
OSStatus err;
// Does the endpoint have connections?
CFDataRef connections = NULL;
int nConnected = 0;
bool anyStrings = false;
err = MIDIObjectGetDataProperty(endpoint, kMIDIPropertyConnectionUniqueID, &connections);
if (connections != NULL) {
// It has connections, follow them
// Concatenate the names of all connected devices
nConnected = CFDataGetLength(connections) / sizeof(MIDIUniqueID);
if (nConnected) {
const SInt32 *pid = reinterpret_cast <const SInt32 *>(CFDataGetBytePtr(connections));
for (int i = 0; i < nConnected; ++i, ++pid) {
MIDIUniqueID id = EndianS32_BtoN(*pid);
MIDIObjectRef connObject;
MIDIObjectType connObjectType;
err = MIDIObjectFindByUniqueID(id, &connObject, &connObjectType);
if (err == noErr) {
if (connObjectType == kMIDIObjectType_ExternalSource
|| connObjectType == kMIDIObjectType_ExternalDestination) {
// Connected to an external device's endpoint (10.3 and later).
str = EndpointName(static_cast <MIDIEndpointRef>(connObject), true);
}
else {
// Connected to an external device (10.2) (or something else, catch-all)
str = NULL;
MIDIObjectGetStringProperty(connObject, kMIDIPropertyName, &str);
}
if (str != NULL) {
if (anyStrings)
CFStringAppend(result, CFSTR(", "));
else anyStrings = true;
CFStringAppend(result, str);
CFRelease(str);
}
}
}
}
CFRelease(connections);
}
if (anyStrings)
return result;
// Here, either the endpoint had no connections, or we failed to obtain names for any of them.
return EndpointName(endpoint, false);
}
static CFURLRef FindJnlpURLInFile(char* fileName) {
XMLNode* doc = NULL;
CFURLRef returnValue = NULL;
char* jnlbuffer = NULL;
/* Parse XML document. */
if (!ReadFileToBuffer(fileName, &jnlbuffer)) {
return NULL;
}
doc = ParseXMLDocument(jnlbuffer);
if (doc != NULL) {
XMLNode* node = NULL;
char *codebase = NULL;
char *href = NULL;
CFStringRef baseURLString = NULL;
CFStringRef hrefString = NULL;
CFMutableStringRef fullURL = NULL;
node = FindXMLChild(doc, "jnlp");
require(node != NULL, bail);
codebase = FindXMLAttribute(node->_attributes, "codebase");
require(codebase != NULL, bail);
href = FindXMLAttribute(node->_attributes, "href");
require(href != NULL, bail);
baseURLString = CFStringCreateWithCString(NULL, codebase, kCFStringEncodingUTF8);
require(baseURLString != NULL, bail);
fullURL = CFStringCreateMutableCopy(NULL, 0, baseURLString);
hrefString = CFStringCreateWithCString(NULL, href, kCFStringEncodingUTF8);
require(hrefString != NULL, bail);
// a relative JNLP path needs a URL that starts at the specificed codebase
if (!CFStringHasSuffix(fullURL, CFSTR("/")))
CFStringAppend(fullURL, CFSTR("/"));
CFStringAppend(fullURL, hrefString);
returnValue = CFURLCreateWithString(NULL, fullURL, NULL);
bail:
if (baseURLString != NULL) CFRelease(baseURLString);
if (hrefString != NULL) CFRelease(hrefString);
if (fullURL != NULL) CFRelease(fullURL);
FreeXMLDocument(doc);
}
free(jnlbuffer);
return returnValue;
}
static CFStringRef __CFArrayCopyDescription(CFTypeRef cf) {
CFArrayRef array = (CFArrayRef)cf;
CFMutableStringRef result;
const CFArrayCallBacks *cb;
CFAllocatorRef allocator;
CFIndex idx, cnt;
cnt = __CFArrayGetCount(array);
allocator = CFGetAllocator(array);
result = CFStringCreateMutable(allocator, 0);
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
CFStringAppendFormat(result, NULL, CFSTR("<CFArray %p [%p]>{type = immutable, count = %lu, values = (%s"), cf, allocator, (unsigned long)cnt, cnt ? "\n" : "");
break;
case __kCFArrayDeque:
CFStringAppendFormat(result, NULL, CFSTR("<CFArray %p [%p]>{type = mutable-small, count = %lu, values = (%s"), cf, allocator, (unsigned long)cnt, cnt ? "\n" : "");
break;
}
cb = __CFArrayGetCallBacks(array);
for (idx = 0; idx < cnt; idx++) {
CFStringRef desc = NULL;
const void *val = __CFArrayGetBucketAtIndex(array, idx)->_item;
if (NULL != cb->copyDescription) {
desc = (CFStringRef)INVOKE_CALLBACK1(cb->copyDescription, val);
}
if (NULL != desc) {
CFStringAppendFormat(result, NULL, CFSTR("\t%lu : %@\n"), (unsigned long)idx, desc);
CFRelease(desc);
} else {
CFStringAppendFormat(result, NULL, CFSTR("\t%lu : <%p>\n"), (unsigned long)idx, val);
}
}
CFStringAppend(result, CFSTR(")}"));
return result;
}
/*
* Given a Dfs Referral string create a CFURL. Remember referral have a file
* syntax
*
* Example: "/smb-win2003.apple.com/DfsRoot/DfsLink1"
*/
CFURLRef CreateURLFromReferral(CFStringRef inStr)
{
CFURLRef ct_url = NULL;
CFMutableStringRef urlString = CFStringCreateMutableCopy(NULL, 0, CFSTR("smb:/"));
CFStringRef escapeStr = inStr;
/*
* CreateStringByAddingPercentEscapesUTF8() will either create a new string
* or return the original with ref count incremented. Either way we have to
* call CFRelease on the returned string
*/
CreateStringByAddingPercentEscapesUTF8(&escapeStr, NULL, NULL, FALSE);
if (urlString) {
CFStringAppend(urlString, escapeStr);
ct_url = CFURLCreateWithString(kCFAllocatorDefault, urlString, NULL);
CFRelease(urlString); /* We create it now release it */
}
if (!ct_url) {
LogCFString(inStr, "creating url failed", __FUNCTION__, __LINE__);
}
if (escapeStr) {
CFRelease(escapeStr);
}
return ct_url;
}
static CFStringRef __CFBinaryHeapCopyDescription(CFTypeRef cf) {
CFBinaryHeapRef heap = (CFBinaryHeapRef)cf;
CFMutableStringRef result;
CFIndex idx;
CFIndex cnt;
const void **list, *buffer[256];
cnt = __CFBinaryHeapCount(heap);
result = CFStringCreateMutable(CFGetAllocator(heap), 0);
CFStringAppendFormat(result, NULL, CFSTR("<CFBinaryHeap %p [%p]>{count = %lu, capacity = %lu, objects = (\n"), cf, CFGetAllocator(heap), (unsigned long)cnt, (unsigned long)__CFBinaryHeapCapacity(heap));
list = (cnt <= 128) ? (const void **)buffer : (const void **)CFAllocatorAllocate(kCFAllocatorSystemDefault, cnt * sizeof(void *), 0); // GC OK
if (__CFOASafe && list != buffer) __CFSetLastAllocationEventName(list, "CFBinaryHeap (temp)");
CFBinaryHeapGetValues(heap, list);
for (idx = 0; idx < cnt; idx++) {
CFStringRef desc = NULL;
const void *item = list[idx];
if (NULL != heap->_callbacks.copyDescription) {
desc = heap->_callbacks.copyDescription(item);
}
if (NULL != desc) {
CFStringAppendFormat(result, NULL, CFSTR("\t%lu : %@\n"), (unsigned long)idx, desc);
CFRelease(desc);
} else {
CFStringAppendFormat(result, NULL, CFSTR("\t%lu : <%p>\n"), (unsigned long)idx, item);
}
}
CFStringAppend(result, CFSTR(")}"));
if (list != buffer) CFAllocatorDeallocate(CFGetAllocator(heap), list); // GC OK
return result;
}
static CFStringRef BIMCreatePortName( const ProcessSerialNumber *inProcessSerialNumber )
{
CFMutableStringRef portName;
CFStringRef processSerialNumberStringRef;
Str255 processSerialNumberString;
Str255 processSerialNumberLowString;
// Convert the high and low parts of the process serial number into a string.
NumToString( inProcessSerialNumber->highLongOfPSN, processSerialNumberString );
NumToString( inProcessSerialNumber->lowLongOfPSN, processSerialNumberLowString );
BlockMoveData( processSerialNumberLowString + 1,
processSerialNumberString + processSerialNumberString [0] + 1,
processSerialNumberLowString [0] );
processSerialNumberString [0] += processSerialNumberLowString [0];
// Create a CFString and append the process serial number string onto the end.
portName = CFStringCreateMutableCopy( NULL, 255, CFSTR( kBasicServerPortName ) );
processSerialNumberStringRef = CFStringCreateWithPascalString( NULL,
processSerialNumberString,
CFStringGetSystemEncoding() );
CFStringAppend( portName, processSerialNumberStringRef );
CFRelease( processSerialNumberStringRef );
return portName;
}
/*
* Create the target name using the host name. Note we will use the
* GSS_C_NT_HOSTBASE name type of cifs@<server> and will return a CFString
*/
CFStringRef TargetNameCreatedWithHostName(struct smb_ctx *ctx)
{
CFStringRef hostName;
CFMutableStringRef kerbHintsHostname;
/* We need to add "cifs@ server part" */
kerbHintsHostname = CFStringCreateMutableCopy(kCFAllocatorDefault, 0,
CFSTR("cifs@"));
if (kerbHintsHostname == NULL) {
return NULL;
}
/*
* The old code would return an IP dot address if the name was NetBIOS. This
* was done for Leopard gss. After talking this over with LHA we now always
* return the server name. The IP dot address never worked and was causing
* Dfs links to fail.
*/
hostName = CFStringCreateWithCString(kCFAllocatorDefault, ctx->serverName, kCFStringEncodingUTF8);
if (hostName) {
CFStringAppend(kerbHintsHostname, hostName);
CFRelease(hostName);
} else {
CFRelease(kerbHintsHostname);
kerbHintsHostname = NULL;
}
return kerbHintsHostname;
}
CFStringRef GetBinaryDataAsString(QTPropertyValuePtr keyValuePtr, ByteCount propValueSizeUsed)
{
CFMutableStringRef byteStr = CFStringCreateMutable (kCFAllocatorDefault, 0);
require(byteStr != nil, CANTCREATESTR);
short i;
UInt8 *byteP = keyValuePtr;
CFStringRef theStringRef = NULL;
for (i=0; i<propValueSizeUsed; ++i)
{
theStringRef = CFStringCreateWithFormat( kCFAllocatorDefault,
NULL,
CFSTR(" %x"),
*byteP);
++byteP;
if (theStringRef)
{
CFStringAppend (byteStr, theStringRef);
CFRelease(theStringRef);
}
}
CFStringRef destStr = CFStringCreateCopy (kCFAllocatorDefault, byteStr);
require(destStr != nil, CANTCREATEDESTSTR);
CFRelease(byteStr);
return destStr;
CANTCREATEDESTSTR:
CFRelease(byteStr);
CANTCREATESTR:
return nil;
}
bool setPlayerWinTitle(CFStringRef sTitle)
{
CFMutableStringRef sFinalStr = NULL;
OSStatus iErr = noErr;
if (NULL == (sFinalStr = CFStringCreateMutableCopy(NULL, 8 + CFStringGetLength(sTitle), CFSTR("Frogg - "))))
{
fprintf(stderr, "setPlayerWinTitle() - CFStringCreateMutableCopy() failed!\n");
return false;
}
else
{
CFStringAppend(sFinalStr, sTitle);
if (noErr != (iErr = SetWindowTitleWithCFString(g_refPlayerWin, sFinalStr)))
{
CFRelease(sFinalStr);
fprintf(stderr, "setPlayerWinTitle() - SetWindowTitleWithCFString() failed, returning %lu!\n", (unsigned long) iErr);
return false;
}
CFRelease(sFinalStr);
return true;
}
}
static CFStringRef __CFSetCopyDescription(CFTypeRef cf) {
CFSetRef set = (CFSetRef)cf;
const CFSetCallBacks *cb;
const struct __CFSetBucket *buckets;
CFIndex idx, nbuckets;
CFMutableStringRef result;
cb = __CFSetGetCallBacks(set);
buckets = set->_buckets;
nbuckets = set->_bucketsNum;
result = CFStringCreateMutable(kCFAllocatorSystemDefault, 0);
CFStringAppendFormat(result, NULL, CFSTR("<CFSet %p [%p]>{count = %u, capacity = %u, values = (\n"), set, CFGetAllocator(set), set->_count, set->_capacity);
for (idx = 0; idx < nbuckets; idx++) {
if (__CFSetBucketIsOccupied(set, &buckets[idx])) {
CFStringRef desc = NULL;
if (NULL != cb->copyDescription) {
desc = (CFStringRef)INVOKE_CALLBACK2(((CFStringRef (*)(const void *, void *))cb->copyDescription), buckets[idx]._key, set->_context);
}
if (NULL != desc) {
CFStringAppendFormat(result, NULL, CFSTR("\t%u : %@\n"), idx, desc, NULL);
CFRelease(desc);
} else {
CFStringAppendFormat(result, NULL, CFSTR("\t%u : <%p>\n"), idx, buckets[idx]._key, NULL);
}
}
}
CFStringAppend(result, CFSTR(")}"));
return result;
}
CFStringRef diff_CFStringCreateByCombiningTwoStrings(CFStringRef best_common_part1, CFStringRef best_common_part2) {
CFIndex best_common_length;
CFMutableStringRef best_common_mutable;
best_common_length = CFStringGetLength(best_common_part1) + CFStringGetLength(best_common_part2);
best_common_mutable = CFStringCreateMutableCopy(kCFAllocatorDefault, best_common_length, best_common_part1);
CFStringAppend(best_common_mutable, best_common_part2);
return best_common_mutable;
}
/* -----------------------------------------------------------------------------
----------------------------------------------------------------------------- */
CFStringRef
copy_padded_string(CFStringRef original, int width, CFStringRef prefix, CFStringRef suffix)
{
CFMutableStringRef padded;
padded = CFStringCreateMutable(NULL, 0);
if (prefix != NULL) {
CFStringAppend(padded, prefix);
}
if (original != NULL) {
CFStringAppend(padded, original);
}
if (suffix != NULL) {
CFStringAppend(padded, suffix);
}
CFStringPad(padded, CFSTR(" "), MAX(CFStringGetLength(original), width), 0);
return padded;
}
static CFURLRef _preferencesDirectoryForUserHostSafetyLevel(CFStringRef userName, CFStringRef hostName, unsigned long safeLevel) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
#if DEPLOYMENT_TARGET_WINDOWS
CFURLRef url = NULL;
CFMutableStringRef completePath = _CFCreateApplicationRepositoryPath(alloc, CSIDL_APPDATA);
if (completePath) {
// append "Preferences\" and make the CFURL
CFStringAppend(completePath, CFSTR("Preferences\\"));
url = CFURLCreateWithFileSystemPath(alloc, completePath, kCFURLWindowsPathStyle, true);
CFRelease(completePath);
}
// Can't find a better place? Home directory then?
if (url == NULL)
url = CFCopyHomeDirectoryURLForUser((userName == kCFPreferencesCurrentUser) ? NULL : userName);
return url;
#else
CFURLRef home = NULL;
CFURLRef url;
int levels = 0;
// if (hostName != kCFPreferencesCurrentHost && hostName != kCFPreferencesAnyHost) return NULL; // Arbitrary host access not permitted
if (userName == kCFPreferencesAnyUser) {
if (!home) home = CFURLCreateWithFileSystemPath(alloc, CFSTR("/Library/Preferences/"), kCFURLPOSIXPathStyle, true);
levels = 1;
if (hostName == kCFPreferencesCurrentHost) url = home;
else {
url = CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR("Network/"), kCFURLPOSIXPathStyle, true, home);
levels ++;
CFRelease(home);
}
} else {
home = CFCopyHomeDirectoryURLForUser((userName == kCFPreferencesCurrentUser) ? NULL : userName);
if (home) {
url = (safeLevel > 0) ? CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR("Library/Safe Preferences/"), kCFURLPOSIXPathStyle, true, home) :
CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR("Library/Preferences/"), kCFURLPOSIXPathStyle, true, home);
levels = 2;
CFRelease(home);
if (hostName != kCFPreferencesAnyHost) {
home = url;
url = CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR("ByHost/"), kCFURLPOSIXPathStyle, true, home);
levels ++;
CFRelease(home);
}
} else {
url = NULL;
}
}
return url;
#endif
}
STATIC CFStringRef
__EAPOLClientItemIDCopyDebugDesc(CFTypeRef cf)
{
CFAllocatorRef allocator = CFGetAllocator(cf);
EAPOLClientItemIDRef itemID = (EAPOLClientItemIDRef)cf;
CFStringRef profileID;
CFMutableStringRef result;
CFStringRef ssid_str;
result = CFStringCreateMutable(allocator, 0);
CFStringAppendFormat(result, NULL,
CFSTR("<EAPOLClientItemID %p [%p]> {"), cf, allocator);
switch (itemID->type) {
case kEAPOLClientItemIDTypeWLANSSID:
ssid_str = my_CFStringCreateWithData(itemID->u.ssid);
CFStringAppendFormat(result, NULL, CFSTR("WLAN SSID = %@"),
ssid_str);
CFRelease(ssid_str);
break;
case kEAPOLClientItemIDTypeWLANDomain:
CFStringAppendFormat(result, NULL, CFSTR("WLAN domain = %@"),
itemID->u.domain);
break;
case kEAPOLClientItemIDTypeProfileID:
CFStringAppendFormat(result, NULL, CFSTR("ProfileID = %@"),
itemID->u.profileID);
break;
case kEAPOLClientItemIDTypeProfile:
profileID = EAPOLClientProfileGetID(itemID->u.profile);
CFStringAppendFormat(result, NULL, CFSTR("Profile = %@"),
profileID);
break;
case kEAPOLClientItemIDTypeDefault:
CFStringAppend(result, CFSTR("Default"));
break;
default:
break;
}
CFStringAppend(result, CFSTR("}"));
return result;
}
bool CAMIDIEndpoints::Endpoint::GetEndpointInfo(EMode mode, EndpointInfo &info) {
Endpoint *ept = this, *ept2;
if (mode == kPairs) {
if ((ept2 = ept->PairMate()) == NULL)
return false;
info.mSourceEndpoint = ept2->IOEndpoint();
info.mDestinationEndpoint = ept->IOEndpoint();
}
else if (mode == kSources) {
info.mSourceEndpoint = ept->IOEndpoint();
info.mDestinationEndpoint = NULL;
}
else {
info.mSourceEndpoint = NULL;
info.mDestinationEndpoint = ept->IOEndpoint();
}
info.mUniqueID = ept->UniqueID();
if (ept->DriverOwned() && ept->Next() != NULL) {
// add one item for all connected items
CFMutableStringRef names = CFStringCreateMutable(NULL, 0);
bool first = true;
while (true) {
ept = ept->Next();
if (ept == NULL)
break;
if (!first) {
CFStringAppend(names, CFSTR(", "));
}
else first = false;
CFStringAppend(names, ept->Name());
}
info.mDisplayName = names;
}
else {
// a driver-owned endpoint with nothing connected externally,
// or an external endpoint
CFRetain(info.mDisplayName = ept->Name());
}
return true;
}
CF_PRIVATE Boolean _CFAppendPathExtension2(CFMutableStringRef path, CFStringRef extension) {
if (!path) {
return false;
}
if (0 < CFStringGetLength(extension) && IS_SLASH(CFStringGetCharacterAtIndex(extension, 0))) {
return false;
}
if (1 < CFStringGetLength(extension)) {
if (_hasDrive(extension)) return false;
}
Boolean destHasDrive = (1 < CFStringGetLength(path)) && _hasDrive(path);
while (((destHasDrive && 3 < CFStringGetLength(path)) || (!destHasDrive && 1 < CFStringGetLength(path))) && IS_SLASH(CFStringGetCharacterAtIndex(path, CFStringGetLength(path) - 1))) {
CFStringDelete(path, CFRangeMake(CFStringGetLength(path) - 1, 1));
}
if (CFStringGetLength(path) == 0) {
return false;
}
UniChar firstChar = CFStringGetCharacterAtIndex(path, 0);
CFIndex newLength = CFStringGetLength(path);
switch (newLength) {
case 0:
return false;
case 1:
if (IS_SLASH(firstChar) || firstChar == '~') {
return false;
}
break;
case 2:
if (_hasDrive(path) || _hasNet(path)) {
return false;
}
break;
case 3:
if (IS_SLASH(CFStringGetCharacterAtIndex(path, 2)) && _hasDrive(path)) {
return false;
}
break;
}
if (0 < newLength && firstChar == '~') {
// Make sure we have a slash in the string
if (!CFStringFindWithOptions(path, CFPreferredSlashStr, CFRangeMake(1, newLength - 1), 0, NULL)) {
return false;
}
}
static const UniChar dotChar = '.';
CFStringAppendCharacters(path, &dotChar, 1);
CFStringAppend(path, extension);
return true;
}
static CFStringRef __CFNumberCopyDescription(CFTypeRef cf) {
CFNumberRef number = (CFNumberRef)cf;
CFNumberType type = __CFNumberGetType(number);
CFMutableStringRef mstr = CFStringCreateMutable(kCFAllocatorSystemDefault, 0);
CFStringAppendFormat(mstr, NULL, CFSTR("<CFNumber %p [%p]>{value = "), cf, CFGetAllocator(cf));
if (__CFNumberTypeTable[type].floatBit) {
Float64 d;
__CFNumberGetValue(number, kCFNumberFloat64Type, &d);
if (isnan(d)) {
CFStringAppend(mstr, CFSTR("nan"));
} else if (isinf(d)) {
CFStringAppend(mstr, (0.0 < d) ? CFSTR("+infinity") : CFSTR("-infinity"));
} else if (0.0 == d) {
CFStringAppend(mstr, (copysign(1.0, d) < 0.0) ? CFSTR("-0.0") : CFSTR("+0.0"));
} else {
CFStringAppendFormat(mstr, NULL, CFSTR("%+.*f"), (__CFNumberTypeTable[type].storageBit ? 20 : 10), d);
}
const char* typeName = "unknown float";
switch (type) {
case kCFNumberFloat32Type: typeName = "kCFNumberFloat32Type"; break;
case kCFNumberFloat64Type: typeName = "kCFNumberFloat64Type"; break;
}
CFStringAppendFormat(mstr, NULL, CFSTR(", type = %s}"), typeName);
} else {
CFSInt128Struct i;
__CFNumberGetValue(number, kCFNumberSInt128Type, &i);
char buffer[128];
__CFSInt128Format(buffer, &i, true);
const char* typeName = "unknown integer";
switch (type) {
case kCFNumberSInt8Type: typeName = "kCFNumberSInt8Type"; break;
case kCFNumberSInt16Type: typeName = "kCFNumberSInt16Type"; break;
case kCFNumberSInt32Type: typeName = "kCFNumberSInt32Type"; break;
case kCFNumberSInt64Type: typeName = "kCFNumberSInt64Type"; break;
case kCFNumberSInt128Type: typeName = "kCFNumberSInt128Type"; break;
}
CFStringAppendFormat(mstr, NULL, CFSTR("%s, type = %s}"), buffer, typeName);
}
return mstr;
}
void SavePrefs (void)
{
CFMutableStringRef mref;
CFStringRef sref;
CFDataRef data;
for (unsigned int i = 0; i < kPrefListSize; i++)
{
mref = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFSTR("Preferences_"));
if (mref)
{
sref = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *) &(prefList[i].itemName), sizeof(OSType), kCFStringEncodingMacRoman, false);
if (sref)
{
CFStringAppend(mref, sref);
data = CFDataCreate(kCFAllocatorDefault, (UInt8 *) prefList[i].itemPointer, prefList[i].size);
if (data)
{
CFPreferencesSetAppValue(mref, data, kCFPreferencesCurrentApplication);
CFRelease(data);
}
CFRelease(sref);
}
CFRelease(mref);
}
}
mref = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFSTR("Preferences_SaveFolder"));
if (mref)
{
if (saveFolderPath)
{
CFPreferencesSetAppValue(mref, saveFolderPath, kCFPreferencesCurrentApplication);
CFRelease(saveFolderPath);
}
else
CFPreferencesSetAppValue(mref, NULL, kCFPreferencesCurrentApplication);
CFRelease(mref);
}
sref = (CFStringRef) CFDictionaryGetValue(CFBundleGetInfoDictionary(CFBundleGetMainBundle()), CFSTR("CFBundleShortVersionString"));
if (sref)
{
CFPreferencesSetAppValue(CFSTR("LastVersionUsed"), sref, kCFPreferencesCurrentApplication);
}
CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
}
static CFStringRef SOSRecoveryKeyBagCopyFormatDescription(CFTypeRef aObj, CFDictionaryRef formatOptions) {
SOSRecoveryKeyBagRef rb = (SOSRecoveryKeyBagRef) aObj;
CFStringRef gcString = SOSGenerationCountCopyDescription(rb->generation);
CFStringRef rkbID = SOSCopyIDOfDataBufferWithLength(rb->recoveryKeyBag, 8, NULL);
CFMutableStringRef description = CFStringCreateMutable(kCFAllocatorDefault, 0);
CFStringAppendFormat(description, NULL, CFSTR("<SOSRecoveryKeyBag@%p DSID: %@ version: %d gencount: %@ RecoveryKeyID: %@ "), rb, rb->accountDSID, (int) rb->rkbVersion, gcString, rkbID);
CFStringAppend(description, CFSTR(">"));
CFReleaseNull(gcString);
CFReleaseNull(rkbID);
return description;
}
SOSCoderStatus SOSCoderWrap(SOSCoderRef coder, CFDataRef message, CFMutableDataRef *codedMessage, CFStringRef clientId, CFErrorRef *error) {
CFMutableStringRef action = CFStringCreateMutable(kCFAllocatorDefault, 0);
SOSCoderStatus result = kSOSCoderDataReturned;
CFStringRef beginState = NULL;
CFMutableDataRef encoded = NULL;
OSStatus otrStatus = 0;
require_action_quiet(coder->sessRef, errOut,
CFStringAppend(action, CFSTR("*** using null coder ***"));
result = nullCoder(message, codedMessage));
beginState = CFCopyDescription(coder->sessRef);
require_action_quiet(SecOTRSGetIsReadyForMessages(coder->sessRef), errOut,
CFStringAppend(action, CFSTR("not ready"));
result = kSOSCoderNegotiating);
require_action_quiet(!coder->waitingForDataPacket, errOut,
CFStringAppend(action, CFSTR("waiting for peer to send data packet first"));
result = kSOSCoderNegotiating);
require_action_quiet(encoded = CFDataCreateMutable(kCFAllocatorDefault, 0), errOut,
SOSCreateErrorWithFormat(kSOSErrorAllocationFailure, NULL, error, NULL, CFSTR("%@ alloc failed"), clientId);
result = kSOSCoderFailure);
require_noerr_action_quiet(otrStatus = SecOTRSSignAndProtectMessage(coder->sessRef, message, encoded), errOut,
SOSCreateErrorWithFormat(kSOSErrorEncodeFailure, (error != NULL) ? *error : NULL, error, NULL, CFSTR("%@ cannot protect message: %" PRIdOSStatus), clientId, otrStatus);
CFReleaseNull(encoded);
result = kSOSCoderFailure);
*codedMessage = encoded;
errOut:
// Uber state log
if (result == kSOSCoderFailure && error && *error)
CFStringAppendFormat(action, NULL, CFSTR(" %@"), *error);
secnotice("coder", "%@ %@ %s %@ %@ returned %s", clientId, beginState,
SecOTRPacketTypeString(encoded), action, coder->sessRef, SOSCoderString(result));
CFReleaseSafe(beginState);
CFRelease(action);
return result;
}
