bool QConfFileSettingsPrivate::writePlistFile(const QString &fileName,
const ParsedSettingsMap &map) const
{
QVarLengthArray<QCFType<CFStringRef> > cfkeys(map.size());
QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(map.size());
int i = 0;
ParsedSettingsMap::const_iterator j;
for (j = map.constBegin(); j != map.constEnd(); ++j) {
cfkeys[i] = macKey(j.key());
cfvalues[i] = macValue(j.value());
++i;
}
QCFType<CFDictionaryRef> propertyList =
CFDictionaryCreate(kCFAllocatorDefault,
reinterpret_cast<const void **>(cfkeys.data()),
reinterpret_cast<const void **>(cfvalues.data()),
CFIndex(map.size()),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
QCFType<CFDataRef> xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, propertyList);
SInt32 code;
return CFURLWriteDataAndPropertiesToResource(urlFromFileName(fileName), xmlData, 0, &code);
}
static SInt32 _CFUserNotificationSendRequest(CFAllocatorRef allocator, CFStringRef sessionID, mach_port_t replyPort, SInt32 token, CFTimeInterval timeout, CFOptionFlags flags, CFDictionaryRef dictionary) {
CFDictionaryRef modifiedDictionary = NULL;
SInt32 retval = ERR_SUCCESS, itimeout = (timeout > 0.0 && timeout < INT_MAX) ? (SInt32)timeout : 0;
CFDataRef data;
mach_msg_base_t *msg = NULL;
mach_port_t bootstrapPort = MACH_PORT_NULL, serverPort = MACH_PORT_NULL;
CFIndex size;
char namebuffer[MAX_PORT_NAME_LENGTH + 1];
strlcpy(namebuffer, NOTIFICATION_PORT_NAME, sizeof(namebuffer));
if (sessionID) {
char sessionid[MAX_PORT_NAME_LENGTH + 1];
CFIndex len = MAX_PORT_NAME_LENGTH - sizeof(NOTIFICATION_PORT_NAME) - sizeof(NOTIFICATION_PORT_NAME_SUFFIX);
CFStringGetBytes(sessionID, CFRangeMake(0, CFStringGetLength(sessionID)), kCFStringEncodingUTF8, 0, false, (uint8_t *)sessionid, len, &size);
sessionid[len - 1] = '\0';
strlcat(namebuffer, NOTIFICATION_PORT_NAME_SUFFIX, sizeof(namebuffer));
strlcat(namebuffer, sessionid, sizeof(namebuffer));
}
retval = task_get_bootstrap_port(mach_task_self(), &bootstrapPort);
if (ERR_SUCCESS == retval && MACH_PORT_NULL != bootstrapPort) retval = bootstrap_look_up2(bootstrapPort, namebuffer, &serverPort, 0, 0);
if (ERR_SUCCESS == retval && MACH_PORT_NULL != serverPort) {
modifiedDictionary = _CFUserNotificationModifiedDictionary(allocator, dictionary, token, itimeout, _CFProcessNameString());
if (modifiedDictionary) {
data = CFPropertyListCreateXMLData(allocator, modifiedDictionary);
if (data) {
size = sizeof(mach_msg_base_t) + ((CFDataGetLength(data) + 3) & (~0x3));
msg = (mach_msg_base_t *)CFAllocatorAllocate(kCFAllocatorSystemDefault, size, 0);
if (__CFOASafe) __CFSetLastAllocationEventName(msg, "CFUserNotification (temp)");
if (msg) {
memset(msg, 0, size);
msg->header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE);
msg->header.msgh_size = size;
msg->header.msgh_remote_port = serverPort;
msg->header.msgh_local_port = replyPort;
msg->header.msgh_id = flags;
msg->body.msgh_descriptor_count = 0;
CFDataGetBytes(data, CFRangeMake(0, CFDataGetLength(data)), (uint8_t *)msg + sizeof(mach_msg_base_t));
//CFShow(CFStringCreateWithBytes(kCFAllocatorSystemDefault, (UInt8 *)msg + sizeof(mach_msg_base_t), CFDataGetLength(data), kCFStringEncodingUTF8, false));
retval = mach_msg((mach_msg_header_t *)msg, MACH_SEND_MSG|MACH_SEND_TIMEOUT, size, 0, MACH_PORT_NULL, MESSAGE_TIMEOUT, MACH_PORT_NULL);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, msg);
} else {
retval = unix_err(ENOMEM);
}
CFRelease(data);
} else {
retval = unix_err(ENOMEM);
}
CFRelease(modifiedDictionary);
} else {
retval = unix_err(ENOMEM);
}
}
return retval;
}
static void writeFontDatabaseToPlist(CFPropertyListRef cgFontDBPropertyList, CFPropertyListRef filenamesFromRegistry)
{
if (!cgFontDBPropertyList)
return;
RetainPtr<CFDataRef> data;
if (!filenamesFromRegistry || CFGetTypeID(cgFontDBPropertyList) != CFDictionaryGetTypeID())
data.adoptCF(CFPropertyListCreateXMLData(kCFAllocatorDefault, cgFontDBPropertyList));
else {
RetainPtr<CFMutableDictionaryRef> dictionary(AdoptCF, CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 2, static_cast<CFDictionaryRef>(cgFontDBPropertyList)));
CFDictionarySetValue(dictionary.get(), fontFilenamesFromRegistryKey(), filenamesFromRegistry);
data.adoptCF(CFPropertyListCreateXMLData(kCFAllocatorDefault, dictionary.get()));
}
if (!data)
return;
safeCreateFile(fontsPlistPath(), data.get());
}
/* -------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------- */
CFDataRef Serialize(CFPropertyListRef obj, void **data, u_int32_t *dataLen)
{
CFDataRef xml;
xml = CFPropertyListCreateXMLData(NULL, obj);
if (xml) {
*data = (void*)CFDataGetBytePtr(xml);
*dataLen = CFDataGetLength(xml);
}
return xml;
}
static int TearOffSignatureAndHashManifest(CFDictionaryRef manifestDict, CFDataRef* signature, CFDataRef* manifest_data)
{
int result = -1;
CFMutableDictionaryRef new_manifest_dict = NULL;
CFStringRef sig_data_str = NULL;
CFDataRef sig_data = NULL;
CFDataRef prop_list = NULL;
CFDataRef decoded_sig_data = NULL;
if (NULL == manifestDict || NULL == signature || NULL == manifest_data)
{
return result;
}
*signature = NULL;
*manifest_data = NULL;
new_manifest_dict = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, CFDictionaryGetCount(manifestDict), manifestDict);
sig_data_str = (CFStringRef)CFDictionaryGetValue(new_manifest_dict, CFSTR("Signature"));
if (NULL == sig_data_str)
{
CFRelease(new_manifest_dict);
return result;
}
sig_data = CFStringCreateExternalRepresentation(kCFAllocatorDefault, sig_data_str, kCFStringEncodingUTF8, 0);
if (NULL == sig_data)
{
CFRelease(sig_data_str);
CFRelease(new_manifest_dict);
return result;
}
if (Base64Data(sig_data, 0, &decoded_sig_data))
{
CFRelease(sig_data);
CFRelease(new_manifest_dict);
return result;
}
*signature = decoded_sig_data;
CFDictionaryRemoveValue(new_manifest_dict, CFSTR("Signature"));
prop_list = CFPropertyListCreateXMLData (kCFAllocatorDefault, new_manifest_dict);
CFRelease(new_manifest_dict);
if (NULL == prop_list)
{
return result;
}
(void)CreateHashForData(prop_list, 1, manifest_data);
result = (NULL == *manifest_data) ? -1 : 0;
return result;
}
static void
dump_plist(FILE * f, CFTypeRef p)
{
CFDataRef data;
data = CFPropertyListCreateXMLData(NULL, p);
if (data == NULL) {
return;
}
fwrite(CFDataGetBytePtr(data), CFDataGetLength(data), 1, f);
CFRelease(data);
return;
}
void
printDictionaryAsXML(CFMutableDictionaryRef dict)
{
CFDataRef xml = CFPropertyListCreateXMLData(kCFAllocatorDefault,
(CFPropertyListRef)dict);
if (xml) {
write(1, CFDataGetBytePtr(xml), CFDataGetLength(xml));
printf("done\n");
CFRelease(xml);
}
printf("..\n");
}
static bool populateFontDatabaseFromPlist()
{
RetainPtr<CFPropertyListRef> plist = readFontPlist();
if (!plist)
return false;
RetainPtr<CFDataRef> data(AdoptCF, CFPropertyListCreateXMLData(0, plist.get()));
if (!data)
return false;
wkAddFontsFromPlistRepresentation(data.get());
return true;
}
STATIC CFDataRef
itemID_copy_data(EAPOLClientItemIDRef itemID)
{
CFDataRef data;
CFDictionaryRef dict;
dict = EAPOLClientItemIDCopyDictionary(itemID);
data = CFPropertyListCreateXMLData(NULL, dict);
if (dict != NULL) {
CFRelease(dict);
}
return (data);
}
int
printDictionaryAsXML(CFDictionaryRef dict)
{
CFDataRef xml = CFPropertyListCreateXMLData(kCFAllocatorDefault,
(CFPropertyListRef)dict);
if (!xml)
return -1;
write(STDOUT_FILENO, CFDataGetBytePtr(xml), CFDataGetLength(xml));
CFRelease(xml);
return 0;
}
static void
dump_as_xml(CFPropertyListRef p)
{
CFDataRef xml;
xml = CFPropertyListCreateXMLData(NULL, p);
if (xml != NULL) {
fwrite(CFDataGetBytePtr(xml), CFDataGetLength(xml), 1,
stdout);
CFRelease(xml);
}
return;
}
void subsurface_close_conf(void)
{
Boolean status;
SInt32 errorCode;
CFDataRef xmlData;
propertyList = dict;
dict = NULL;
xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, propertyList);
status = CFURLWriteDataAndPropertiesToResource (fileURL, xmlData, NULL, &errorCode);
// some error handling - but really, what can we do?
CFRelease(xmlData);
CFRelease(propertyList);
}
int
main(int argc, char * argv[])
{
const void * data;
int data_len;
CFDataRef cfdata;
const char * type;
CFDataRef xml_data;
if (argc < 3) {
usage(argv[0]);
}
type = argv[1];
argv += 2;
argc -= 2;
if (strcmp(type, "ip") == 0) {
data = data_from_ip(argc, argv, &data_len);
}
else if (strcmp(type, "uint8") == 0) {
data = data_from_uint8(argc, argv, &data_len);
}
else if (strcmp(type, "uint16") == 0) {
data = data_from_uint16(argc, argv, &data_len);
}
else if (strcmp(type, "uint32") == 0) {
data = data_from_uint32(argc, argv, &data_len);
}
else if (strcmp(type, "string") == 0) {
data = argv[0];
data_len = strlen(data);
}
else {
fprintf(stderr, "unrecognized type '%s'\n", type);
exit(2);
}
if (data == NULL) {
exit(2);
}
cfdata = CFDataCreateWithBytesNoCopy(NULL, data, data_len,
kCFAllocatorNull);
xml_data = CFPropertyListCreateXMLData(NULL, cfdata);
CFRelease(cfdata);
fwrite(CFDataGetBytePtr(xml_data), CFDataGetLength(xml_data), 1,
stdout);
CFRelease(xml_data);
exit(0);
return (0);
}
/*************************************************************************
*
* hu_SaveToXMLFile( inCFPRef, inCFURLRef )
*
* Purpose: save a property list into an XML file
*
* Inputs: inCFPRef - the data
* inCFURLRef - URL for the file
*
* Returns: SInt32 - error code ( if any )
*/
static SInt32 hu_SaveToXMLFile(CFPropertyListRef inCFPRef, CFURLRef inCFURLRef) {
CFDataRef xmlCFDataRef;
SInt32 error = coreFoundationUnknownErr;
// Convert the property list into XML data.
xmlCFDataRef = CFPropertyListCreateXMLData(kCFAllocatorDefault, inCFPRef);
if ( xmlCFDataRef ) {
// Write the XML data to the file.
(void) CFURLWriteDataAndPropertiesToResource(inCFURLRef, xmlCFDataRef, NULL, &error);
// Release the XML data
CFRelease(xmlCFDataRef);
}
return (error);
} // hu_SaveToXMLFile
// Translates an iPod binary Property-list into a text property list.
//
// Returns:
// true on success
// false on failure
//
bool CiPoTApi::TranslatePLIST(char *originalFile, char *newFile)
{
CFPropertyListRef propertyList;
CFURLRef fileURL;
CFStringRef inputFile, errorString;
CFDataRef resourceData;
Boolean status;
SInt32 errorCode;
bool ok = false;
// Create a URL that specifies the file we will create to hold the XML data.
inputFile = CFStringCreateWithCString(kCFAllocatorDefault, originalFile, kStrEncoding);
fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, inputFile, kPathStyle, false);
if (!fileURL)
return false;
// Read the XML file.
status = CFURLCreateDataAndPropertiesFromResource(
kCFAllocatorDefault, fileURL, &resourceData, NULL, NULL, &errorCode);
if (resourceData) {
// Reconstitute the dictionary using the XML data.
propertyList = CFPropertyListCreateFromXMLData(
kCFAllocatorDefault, resourceData,kCFPropertyListImmutable, &errorString);
if (propertyList != NULL) {
CFStringRef outputFile;
CFDataRef xmlData;
Boolean status;
SInt32 errorCode;
CFRelease(fileURL);
outputFile = CFStringCreateWithCString(kCFAllocatorDefault, newFile, kStrEncoding);
fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, outputFile, kPathStyle, false);
// Convert the property list into XML data.
xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, propertyList);
// Write the XML data to the file.
status = CFURLWriteDataAndPropertiesToResource(fileURL, xmlData, NULL, &errorCode);
ok = status ? true : false;
CFRelease(xmlData);
CFRelease(outputFile);
CFRelease(propertyList);
}
}
CFRelease(inputFile);
CFRelease(fileURL);
return ok;
}
RetainPtr<CFDataRef> LegacyWebArchive::rawDataRepresentation()
{
RetainPtr<CFDictionaryRef> propertyList = createPropertyListRep(this);
if (!propertyList) {
LOG(Archives, "LegacyWebArchive - Failed to create property list for archive, returning no data");
return 0;
}
// FIXME: On Mac, WebArchives have been written out as Binary Property Lists until this change.
// Unless we jump through CFWriteStream hoops, they'll now be textual XML data. Is this okay?
RetainPtr<CFDataRef> plistData(AdoptCF, CFPropertyListCreateXMLData(0, propertyList.get()));
if (!plistData) {
LOG(Archives, "LegacyWebArchive - Failed to convert property list into raw data, returning no data");
return 0;
}
return plistData;
}
/* ------------------------------------------------------------------
* write_user_settings ()
*/
static void write_user_settings ( const char *in_file, CFPropertyListRef in_data )
{
CFURLRef cf_url = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8 *)in_file, strlen(in_file), FALSE);
if ( !cf_url ) {
msg_error("aod: could not create URL from: %s", in_file);
return;
}
CFDataRef cf_data = CFPropertyListCreateXMLData(NULL, in_data);
if ( cf_data ) {
SInt32 write_err = noErr;
if ( !CFURLWriteDataAndPropertiesToResource(cf_url, cf_data, NULL, &write_err) )
if ( msg_verbose )
msg_warn("aod: could not write to %s (error: %d)", in_file, (int) write_err);
CFRelease(cf_data);
}
CFRelease(cf_url);
} /* write_user_settings */
void USBMuxSend(uint32_t sock, struct USBMuxPacket *packet) {
CFDataRef xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, packet->payload);
char *buffer = (char *)CFDataGetBytePtr(xmlData);
ssize_t result = send(sock, &packet->body, sizeof(struct USBMuxPacketBody), 0x0);
if (result == sizeof(struct USBMuxPacketBody)) {
if (packet->body.length > result) {
ssize_t payloadSize = packet->body.length - result;
ssize_t remainder = payloadSize;
while (remainder) {
result = send(sock, &buffer[payloadSize-remainder], sizeof(char), 0x0);
if (result != sizeof(char)) {
break;
}
remainder -= result;
}
}
}
CFSafeRelease(xmlData);
}
extern OSStatus MySyncTicketFromPane (
MyCustomContext context,
PMPrintSession session
)
{
OSStatus result = noErr;
PMTicketRef ticket = NULL;
CFMutableDictionaryRef dict = NULL;
CFDataRef xmlData = NULL;
result = MyGetTicket (session, kPDE_PMPrintSettingsRef, &ticket);
if (result == noErr)
{
// If our pane has never been shown, this will be a noop.
SyncSettingsFromPane(context);
dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
(const CFDictionaryKeyCallBacks *)&kCFTypeDictionaryKeyCallBacks,
(const CFDictionaryValueCallBacks *)&kCFTypeDictionaryValueCallBacks);
if (dict)
{
ExternSettings(&context->settings, dict);
xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, dict);
if (xmlData)
{
result = PMTicketSetCFData (
ticket,
kMyBundleIdentifier,
kAppPrintDialogPDEOnlyKey,
xmlData,
kPMUnlocked
);
CFRelease(xmlData);
}
CFRelease(dict);
}
}
MyDebugMessage("MySyncTicket", result);
return result;
}
/**
* Export the #plist_t structure to XML format.
*
* @param plist the root node to export
* @param plist_xml a pointer to a C-string. This function allocates the memory,
* caller is responsible for freeing it. Data is UTF-8 encoded.
* @param length a pointer to an uint32_t variable. Represents the length of the allocated buffer.
*/
void plist_to_xml(plist_t plist, char **plist_xml, uint32_t * length)
{
UInt8 *data;
CFIndex dataLen;
*plist_xml = NULL;
*length = 0;
CFDataRef xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, plist);
if (xmlData) {
dataLen = CFDataGetLength(xmlData);
data = malloc(dataLen + 1);
if (data) {
CFDataGetBytes(xmlData, CFRangeMake(0, dataLen), data);
data[dataLen] = 0;
*plist_xml = (char *)data;
*length = dataLen;
}
CFRelease(xmlData);
}
}
/* AUDIT[securityd](done):
reply (checked by mig) is a caller provided mach_port.
request_id (checked by mig) is caller provided value, that matches the
mig entry for the server function.
*/
kern_return_t securityd_server_send_reply(mach_port_t reply,
uint32_t request_id, OSStatus status, CFTypeRef args_out) {
CFDataRef data_out = NULL;
if (args_out) {
#ifndef NDEBUG
CFDataRef query_debug = CFPropertyListCreateXMLData(kCFAllocatorDefault,
args_out);
secdebug("client", "securityd response: %.*s\n",
CFDataGetLength(query_debug), CFDataGetBytePtr(query_debug));
CFReleaseSafe(query_debug);
#endif
CFErrorRef error = NULL;
data_out = CFPropertyListCreateData(kCFAllocatorDefault, args_out,
kCFPropertyListBinaryFormat_v1_0,
0, &error);
CFRelease(args_out);
if (error) {
secdebug("server", "failed to encode return data: %@", error);
CFReleaseSafe(error);
}
}
void *p = (data_out ? (void *)CFDataGetBytePtr(data_out) : NULL);
CFIndex l = (data_out ? CFDataGetLength(data_out) : 0);
/* 64 bits cast: securityd should never generate replies bigger than 2^32 bytes.
Worst case is we are truncating the reply we send to the client. This would only
cause the client side to not be able to decode the response. */
assert((unsigned long)l<UINT_MAX); /* Debug check */
kern_return_t err = securityd_client_reply(reply, request_id, status,
p, (unsigned int)l);
CFReleaseSafe(data_out);
request_end();
return err;
}
void main () {
CFStringRef names[kNumFamilyMembers];
CFArrayRef array;
CFDataRef xmlData;
CFRange range = {0, kNumFamilyMembers};
char name[100];
const void *ret_val = NULL;
// Define the family members.
names[0] = CFSTR("Marge");
names[1] = CFSTR("Homer");
names[2] = CFSTR("Bart");
names[3] = CFSTR("Lisa");
names[4] = CFSTR("Maggie");
// Create a property list using the string array of names.
array = CFArrayCreate( kCFAllocatorDefault,
(const void **)names,
kNumFamilyMembers,
&kCFTypeArrayCallBacks );
printf("Array size = %d\n", CFArrayGetCount(array));
printf("Array has %s %d times\n", "Marge", CFArrayGetCountOfValue(array, range, CFSTR("Marge")));
printf("\nCFShow:\n");
CFShow((CFTypeRef)CFArrayGetValueAtIndex(array, 3));
printf("\n\nCFShowStr:");
CFShowStr(CFArrayGetValueAtIndex(array, 3));
printf("\n");
ret_val = CFArrayGetValueAtIndex(array, 3);
CFStringGetCString(ret_val, name, sizeof(name), 0);
printf("Value at index %d is 0x%x %s\n", 3, ret_val, name);
// Convert the plist into XML data.
xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, array );
// Clean up CF types.
CFRelease( array );
CFRelease( xmlData );
}
void propertyListExample(void) {
CFMutableDictionaryRef dict;
CFNumberRef num;
CFArrayRef array;
CFDataRef data;
#define NumKids 2
CFStringRef kidsNames[] = {CFSTR("John"), CFSTR("Kyra")};
#define NumPets 0
int yearOfBirth = 1965;
#define NumBytesInPic 10
const unsigned char pic[NumBytesInPic] = {0x3c, 0x42, 0x81, 0xa5, 0x81, 0xa5, 0x99, 0x81, 0x42, 0x3c};
CFDataRef xmlPropertyListData;
CFStringRef xmlAsString;
// Create and populate a pretty standard mutable dictionary: CFString keys, CF type values.
// To be written out as a "propertyList", the tree of CF types can contain only:
// CFDictionary, CFArray, CFString, CFData, CFNumber, and CFDate.
// In addition, the keys of the dictionaries should be CFStrings.
dict = CFDictionaryCreateMutable(NULL, 0, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(dict, CFSTR("Name"), CFSTR("John Doe"));
CFDictionarySetValue(dict, CFSTR("City of Birth"), CFSTR("Springfield"));
num = CFNumberCreate(NULL, kCFNumberIntType, &yearOfBirth);
CFDictionarySetValue(dict, CFSTR("Year Of Birth"), num);
CFRelease(num);
array = CFArrayCreate(NULL, (const void **)kidsNames, 2, &kCFTypeArrayCallBacks);
CFDictionarySetValue(dict, CFSTR("Kids Names"), array);
CFRelease(array);
array = CFArrayCreate(NULL, NULL, 0, &kCFTypeArrayCallBacks);
CFDictionarySetValue(dict, CFSTR("Pets Names"), array);
CFRelease(array);
data = CFDataCreate(NULL, pic, NumBytesInPic);
CFDictionarySetValue(dict, CFSTR("Picture"), data);
CFRelease(data);
// We now have a dictionary which contains everything we want to know about
// John Doe; let's show it first:
show(CFSTR("John Doe info dictionary: %@"), dict);
// Now create a "property list", which is a flattened, XML version of the
// dictionary:
xmlPropertyListData = CFPropertyListCreateXMLData(NULL, dict);
// The return value is a CFData containing the XML file; show the data
show(CFSTR("Shown as XML property list (bytes): %@"), xmlPropertyListData);
// Given CFDatas are shown as ASCII versions of their hex contents, we can also
// attempt to show the contents of the XML, assuming it was encoded in UTF8
// (This is the case for XML property lists generated by CoreFoundation currently)
xmlAsString = CFStringCreateFromExternalRepresentation(NULL, xmlPropertyListData, kCFStringEncodingUTF8);
show(CFSTR("The XML property list contents: %@"), xmlAsString);
CFRelease(dict);
CFRelease(xmlAsString);
CFRelease(xmlPropertyListData);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// SaveToPrefs()
// The settings for each device are stored in CFPreferences on a per-user basis.
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void DeviceSettings::SaveToPrefs(const Device& device, const DeviceSettings::ControlInfo* controlsToSave, UInt32 numberControlsToSave)
{
// Until further implementation, make this a NOP
return;
#if Log_SaveRestoreFromPrefs
CACFString deviceName(device.CopyDeviceName());
char name[256];
UInt32 nameSize = 256;
deviceName.GetCString(name, nameSize);
DebugMessage("CMIO::DP::DeviceSettings::SaveToPrefs: %s", name);
#endif
// Get the current prefs Data
CFMutableDictionaryRef currentPrefsCFDictionary = NULL;
// Open the prefs file for reading
FILE* prefsFile = fopen(kDALDeviceSettingsFilePath, "r");
if (prefsFile != NULL)
{
// Get the length of the file
fseek(prefsFile, 0, SEEK_END);
UInt32 fileLength = ftell(prefsFile);
fseek(prefsFile, 0, SEEK_SET);
if (fileLength > 0)
{
// Allocate a block of memory to hold the data in the file
CAAutoFree<Byte> rawPrefsData(fileLength);
// Read all the data in
fread(static_cast<Byte*>(rawPrefsData), fileLength, 1, prefsFile);
// Close the file
fclose(prefsFile);
// Put it into a CFData object
CACFData rawPrefsCFData(static_cast<Byte*>(rawPrefsData), fileLength);
// Parse the data as a property list
currentPrefsCFDictionary = (CFMutableDictionaryRef)CFPropertyListCreateFromXMLData(NULL, rawPrefsCFData.GetCFData(), kCFPropertyListMutableContainersAndLeaves, NULL);
}
else
{
// No data, so close the file
fclose(prefsFile);
// Create a new, mutable dictionary
currentPrefsCFDictionary = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
}
else
{
// No file, or a bad file, so just create a new, mutable dictionary
currentPrefsCFDictionary = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
// Just skip things if we still don't have a current prefs dictionary
if (currentPrefsCFDictionary != NULL)
{
// Make a CACFDictionary for convenience and to be sure it gets released
CACFDictionary currentPrefsDictionary(currentPrefsCFDictionary, true);
// Make the dictionary key for this device
CACFString uid(device.CopyDeviceUID());
CACFString prefsKey(CFStringCreateWithFormat(NULL, NULL, CFSTR("com.apple.cmio.CMIO.DeviceSettings.%@"), uid.GetCFString()));
// Save the device's settings into a dictionary
CACFDictionary settingsDictionary(SaveToDictionary(device, controlsToSave, numberControlsToSave), true);
// Put the settings into the prefs
currentPrefsDictionary.AddDictionary(prefsKey.GetCFString(), settingsDictionary.GetCFDictionary());
// Make a CFData that contains the new prefs
CACFData newRawPrefsCFData(CFPropertyListCreateXMLData(NULL, (CFPropertyListRef)currentPrefsDictionary.GetCFMutableDictionary()), true);
if (newRawPrefsCFData.IsValid())
{
// Open the prefs file for writing
prefsFile = fopen(kDALDeviceSettingsFilePath, "w+");
if (prefsFile != NULL)
{
// Write the data
fwrite(newRawPrefsCFData.GetDataPtr(), newRawPrefsCFData.GetSize(), 1, prefsFile);
// Close the file
fclose(prefsFile);
}
}
}
#if Log_SaveRestoreFromPrefs
DebugMessage("CMIO::DP::DeviceSettings::SaveToPrefs: %s finished", name);
#endif
}
static void cb(am_device_notification_callback_info * info, void *foo)
{
struct am_device *dev;
if (info->msg == ADNCI_MSG_CONNECTED) {
dev = info->dev;
AMDeviceConnect(dev);
assert(AMDeviceIsPaired(dev));
assert(!AMDeviceValidatePairing(dev));
assert(!AMDeviceStartSession(dev));
CFStringRef product =
AMDeviceCopyValue(dev, 0, CFSTR("ProductVersion"));
assert(product);
UniChar first = CFStringGetCharacterAtIndex(product, 0);
int epoch = first - '0';
Retry: {}
printf("Attempting to mount image...\n");
service_conn_t afc_socket = 0;
struct afc_connection *afc = NULL;
assert(!AMDeviceStartService(dev, CFSTR("com.apple.afc"), &afc_socket, NULL));
assert(!AFCConnectionOpen(afc_socket, 0, &afc));
assert(!AFCDirectoryCreate(afc, "PublicStaging"));
AFCRemovePath(afc, "PublicStaging/staging.dimage");
qwrite(afc, real_dmg, "PublicStaging/staging.dimage");
qwrite(afc, ddi_dmg, "PublicStaging/ddi.dimage");
service_conn_t mim_socket1 = 0;
service_conn_t mim_socket2 = 0;
assert(!AMDeviceStartService(dev, CFSTR("com.apple.mobile.mobile_image_mounter"), &mim_socket1, NULL));
assert(mim_socket1);
CFPropertyListRef result = NULL;
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(dict, CFSTR("Command"), CFSTR("MountImage"));
CFDictionarySetValue(dict, CFSTR("ImageType"), CFSTR("Developer"));
CFDictionarySetValue(dict, CFSTR("ImagePath"), CFSTR("/var/mobile/Media/PublicStaging/staging.dimage"));
int fd = open(real_dmg_signature, O_RDONLY);
assert(fd != -1);
uint8_t sig[128];
assert(read(fd, sig, sizeof(sig)) == sizeof(sig));
close(fd);
CFDictionarySetValue(dict, CFSTR("ImageSignature"), CFDataCreateWithBytesNoCopy(NULL, sig, sizeof(sig), kCFAllocatorNull));
send_message(mim_socket1, dict);
usleep(timesl);
assert(!AFCRenamePath(afc, "PublicStaging/ddi.dimage", "PublicStaging/staging.dimage"));
result = receive_message(mim_socket1);
int len = CFDataGetLength(CFPropertyListCreateXMLData(NULL, result));
char* bytes = CFDataGetBytePtr(CFPropertyListCreateXMLData(NULL, result));
if(strstr(bytes, "Complete")) {
char* the_service = "CopyIt";
service_conn_t socket = 0;
sleep(2);
printf("Image mounted, running helper...\n");
assert(!AMDeviceStartService(dev, CFStringCreateWithCStringNoCopy(NULL, the_service, kCFStringEncodingUTF8, kCFAllocatorNull),
&socket, NULL));
assert(!fcntl(socket, F_SETFL, O_NONBLOCK));
assert(!fcntl(0, F_SETFL, O_NONBLOCK));
} else {
printf("Failed to inject image, trying again... (if it fails, try a different time), delay ... %dus\n", timesl);
timesl += 1000;
goto Retry;
}
exit(0);
}
}
Boolean GTMSMJobSubmit(CFDictionaryRef cf_job, CFErrorRef *error) {
// We launch our jobs using launchctl instead of doing it by hand
// because launchctl does a whole pile of parsing of the job internally
// to handle the sockets cases that we don't want to duplicate here.
int fd = -1;
CFDataRef xmlData = NULL;
char fileName[] = _PATH_TMP "GTMServiceManagement.XXXXXX";
CFErrorRef local_error = NULL;
if (!cf_job) {
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("NULL Job."),
NULL);
goto exit;
}
CFStringRef jobLabel = CFDictionaryGetValue(cf_job,
CFSTR(LAUNCH_JOBKEY_LABEL));
if (!jobLabel) {
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("Job missing label."),
NULL);
goto exit;
}
CFDictionaryRef jobDict = GTMSMJobCopyDictionary(jobLabel);
if (jobDict) {
CFRelease(jobDict);
local_error
= GTMCFLaunchCreateUnlocalizedError(EEXIST,
CFSTR("Job already exists %@."),
jobLabel);
goto exit;
}
xmlData = CFPropertyListCreateXMLData(NULL, cf_job);
if (!xmlData) {
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("Invalid Job %@."),
jobLabel);
goto exit;
}
fd = mkstemp(fileName);
if (fd == -1) {
local_error
= GTMCFLaunchCreateUnlocalizedError(errno,
CFSTR("Unable to create %s."),
fileName);
goto exit;
}
write(fd, CFDataGetBytePtr(xmlData), CFDataGetLength(xmlData));
close(fd);
pid_t childpid = fork();
if (childpid == -1) {
local_error
= GTMCFLaunchCreateUnlocalizedError(errno,
CFSTR("Unable to fork."),
NULL);
goto exit;
}
if (childpid != 0) {
// Parent process
int status = 0;
pid_t pid = -1;
do {
pid = waitpid(childpid, &status, 0);
} while (pid == -1 && errno == EINTR);
if (pid == -1) {
local_error
= GTMCFLaunchCreateUnlocalizedError(errno,
CFSTR("waitpid failed."));
goto exit;
} else if (WEXITSTATUS(status)) {
local_error
= GTMCFLaunchCreateUnlocalizedError(ECHILD,
CFSTR("Child exit status: %d "
"pid: %d"),
WEXITSTATUS(status), childpid);
goto exit;
}
} else {
// Child Process
spc_sanitize_files();
spc_drop_privileges();
const char *args[] = { "launchctl", "load", fileName, NULL };
execve("/bin/launchctl", (char* const*)args, NULL);
abort();
}
exit:
if (xmlData) {
CFRelease(xmlData);
}
if (fd != -1) {
unlink(fileName);
}
if (error) {
*error = local_error;
} else if (local_error) {
#ifdef DEBUG
CFShow(local_error);
#endif // DEBUG
CFRelease(local_error);
}
return local_error == NULL;
}
Boolean AddCommands( SRRecognizer inSpeechRecognizer, SRLanguageModel inCommandsLangaugeModel, CFArrayRef inCommandNamesArray )
{
// Dictionary keys for Commands Data property list
#define kCommandsDataPlacementHintKey "PlacementHint" // value type is: CFNumberRef
#define kPlacementHintWhereverNumValue 0
#define kPlacementHintProcessNumValue 1 // you must also provide the PSN using kCommandsDataProcessPSNHighKey & kCommandsDataProcessPSNLowKey
#define kPlacementHintFirstNumValue 2
#define kPlacementHintMiddleNumValue 3
#define kPlacementHintLastNumValue 4
#define kCommandsDataProcessPSNHighKey "ProcessPSNHigh" // value type is: CFNumberRef
#define kCommandsDataProcessPSNLowKey "ProcessPSNLow" // value type is: CFNumberRef
#define kCommandsDataDisplayOrderKey "DisplayOrder" // value type is: CFNumberRef - the order in which recognizers from the same client process should be displayed.
#define kCommandsDataCmdInfoArrayKey "CommandInfoArray" // value type is: CFArrayRef of CFDictionaryRef values
#define kCommandInfoNameKey "Text"
#define kCommandInfoChildrenKey "Children"
Boolean successfullyAddCommands = false;
if (inCommandNamesArray) {
CFIndex numOfCommands = CFArrayGetCount( inCommandNamesArray );
CFMutableArrayRef theSectionArray = CFArrayCreateMutable( NULL, 0, &kCFTypeArrayCallBacks );
// Erase any existing commands in the language model before we begin adding the given list of commands
if (SREmptyLanguageObject( inCommandsLangaugeModel ) == noErr && theSectionArray) {
CFIndex i;
char theCSringBuffer[100];
successfullyAddCommands = true;
for (i = 0; i < numOfCommands; i++) {
CFStringRef theCommandName = CFArrayGetValueAtIndex(inCommandNamesArray, i);
if (theCommandName && CFStringGetCString( theCommandName, theCSringBuffer, 100, kCFStringEncodingMacRoman )) {
if (SRAddText( inCommandsLangaugeModel, theCSringBuffer, strlen(theCSringBuffer), i) == noErr) {
CFStringRef keys[1];
CFTypeRef values[1];
CFDictionaryRef theItemDict;
keys[0] = CFSTR( kCommandInfoNameKey );
values[0] = theCommandName;
// Make CDDictionary our keys and values.
theItemDict = CFDictionaryCreate(NULL, (const void **)keys, (const void **)values, 1, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
// Add to command array
if (theItemDict) {
CFArrayAppendValue( theSectionArray, theItemDict );
CFRelease( theItemDict ); // We release our hold on the dictionary object and let the array own it now.
}
else
successfullyAddCommands = false;
}
else
successfullyAddCommands = false;
if (! successfullyAddCommands)
break;
}
}
//
// Create the XML data that contains the commands to display and give this data to the
// recognizer object to display in the Speech Commands window.
//
{
CFIndex numOfParams = 4;
CFStringRef keys[numOfParams];
CFTypeRef values[numOfParams];
CFDictionaryRef theItemDict;
SInt32 placementHint = 1; // 1 = show only when this app is front process
ProcessSerialNumber thisAppsPSN;
thisAppsPSN.highLongOfPSN = 0;
thisAppsPSN.lowLongOfPSN = 0;
GetCurrentProcess( &thisAppsPSN );
keys[0] = CFSTR( kCommandsDataPlacementHintKey );
keys[1] = CFSTR( kCommandsDataCmdInfoArrayKey );
keys[2] = CFSTR( kCommandsDataProcessPSNHighKey );
keys[3] = CFSTR( kCommandsDataProcessPSNLowKey );
values[0] = CFNumberCreate(NULL, kCFNumberSInt32Type, &placementHint);
values[1] = theSectionArray;
values[2] = CFNumberCreate(NULL, kCFNumberSInt32Type, &(thisAppsPSN.highLongOfPSN));
values[3] = CFNumberCreate(NULL, kCFNumberSInt32Type, &(thisAppsPSN.lowLongOfPSN));
// Make CDDictionary of our keys and values.
theItemDict = CFDictionaryCreate(NULL, (const void **)keys, (const void **)values, numOfParams, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (theItemDict) {
// Convert CFDictionary object to XML representation
CFDataRef dictData = CFPropertyListCreateXMLData(NULL, theItemDict);
if (dictData) {
// Set command list in our SRRecognizer object, causing the Speech Commands window to update.
(void)SRSetProperty (inSpeechRecognizer, 'cdpl', CFDataGetBytePtr(dictData), CFDataGetLength(dictData));
CFRelease( dictData );
}
}
// Release our hold on the dictionary object and let the array own it now.
if (theItemDict)
CFRelease( theItemDict );
// Release our values
if (values[0])
CFRelease( values[0] );
if (values[2])
CFRelease( values[2] );
if (values[3])
CFRelease( values[3] );
CFRelease( theSectionArray );
}
}
}
return successfullyAddCommands;
}
//
// Contemplate the object-to-be-signed and set up the Signer state accordingly.
//
void SecCodeSigner::Signer::prepare(SecCSFlags flags)
{
// get the Info.plist out of the rep for some creative defaulting
CFRef<CFDictionaryRef> infoDict;
if (CFRef<CFDataRef> infoData = rep->component(cdInfoSlot))
infoDict.take(makeCFDictionaryFrom(infoData));
// work out the canonical identifier
identifier = state.mIdentifier;
if (identifier.empty()) {
identifier = rep->recommendedIdentifier(state);
if (identifier.find('.') == string::npos)
identifier = state.mIdentifierPrefix + identifier;
if (identifier.find('.') == string::npos && state.isAdhoc())
identifier = identifier + "-" + uniqueName();
secdebug("signer", "using default identifier=%s", identifier.c_str());
} else
secdebug("signer", "using explicit identifier=%s", identifier.c_str());
// work out the CodeDirectory flags word
if (state.mCdFlagsGiven) {
cdFlags = state.mCdFlags;
secdebug("signer", "using explicit cdFlags=0x%x", cdFlags);
} else {
cdFlags = 0;
if (infoDict)
if (CFTypeRef csflags = CFDictionaryGetValue(infoDict, CFSTR("CSFlags"))) {
if (CFGetTypeID(csflags) == CFNumberGetTypeID()) {
cdFlags = cfNumber<uint32_t>(CFNumberRef(csflags));
secdebug("signer", "using numeric cdFlags=0x%x from Info.plist", cdFlags);
} else if (CFGetTypeID(csflags) == CFStringGetTypeID()) {
cdFlags = cdTextFlags(cfString(CFStringRef(csflags)));
secdebug("signer", "using text cdFlags=0x%x from Info.plist", cdFlags);
} else
MacOSError::throwMe(errSecCSBadDictionaryFormat);
}
}
if (state.mSigner == SecIdentityRef(kCFNull)) // ad-hoc signing requested...
cdFlags |= kSecCodeSignatureAdhoc; // ... so note that
// prepare the resource directory, if any
string rpath = rep->resourcesRootPath();
if (!rpath.empty()) {
// explicitly given resource rules always win
CFCopyRef<CFDictionaryRef> resourceRules = state.mResourceRules;
// embedded resource rules come next
if (!resourceRules && infoDict)
if (CFTypeRef spec = CFDictionaryGetValue(infoDict, _kCFBundleResourceSpecificationKey)) {
if (CFGetTypeID(spec) == CFStringGetTypeID())
if (CFRef<CFDataRef> data = cfLoadFile(rpath + "/" + cfString(CFStringRef(spec))))
if (CFDictionaryRef dict = makeCFDictionaryFrom(data))
resourceRules.take(dict);
if (!resourceRules) // embedded rules present but unacceptable
MacOSError::throwMe(errSecCSResourceRulesInvalid);
}
// finally, ask the DiskRep for its default
if (!resourceRules)
resourceRules.take(rep->defaultResourceRules(state));
// build the resource directory
ResourceBuilder resources(rpath, cfget<CFDictionaryRef>(resourceRules, "rules"), digestAlgorithm());
rep->adjustResources(resources); // DiskRep-specific adjustments
CFRef<CFDictionaryRef> rdir = resources.build();
resourceDirectory.take(CFPropertyListCreateXMLData(NULL, rdir));
}
// screen and set the signing time
CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
if (state.mSigningTime == CFDateRef(kCFNull)) {
signingTime = 0; // no time at all
} else if (!state.mSigningTime) {
signingTime = now; // default
} else {
CFAbsoluteTime time = CFDateGetAbsoluteTime(state.mSigningTime);
if (time > now) // not allowed to post-date a signature
MacOSError::throwMe(errSecCSBadDictionaryFormat);
signingTime = time;
}
pagesize = state.mPageSize ? cfNumber<size_t>(state.mPageSize) : rep->pageSize(state);
// Timestamping setup
CFRef<SecIdentityRef> mTSAuth; // identity for client-side authentication to the Timestamp server
}
Boolean AddCommands( SRRecognizer inSpeechRecognizer, SRLanguageModel inCommandsLangaugeModel, CFArrayRef inCommandNamesArray )
{
// Dictionary keys for Commands Data property list
#define kCommandsDataPlacementHintKey "PlacementHint" // value type is: CFNumberRef
#define kPlacementHintWhereverNumValue 0
#define kPlacementHintProcessNumValue 1 // you must also provide the PSN using kCommandsDataProcessPSNHighKey & kCommandsDataProcessPSNLowKey
#define kPlacementHintFirstNumValue 2
#define kPlacementHintMiddleNumValue 3
#define kPlacementHintLastNumValue 4
#define kCommandsDataProcessPSNHighKey "ProcessPSNHigh" // value type is: CFNumberRef
#define kCommandsDataProcessPSNLowKey "ProcessPSNLow" // value type is: CFNumberRef
#define kCommandsDataDisplayOrderKey "DisplayOrder" // value type is: CFNumberRef - the order in which recognizers from the same client process should be displayed.
#define kCommandsDataCmdInfoArrayKey "CommandInfoArray" // value type is: CFArrayRef of CFDictionaryRef values
#define kCommandInfoNameKey "Text"
#define kCommandInfoChildrenKey "Children"
Boolean successfullyAddCommands = false;
if (inCommandNamesArray) {
CFIndex numOfCommands = CFArrayGetCount( inCommandNamesArray );
CFMutableArrayRef theSectionArray = CFArrayCreateMutable( NULL, 0, &kCFTypeArrayCallBacks );
// Erase any existing commands in the language model before we begin adding the given list of commands
if (SREmptyLanguageObject( inCommandsLangaugeModel ) == noErr && theSectionArray) {
CFIndex i;
char theCSringBuffer[100];
successfullyAddCommands = true;
for (i = 0; i < numOfCommands; i++) {
CFStringRef theCommandName = CFArrayGetValueAtIndex(inCommandNamesArray, i);
if (theCommandName && CFStringGetCString( theCommandName, theCSringBuffer, 100, kCFStringEncodingMacRoman )) {
// Conditionalized just to remove compiler warnings.
#if __LP64__
if (SRAddText( inCommandsLangaugeModel, theCSringBuffer, strlen(theCSringBuffer), (void *)i) == noErr) {
#else
if (SRAddText( inCommandsLangaugeModel, theCSringBuffer, strlen(theCSringBuffer), i) == noErr) {
#endif
CFStringRef keys[1];
CFTypeRef values[1];
CFDictionaryRef theItemDict;
keys[0] = CFSTR( kCommandInfoNameKey );
values[0] = theCommandName;
// Make CDDictionary our keys and values.
theItemDict = CFDictionaryCreate(NULL, (const void **)keys, (const void **)values, 1, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
// Add to command array
if (theItemDict) {
CFArrayAppendValue( theSectionArray, theItemDict );
CFRelease( theItemDict ); // We release our hold on the dictionary object and let the array own it now.
}
else
successfullyAddCommands = false;
}
else
successfullyAddCommands = false;
if (! successfullyAddCommands)
break;
}
}
//
// Create the XML data that contains the commands to display and give this data to the
// recognizer object to display in the Speech Commands window.
//
{
CFIndex numOfParams = 4;
CFStringRef keys[numOfParams];
CFTypeRef values[numOfParams];
CFDictionaryRef theItemDict;
SInt32 placementHint = 1; // 1 = show only when this app is front process
ProcessSerialNumber thisAppsPSN;
thisAppsPSN.highLongOfPSN = 0;
thisAppsPSN.lowLongOfPSN = 0;
GetCurrentProcess( &thisAppsPSN );
keys[0] = CFSTR( kCommandsDataPlacementHintKey );
keys[1] = CFSTR( kCommandsDataCmdInfoArrayKey );
keys[2] = CFSTR( kCommandsDataProcessPSNHighKey );
keys[3] = CFSTR( kCommandsDataProcessPSNLowKey );
values[0] = CFNumberCreate(NULL, kCFNumberSInt32Type, &placementHint);
values[1] = theSectionArray;
values[2] = CFNumberCreate(NULL, kCFNumberSInt32Type, &(thisAppsPSN.highLongOfPSN));
values[3] = CFNumberCreate(NULL, kCFNumberSInt32Type, &(thisAppsPSN.lowLongOfPSN));
// Make CDDictionary of our keys and values.
theItemDict = CFDictionaryCreate(NULL, (const void **)keys, (const void **)values, numOfParams, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (theItemDict) {
// Convert CFDictionary object to XML representation
CFDataRef dictData = CFPropertyListCreateXMLData(NULL, theItemDict);
if (dictData) {
// Set command list in our SRRecognizer object, causing the Speech Commands window to update.
(void)SRSetProperty (inSpeechRecognizer, 'cdpl', CFDataGetBytePtr(dictData), CFDataGetLength(dictData));
CFRelease( dictData );
}
}
// Release our hold on the dictionary object and let the array own it now.
if (theItemDict)
CFRelease( theItemDict );
// Release our values
if (values[0])
CFRelease( values[0] );
if (values[2])
CFRelease( values[2] );
if (values[3])
CFRelease( values[3] );
CFRelease( theSectionArray );
}
}
}
return successfullyAddCommands;
}
/*
ConvertAppleEventResultIntoCommandID
This routine converts the Apple event data received from a speech done (kAESpeechSuite, kAESpeechDone)
Apple event into a command ID when using the AddCommands routine to add your commands to the top-level
language model.
This routine returns true if the spoken utterance was recognized as a valid command.
*/
Boolean ConvertAppleEventResultIntoCommandID( const AppleEvent *inAppleEvent, long * outCommandID )
{
Boolean successfullyFound = false;
Size actualSize;
DescType actualType;
OSErr recStatus = noErr;
// Get recognition status from AE, and check that it is equal to 0.
if (AEGetParamPtr( inAppleEvent, keySRSpeechStatus, typeSInt16, &actualType, (Ptr)&recStatus, sizeof(recStatus), &actualSize) == noErr && recStatus == noErr) {
// Get recognition result from AE, and continue if not NULL.
SRRecognitionResult recResult = NULL;
if (AEGetParamPtr( inAppleEvent, keySRSpeechResult, typeSRSpeechResult, &actualType, (Ptr)&recResult, sizeof(recResult), &actualSize) == noErr && recResult) {
// Get language model result from recognition result
Size theLen = sizeof(SRLanguageModel);
SRLanguageModel resultLanguageModel = 0;
if (SRGetProperty( recResult, kSRLanguageModelFormat, &resultLanguageModel, &theLen ) == noErr) {
// Get the recognized command object from the language model
// Since there will only be one object in the langauge model, we just grab the first one.
SRLanguageObject resultingCommandObj = 0;
if (SRGetIndexedItem( resultLanguageModel, &resultingCommandObj, 0 ) == noErr) {
// Get the command ID from the refCon property of the recognized command object.
theLen = sizeof(long);
if (SRGetProperty( resultingCommandObj, kSRRefCon, outCommandID, &theLen ) == noErr)
successfullyFound = true;
}
}
}
}
return successfullyFound;
}
static int run(CFArrayRef argv) {
ssize_t res = 0;
CFIndex count = CFArrayGetCount(argv);
if (count > 2) return -1;
int xml = 0, i;
CFMutableDictionaryRef dict, preplist;
CFDictionaryRef project = NULL;
CFStringRef projname;
CFArrayRef builds;
const void *ssites, *bsites;
CFStringRef build = DBGetCurrentBuild();
if (count == 2) {
CFStringRef arg = CFArrayGetValueAtIndex(argv, 0);
xml = CFEqual(arg, CFSTR("-xml"));
// -xml is the only supported option
if (!xml) return -1;
projname = CFArrayGetValueAtIndex(argv, 1);
} else if (count == 1 ) {
projname = CFArrayGetValueAtIndex(argv, 0);
} else
return -1;
builds = DBCopyBuildInheritance(build);
dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks,&kCFTypeDictionaryValueCallBacks);
preplist = (CFMutableDictionaryRef)DBCopyProjectPlist(build, NULL);
ssites = CFDictionaryGetValue(preplist, CFSTR("source_sites"));
bsites = CFDictionaryGetValue(preplist, CFSTR("binary_sites"));
preplist = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks,&kCFTypeDictionaryValueCallBacks);
for( i = 0; i < CFArrayGetCount(builds); i++ ) {
build = CFArrayGetValueAtIndex(builds, i);
project = DBCopyProjectPlist(build, projname);
if( CFDictionaryGetCount(project) > 0 )
break;
}
if( CFDictionaryGetCount(project) < 1 )
return -1;
CFDictionaryAddValue(dict, projname, project);
CFRelease(project);
CFDictionarySetValue(preplist, CFSTR("build"), build);
CFDictionarySetValue(preplist, CFSTR("projects"), dict);
if(ssites) CFDictionarySetValue(preplist, CFSTR("source_sites"), ssites);
if(bsites) CFDictionarySetValue(preplist, CFSTR("binary_sites"), bsites);
CFPropertyListRef plist = preplist;
if (xml) {
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
CFDataRef data = CFPropertyListCreateData(kCFAllocatorDefault,
plist,
kCFPropertyListXMLFormat_v1_0,
0,
NULL);
#else
CFDataRef data = CFPropertyListCreateXMLData(NULL, plist);
#endif
res = write(STDOUT_FILENO, CFDataGetBytePtr(data), (ssize_t)CFDataGetLength(data));
} else {
res = writePlist(stdout, plist, 0);
}
return (int)res;
}
