static void printEntry(const void *key, const void *value, void *context)
{
struct indent_ctxt * ctxt = context;
#if 1
// IOKit pretty
CFDataRef data;
indent(false, ctxt->depth, ctxt->stackOfBits);
printf(" ");
printCFString( (CFStringRef)key );
printf(" = ");
data = IOCFSerialize((CFStringRef)value, kNilOptions);
if( data) {
if( 10000 > CFDataGetLength(data))
printf(CFDataGetBytePtr(data));
else
printf("<is BIG>");
CFRelease(data);
} else
printf("<IOCFSerialize failed>");
printf("\n");
#else
// CF ugly
CFStringRef keyStr = (CFStringRef) key;
CFStringRef valueStr = CFCopyDescription((CFTypeRef) val);
CFStringRef outStr;
indent(false, ctxt->depth, ctxt->stackOfBits);
outStr = CFStringCreateWithFormat(kCFAllocatorDefault, 0,
CFSTR(" %@ = %@\n"), keyStr, valueStr);
assert(outStr);
printCFString(outStr);
CFRelease(valueStr);
CFRelease(outStr);
#endif
}
SECURITY_STATUS schan_imp_get_session_peer_certificate(schan_imp_session session,
PCCERT_CONTEXT *cert)
{
struct mac_session* s = (struct mac_session*)session;
SECURITY_STATUS ret = SEC_E_INTERNAL_ERROR;
CFArrayRef certs;
OSStatus status;
TRACE("(%p/%p, %p)\n", s, s->context, cert);
status = SSLCopyPeerCertificates(s->context, &certs);
if (status == noErr && certs)
{
SecCertificateRef mac_cert;
CFDataRef data;
if (CFArrayGetCount(certs) &&
(mac_cert = (SecCertificateRef)CFArrayGetValueAtIndex(certs, 0)) &&
(SecKeychainItemExport(mac_cert, kSecFormatX509Cert, 0, NULL, &data) == noErr))
{
*cert = CertCreateCertificateContext(X509_ASN_ENCODING,
CFDataGetBytePtr(data), CFDataGetLength(data));
if (*cert)
ret = SEC_E_OK;
else
{
ret = GetLastError();
WARN("CertCreateCertificateContext failed: %x\n", ret);
}
CFRelease(data);
}
else
WARN("Couldn't extract certificate data\n");
CFRelease(certs);
}
else
WARN("SSLCopyPeerCertificates failed: %ld\n", (long)status);
return ret;
}
static CFIndex dataRead(CFReadStreamRef stream, UInt8 *buffer, CFIndex bufferLength, CFStreamError *error, Boolean *atEOF, void *info) {
_CFReadDataStreamContext *dataCtxt = (_CFReadDataStreamContext *)info;
const UInt8 *bytePtr = CFDataGetBytePtr(dataCtxt->data);
CFIndex length = CFDataGetLength(dataCtxt->data);
CFIndex bytesToCopy = bytePtr + length - dataCtxt->loc;
if (bytesToCopy > bufferLength) {
bytesToCopy = bufferLength;
}
if (bytesToCopy < 0) {
bytesToCopy = 0;
}
if (bytesToCopy != 0) {
memmove(buffer, dataCtxt->loc, bytesToCopy);
dataCtxt->loc += bytesToCopy;
}
error->error = 0;
*atEOF = (dataCtxt->loc < bytePtr + length) ? FALSE : TRUE;
if (dataCtxt->scheduled && !*atEOF) {
CFReadStreamSignalEvent(stream, kCFStreamEventHasBytesAvailable, NULL);
}
return bytesToCopy;
}
GHOST_TUns8* GHOST_SystemCarbon::getClipboard(bool selection) const
{
PasteboardRef inPasteboard;
PasteboardItemID itemID;
CFDataRef flavorData;
OSStatus err = noErr;
GHOST_TUns8 * temp_buff;
CFRange range;
OSStatus syncFlags;
err = PasteboardCreate(kPasteboardClipboard, &inPasteboard);
if(err != noErr) { return NULL;}
syncFlags = PasteboardSynchronize( inPasteboard );
/* as we always get in a new string, we can safely ignore sync flags if not an error*/
if(syncFlags <0) { return NULL;}
err = PasteboardGetItemIdentifier( inPasteboard, 1, &itemID );
if(err != noErr) { return NULL;}
err = PasteboardCopyItemFlavorData( inPasteboard, itemID, CFSTR("public.utf8-plain-text"), &flavorData);
if(err != noErr) { return NULL;}
range = CFRangeMake(0, CFDataGetLength(flavorData));
temp_buff = (GHOST_TUns8*) malloc(range.length+1);
CFDataGetBytes(flavorData, range, (UInt8*)temp_buff);
temp_buff[range.length] = '\0';
if(temp_buff) {
return temp_buff;
} else {
return NULL;
}
}
std::vector<char> metadata_realm_encryption_key()
{
const size_t key_size = 64;
const std::string service = "io.realm.sync.keychain";
const std::string account = "metadata";
auto search_dictionary = build_search_dictionary(account, service, none);
CFDataRef retained_key_data;
if (OSStatus status = SecItemCopyMatching(search_dictionary.get(), (CFTypeRef *)&retained_key_data)) {
if (status != errSecItemNotFound) {
throw KeychainAccessException(status);
}
// Key was not found. Generate a new key, store it, and return it.
std::vector<char> key(key_size);
arc4random_buf(key.data(), key_size);
auto key_data = adoptCF(CFDataCreate(nullptr, reinterpret_cast<const UInt8 *>(key.data()), key_size));
if (!key_data) {
throw std::bad_alloc();
}
CFDictionaryAddValue(search_dictionary.get(), kSecValueData, key_data.get());
if (OSStatus status = SecItemAdd(search_dictionary.get(), nullptr)) {
throw KeychainAccessException(status);
}
return key;
}
CFPtr<CFDataRef> key_data = adoptCF(retained_key_data);
// Key was previously stored. Extract it.
if (key_size != CFDataGetLength(key_data.get())) {
throw std::runtime_error("Password stored in keychain was not expected size.");
}
auto key_bytes = reinterpret_cast<const char *>(CFDataGetBytePtr(key_data.get()));
return std::vector<char>(key_bytes, key_bytes + key_size);
}
static void __DAQueueResponse( DASessionRef session,
void * address,
void * context,
_DACallbackKind kind,
DADiskRef disk,
CFTypeRef response,
SInt32 responseID )
{
CFDataRef _response = NULL;
if ( response ) _response = _DASerialize( kCFAllocatorDefault, response );
_DAServerSessionQueueResponse( _DASessionGetID( session ),
( uintptr_t ) address,
( uintptr_t ) context,
( int32_t ) kind,
( caddr_t ) _DADiskGetID( disk ),
( vm_address_t ) ( _response ? CFDataGetBytePtr( _response ) : 0 ),
( mach_msg_type_number_t ) ( _response ? CFDataGetLength( _response ) : 0 ),
( int32_t ) responseID );
if ( _response ) CFRelease( _response );
}
int img3_flash_NOR_image(io_connect_t norServiceConnection, CFDataRef imageData, int isLLB) {
restored_log("%s: flashing %s data\n", "img3_flash_NOR_image", (isLLB ? "LLB" : "NOR"));
size_t imgLen = CFDataGetLength(imageData);
void *mappedImage = mmap(NULL, imgLen, PROT_READ | PROT_WRITE, MAP_SHARED, -1, 0);
if(mappedImage == MAP_FAILED) {
int err = errno;
restored_log("mmap (size = %d) failed: %s\n", imgLen, strerror(err));
return err;
}
const void *imageDataPtr = CFDataGetBytePtr(imageData);
bcopy(imageDataPtr, mappedImage, imgLen);
kern_return_t result;
if((result = IOConnectCallStructMethod(norServiceConnection, 0, mappedImage, imgLen, NULL, 0)) != KERN_SUCCESS) {
restored_log("IOConnectCallStructMethod failed: 0x%x\n", result);
}
munmap(mappedImage, imgLen);
return result;
}
static void
dumpLogicalVolumeExtents(CFMutableDictionaryRef lv)
{
CFStringRef lvUUID = CFDictionaryGetValue(lv, CFSTR(kAppleLVMVolumeUUIDKey));
if (!lvUUID) { printf("\ninternal error, no uuid in lv dict\n"); return; };
CFDataRef extentData = (CFDataRef)AppleLVMGetVolumeExtents(lvUUID);
if (!extentData) { printf("\nno extent data found?\n"); return; };
AppleRAIDExtentOnDisk * extentList = (AppleRAIDExtentOnDisk *)CFDataGetBytePtr(extentData);
UInt64 extentCount = CFDataGetLength(extentData) / sizeof(AppleRAIDExtentOnDisk);
if (!extentCount || !extentList) { printf("\nextent data empty?\n"); return; };
printf("\textent list:\n");
UInt32 i;
for (i = 0; i < extentCount; i++) {
printf(" %20llu - %12llu (%llu)\n",
extentList[i].extentByteOffset,
extentList[i].extentByteOffset + extentList[i].extentByteCount - 1,
extentList[i].extentByteCount);
}
}
static inline CFDataRef TSICTStringCreateDataFromIntermediateRepresentation(TStringIRep* rep)
{
CFIndex len = CFDataGetLength(rep->data);
CFMutableDataRef buffer = CFDataCreateMutableCopy(kCFAllocatorDefault, (len + 12), rep->data);
UInt8* bufferBytes = CFDataGetMutableBytePtr(buffer);
size_t prefixLength = strlen(rep->length) + 1;
CFDataReplaceBytes(buffer, BeginningRange, (const UInt8*)rep->length, (CFIndex)prefixLength);
if (rep->format == kTSITStringFormatTNetstring) {
const UInt8 ftag = (UInt8)TNetstringTypes[rep->type];
CFDataAppendBytes(buffer, &ftag, 1);
bufferBytes[(prefixLength - 1)] = TNetstringSeparator;
} else if (rep->format == kTSITStringFormatOTNetstring) {
const UInt8 ftag = (UInt8)OTNetstringTypes[rep->type];
bufferBytes[(prefixLength - 1)] = ftag;
}
CFDataRef dataRep = CFDataCreateCopy(kCFAllocatorDefault, buffer);
CFRelease(buffer);
return dataRep;
}
static int mailstream_low_cfstream_get_fd(mailstream_low * s)
{
#if HAVE_CFNETWORK
struct mailstream_cfstream_data * cfstream_data = NULL;
CFDataRef native_handle_data = NULL;
CFSocketNativeHandle native_handle_value = -1;
CFIndex native_data_len = 0;
CFIndex native_value_len = 0;
if (!s)
return -1;
cfstream_data = (struct mailstream_cfstream_data *) s->data;
if (!cfstream_data->readStream)
return -1;
native_handle_data = (CFDataRef)CFReadStreamCopyProperty(cfstream_data->readStream, kCFStreamPropertySocketNativeHandle);
if (!native_handle_data)
return -1;
native_data_len = CFDataGetLength(native_handle_data);
native_value_len = (CFIndex)sizeof(native_handle_value);
if (native_data_len != native_value_len) {
CFRelease(native_handle_data);
return -1;
}
CFDataGetBytes(native_handle_data, CFRangeMake(0, MIN(native_data_len, native_value_len)), (UInt8 *)&native_handle_value);
CFRelease(native_handle_data);
return native_handle_value;
#else
return -1;
#endif
}
void start_paste(widget_list *widget)
{
OSStatus err = noErr;
PasteboardRef gClipboard;
PasteboardItemID itemID;
CFDataRef flavorData;
char* flavorText;
err = PasteboardCreate( kPasteboardClipboard, &gClipboard );
//require_noerr( err, CantCreateClipboard );
err = PasteboardGetItemIdentifier( gClipboard, 1, &itemID );
err = PasteboardCopyItemFlavorData( gClipboard, itemID, CFSTR("com.apple.traditional-mac-plain-text"), &flavorData );
int flavorDataSize = CFDataGetLength(flavorData);
flavorText=(char*)malloc(flavorDataSize+1);
short dataIndex;
for(dataIndex = 0; dataIndex <= flavorDataSize; dataIndex++ )
{
char byte = *(CFDataGetBytePtr( flavorData ) + dataIndex);
flavorText[dataIndex] = (byte>32) ? byte : ' ';
}
flavorText[flavorDataSize] = '\0';
CFRelease(flavorData);
if (widget == NULL)
{
do_paste (flavorText);
}
else
{
do_paste_to_text_field(widget, flavorText);
}
free(flavorText);
CFRelease( gClipboard );
}
/*! Creates a dictionary of session parameters for the session associated with
* the specified target, if one exists.
* @param handle a handle to a daemon connection.
* @param target the target to check for associated sessions to generate
* a dictionary of session parameters.
* @return a dictionary of session properties. */
CFDictionaryRef iSCSIDaemonCreateCFPropertiesForSession(iSCSIDaemonHandle handle,
iSCSITargetRef target)
{
// Validate inputs
if(handle < 0 || !target)
return NULL;
CFDictionaryRef properties = NULL;
CFDataRef targetData = iSCSITargetCreateData(target);
// Send command to daemon
iSCSIDMsgCreateCFPropertiesForSessionCmd cmd = iSCSIDMsgCreateCFPropertiesForSessionCmdInit;
cmd.targetLength = (UInt32)CFDataGetLength(targetData);
errno_t error = iSCSIDaemonSendMsg(handle,(iSCSIDMsgGeneric *)&cmd,
targetData,NULL);
CFRelease(targetData);
iSCSIDMsgCreateCFPropertiesForSessionRsp rsp;
if(!error)
error = iSCSIDaemonRecvMsg(handle,(iSCSIDMsgGeneric*)&rsp,NULL);
if(!error) {
CFDataRef data = NULL;
error = iSCSIDaemonRecvMsg(handle,0,&data,rsp.dataLength,NULL);
if(!error && data) {
CFPropertyListFormat format;
properties = CFPropertyListCreateWithData(kCFAllocatorDefault,data,0,&format,NULL);
CFRelease(data);
}
}
return properties;
}
/* Private call for Apple Internal use only */
IOReturn IOPMSleepSystemWithOptions ( io_connect_t fb, CFDictionaryRef options )
{
uint64_t rtn = 0;
size_t len = sizeof(uint32_t);
kern_return_t err;
CFDataRef serializedOptions = NULL;
if( !options ) {
return IOPMSleepSystem( fb );
}
serializedOptions = IOCFSerialize( options, 0 );
if (!serializedOptions)
{
return kIOReturnInternalError;
}
/* kPMSleepSystemOptions
* in: serialized CFDictionary of options
* out: IOReturn code returned from sleepSystem
*/
err = IOConnectCallStructMethod(
fb,
kPMSleepSystemOptions,
CFDataGetBytePtr(serializedOptions), /* inputStruct */
CFDataGetLength(serializedOptions), /* inputStructCnt */
&rtn, /* outputStruct */
&len); /* outputStructCnt */
CFRelease(serializedOptions);
if (kIOReturnSuccess != err)
return err;
else
return (IOReturn) rtn;
}
CFNetDiagnosticStatus CFNetDiagnosticDiagnoseProblemInteractively(CFNetDiagnosticRef details) {
SInt32 retval = 0;
mach_port_t port = MACH_PORT_NULL;
CFDataRef msgData = NULL;
kern_return_t err;
//build message
CFWriteStreamRef stream = CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault);
CFWriteStreamOpen(stream);
CFIndex len = CFPropertyListWriteToStream(details, stream, kCFPropertyListBinaryFormat_v1_0, NULL);
CFWriteStreamClose(stream);
if(len > 0) {
msgData = CFWriteStreamCopyProperty(stream, kCFStreamPropertyDataWritten);
}
CFRelease(stream);
if(msgData) {
err = bootstrap_look_up(bootstrap_port, *((name_t*)(&_CFNetDiagnosticMachPortName)), &port);
if (err == KERN_SUCCESS) {
err = _CFNetDiagnosticClient_passDescriptor( port,
_CFNetDiagnosticMachProtocolVersion,
(vm_address_t)CFDataGetBytePtr(msgData),
CFDataGetLength(msgData));
if (err == KERN_SUCCESS) {
//FIXME Yay!!!
}
}
CFRelease(msgData);
}
return (CFNetDiagnosticStatus)retval;
}
sdmmd_return_t SDMMD_MB2SendFileStream(SDMMD_AMConnectionRef conn, CFStringRef path, CFDataRef file) {
sdmmd_return_t result = kAMDSuccess;
CFDataRef file_path = CFStringCreateExternalRepresentation(kCFAllocatorDefault, path, kCFStringEncodingUTF8, 0);
result = SDMMD_ServiceSend(SDMMD_TranslateConnectionToSocket(conn), file_path);
CFSafeRelease(file_path);
CheckErrorAndReturn(result);
char data_chunk[1] = { 0x0C };
CFMutableDataRef data_separator = CFDataCreateMutable(kCFAllocatorDefault, 0);
CFDataAppendBytes(data_separator, (const UInt8 *)data_chunk, sizeof(uint8_t));
CFDataAppendBytes(data_separator, CFDataGetBytePtr(file), CFDataGetLength(file));
result = SDMMD_ServiceSend(SDMMD_TranslateConnectionToSocket(conn), data_separator);
CFSafeRelease(data_separator);
CheckErrorAndReturn(result);
char zero_chunk[1] = { 0x0 };
CFDataRef data_end = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)zero_chunk, sizeof(uint8_t));
result = SDMMD_ServiceSend(SDMMD_TranslateConnectionToSocket(conn), data_end);
CFSafeRelease(data_end);
CheckErrorAndReturn(result);
ExitLabelAndReturn(result);
}
CFDataRef SC_MachMessagePort::messagePortCallBack(CFMessagePortRef local, SInt32 msgid, CFDataRef data, void *info)
{
// CFShow(data);
SC_MachMessagePort *port = (SC_MachMessagePort *) info;
OSC_Packet* packet = (OSC_Packet *) malloc(sizeof(OSC_Packet));
bzero(&packet->mReplyAddr, sizeof(ReplyAddress));
packet->mReplyAddr.mReplyFunc = port->mReplyPort ? mach_reply_func : null_reply_func;
packet->mReplyAddr.mReplyData = 0;
packet->mReplyAddr.mSocket = (int)(int64)port->mReplyPort;
packet->mSize = CFDataGetLength(data);
packet->mData = (char*) memcpy(malloc(packet->mSize), CFDataGetBytePtr(data), packet->mSize);
World *world = port->mWorld;
if (world->mDumpOSC) dumpOSC(world->mDumpOSC, packet->mSize, packet->mData);
if (!ProcessOSCPacket(world, packet)) {
scprintf("command FIFO full\n");
free(packet->mData);
free(packet);
}
// how can we send a reply? we could block here until the message is processed...
return NULL;
}
static int convertOid(
CFTypeRef inRef,
CSSM_OID *outOid)
{
if (!inRef || !outOid)
return errSecParam;
unsigned char *oidData = NULL;
unsigned int oidLen = 0;
if (CFGetTypeID(inRef) == CFStringGetTypeID()) {
// CFStringRef: OID representation is a dotted-decimal string
CFStringRef inStr = (CFStringRef)inRef;
CFIndex max = CFStringGetLength(inStr) * 3;
char buf[max];
if (!CFStringGetCString(inStr, buf, max-1, kCFStringEncodingASCII))
return errSecParam;
if(encodeOid((unsigned char *)buf, &oidData, &oidLen) != 0)
return errSecParam;
}
else if (CFGetTypeID(inRef) == CFDataGetTypeID()) {
// CFDataRef: OID representation is in binary DER format
CFDataRef inData = (CFDataRef)inRef;
oidLen = (unsigned int) CFDataGetLength(inData);
oidData = (unsigned char *) malloc(oidLen);
memcpy(oidData, CFDataGetBytePtr(inData), oidLen);
}
else {
// Not in a format we understand
return errSecParam;
}
outOid->Length = oidLen;
outOid->Data = (uint8 *)oidData;
return 0;
}
Boolean IOURLWriteDataAndPropertiesToResource(CFURLRef url, CFDataRef data, CFDictionaryRef propertyDict, SInt32 *errorCode) {
CFStringRef scheme = CFURLCopyScheme(url);
if (!scheme) {
if (errorCode) *errorCode = kIOURLImproperArgumentsError;
return FALSE;
} else if (CFStringCompare(scheme, CFSTR("file"), 0) == kCFCompareEqualTo) {
Boolean success = TRUE;
CFRelease(scheme);
if (errorCode) *errorCode = 0;
if (data) {
char cPath[CFMaxPathSize];
if (!CFURLGetFileSystemRepresentation(url, TRUE, cPath, CFMaxPathSize)) {
if (errorCode) *errorCode = kIOURLImproperArgumentsError;
success = FALSE;
} else if (CFURLHasDirectoryPath(url)) {
// Create a directory
success = !mkdir(cPath, 0777);
if (!success && errorCode) *errorCode = kIOURLUnknownError;
} else {
// Write data
SInt32 length = CFDataGetLength(data);
const void *bytes = (0 == length) ? (const void *)"" : CFDataGetBytePtr(data);
success = _IOWriteBytesToFile(cPath, bytes, length);
if (!success && errorCode) *errorCode = kIOURLUnknownError;
}
}
if (propertyDict) {
if (!_IOFileURLWritePropertiesToResource(url, propertyDict, errorCode))
success = FALSE;
}
return success;
} else {
if (errorCode) *errorCode = kIOURLUnknownSchemeError;
return FALSE;
}
}
static int Base64Data(CFDataRef cfData, int for_encoding, CFDataRef* encoded_data)
{
int result = -1; // Guilty until proven
CNEncodings encoding = kCNEncodingBase64;
CNStatus status = kCCSuccess;
CNEncodingDirection direction = (for_encoding) ? kCNEncode : kCNDecode;
unsigned char buffer[1024];
size_t encoded_data_length = 1024;
if (NULL == cfData || NULL == encoded_data)
{
return result;
}
memset(buffer, 0, 1024);
*encoded_data = NULL;
status = CNEncode(encoding, direction, CFDataGetBytePtr(cfData), CFDataGetLength(cfData), buffer, &encoded_data_length);
if (kCCSuccess == status)
{
*encoded_data = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)buffer, encoded_data_length);
result = (NULL == *encoded_data) ? -1 : 0;
}
return result;
}
sdmmd_return_t SDMMD_DirectServiceReceive(SocketConnection handle, CFDataRef *data) {
uint32_t size = (data && *data ? (uint32_t)CFDataGetLength(*data) : 0);
if (size) {
if (CheckIfExpectingResponse(handle, 1000)) {
unsigned char *buffer = malloc(size);
uint32_t remainder = size;
size_t recieved;
while (remainder) {
if (handle.isSSL) {
recieved = SSL_read(handle.socket.ssl, &buffer[size-remainder], remainder);
} else {
recieved = recv(handle.socket.conn, &buffer[size-remainder], remainder, 0);
}
if (!recieved)
break;
remainder -= recieved;
}
*data = CFDataCreate(kCFAllocatorDefault, buffer, size);
free(buffer);
}
return kAMDSuccess;
}
return kAMDSuccess;
}
static String CGImageToDataURL(CGImageRef image, const String& mimeType, const double* quality)
{
if (!image)
return "data:,";
RetainPtr<CFMutableDataRef> data(AdoptCF, CFDataCreateMutable(kCFAllocatorDefault, 0));
if (!data)
return "data:,";
RetainPtr<CFStringRef> uti = utiFromMIMEType(mimeType);
ASSERT(uti);
RetainPtr<CGImageDestinationRef> destination(AdoptCF, CGImageDestinationCreateWithData(data.get(), uti.get(), 1, 0));
if (!destination)
return "data:,";
RetainPtr<CFDictionaryRef> imageProperties = 0;
if (CFEqual(uti.get(), jpegUTI()) && quality && *quality >= 0.0 && *quality <= 1.0) {
// Apply the compression quality to the JPEG image destination.
RetainPtr<CFNumberRef> compressionQuality(AdoptCF, CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, quality));
const void* key = kCGImageDestinationLossyCompressionQuality;
const void* value = compressionQuality.get();
imageProperties.adoptCF(CFDictionaryCreate(0, &key, &value, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
}
// Setting kCGImageDestinationBackgroundColor to black for JPEG images in imageProperties would save some math
// in the calling functions, but it doesn't seem to work.
CGImageDestinationAddImage(destination.get(), image, imageProperties.get());
CGImageDestinationFinalize(destination.get());
Vector<char> base64Data;
base64Encode(reinterpret_cast<const char*>(CFDataGetBytePtr(data.get())), CFDataGetLength(data.get()), base64Data);
return "data:" + mimeType + ";base64," + base64Data;
}
sdmmd_return_t SDMMD_ServiceSend(SocketConnection handle, CFDataRef data) {
CFIndex msgLen = (data ? CFDataGetLength(data) : 0);
if (msgLen) {
msgLen = htonl((uint32_t)msgLen);
uint64_t result;
// Send 32-bit data length header
if (handle.isSSL) {
if (SSL_is_init_finished(handle.socket.ssl)) {
result = SSL_write(handle.socket.ssl, &msgLen, sizeof(uint32_t));
}
else {
return kAMDNotConnectedError;
}
}
else {
result = send(handle.socket.conn, &msgLen, sizeof(uint32_t), 0);
}
// Send data body
if (result == sizeof(uint32_t)) {
msgLen = ntohl(msgLen);
if (handle.isSSL) {
result = SSL_write(handle.socket.ssl, CFDataGetBytePtr(data), (uint32_t)msgLen);
}
else {
result = send(handle.socket.conn, CFDataGetBytePtr(data), msgLen, 0);
}
return (result == msgLen ? kAMDSuccess : kAMDInvalidResponseError);
}
else {
return kAMDNotConnectedError;
}
}
else {
return kAMDInvalidArgumentError;
}
}
TagLib::ByteVector TagLib::DecodeBase64(const TagLib::ByteVector& input)
{
SFB::CFError error;
SFB::SecTransform decoder(SecDecodeTransformCreate(kSecBase64Encoding, &error));
if(!decoder) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecDecodeTransformCreate failed: " << error);
return {};
}
SFB::CFData sourceData(CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, (const UInt8 *)input.data(), (CFIndex)input.size(), kCFAllocatorNull));
if(!sourceData)
return {};
if(!SecTransformSetAttribute(decoder, kSecTransformInputAttributeName, sourceData, &error)) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecTransformSetAttribute failed: " << error);
return {};
}
SFB::CFData decodedData((CFDataRef)SecTransformExecute(decoder, &error));
if(!decodedData)
return {};
return {(const char *)CFDataGetBytePtr((CFDataRef)decodedData), (size_t)CFDataGetLength((CFDataRef)decodedData)};
}
/*! Synchronizes cached preference changes to disk and releases the locked
* semaphore, allowing other clients to make changes. If the prefereneces
* parameter is NULL, then no changes are made to disk and the semaphore is
* unlocked.
* @param handle a handle to a daemon connection.
* @param preferences the preferences to be synchronized
* @return an error code indicating whether the operating was successful. */
errno_t iSCSIDaemonPreferencesIOUnlockAndSync(iSCSIDaemonHandle handle,
iSCSIPreferencesRef preferences)
{
// Validate inputs
if(handle < 0)
return EINVAL;
CFDataRef preferencesData = NULL;
iSCSIDMsgPreferencesIOUnlockAndSyncCmd cmd = iSCSIDMsgPreferencesIOUnlockAndSyncCmdInit;
if(preferences) {
preferencesData = iSCSIPreferencesCreateData(preferences);
cmd.preferencesLength = (UInt32)CFDataGetLength(preferencesData);
}
else
cmd.preferencesLength = 0;
errno_t error = iSCSIDaemonSendMsg(handle,(iSCSIDMsgGeneric *)&cmd,preferencesData,NULL);
if(preferencesData)
CFRelease(preferencesData);
if(error)
return error;
iSCSIDMsgPreferencesIOUnlockAndSyncRsp rsp;
if(recv(handle,&rsp,sizeof(rsp),0) != sizeof(rsp))
return EIO;
if(rsp.funcCode != kiSCSIDPreferencesIOUnlockAndSync)
return EIO;
return rsp.errorCode;
}
CFDataRef createHTMLData(CFDataRef nfo) {
// Load HTML constants (UCS2)
CFDataRef preNfo = createUCS2FromConst(PRE_NFO_HTML, sizeof(PRE_NFO_HTML));
CFDataRef postNfo = createUCS2FromConst(POST_NFO_HTML, sizeof(POST_NFO_HTML));
CFDataRef preBlock = createUCS2FromConst(PRE_BLOCK_HTML, sizeof(PRE_BLOCK_HTML));
CFDataRef postBlock = createUCS2FromConst(POST_BLOCK_HTML, sizeof(POST_BLOCK_HTML));
CFMutableDataRef result = CFDataCreateMutable(NULL, 0);
appendCFData(result, preNfo);
CFRelease(preNfo);
const UInt8* inPtr = CFDataGetBytePtr(nfo);
size_t inCharsLeft = CFDataGetLength(nfo) / sizeof(UInt16);
const UInt8* bsPtr = inPtr;
bool inRun = false;
while (inCharsLeft-- > 0) {
UInt16 chr = *((const UInt16*)inPtr);
// Look ahead for new state
bool newState = inRun;
if(!inRun) {
if(ISBLOCKORBOX(chr)) {
newState = true;
}
} else {
if(!ISBLOCKORBOX(chr) && !ISWHITESPACE(chr)) {
newState = false;
}
}
// Process change of state, append data
if(inRun != newState) {
if(inPtr != bsPtr) {
if(inRun) {
appendCFData(result, preBlock);
CFDataAppendBytes(result, (const UInt8*)bsPtr, (inPtr - bsPtr));
appendCFData(result, postBlock);
} else {
CFDataAppendBytes(result, (const UInt8*)bsPtr, (inPtr - bsPtr));
}
bsPtr = inPtr;
}
inRun = newState;
}
inPtr += sizeof(UInt16);
}
// Append trailing data
if(inPtr > bsPtr) {
if(inRun) {
appendCFData(result, preBlock);
CFDataAppendBytes(result, (const UInt8*)bsPtr, (inPtr - bsPtr));
appendCFData(result, postBlock);
} else {
CFDataAppendBytes(result, (const UInt8*)bsPtr, (inPtr - bsPtr));
}
}
CFRelease(preBlock);
CFRelease(postBlock);
appendCFData(result, postNfo);
CFRelease(postNfo);
return result;
}
void appendCFData(CFMutableDataRef dst, CFDataRef src) {
CFDataAppendBytes(dst, CFDataGetBytePtr(src), CFDataGetLength(src));
}
CFMutableDataRef CFDataCreateMutableCopy(CFAllocatorRef allocator, CFIndex capacity, CFDataRef data) {
// Do not allow magic allocator for now for mutable datas, because it
// isn't remembered for proper handling later when growth of the buffer
// has to occur.
Boolean wasMagic = _CFAllocatorIsGCRefZero(allocator);
if (0 == capacity) allocator = _CFConvertAllocatorToNonGCRefZeroEquivalent(allocator);
CFMutableDataRef r = (CFMutableDataRef) __CFDataInit(allocator, (0 == capacity) ? kCFMutable : kCFFixedMutable, capacity, CFDataGetBytePtr(data), CFDataGetLength(data), NULL);
if (wasMagic) CFMakeCollectable(r);
return r;
}
CFDataRef CFDataCreateCopy(CFAllocatorRef allocator, CFDataRef data) {
CFIndex length = CFDataGetLength(data);
return __CFDataInit(allocator, kCFImmutable, length, CFDataGetBytePtr(data), length, NULL);
}
bool CDVDVideoCodecVDA::Open(CDVDStreamInfo &hints, CDVDCodecOptions &options)
{
if (CSettings::GetInstance().GetBool(CSettings::SETTING_VIDEOPLAYER_USEVDA) && !hints.software)
{
CCocoaAutoPool pool;
//
int width = hints.width;
int height = hints.height;
int level = hints.level;
int profile = hints.profile;
switch(profile)
{
case FF_PROFILE_H264_HIGH_10:
case FF_PROFILE_H264_HIGH_10_INTRA:
case FF_PROFILE_H264_HIGH_422:
case FF_PROFILE_H264_HIGH_422_INTRA:
case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
case FF_PROFILE_H264_HIGH_444_INTRA:
case FF_PROFILE_H264_CAVLC_444:
CLog::Log(LOGNOTICE, "%s - unsupported h264 profile(%d)", __FUNCTION__, hints.profile);
return false;
break;
}
if (width <= 0 || height <= 0)
{
CLog::Log(LOGNOTICE, "%s - bailing with bogus hints, width(%d), height(%d)",
__FUNCTION__, width, height);
return false;
}
if (Cocoa_GPUForDisplayIsNvidiaPureVideo3() && !CDVDCodecUtils::IsVP3CompatibleWidth(width))
{
CLog::Log(LOGNOTICE, "%s - Nvidia 9400 GPU hardware limitation, cannot decode a width of %d", __FUNCTION__, width);
return false;
}
CFDataRef avcCData;
switch (hints.codec)
{
case AV_CODEC_ID_H264:
m_bitstream = new CBitstreamConverter;
if (!m_bitstream->Open(hints.codec, (uint8_t*)hints.extradata, hints.extrasize, false))
return false;
avcCData = CFDataCreate(kCFAllocatorDefault,
(const uint8_t*)m_bitstream->GetExtraData(), m_bitstream->GetExtraSize());
m_format = 'avc1';
m_pFormatName = "vda-h264";
break;
default:
return false;
break;
}
// check the avcC atom's sps for number of reference frames and
// bail if interlaced, VDA does not handle interlaced h264.
uint32_t avcc_len = CFDataGetLength(avcCData);
if (avcc_len < 8)
{
// avcc atoms with length less than 8 are borked.
CFRelease(avcCData);
delete m_bitstream, m_bitstream = NULL;
return false;
}
else
{
bool interlaced = true;
uint8_t *spc = (uint8_t*)CFDataGetBytePtr(avcCData) + 6;
uint32_t sps_size = BS_RB16(spc);
if (sps_size)
m_bitstream->parseh264_sps(spc+3, sps_size-1, &interlaced, &m_max_ref_frames);
if (interlaced)
{
CLog::Log(LOGNOTICE, "%s - possible interlaced content.", __FUNCTION__);
CFRelease(avcCData);
return false;
}
}
if (profile == FF_PROFILE_H264_MAIN && level == 32 && m_max_ref_frames > 4)
{
// [email protected], VDA cannot handle greater than 4 reference frames
CLog::Log(LOGNOTICE, "%s - [email protected] detected, VDA cannot decode.", __FUNCTION__);
CFRelease(avcCData);
return false;
}
std::string rendervendor = g_Windowing.GetRenderVendor();
StringUtils::ToLower(rendervendor);
if (rendervendor.find("nvidia") != std::string::npos)
{
// Nvidia gpu's are all powerful and work the way god intended
m_decode_async = true;
// The gods are liars, ignore the sirens for now.
m_use_cvBufferRef = false;
}
else if (rendervendor.find("intel") != std::string::npos)
{
// Intel gpu are borked when using cvBufferRef
m_decode_async = true;
m_use_cvBufferRef = false;
}
else
{
// ATI gpu's are borked when using async decode
m_decode_async = false;
// They lie here too.
m_use_cvBufferRef = false;
}
if (!m_use_cvBufferRef)
{
// allocate a YV12 DVDVideoPicture buffer.
// first make sure all properties are reset.
memset(&m_videobuffer, 0, sizeof(DVDVideoPicture));
unsigned int iPixels = width * height;
unsigned int iChromaPixels = iPixels/4;
m_videobuffer.dts = DVD_NOPTS_VALUE;
m_videobuffer.pts = DVD_NOPTS_VALUE;
m_videobuffer.iFlags = DVP_FLAG_ALLOCATED;
m_videobuffer.format = RENDER_FMT_YUV420P;
m_videobuffer.color_range = 0;
m_videobuffer.color_matrix = 4;
m_videobuffer.iWidth = width;
m_videobuffer.iHeight = height;
m_videobuffer.iDisplayWidth = width;
m_videobuffer.iDisplayHeight = height;
m_videobuffer.iLineSize[0] = width; //Y
m_videobuffer.iLineSize[1] = width/2; //U
m_videobuffer.iLineSize[2] = width/2; //V
m_videobuffer.iLineSize[3] = 0;
m_videobuffer.data[0] = (uint8_t*)malloc(16 + iPixels);
m_videobuffer.data[1] = (uint8_t*)malloc(16 + iChromaPixels);
m_videobuffer.data[2] = (uint8_t*)malloc(16 + iChromaPixels);
m_videobuffer.data[3] = NULL;
// set all data to 0 for less artifacts.. hmm.. what is black in YUV??
memset(m_videobuffer.data[0], 0, iPixels);
memset(m_videobuffer.data[1], 0, iChromaPixels);
memset(m_videobuffer.data[2], 0, iChromaPixels);
}
// setup the decoder configuration dict
CFMutableDictionaryRef decoderConfiguration = CFDictionaryCreateMutable(
kCFAllocatorDefault, 4, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFNumberRef avcWidth = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &width);
CFNumberRef avcHeight = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &height);
CFNumberRef avcFormat = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &m_format);
CFDictionarySetValue(decoderConfiguration, kVDADecoderConfiguration_Height, avcHeight);
CFDictionarySetValue(decoderConfiguration, kVDADecoderConfiguration_Width, avcWidth);
CFDictionarySetValue(decoderConfiguration, kVDADecoderConfiguration_SourceFormat, avcFormat);
CFDictionarySetValue(decoderConfiguration, kVDADecoderConfiguration_avcCData, avcCData);
// release the retained object refs, decoderConfiguration owns them now
CFRelease(avcWidth);
CFRelease(avcHeight);
CFRelease(avcFormat);
CFRelease(avcCData);
// setup the destination image buffer dict, vda will output this pict format
CFMutableDictionaryRef destinationImageBufferAttributes = CFDictionaryCreateMutable(
kCFAllocatorDefault, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
OSType cvPixelFormatType = kCVPixelFormatType_422YpCbCr8;
CFNumberRef pixelFormat = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &cvPixelFormatType);
// an IOSurface properties dictionary
CFDictionaryRef iosurfaceDictionary = CFDictionaryCreate(kCFAllocatorDefault,
NULL, NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(destinationImageBufferAttributes,
kCVPixelBufferPixelFormatTypeKey, pixelFormat);
CFDictionarySetValue(destinationImageBufferAttributes,
kCVPixelBufferIOSurfacePropertiesKey, iosurfaceDictionary);
// release the retained object refs, destinationImageBufferAttributes owns them now
CFRelease(pixelFormat);
CFRelease(iosurfaceDictionary);
// create the VDADecoder object
OSStatus status;
try
{
status = VDADecoderCreate(decoderConfiguration, destinationImageBufferAttributes,
(VDADecoderOutputCallback*)VDADecoderCallback, this, (VDADecoder*)&m_vda_decoder);
}
catch (...)
{
CLog::Log(LOGERROR, "%s - exception",__FUNCTION__);
status = kVDADecoderDecoderFailedErr;
}
CFRelease(decoderConfiguration);
CFRelease(destinationImageBufferAttributes);
if (CDarwinUtils::DeviceHasLeakyVDA())
CFRelease(pixelFormat);
if (status != kVDADecoderNoErr)
{
if (status == kVDADecoderDecoderFailedErr)
CLog::Log(LOGNOTICE, "%s - VDADecoder Codec failed to open, currently in use by another process",
__FUNCTION__);
else
CLog::Log(LOGNOTICE, "%s - VDADecoder Codec failed to open, status(%d), profile(%d), level(%d)",
__FUNCTION__, (int)status, profile, level);
return false;
}
m_DropPictures = false;
m_max_ref_frames = std::max(m_max_ref_frames + 1, 5);
m_sort_time = 0;
return true;
}
return false;
}
char *osd_get_clipboard_text(void)
{
OSStatus err;
PasteboardRef pasteboard_ref;
err = PasteboardCreate(kPasteboardClipboard, &pasteboard_ref);
if (err)
return nullptr;
PasteboardSynchronize(pasteboard_ref);
ItemCount item_count;
err = PasteboardGetItemCount(pasteboard_ref, &item_count);
char *result = nullptr; // core expects a malloced C string of uft8 data
for (UInt32 item_index = 1; (item_index <= item_count) && !result; item_index++)
{
PasteboardItemID item_id;
err = PasteboardGetItemIdentifier(pasteboard_ref, item_index, &item_id);
if (err)
continue;
CFArrayRef flavor_type_array;
err = PasteboardCopyItemFlavors(pasteboard_ref, item_id, &flavor_type_array);
if (err)
continue;
CFIndex const flavor_count = CFArrayGetCount(flavor_type_array);
for (CFIndex flavor_index = 0; (flavor_index < flavor_count) && !result; flavor_index++)
{
CFStringRef const flavor_type = (CFStringRef)CFArrayGetValueAtIndex(flavor_type_array, flavor_index);
CFStringEncoding encoding;
if (UTTypeConformsTo(flavor_type, kUTTypeUTF16PlainText))
encoding = kCFStringEncodingUTF16;
else if (UTTypeConformsTo (flavor_type, kUTTypeUTF8PlainText))
encoding = kCFStringEncodingUTF8;
else if (UTTypeConformsTo (flavor_type, kUTTypePlainText))
encoding = kCFStringEncodingMacRoman;
else
continue;
CFDataRef flavor_data;
err = PasteboardCopyItemFlavorData(pasteboard_ref, item_id, flavor_type, &flavor_data);
if (!err)
{
CFStringRef string_ref = CFStringCreateFromExternalRepresentation(kCFAllocatorDefault, flavor_data, encoding);
CFDataRef data_ref = CFStringCreateExternalRepresentation (kCFAllocatorDefault, string_ref, kCFStringEncodingUTF8, '?');
CFRelease(string_ref);
CFRelease(flavor_data);
CFIndex const length = CFDataGetLength(data_ref);
CFRange const range = CFRangeMake(0, length);
result = reinterpret_cast<char *>(malloc(length + 1));
if (result)
{
CFDataGetBytes(data_ref, range, reinterpret_cast<unsigned char *>(result));
result[length] = 0;
}
CFRelease(data_ref);
}
}
CFRelease(flavor_type_array);
}
CFRelease(pasteboard_ref);
return result;
}