diff --git a/DEPS b/DEPS index dfb4df54..8debd5e2 100644 --- a/DEPS +++ b/DEPS @@ -28,7 +28,7 @@ deps = { '32ca1cd8e010d013a606a752fb49a603a3598071', # svn r2015 'crashpad/third_party/mini_chromium/mini_chromium': Var('chromium_git') + '/chromium/mini_chromium@' + - '8773bfd3a0006ee8795b296b6f772e08b7d518c5', + 'e7847b381703096126b37539c62a0718671d6100', } hooks = [ diff --git a/util/mac/launchd.h b/util/mac/launchd.h index 11340bf6..03f8bf09 100644 --- a/util/mac/launchd.h +++ b/util/mac/launchd.h @@ -20,6 +20,114 @@ namespace crashpad { +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-declarations" + +//! \{ +//! \brief Wraps the `` function of the same name. +//! +//! The Mac OS X 10.10 SDK deprecates ``, although the functionality +//! it provides is still useful. These wrappers allow the deprecated functions +//! to be called without triggering deprecated-declaration warnings. + +inline launch_data_t LaunchDataAlloc(launch_data_type_t type) { + return launch_data_alloc(type); +} + +inline launch_data_type_t LaunchDataGetType(const launch_data_t data) { + return launch_data_get_type(data); +} + +inline void LaunchDataFree(launch_data_t data) { + return launch_data_free(data); +} + +inline bool LaunchDataDictInsert(launch_data_t dict, + const launch_data_t value, + const char* key) { + return launch_data_dict_insert(dict, value, key); +} + +inline launch_data_t LaunchDataDictLookup(const launch_data_t dict, + const char* key) { + return launch_data_dict_lookup(dict, key); +} + +inline size_t LaunchDataDictGetCount(launch_data_t dict) { + return launch_data_dict_get_count(dict); +} + +inline bool LaunchDataArraySetIndex(launch_data_t array, + const launch_data_t value, + size_t index) { + return launch_data_array_set_index(array, value, index); +} + +inline launch_data_t LaunchDataArrayGetIndex(launch_data_t array, + size_t index) { + return launch_data_array_get_index(array, index); +} + +inline size_t LaunchDataArrayGetCount(launch_data_t array) { + return launch_data_array_get_count(array); +} + +inline launch_data_t LaunchDataNewInteger(long long integer) { + return launch_data_new_integer(integer); +} + +inline launch_data_t LaunchDataNewBool(bool boolean) { + return launch_data_new_bool(boolean); +} + +inline launch_data_t LaunchDataNewReal(double real) { + return launch_data_new_real(real); +} + +inline launch_data_t LaunchDataNewString(const char* string) { + return launch_data_new_string(string); +} + +inline launch_data_t LaunchDataNewOpaque(const void* opaque, size_t size) { + return launch_data_new_opaque(opaque, size); +} + +inline long long LaunchDataGetInteger(const launch_data_t data) { + return launch_data_get_integer(data); +} + +inline bool LaunchDataGetBool(const launch_data_t data) { + return launch_data_get_bool(data); +} + +inline double LaunchDataGetReal(const launch_data_t data) { + return launch_data_get_real(data); +} + +inline const char* LaunchDataGetString(const launch_data_t data) { + return launch_data_get_string(data); +} + +inline void* LaunchDataGetOpaque(const launch_data_t data) { + return launch_data_get_opaque(data); +} + +inline size_t LaunchDataGetOpaqueSize(const launch_data_t data) { + return launch_data_get_opaque_size(data); +} + +inline int LaunchDataGetErrno(const launch_data_t data) { + return launch_data_get_errno(data); +} + +inline launch_data_t LaunchMsg(const launch_data_t data) { + return launch_msg(data); +} + +//! \} + +#pragma clang diagnostic pop + //! \brief Converts a Core Foundation-type property list to a launchd-type //! `launch_data_t`. //! diff --git a/util/mac/launchd.mm b/util/mac/launchd.mm index f5aede54..5d59cd2e 100644 --- a/util/mac/launchd.mm +++ b/util/mac/launchd.mm @@ -37,7 +37,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { NSDictionary* dictionary_ns = base::mac::CFToNSCast( base::mac::CFCastStrict(property_cf)); base::mac::ScopedLaunchData dictionary_launch( - launch_data_alloc(LAUNCH_DATA_DICTIONARY)); + LaunchDataAlloc(LAUNCH_DATA_DICTIONARY)); for (NSString* key in dictionary_ns) { if (![key isKindOfClass:[NSString class]]) { @@ -51,8 +51,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { return nullptr; } - launch_data_dict_insert( - dictionary_launch, value_launch, [key UTF8String]); + LaunchDataDictInsert(dictionary_launch, value_launch, [key UTF8String]); } data_launch = dictionary_launch.release(); @@ -61,7 +60,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { NSArray* array_ns = base::mac::CFToNSCast( base::mac::CFCastStrict(property_cf)); base::mac::ScopedLaunchData array_launch( - launch_data_alloc(LAUNCH_DATA_ARRAY)); + LaunchDataAlloc(LAUNCH_DATA_ARRAY)); size_t index = 0; for (id element_ns in array_ns) { @@ -72,7 +71,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { return nullptr; } - launch_data_array_set_index(array_launch, element_launch, index++); + LaunchDataArraySetIndex(array_launch, element_launch, index++); } data_launch = array_launch.release(); @@ -92,7 +91,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { case kCFNumberLongLongType: case kCFNumberCFIndexType: case kCFNumberNSIntegerType: { - data_launch = launch_data_new_integer([number_ns longLongValue]); + data_launch = LaunchDataNewInteger([number_ns longLongValue]); break; } @@ -100,7 +99,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { case kCFNumberFloat64Type: case kCFNumberFloatType: case kCFNumberDoubleType: { - data_launch = launch_data_new_real([number_ns doubleValue]); + data_launch = LaunchDataNewReal([number_ns doubleValue]); break; } @@ -110,7 +109,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { } else if (type_id_cf == CFBooleanGetTypeID()) { CFBooleanRef boolean_cf = base::mac::CFCastStrict(property_cf); - data_launch = launch_data_new_bool(CFBooleanGetValue(boolean_cf)); + data_launch = LaunchDataNewBool(CFBooleanGetValue(boolean_cf)); } else if (type_id_cf == CFStringGetTypeID()) { NSString* string_ns = base::mac::CFToNSCast( @@ -122,12 +121,12 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) { // launchd-842.92.1/support/launchctl.c), uses UTF-8 instead of filesystem // encoding, so do the same here. Note that there’s another occurrence of // -UTF8String above, used for dictionary keys. - data_launch = launch_data_new_string([string_ns UTF8String]); + data_launch = LaunchDataNewString([string_ns UTF8String]); } else if (type_id_cf == CFDataGetTypeID()) { NSData* data_ns = base::mac::CFToNSCast( base::mac::CFCastStrict(property_cf)); - data_launch = launch_data_new_opaque([data_ns bytes], [data_ns length]); + data_launch = LaunchDataNewOpaque([data_ns bytes], [data_ns length]); } else { base::ScopedCFTypeRef type_name_cf( CFCopyTypeIDDescription(type_id_cf)); diff --git a/util/mac/launchd_test.mm b/util/mac/launchd_test.mm index 03953cdf..65722a42 100644 --- a/util/mac/launchd_test.mm +++ b/util/mac/launchd_test.mm @@ -61,9 +61,8 @@ TEST(Launchd, CFPropertyToLaunchData_Integer) { NSNumber* integer_ns = integer_nses[index]; launch_data.reset(CFPropertyToLaunchData(integer_ns)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_INTEGER, launch_data_get_type(launch_data)); - EXPECT_EQ( - [integer_ns longLongValue], launch_data_get_integer(launch_data)) + ASSERT_EQ(LAUNCH_DATA_INTEGER, LaunchDataGetType(launch_data)); + EXPECT_EQ([integer_ns longLongValue], LaunchDataGetInteger(launch_data)) << "index " << index; } } @@ -91,9 +90,9 @@ TEST(Launchd, CFPropertyToLaunchData_FloatingPoint) { NSNumber* double_ns = double_nses[index]; launch_data.reset(CFPropertyToLaunchData(double_ns)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_REAL, launch_data_get_type(launch_data)); + ASSERT_EQ(LAUNCH_DATA_REAL, LaunchDataGetType(launch_data)); double expected_double_value = [double_ns doubleValue]; - double observed_double_value = launch_data_get_real(launch_data); + double observed_double_value = LaunchDataGetReal(launch_data); bool expected_is_nan = std::isnan(expected_double_value); EXPECT_EQ(expected_is_nan, std::isnan(observed_double_value)); if (!expected_is_nan) { @@ -117,11 +116,11 @@ TEST(Launchd, CFPropertyToLaunchData_Boolean) { NSNumber* bool_ns = bool_nses[index]; launch_data.reset(CFPropertyToLaunchData(bool_ns)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_BOOL, launch_data_get_type(launch_data)); + ASSERT_EQ(LAUNCH_DATA_BOOL, LaunchDataGetType(launch_data)); if ([bool_ns boolValue]) { - EXPECT_TRUE(launch_data_get_bool(launch_data)); + EXPECT_TRUE(LaunchDataGetBool(launch_data)); } else { - EXPECT_FALSE(launch_data_get_bool(launch_data)); + EXPECT_FALSE(LaunchDataGetBool(launch_data)); } } } @@ -141,8 +140,8 @@ TEST(Launchd, CFPropertyToLaunchData_String) { NSString* string_ns = string_nses[index]; launch_data.reset(CFPropertyToLaunchData(string_ns)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_data)); - EXPECT_STREQ([string_ns UTF8String], launch_data_get_string(launch_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_data)); + EXPECT_STREQ([string_ns UTF8String], LaunchDataGetString(launch_data)); } } } @@ -156,10 +155,10 @@ TEST(Launchd, CFPropertyToLaunchData_Data) { NSData* data_ns = [NSData dataWithBytes:data_c length:sizeof(data_c)]; launch_data.reset(CFPropertyToLaunchData(data_ns)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_OPAQUE, launch_data_get_type(launch_data)); - EXPECT_EQ(sizeof(data_c), launch_data_get_opaque_size(launch_data)); - EXPECT_EQ( - 0, memcmp(launch_data_get_opaque(launch_data), data_c, sizeof(data_c))); + ASSERT_EQ(LAUNCH_DATA_OPAQUE, LaunchDataGetType(launch_data)); + EXPECT_EQ(sizeof(data_c), LaunchDataGetOpaqueSize(launch_data)); + EXPECT_EQ(0, + memcmp(LaunchDataGetOpaque(launch_data), data_c, sizeof(data_c))); } } @@ -173,14 +172,13 @@ TEST(Launchd, CFPropertyToLaunchData_Dictionary) { launch_data.reset(CFPropertyToLaunchData(dictionary_ns)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_DICTIONARY, launch_data_get_type(launch_data)); - EXPECT_EQ([dictionary_ns count], launch_data_dict_get_count(launch_data)); + ASSERT_EQ(LAUNCH_DATA_DICTIONARY, LaunchDataGetType(launch_data)); + EXPECT_EQ([dictionary_ns count], LaunchDataDictGetCount(launch_data)); - launch_data_t launch_lookup_data = - launch_data_dict_lookup(launch_data, "key"); + launch_data_t launch_lookup_data = LaunchDataDictLookup(launch_data, "key"); ASSERT_TRUE(launch_lookup_data); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data)); - EXPECT_STREQ("value", launch_data_get_string(launch_lookup_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data)); + EXPECT_STREQ("value", LaunchDataGetString(launch_lookup_data)); } } @@ -192,19 +190,18 @@ TEST(Launchd, CFPropertyToLaunchData_Array) { launch_data.reset(CFPropertyToLaunchData(array_ns)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_ARRAY, launch_data_get_type(launch_data)); - EXPECT_EQ([array_ns count], launch_data_array_get_count(launch_data)); + ASSERT_EQ(LAUNCH_DATA_ARRAY, LaunchDataGetType(launch_data)); + EXPECT_EQ([array_ns count], LaunchDataArrayGetCount(launch_data)); - launch_data_t launch_lookup_data = - launch_data_array_get_index(launch_data, 0); + launch_data_t launch_lookup_data = LaunchDataArrayGetIndex(launch_data, 0); ASSERT_TRUE(launch_lookup_data); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data)); - EXPECT_STREQ("element_1", launch_data_get_string(launch_lookup_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data)); + EXPECT_STREQ("element_1", LaunchDataGetString(launch_lookup_data)); - launch_lookup_data = launch_data_array_get_index(launch_data, 1); + launch_lookup_data = LaunchDataArrayGetIndex(launch_data, 1); ASSERT_TRUE(launch_lookup_data); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data)); - EXPECT_STREQ("element_2", launch_data_get_string(launch_lookup_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data)); + EXPECT_STREQ("element_2", LaunchDataGetString(launch_lookup_data)); } } @@ -248,55 +245,55 @@ TEST(Launchd, CFPropertyToLaunchData_RealWorldJobDictionary) { launch_data.reset(CFPropertyToLaunchData(job_dictionary)); ASSERT_TRUE(launch_data.get()); - ASSERT_EQ(LAUNCH_DATA_DICTIONARY, launch_data_get_type(launch_data)); - EXPECT_EQ(4u, launch_data_dict_get_count(launch_data)); + ASSERT_EQ(LAUNCH_DATA_DICTIONARY, LaunchDataGetType(launch_data)); + EXPECT_EQ(4u, LaunchDataDictGetCount(launch_data)); launch_data_t launch_lookup_data = - launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_LABEL); + LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_LABEL); ASSERT_TRUE(launch_lookup_data); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data)); EXPECT_STREQ("com.example.job.rebooter", - launch_data_get_string(launch_lookup_data)); + LaunchDataGetString(launch_lookup_data)); launch_lookup_data = - launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_ONDEMAND); + LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_ONDEMAND); ASSERT_TRUE(launch_lookup_data); - ASSERT_EQ(LAUNCH_DATA_BOOL, launch_data_get_type(launch_lookup_data)); - EXPECT_TRUE(launch_data_get_bool(launch_lookup_data)); + ASSERT_EQ(LAUNCH_DATA_BOOL, LaunchDataGetType(launch_lookup_data)); + EXPECT_TRUE(LaunchDataGetBool(launch_lookup_data)); launch_lookup_data = - launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_PROGRAMARGUMENTS); + LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_PROGRAMARGUMENTS); ASSERT_TRUE(launch_lookup_data); - ASSERT_EQ(LAUNCH_DATA_ARRAY, launch_data_get_type(launch_lookup_data)); - EXPECT_EQ(3u, launch_data_array_get_count(launch_lookup_data)); + ASSERT_EQ(LAUNCH_DATA_ARRAY, LaunchDataGetType(launch_lookup_data)); + EXPECT_EQ(3u, LaunchDataArrayGetCount(launch_lookup_data)); launch_data_t launch_sublookup_data = - launch_data_array_get_index(launch_lookup_data, 0); + LaunchDataArrayGetIndex(launch_lookup_data, 0); ASSERT_TRUE(launch_sublookup_data); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_sublookup_data)); - EXPECT_STREQ("/bin/bash", launch_data_get_string(launch_sublookup_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_sublookup_data)); + EXPECT_STREQ("/bin/bash", LaunchDataGetString(launch_sublookup_data)); - launch_sublookup_data = launch_data_array_get_index(launch_lookup_data, 1); + launch_sublookup_data = LaunchDataArrayGetIndex(launch_lookup_data, 1); ASSERT_TRUE(launch_sublookup_data); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_sublookup_data)); - EXPECT_STREQ("-c", launch_data_get_string(launch_sublookup_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_sublookup_data)); + EXPECT_STREQ("-c", LaunchDataGetString(launch_sublookup_data)); - launch_sublookup_data = launch_data_array_get_index(launch_lookup_data, 2); + launch_sublookup_data = LaunchDataArrayGetIndex(launch_lookup_data, 2); ASSERT_TRUE(launch_sublookup_data); - ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_sublookup_data)); - EXPECT_STREQ("/sbin/reboot", launch_data_get_string(launch_sublookup_data)); + ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_sublookup_data)); + EXPECT_STREQ("/sbin/reboot", LaunchDataGetString(launch_sublookup_data)); launch_lookup_data = - launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_MACHSERVICES); + LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_MACHSERVICES); ASSERT_TRUE(launch_lookup_data); - ASSERT_EQ(LAUNCH_DATA_DICTIONARY, launch_data_get_type(launch_lookup_data)); - EXPECT_EQ(1u, launch_data_dict_get_count(launch_lookup_data)); + ASSERT_EQ(LAUNCH_DATA_DICTIONARY, LaunchDataGetType(launch_lookup_data)); + EXPECT_EQ(1u, LaunchDataDictGetCount(launch_lookup_data)); - launch_sublookup_data = launch_data_dict_lookup( + launch_sublookup_data = LaunchDataDictLookup( launch_lookup_data, "com.example.service.rebooter"); ASSERT_TRUE(launch_sublookup_data); - ASSERT_EQ(LAUNCH_DATA_BOOL, launch_data_get_type(launch_sublookup_data)); - EXPECT_TRUE(launch_data_get_bool(launch_sublookup_data)); + ASSERT_EQ(LAUNCH_DATA_BOOL, LaunchDataGetType(launch_sublookup_data)); + EXPECT_TRUE(LaunchDataGetBool(launch_sublookup_data)); } } diff --git a/util/mac/service_management.cc b/util/mac/service_management.cc index 32486be9..3474a96a 100644 --- a/util/mac/service_management.cc +++ b/util/mac/service_management.cc @@ -21,16 +21,17 @@ #include "util/mac/launchd.h" #include "util/misc/clock.h" +namespace crashpad { + namespace { launch_data_t LaunchDataDictionaryForJob(const std::string& label) { - base::mac::ScopedLaunchData request( - launch_data_alloc(LAUNCH_DATA_DICTIONARY)); - launch_data_dict_insert( - request, launch_data_new_string(label.c_str()), LAUNCH_KEY_GETJOB); + base::mac::ScopedLaunchData request(LaunchDataAlloc(LAUNCH_DATA_DICTIONARY)); + LaunchDataDictInsert( + request, LaunchDataNewString(label.c_str()), LAUNCH_KEY_GETJOB); base::mac::ScopedLaunchData response(launch_msg(request)); - if (launch_data_get_type(response) != LAUNCH_DATA_DICTIONARY) { + if (LaunchDataGetType(response) != LAUNCH_DATA_DICTIONARY) { return nullptr; } @@ -39,37 +40,34 @@ launch_data_t LaunchDataDictionaryForJob(const std::string& label) { } // namespace -namespace crashpad { - bool ServiceManagementSubmitJob(CFDictionaryRef job_cf) { base::mac::ScopedLaunchData job_launch(CFPropertyToLaunchData(job_cf)); if (!job_launch.get()) { return false; } - base::mac::ScopedLaunchData jobs(launch_data_alloc(LAUNCH_DATA_ARRAY)); - launch_data_array_set_index(jobs, job_launch.release(), 0); + base::mac::ScopedLaunchData jobs(LaunchDataAlloc(LAUNCH_DATA_ARRAY)); + LaunchDataArraySetIndex(jobs, job_launch.release(), 0); - base::mac::ScopedLaunchData request( - launch_data_alloc(LAUNCH_DATA_DICTIONARY)); - launch_data_dict_insert(request, jobs.release(), LAUNCH_KEY_SUBMITJOB); + base::mac::ScopedLaunchData request(LaunchDataAlloc(LAUNCH_DATA_DICTIONARY)); + LaunchDataDictInsert(request, jobs.release(), LAUNCH_KEY_SUBMITJOB); base::mac::ScopedLaunchData response(launch_msg(request)); - if (launch_data_get_type(response) != LAUNCH_DATA_ARRAY) { + if (LaunchDataGetType(response) != LAUNCH_DATA_ARRAY) { return false; } - if (launch_data_array_get_count(response) != 1) { + if (LaunchDataArrayGetCount(response) != 1) { return false; } - launch_data_t response_element = launch_data_array_get_index(response, 0); - if (launch_data_get_type(response_element) != LAUNCH_DATA_ERRNO) { + launch_data_t response_element = LaunchDataArrayGetIndex(response, 0); + if (LaunchDataGetType(response_element) != LAUNCH_DATA_ERRNO) { return false; } - int err = launch_data_get_errno(response_element); + int err = LaunchDataGetErrno(response_element); if (err != 0) { return false; } @@ -78,17 +76,16 @@ bool ServiceManagementSubmitJob(CFDictionaryRef job_cf) { } bool ServiceManagementRemoveJob(const std::string& label, bool wait) { - base::mac::ScopedLaunchData request( - launch_data_alloc(LAUNCH_DATA_DICTIONARY)); - launch_data_dict_insert( - request, launch_data_new_string(label.c_str()), LAUNCH_KEY_REMOVEJOB); + base::mac::ScopedLaunchData request(LaunchDataAlloc(LAUNCH_DATA_DICTIONARY)); + LaunchDataDictInsert( + request, LaunchDataNewString(label.c_str()), LAUNCH_KEY_REMOVEJOB); base::mac::ScopedLaunchData response(launch_msg(request)); - if (launch_data_get_type(response) != LAUNCH_DATA_ERRNO) { + if (LaunchDataGetType(response) != LAUNCH_DATA_ERRNO) { return false; } - int err = launch_data_get_errno(response); + int err = LaunchDataGetErrno(response); if (err == EINPROGRESS) { if (wait) { // TODO(mark): Use a kqueue to wait for the process to exit. To avoid a @@ -125,12 +122,12 @@ pid_t ServiceManagementIsJobRunning(const std::string& label) { return 0; } - launch_data_t pid = launch_data_dict_lookup(dictionary, LAUNCH_JOBKEY_PID); + launch_data_t pid = LaunchDataDictLookup(dictionary, LAUNCH_JOBKEY_PID); if (!pid) { return 0; } - if (launch_data_get_type(pid) != LAUNCH_DATA_INTEGER) { + if (LaunchDataGetType(pid) != LAUNCH_DATA_INTEGER) { return 0; }