static VALUE convert2rb_type(CFTypeRef ref) {
VALUE result = Qnil;
double double_result;
int int_result;
long long_result;
int i;
if (ref) {
if (CFGetTypeID(ref) == CFStringGetTypeID()) {
result = cfstring2rbstr(ref);
} else if (CFGetTypeID(ref) == CFDateGetTypeID()) {
// 978307200.0 == (January 1, 2001 00:00 GMT) - (January 1, 1970 00:00 UTC)
// CFAbsoluteTime => January 1, 2001 00:00 GMT
// ruby Time => January 1, 1970 00:00 UTC
double_result = (double) CFDateGetAbsoluteTime(ref) + 978307200;
result = rb_funcall(rb_cTime, rb_intern("at"), 1, rb_float_new(double_result));
} else if (CFGetTypeID(ref) == CFArrayGetTypeID()) {
result = rb_ary_new();
for (i = 0; i < CFArrayGetCount(ref); i++) {
rb_ary_push(result, convert2rb_type(CFArrayGetValueAtIndex(ref, i)));
}
} else if (CFGetTypeID(ref) == CFNumberGetTypeID()) {
if (CFNumberIsFloatType(ref)) {
CFNumberGetValue(ref, CFNumberGetType(ref), &double_result);
result = rb_float_new(double_result);
} else {
CFNumberGetValue(ref, CFNumberGetType(ref), &long_result);
result = LONG2NUM(long_result);
}
}
}
return result;
}
std::string DiskArbitrationEventPublisher::getProperty(
const CFStringRef& property, const CFDictionaryRef& dict) {
CFTypeRef value = (CFTypeRef)CFDictionaryGetValue(dict, property);
if (value == nullptr) {
return "";
}
if (CFStringCompare(property, CFSTR(kDAAppearanceTime_), kNilOptions) ==
kCFCompareEqualTo) {
return stringFromCFAbsoluteTime((CFDataRef)value);
}
if (CFGetTypeID(value) == CFNumberGetTypeID()) {
return stringFromCFNumber((CFDataRef)value,
CFNumberGetType((CFNumberRef)value));
} else if (CFGetTypeID(value) == CFStringGetTypeID()) {
return stringFromCFString((CFStringRef)value);
} else if (CFGetTypeID(value) == CFBooleanGetTypeID()) {
return (CFBooleanGetValue((CFBooleanRef)value)) ? "1" : "0";
} else if (CFGetTypeID(value) == CFUUIDGetTypeID()) {
return stringFromCFString(
CFUUIDCreateString(kCFAllocatorDefault, (CFUUIDRef)value));
}
return "";
}
void encode(ArgumentEncoder* encoder, CFNumberRef number)
{
CFNumberType numberType = CFNumberGetType(number);
Vector<uint8_t> buffer(CFNumberGetByteSize(number));
bool result = CFNumberGetValue(number, numberType, buffer.data());
ASSERT_UNUSED(result, result);
encoder->encodeEnum(numberType);
encoder->encodeVariableLengthByteArray(buffer);
}
/**
* Get the #plist_type of a node.
*
* @param node the node
* @return the type of the node
*/
plist_type plist_get_node_type(plist_t node)
{
if (!node)
return PLIST_NONE;
CFTypeID type = CFGetTypeID(node);
if (type == CFArrayGetTypeID())
return PLIST_ARRAY;
else if (type == CFDictionaryGetTypeID())
return PLIST_DICT;
else if (type == CFStringGetTypeID())
return PLIST_STRING;
else if (type == CFDataGetTypeID())
return PLIST_DATA;
else if (type == CFBooleanGetTypeID())
return PLIST_BOOLEAN;
else if (type == CFDateGetTypeID())
return PLIST_DATE;
else if (type == CFNumberGetTypeID()) {
CFTypeID numType = CFNumberGetType(node);
switch (numType) {
case kCFNumberFloat32Type:
case kCFNumberFloat64Type:
case kCFNumberFloatType:
case kCFNumberDoubleType:
return PLIST_REAL;
break;
case kCFNumberSInt8Type:
case kCFNumberSInt16Type:
case kCFNumberSInt32Type:
case kCFNumberSInt64Type:
case kCFNumberCharType:
case kCFNumberShortType:
case kCFNumberIntType:
return PLIST_UINT;
break;
default:
return PLIST_NONE;
break;
}
}
return PLIST_NONE;
}
inline SQLite3Status SQLite3StatementBindNumber(SQLite3StatementRef statement, CFIndex index, CFNumberRef value) {
SQLite3Status status = kSQLite3StatusError;
if (value) {
switch (CFNumberGetType(value)) {
case kCFNumberSInt8Type:
case kCFNumberSInt16Type:
case kCFNumberSInt32Type:
case kCFNumberSInt64Type:
case kCFNumberCharType:
case kCFNumberShortType:
case kCFNumberIntType:
case kCFNumberLongType:
case kCFNumberLongLongType:
case kCFNumberCFIndexType:
case kCFNumberNSIntegerType:
{
int64_t value_ = 0;
CFNumberGetValue(value, kCFNumberSInt64Type, (void *)&value_);
status = SQLite3StatementBindInt64(statement, index, value_);
break;
}
case kCFNumberFloat32Type:
case kCFNumberFloat64Type:
case kCFNumberFloatType:
case kCFNumberDoubleType:
case kCFNumberCGFloatType: // == kCFNumberMaxType
{
double_t value_ = 0.0;
CFNumberGetValue(value, kCFNumberDoubleType, (void *)&value_);
status = SQLite3StatementBindDouble(statement, index, value_);
break;
}
}
} else {
status = SQLite3StatementBindNULL(statement, index);
}
return status;
}
/* Main program */
int main (int argc, const char * argv[])
{
enum suspend_type {soft, dump, hard};
int vmmib[2] = {CTL_VM, VM_SWAPUSAGE};
int osmib[2] = {CTL_KERN, KERN_OSRELEASE};
int original_mode;
int target_mode;
int default_mode;
int original_profile;
int target_profile = -1;
void *refCon;
struct xsw_usage swap;
size_t swlen = sizeof(swap);
size_t oslen;
char *kernel_version;
int major_version = 0;
int minor_version = 0;
struct stat sleepimage;
/* By default, */
int do_sleep = 1; /* send the sleep call, */
int repair = 0; /* do not check the validity of the original hibernation mode, */
int check_hibernation = 1; /* check if the hibernation file is present, */
int check_os = 1; /* check if the operating system is supported, */
enum suspend_type target_suspend = soft; /* send computer to software suspend mode, */
int restore = 1; /* restore the original mode, */
if (argc >= 2) {
if (!strcmp(argv[1], "-v")) { /* Display version number if invoked with -v */
printf("deepsleep build %s\n", VERSION);
return 0;
} else if (!strcmp(argv[1], "-h")) {
printf("deepsleep usage: deepsleep [-bdhrvsu] [hard|dump|soft]\n");
printf(" -b : bypass the hibernation file check\n");
printf(" -d : debug mode - be verbose\n");
printf(" -h : display this help screen\n");
printf(" -m : mute - be silent\n");
printf(" -o : do not restore the original hibernation mode\n");
printf(" -r : repair the default hibernation mode if needed\n");
printf(" -s : simulation - do not send the computer to sleep\n");
printf(" -v : display version number\n");
printf(" -u : perform operations even on unsupported OS revisions\n");
printf(" hard : send computer to hardware suspend mode\n");
printf(" dump : send computer to safe hardware suspend mode\n");
printf(" soft : send computer to software suspend mode (by default)\n");
return 0;
} else {
if (argc >= 3) {
if (strstr(argv[1], "b")) /* Do not check the existence of the hibernation file if invoked with -b */
check_hibernation = 0;
if (strstr(argv[1], "d")) /* Print debug information if invoked with -d */
debug = 1;
if (strstr(argv[1], "o")) /* Do not restore the original hibernation mode if invoked with -o */
restore = 0;
if (strstr(argv[1], "r")) /* Check for the validity of the original hibernation mode if invoked with -r*/
repair = 1;
if (strstr(argv[1], "s")) /* Do not send the sleep call if invoked with -s */
do_sleep = 0;
if (strstr(argv[1], "u")) /* Do not care about OS revision if invoked with -u */
check_os = 0;
if (strstr(argv[1], "m"))
mute = 1;
}
if (strstr(argv[argc-1], "hard")) /* Send computer to hardware suspend mode instead of software suspend mode if the hard argument is present */
target_suspend = hard;
else if (strstr(argv[argc-1], "dump")) /* Send computer to safe hardware suspend mode instead of software suspend mode if the safe argument is present */
target_suspend = dump;
}
}
if (sysctl(osmib, 2, NULL, &oslen, NULL, 0) == -1) { /* Get the operating system revision length */
printf("Failed to get the operating system revision\n"); /* On failure: quit */
return 1;
} else {
kernel_version = malloc(oslen * sizeof(char));
sysctl(osmib, 2, kernel_version, &oslen, NULL, 0); /* Get the operating system revision length */
sscanf(kernel_version, "%d.%d", &major_version, &minor_version);
free(kernel_version);
}
if (debug) {
printf("OS revision: %d.%d", major_version, minor_version);
if (!check_os) printf(" (ignored)");
printf("\n");
}
if (check_os && (major_version != 8 || minor_version < 3) && (major_version <= 8)) { /* If needed, check if major version is 8 (Mac OS X 10.4) and minor version is greater or equal than 3. Mac OS X 10.5 is also supported.*/
printf("This operating system is not supported\n"); /* On failure: quit */
return 1;
}
if (check_hibernation && stat("/private/var/vm/sleepimage", &sleepimage)) { /* If needed, check if the hibernation file (/private/var/vm/sleepimage) exists */
printf("Hibernation file is missing\n"); /* On failure: quit */
return 1;
}
if (sysctl(vmmib, 2, &swap, &swlen, NULL, 0) == -1) { /* Get the current virtual memory parameters */
printf("Failed to get the virtual memory information\n"); /* On failure: quit */
return 1;
} else {
default_mode = 3;
if (target_suspend == dump) {
target_mode = default_mode; /* we will use the regular mode 3 for safe hardware suspsend */
} else /*if (target_suspend == soft)*/ {
target_mode = 25; /* or the regular mode 25 for software suspsend */
}
if (target_suspend == hard) /* If we only want to perform basic hardware suspend */
target_mode = 0; /* we will sleep with hibernate mode 0 */
if (debug) printf("target mode: %d\n", target_mode);
}
ps_info = IOPSCopyPowerSourcesInfo(); /* Get the power source information */
if (ps_info) {
current_ps = IOPSGetProvidingPowerSourceType(ps_info); /* On success, store the active power source */
} else {
printf("Failed to get the power source information\n"); /* On failure: quit */
return 1;
}
if (debug) printf("target power source: %s\n", CFStringGetCStringPtr(current_ps, kCFStringEncodingMacRoman));
active_prof = IOPMCopyActivePowerProfiles(); /* Get the power profiles */
if (!active_prof) {
printf("Failed to get the active profile\n");
CFCleanup();
return 1;
}
if (CFDictionaryContainsKey(active_prof, current_ps)) { /* Get the active profile corresponding to the current power source */
profile_ref = (CFNumberRef) CFDictionaryGetValue(active_prof, current_ps);
profile_type = CFNumberGetType(profile_ref);
CFNumberGetValue(profile_ref, profile_type, &original_profile); /* On succes, store its value */
if (debug) printf("original profile: %d\n", original_profile);
} else {
printf("Failed to get the power management settings\n"); /* On failure: quit */
CFCleanup();
return 1;
}
ds = SCDynamicStoreCreate(NULL, CFSTR("deepsleep"), NULL, NULL); /* Create a new dynamic store */
live_settings = SCDynamicStoreCopyValue(ds, CFSTR(kIOPMDynamicStoreSettingsKey)); /* Read current settings */
if(!isA_CFDictionary(live_settings)) { /* We did not get the settings: quit */
printf("Failed to get the power management settings\n");
CFCleanup();
return 1;
}
if (CFDictionaryContainsKey(live_settings, CFSTR("Hibernate Mode"))) { /* Check if the hibernate mode key exists */
hm_ref = (CFNumberRef) CFDictionaryGetValue(live_settings, CFSTR("Hibernate Mode")); /* On success, get its value */
hm_type = CFNumberGetType(hm_ref);
CFNumberGetValue(hm_ref, hm_type, &original_mode);
if (debug) printf("original mode: %d\n", original_mode);
}
else { /* On failure, cleanup and quit */
printf("Failed to get the hibernation mode\n");
CFCleanup();
return 1;
}
if (repair && original_mode == target_mode) { /* If the original mode is the same as the target mode */
original_mode = default_mode; /* A crash has probably happened during hibernation: we will set back the hibernation mode to its default value after wakeup */
if (debug) printf("repair mode to: %d\n", default_mode);
}
root_power_port = IORegisterForSystemPower(refCon, ¬ifyPortRef, PowerCallBack, ¬ifierObject); /* Register to the Root Power Domain IOService: notifications will be handled by the PowerCallBack functions */
if (!root_power_port) { /* Registering failed: quit */
printf("Failed to register to the Root Power Domain IOService\n");
CFCleanup();
return 1;
}
CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notifyPortRef), kCFRunLoopCommonModes); /* Add the notification port to the run loop */
if (SetActiveProfile(target_profile, current_ps, active_prof)) { /* Set the active power profile to custom (-1) */
printf("Failed to set the active profile\n");
PortsCleanup();
CFCleanup();
return 1;
}
if (SetHibernateMode(target_mode, current_ps)) { /* Set the hibernate mode to target mode */
printf("Failed to set the hibernation mode\n");
SetActiveProfile(original_profile, current_ps, active_prof);
PortsCleanup();
CFCleanup();
return 1;
}
if (do_sleep) { /* If we are not in simulation mode */
sleep(3); /* Wait for 3s to allow settings to settle down */
if (IOPMSleepSystem(root_power_port) == kIOReturnSuccess) /* Request the system to sleep */
CFRunLoopRun(); /* On success, start the run loop */
else
perror("Failed to send the sleep request\n"); /* On failure, do not start it */
} /* The run loop has stopped: system has woken up */
if (restore) { /* If we are asked to restore the original hibernate mode */
if (SetHibernateMode(original_mode, current_ps)) { /* Restore the original hibernate mode */
printf("Failed to set the hibernation mode\n");
SetActiveProfile(original_profile, current_ps, active_prof);
PortsCleanup();
CFCleanup();
return 1;
}
if (SetActiveProfile(original_profile, current_ps, active_prof)) { /* Restore the original power profile */
printf("Failed to set the active profile\n");
PortsCleanup();
CFCleanup();
return 1;
}
}
PortsCleanup(); /* Cleanup */
CFCleanup();
return 0;
}
TStringIRep* TSICTStringCreateWithNumberAndFormat(CFNumberRef number, TSITStringFormat format)
{
CFRetain(number);
TSITStringTag tag = kTSITStringTagNumber;
CFDataRef data;
CFNumberType numType = CFNumberGetType(number);
switch(numType) {
case kCFNumberCharType:
{
int value;
if (CFNumberGetValue(number, kCFNumberIntType, &value)) {
if (value == 0 || value == 1) {
tag = kTSITStringTagBool;
} else {
tag = kTSITStringTagString;
}
}
break;
}
case kCFNumberFloat32Type:
case kCFNumberFloat64Type:
case kCFNumberFloatType:
case kCFNumberDoubleType:
{
tag = kTSITStringTagFloat;
break;
}
}
if (tag == kTSITStringTagBool) {
bool value;
CFNumberGetValue(number, kCFNumberIntType, &value);
if (value) {
data = CFDataCreate(kCFAllocatorDefault, (UInt8*)"true", 4);
} else {
data = CFDataCreate(kCFAllocatorDefault, (UInt8*)"false", 5);
}
} else if (tag == kTSITStringTagFloat) {
char buf[32];
char *p, *e;
double value;
CFNumberGetValue(number, numType, &value);
sprintf(buf, "%#.15g", value);
e = buf + strlen(buf);
p = e;
while (p[-1]=='0' && ('0' <= p[-2] && p[-2] <= '9')) {
p--;
}
memmove(p, e, strlen(e)+1);
data = CFDataCreate(kCFAllocatorDefault, (UInt8*)buf, (CFIndex)strlen(buf));
} else {
char buf[32];
SInt64 value;
CFNumberGetValue(number, numType, &value);
sprintf(buf, "%lli", value);
data = CFDataCreate(kCFAllocatorDefault, (UInt8*)buf, (CFIndex)strlen(buf));
}
TStringIRep* rep = TSICTStringCreateWithDataOfTypeAndFormat(data, tag, format);
CFRelease(data);
CFRelease(number);
return rep;
}
static QVariant qtValue(CFPropertyListRef cfvalue)
{
if (!cfvalue)
return QVariant();
CFTypeID typeId = CFGetTypeID(cfvalue);
/*
Sorted grossly from most to least frequent type.
*/
if (typeId == CFStringGetTypeID()) {
return QSettingsPrivate::stringToVariant(QCFString::toQString(static_cast<CFStringRef>(cfvalue)));
} else if (typeId == CFNumberGetTypeID()) {
CFNumberRef cfnumber = static_cast<CFNumberRef>(cfvalue);
if (CFNumberIsFloatType(cfnumber)) {
double d;
CFNumberGetValue(cfnumber, kCFNumberDoubleType, &d);
return d;
} else {
int i;
qint64 ll;
if (CFNumberGetType(cfnumber) == kCFNumberIntType) {
CFNumberGetValue(cfnumber, kCFNumberIntType, &i);
return i;
}
CFNumberGetValue(cfnumber, kCFNumberLongLongType, &ll);
return ll;
}
} else if (typeId == CFArrayGetTypeID()) {
CFArrayRef cfarray = static_cast<CFArrayRef>(cfvalue);
QList<QVariant> list;
CFIndex size = CFArrayGetCount(cfarray);
bool metNonString = false;
for (CFIndex i = 0; i < size; ++i) {
QVariant value = qtValue(CFArrayGetValueAtIndex(cfarray, i));
if (value.type() != QVariant::String)
metNonString = true;
list << value;
}
if (metNonString)
return list;
else
return QVariant(list).toStringList();
} else if (typeId == CFBooleanGetTypeID()) {
return (bool)CFBooleanGetValue(static_cast<CFBooleanRef>(cfvalue));
} else if (typeId == CFDataGetTypeID()) {
CFDataRef cfdata = static_cast<CFDataRef>(cfvalue);
return QByteArray(reinterpret_cast<const char *>(CFDataGetBytePtr(cfdata)),
CFDataGetLength(cfdata));
} else if (typeId == CFDictionaryGetTypeID()) {
CFDictionaryRef cfdict = static_cast<CFDictionaryRef>(cfvalue);
CFTypeID arrayTypeId = CFArrayGetTypeID();
int size = (int)CFDictionaryGetCount(cfdict);
QVarLengthArray<CFPropertyListRef> keys(size);
QVarLengthArray<CFPropertyListRef> values(size);
CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data());
QMultiMap<QString, QVariant> map;
for (int i = 0; i < size; ++i) {
QString key = QCFString::toQString(static_cast<CFStringRef>(keys[i]));
if (CFGetTypeID(values[i]) == arrayTypeId) {
CFArrayRef cfarray = static_cast<CFArrayRef>(values[i]);
CFIndex arraySize = CFArrayGetCount(cfarray);
for (CFIndex j = arraySize - 1; j >= 0; --j)
map.insert(key, qtValue(CFArrayGetValueAtIndex(cfarray, j)));
} else {
map.insert(key, qtValue(values[i]));
}
}
return map;
} else if (typeId == CFDateGetTypeID()) {
QDateTime dt;
dt.setTime_t((uint)kCFAbsoluteTimeIntervalSince1970);
return dt.addSecs((int)CFDateGetAbsoluteTime(static_cast<CFDateRef>(cfvalue)));
}
return QVariant();
}
static QVariant q_toVariant(const CFTypeRef &obj)
{
const CFTypeID typeId = CFGetTypeID(obj);
if (typeId == CFStringGetTypeID())
return QVariant(q_toString(static_cast<const CFStringRef>(obj)));
if (typeId == CFNumberGetTypeID()) {
const CFNumberRef num = static_cast<const CFNumberRef>(obj);
const CFNumberType type = CFNumberGetType(num);
switch (type) {
case kCFNumberSInt8Type:
return qVariantFromValue(convertCFNumber<char>(num, type));
case kCFNumberSInt16Type:
return qVariantFromValue(convertCFNumber<qint16>(num, type));
case kCFNumberSInt32Type:
return qVariantFromValue(convertCFNumber<qint32>(num, type));
case kCFNumberSInt64Type:
return qVariantFromValue(convertCFNumber<qint64>(num, type));
case kCFNumberCharType:
return qVariantFromValue(convertCFNumber<uchar>(num, type));
case kCFNumberShortType:
return qVariantFromValue(convertCFNumber<short>(num, type));
case kCFNumberIntType:
return qVariantFromValue(convertCFNumber<int>(num, type));
case kCFNumberLongType:
return qVariantFromValue(convertCFNumber<long>(num, type));
case kCFNumberLongLongType:
return qVariantFromValue(convertCFNumber<long long>(num, type));
case kCFNumberFloatType:
return qVariantFromValue(convertCFNumber<float>(num, type));
case kCFNumberDoubleType:
return qVariantFromValue(convertCFNumber<double>(num, type));
default:
if (CFNumberIsFloatType(num))
return qVariantFromValue(convertCFNumber<double>(num, kCFNumberDoubleType));
return qVariantFromValue(convertCFNumber<quint64>(num, kCFNumberLongLongType));
}
}
if (typeId == CFDateGetTypeID()) {
QDateTime dt;
dt.setTime_t(uint(kCFAbsoluteTimeIntervalSince1970));
return dt.addSecs(int(CFDateGetAbsoluteTime(static_cast<const CFDateRef>(obj))));
}
if (typeId == CFDataGetTypeID()) {
const CFDataRef cfdata = static_cast<const CFDataRef>(obj);
return QByteArray(reinterpret_cast<const char *>(CFDataGetBytePtr(cfdata)),
CFDataGetLength(cfdata));
}
if (typeId == CFBooleanGetTypeID())
return QVariant(bool(CFBooleanGetValue(static_cast<const CFBooleanRef>(obj))));
if (typeId == CFArrayGetTypeID()) {
const CFArrayRef cfarray = static_cast<const CFArrayRef>(obj);
QList<QVariant> list;
CFIndex size = CFArrayGetCount(cfarray);
bool metNonString = false;
for (CFIndex i = 0; i < size; ++i) {
QVariant value = q_toVariant(CFArrayGetValueAtIndex(cfarray, i));
if (value.type() != QVariant::String)
metNonString = true;
list << value;
}
if (metNonString)
return list;
else
return QVariant(list).toStringList();
}
if (typeId == CFDictionaryGetTypeID()) {
const CFDictionaryRef cfdict = static_cast<const CFDictionaryRef>(obj);
const CFTypeID arrayTypeId = CFArrayGetTypeID();
int size = int(CFDictionaryGetCount(cfdict));
QVarLengthArray<CFPropertyListRef> keys(size);
QVarLengthArray<CFPropertyListRef> values(size);
CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data());
QMultiMap<QString, QVariant> map;
for (int i = 0; i < size; ++i) {
QString key = q_toString(static_cast<const CFStringRef>(keys[i]));
if (CFGetTypeID(values[i]) == arrayTypeId) {
const CFArrayRef cfarray = static_cast<const CFArrayRef>(values[i]);
CFIndex arraySize = CFArrayGetCount(cfarray);
for (CFIndex j = arraySize - 1; j >= 0; --j)
map.insert(key, q_toVariant(CFArrayGetValueAtIndex(cfarray, j)));
} else {
map.insert(key, q_toVariant(values[i]));
}
}
return map;
}
return QVariant();
}
launch_data_t GTMLaunchDataCreateFromCFType(CFTypeRef cf_type_ref,
CFErrorRef *error) {
launch_data_t result = NULL;
CFErrorRef local_error = NULL;
if (cf_type_ref == NULL) {
local_error = GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("NULL CFType"));
goto exit;
}
CFTypeID cf_type = CFGetTypeID(cf_type_ref);
if (cf_type == CFStringGetTypeID()) {
CFIndex length = CFStringGetLength(cf_type_ref);
CFIndex max_length
= CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
char *buffer = calloc(max_length, sizeof(char));
size_t buffer_size = max_length * sizeof(char);
if (buffer) {
if (CFStringGetCString(cf_type_ref,
buffer,
buffer_size,
kCFStringEncodingUTF8)) {
result = launch_data_alloc(LAUNCH_DATA_STRING);
launch_data_set_string(result, buffer);
} else {
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("CFStringGetCString failed %@"),
cf_type_ref);
}
free(buffer);
} else {
local_error = GTMCFLaunchCreateUnlocalizedError(ENOMEM,
CFSTR("calloc of %zu failed"),
buffer_size);
}
} else if (cf_type == CFBooleanGetTypeID()) {
result = launch_data_alloc(LAUNCH_DATA_BOOL);
launch_data_set_bool(result, CFBooleanGetValue(cf_type_ref));
} else if (cf_type == CFArrayGetTypeID()) {
CFIndex count = CFArrayGetCount(cf_type_ref);
result = launch_data_alloc(LAUNCH_DATA_ARRAY);
for (CFIndex i = 0; i < count; i++) {
CFTypeRef array_value = CFArrayGetValueAtIndex(cf_type_ref, i);
if (array_value) {
launch_data_t launch_value
= GTMLaunchDataCreateFromCFType(array_value, &local_error);
if (local_error) break;
launch_data_array_set_index(result, launch_value, i);
}
}
} else if (cf_type == CFDictionaryGetTypeID()) {
result = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
GTMCFToLDictContext context = { result, &local_error };
CFDictionaryApplyFunction(cf_type_ref,
GTMConvertCFDictEntryToLaunchDataDictEntry,
&context);
} else if (cf_type == CFDataGetTypeID()) {
result = launch_data_alloc(LAUNCH_DATA_OPAQUE);
launch_data_set_opaque(result,
CFDataGetBytePtr(cf_type_ref),
CFDataGetLength(cf_type_ref));
} else if (cf_type == CFNumberGetTypeID()) {
CFNumberType cf_number_type = CFNumberGetType(cf_type_ref);
switch (cf_number_type) {
case kCFNumberSInt8Type:
case kCFNumberSInt16Type:
case kCFNumberSInt32Type:
case kCFNumberSInt64Type:
case kCFNumberCharType:
case kCFNumberShortType:
case kCFNumberIntType:
case kCFNumberLongType:
case kCFNumberLongLongType:
case kCFNumberCFIndexType:
case kCFNumberNSIntegerType:{
long long value;
if (CFNumberGetValue(cf_type_ref, kCFNumberLongLongType, &value)) {
result = launch_data_alloc(LAUNCH_DATA_INTEGER);
launch_data_set_integer(result, value);
} else {
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("Unknown to convert: %@"),
cf_type_ref);
}
break;
}
case kCFNumberFloat32Type:
case kCFNumberFloat64Type:
case kCFNumberFloatType:
case kCFNumberDoubleType:
case kCFNumberCGFloatType: {
double value;
if (CFNumberGetValue(cf_type_ref, kCFNumberDoubleType, &value)) {
result = launch_data_alloc(LAUNCH_DATA_REAL);
launch_data_set_real(result, value);
} else {
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("Unknown to convert: %@"),
cf_type_ref);
}
break;
}
default:
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("Unknown CFNumberType %lld"),
(long long)cf_number_type);
break;
}
} else {
local_error
= GTMCFLaunchCreateUnlocalizedError(EINVAL,
CFSTR("Unknown CFTypeID %lu"),
cf_type);
}
exit:
if (error) {
*error = local_error;
} else if (local_error) {
#ifdef DEBUG
CFShow(local_error);
#endif // DEBUG
CFRelease(local_error);
}
return result;
}
static void printObjAsNumber(CFNumberRef obj) {
CFNumberType numType = CFNumberGetType(obj);
union {
#define DefineValue(type) type type##Value
DefineValue(SInt8);
DefineValue(SInt16);
DefineValue(SInt32);
DefineValue(SInt64);
DefineValue(Float32);
DefineValue(Float64);
char CharValue;
short ShortValue;
int IntValue;
long LongValue;
long long LongLongValue;
float FloatValue;
double DoubleValue;
DefineValue(CFIndex);
int NSIntegerValue;
float CGFloatValue;
#undef DefineValue
} res;
CFNumberGetValue(obj, numType, &res);
#define PrintType(formatStr, t1, dummy) \
case kCFNumber##t1##Type: \
printf(formatStr, res.t1##Value); \
break
switch (numType) {
PrintType("%d", SInt8, SInt8);
PrintType("%d", SInt16, SInt16);
PrintType("%ld", SInt32, SInt32);
PrintType("%lld", SInt64, SInt64);
PrintType("%g", Float32, Float32);
PrintType("%lg", Float64, Float64);
case kCFNumberCharType:
if (res.CharValue >= ' ' && res.CharValue < '\x7F') {
if (res.CharValue == '\'' || res.CharValue == '\\')
printf("'\\%c'", res.CharValue);
else
printf("'%c'", res.CharValue);
} else if (res.CharValue == '\t')
printf("'\\t'");
else if (res.CharValue == '\n')
printf("'\\n'");
else
printf("'\\U%04x'", res.CharValue);
break;
PrintType("%d", Short, short);
PrintType("%d", Int, int);
PrintType("%ld", Long, long);
PrintType("%lld", LongLong, long long);
PrintType("%f", Float, float);
PrintType("%lg", Double, double);
PrintType("%ld", CFIndex, CFIndex);
PrintType("%d", NSInteger, int);
PrintType("%g", CGFloat, float);
// PrintType("%f", Max, float);
default:
break;
}
#undef PrintType
}
std::string stringFromCFNumber(const CFDataRef& cf_number) {
return stringFromCFNumber(cf_number, CFNumberGetType((CFNumberRef)cf_number));
}
void PrintCFTypeInternalFormat(CFTypeRef value, uint32_t depth) {
bool foundType = false;
CFStringRef valueType = CFCopyTypeIDDescription(CFGetTypeID(value));
CFStringRef dictionaryType = CFCopyTypeIDDescription(CFDictionaryGetTypeID());
if (CFStringCompare(valueType, dictionaryType, 0x0) == kCFCompareEqualTo) {
foundType = true;
printf("{\n");
PrintCFDictionaryInternalFormatting(value, depth+0x1);
PrintDepth(depth,"}\n");
}
CFSafeRelease(dictionaryType);
CFStringRef booleanType = CFCopyTypeIDDescription(CFBooleanGetTypeID());
if (CFStringCompare(valueType, booleanType, 0x0) == kCFCompareEqualTo) {
foundType = true;
printf("%s\n",(CFBooleanGetValue(value) ? "True" : "False"));
}
CFSafeRelease(booleanType);
CFStringRef stringType = CFCopyTypeIDDescription(CFStringGetTypeID());
if (CFStringCompare(valueType, stringType, 0x0) == kCFCompareEqualTo) {
foundType = true;
printf("%s\n",(char*)CFStringGetCStringPtr(value,kCFStringEncodingUTF8));
}
CFSafeRelease(stringType);
CFStringRef numberType = CFCopyTypeIDDescription(CFNumberGetTypeID());
if (CFStringCompare(valueType, numberType, 0x0) == kCFCompareEqualTo) {
foundType = true;
CFIndex numberType = CFNumberGetType(value);
switch (numberType) {
case kCFNumberSInt8Type: {
SInt8 number;
CFNumberGetValue(value, numberType, &number);
printf("%hhd\n",number);
break;
};
case kCFNumberSInt16Type: {
SInt16 number;
CFNumberGetValue(value, numberType, &number);
printf("%hd\n",number);
break;
};
case kCFNumberSInt32Type: {
SInt32 number;
CFNumberGetValue(value, numberType, &number);
printf("%d\n",(int32_t)number);
break;
};
case kCFNumberSInt64Type: {
SInt64 number;
CFNumberGetValue(value, numberType, &number);
printf("%lld\n",number);
break;
};
case kCFNumberFloat32Type: {
Float32 number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberFloat64Type: {
Float64 number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberCharType: {
char number;
CFNumberGetValue(value, numberType, &number);
printf("%c\n",number);
break;
};
case kCFNumberShortType: {
short number;
CFNumberGetValue(value, numberType, &number);
printf("%hd\n",number);
break;
};
case kCFNumberIntType: {
int number;
CFNumberGetValue(value, numberType, &number);
printf("%d\n",number);
break;
};
case kCFNumberLongType: {
long number;
CFNumberGetValue(value, numberType, &number);
printf("%ld\n",number);
break;
};
case kCFNumberLongLongType: {
long long number;
CFNumberGetValue(value, numberType, &number);
printf("%qd\n",number);
break;
};
case kCFNumberFloatType: {
float number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberDoubleType: {
double number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberCFIndexType: {
CFIndex number;
CFNumberGetValue(value, numberType, &number);
printf("%ld\n",number);
break;
};
case kCFNumberNSIntegerType: {
NSInteger number;
CFNumberGetValue(value, numberType, &number);
printf("%ld\n",(long)number);
break;
};
case kCFNumberCGFloatType: {
CGFloat number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
default: {
break;
};
}
}
CFSafeRelease(numberType);
CFStringRef arrayType = CFCopyTypeIDDescription(CFArrayGetTypeID());
if (CFStringCompare(valueType, arrayType, 0x0) == kCFCompareEqualTo) {
foundType = true;
CFIndex count = CFArrayGetCount(value);
printf("[\n");
for (CFIndex i = 0x0; i < count; i++) {
CFTypeRef item = CFArrayGetValueAtIndex(value, i);
PrintDepth(depth+0x1,"");
PrintCFTypeInternalFormat(item, depth+0x1);
}
PrintDepth(depth,"]\n");
}
CFSafeRelease(arrayType);
if (!foundType) {
CFStringRef description = CFCopyDescription(value);
printf("%s\n",(char*)CFStringGetCStringPtr(description,kCFStringEncodingUTF8));
CFSafeRelease(description);
}
CFSafeRelease(valueType);
}
void PrintCFDictionaryInternalFormatting(CFDictionaryRef dictionary, uint32_t depth) {
CFIndex keyCount = CFDictionaryGetCount(dictionary);
Pointer keys[keyCount];
Pointer values[keyCount];
CFDictionaryGetKeysAndValues(dictionary, PtrCast(keys,const void**), PtrCast(values,const void**));
for (uint32_t i = 0x0; i < keyCount; i++) {
CFStringRef key = PtrCast(keys[i],CFStringRef);
CFTypeRef value = PtrCast(values[i],CFTypeRef);
PrintDepth(depth,"%s: ",(char*)CFStringGetCStringPtr(key,kCFStringEncodingUTF8));
CFStringRef valueType = CFCopyTypeIDDescription(CFGetTypeID(value));
if (CFStringCompare(valueType, CFCopyTypeIDDescription(CFDictionaryGetTypeID()), 0x0) == kCFCompareEqualTo) {
printf("\n");
PrintCFDictionaryInternalFormatting(value, depth+0x1);
printf("\n");
}
if (CFStringCompare(valueType, CFCopyTypeIDDescription(CFBooleanGetTypeID()), 0x0) == kCFCompareEqualTo) {
printf("%s\n",(CFBooleanGetValue(value) ? "True" : "False"));
}
if (CFStringCompare(valueType, CFCopyTypeIDDescription(CFStringGetTypeID()), 0x0) == kCFCompareEqualTo) {
printf("%s\n",(char*)CFStringGetCStringPtr(value,kCFStringEncodingUTF8));
}
if (CFStringCompare(valueType, CFCopyTypeIDDescription(CFNumberGetTypeID()), 0x0) == kCFCompareEqualTo) {
CFIndex numberType = CFNumberGetType(value);
switch (numberType) {
case kCFNumberSInt8Type: {
SInt8 number;
CFNumberGetValue(value, numberType, &number);
printf("%hhd\n",number);
break;
};
case kCFNumberSInt16Type: {
SInt16 number;
CFNumberGetValue(value, numberType, &number);
printf("%hd\n",number);
break;
};
case kCFNumberSInt32Type: {
SInt32 number;
CFNumberGetValue(value, numberType, &number);
printf("%dz\n",number);
break;
};
case kCFNumberSInt64Type: {
SInt64 number;
CFNumberGetValue(value, numberType, &number);
printf("%lldz\n",number);
break;
};
case kCFNumberFloat32Type: {
Float32 number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberFloat64Type: {
Float64 number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberCharType: {
char number;
CFNumberGetValue(value, numberType, &number);
printf("%c\n",number);
break;
};
case kCFNumberShortType: {
short number;
CFNumberGetValue(value, numberType, &number);
printf("%hd\n",number);
break;
};
case kCFNumberIntType: {
int number;
CFNumberGetValue(value, numberType, &number);
printf("%dz\n",number);
break;
};
case kCFNumberLongType: {
long number;
CFNumberGetValue(value, numberType, &number);
printf("%ldz\n",number);
break;
};
case kCFNumberLongLongType: {
long long number;
CFNumberGetValue(value, numberType, &number);
printf("%qdz\n",number);
break;
};
case kCFNumberFloatType: {
float number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberDoubleType: {
double number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
case kCFNumberCFIndexType: {
CFIndex number;
CFNumberGetValue(value, numberType, &number);
printf("%ldz\n",number);
break;
};
case kCFNumberNSIntegerType: {
NSInteger number;
CFNumberGetValue(value, numberType, &number);
printf("%ldz\n",number);
break;
};
case kCFNumberCGFloatType: {
CGFloat number;
CFNumberGetValue(value, numberType, &number);
printf("%.f\n",number);
break;
};
default: {
break;
};
}
}
}
}
