diff --git a/AltStore.xcodeproj/project.pbxproj b/AltStore.xcodeproj/project.pbxproj index 97a9be96..846ed0aa 100644 --- a/AltStore.xcodeproj/project.pbxproj +++ b/AltStore.xcodeproj/project.pbxproj @@ -8,6 +8,7 @@ /* Begin PBXBuildFile section */ 03F06CD52942C27E001C4D68 /* Bundle+AltStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF1E314122A05D4C00370A3C /* Bundle+AltStore.swift */; }; + 0E1A1F912AE36A9700364CAD /* bytearray.c in Sources */ = {isa = PBXBuildFile; fileRef = 0E1A1F902AE36A9600364CAD /* bytearray.c */; }; 0E764E172ADFF5740043DD4E /* AltBackup.ipa in Resources */ = {isa = PBXBuildFile; fileRef = 0E764E162ADFF5740043DD4E /* AltBackup.ipa */; }; 0EA1665B2ADFE0D2003015C1 /* out-limd.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166472ADFE0D1003015C1 /* out-limd.c */; }; 0EA1665C2ADFE0D2003015C1 /* out-default.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166522ADFE0D2003015C1 /* out-default.c */; }; @@ -23,7 +24,6 @@ 0EA1666F2ADFE140003015C1 /* hashtable.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA1664F2ADFE0D1003015C1 /* hashtable.c */; }; 0EA166702ADFE140003015C1 /* Node.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166502ADFE0D2003015C1 /* Node.cpp */; }; 0EA166712ADFE140003015C1 /* Key.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166582ADFE0D2003015C1 /* Key.cpp */; }; - 0EA166722ADFE140003015C1 /* bytearray.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA1664D2ADFE0D1003015C1 /* bytearray.c */; }; 0EA166732ADFE140003015C1 /* Dictionary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166462ADFE0D1003015C1 /* Dictionary.cpp */; }; 0EA166742ADFE140003015C1 /* Date.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166422ADFE0D1003015C1 /* Date.cpp */; }; 0EA166752ADFE140003015C1 /* Real.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166542ADFE0D2003015C1 /* Real.cpp */; }; @@ -33,9 +33,9 @@ 0EA166792ADFE140003015C1 /* bplist.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166442ADFE0D1003015C1 /* bplist.c */; }; 0EA1667A2ADFE140003015C1 /* Uid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EA1664B2ADFE0D1003015C1 /* Uid.cpp */; }; 0EA1667B2ADFE140003015C1 /* Structure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EA1665A2ADFE0D2003015C1 /* Structure.cpp */; }; - 0EA1667C2ADFE140003015C1 /* plist.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166482ADFE0D1003015C1 /* plist.c */; }; 0EA1667D2ADFE140003015C1 /* xplist.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA166592ADFE0D2003015C1 /* xplist.c */; }; 0EA1667E2ADFE140003015C1 /* time64.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA1664C2ADFE0D1003015C1 /* time64.c */; }; + 0EA4B9BC2AE4A414009209CE /* plist.c in Sources */ = {isa = PBXBuildFile; fileRef = 0EA4B9BB2AE4A3F6009209CE /* plist.c */; }; 19104D952909BAEA00C49C7B /* libimobiledevice.a in Frameworks */ = {isa = PBXBuildFile; fileRef = BF45872B2298D31600BD7491 /* libimobiledevice.a */; }; 19104DB52909C06D00C49C7B /* EmotionalDamage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 19104DB42909C06D00C49C7B /* EmotionalDamage.swift */; }; 19104DBC2909C4E500C49C7B /* libEmotionalDamage.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 19104DB22909C06C00C49C7B /* libEmotionalDamage.a */; }; @@ -498,42 +498,42 @@ /* End PBXCopyFilesBuildPhase section */ /* Begin PBXFileReference section */ + 0E1A1F902AE36A9600364CAD /* bytearray.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = bytearray.c; path = src/bytearray.c; sourceTree = ""; }; 0E764E162ADFF5740043DD4E /* AltBackup.ipa */ = {isa = PBXFileReference; lastKnownFileType = file; name = AltBackup.ipa; path = AltStore/Resources/AltBackup.ipa; sourceTree = SOURCE_ROOT; }; - 0EA166412ADFE0D1003015C1 /* jplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = jplist.c; path = Dependencies/libplist/jplist.c; sourceTree = SOURCE_ROOT; }; - 0EA166422ADFE0D1003015C1 /* Date.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Date.cpp; path = Dependencies/libplist/Date.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166432ADFE0D1003015C1 /* Data.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Data.cpp; path = Dependencies/libplist/Data.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166442ADFE0D1003015C1 /* bplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = bplist.c; path = Dependencies/libplist/bplist.c; sourceTree = SOURCE_ROOT; }; - 0EA166452ADFE0D1003015C1 /* Array.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Array.cpp; path = Dependencies/libplist/Array.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166462ADFE0D1003015C1 /* Dictionary.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Dictionary.cpp; path = Dependencies/libplist/Dictionary.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166472ADFE0D1003015C1 /* out-limd.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = "out-limd.c"; path = "Dependencies/libplist/out-limd.c"; sourceTree = SOURCE_ROOT; }; - 0EA166482ADFE0D1003015C1 /* plist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = plist.c; path = Dependencies/libplist/plist.c; sourceTree = SOURCE_ROOT; }; - 0EA166492ADFE0D1003015C1 /* String.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = String.cpp; path = Dependencies/libplist/String.cpp; sourceTree = SOURCE_ROOT; }; - 0EA1664A2ADFE0D1003015C1 /* base64.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = base64.c; path = Dependencies/libplist/base64.c; sourceTree = SOURCE_ROOT; }; - 0EA1664B2ADFE0D1003015C1 /* Uid.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Uid.cpp; path = Dependencies/libplist/Uid.cpp; sourceTree = SOURCE_ROOT; }; - 0EA1664C2ADFE0D1003015C1 /* time64.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = time64.c; path = Dependencies/libplist/time64.c; sourceTree = SOURCE_ROOT; }; - 0EA1664D2ADFE0D1003015C1 /* bytearray.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = bytearray.c; path = Dependencies/libplist/bytearray.c; sourceTree = SOURCE_ROOT; }; - 0EA1664E2ADFE0D1003015C1 /* Boolean.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Boolean.cpp; path = Dependencies/libplist/Boolean.cpp; sourceTree = SOURCE_ROOT; }; - 0EA1664F2ADFE0D1003015C1 /* hashtable.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = hashtable.c; path = Dependencies/libplist/hashtable.c; sourceTree = SOURCE_ROOT; }; - 0EA166502ADFE0D2003015C1 /* Node.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Node.cpp; path = Dependencies/libplist/Node.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166512ADFE0D2003015C1 /* ptrarray.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = ptrarray.c; path = Dependencies/libplist/ptrarray.c; sourceTree = SOURCE_ROOT; }; - 0EA166522ADFE0D2003015C1 /* out-default.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = "out-default.c"; path = "Dependencies/libplist/out-default.c"; sourceTree = SOURCE_ROOT; }; - 0EA166532ADFE0D2003015C1 /* Integer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Integer.cpp; path = Dependencies/libplist/Integer.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166542ADFE0D2003015C1 /* Real.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Real.cpp; path = Dependencies/libplist/Real.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166552ADFE0D2003015C1 /* out-plutil.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = "out-plutil.c"; path = "Dependencies/libplist/out-plutil.c"; sourceTree = SOURCE_ROOT; }; - 0EA166562ADFE0D2003015C1 /* oplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = oplist.c; path = Dependencies/libplist/oplist.c; sourceTree = SOURCE_ROOT; }; - 0EA166572ADFE0D2003015C1 /* jsmn.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = jsmn.c; path = Dependencies/libplist/jsmn.c; sourceTree = SOURCE_ROOT; }; - 0EA166582ADFE0D2003015C1 /* Key.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Key.cpp; path = Dependencies/libplist/Key.cpp; sourceTree = SOURCE_ROOT; }; - 0EA166592ADFE0D2003015C1 /* xplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = xplist.c; path = Dependencies/libplist/xplist.c; sourceTree = SOURCE_ROOT; }; - 0EA1665A2ADFE0D2003015C1 /* Structure.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Structure.cpp; path = Dependencies/libplist/Structure.cpp; sourceTree = SOURCE_ROOT; }; - 0EA1665F2ADFE122003015C1 /* time64_limits.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = time64_limits.h; path = Dependencies/libplist/time64_limits.h; sourceTree = SOURCE_ROOT; }; - 0EA166602ADFE122003015C1 /* time64.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = time64.h; path = Dependencies/libplist/time64.h; sourceTree = SOURCE_ROOT; }; - 0EA166612ADFE122003015C1 /* bytearray.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = bytearray.h; path = Dependencies/libplist/bytearray.h; sourceTree = SOURCE_ROOT; }; - 0EA166622ADFE122003015C1 /* ptrarray.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ptrarray.h; path = Dependencies/libplist/ptrarray.h; sourceTree = SOURCE_ROOT; }; - 0EA166632ADFE122003015C1 /* jsmn.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = jsmn.h; path = Dependencies/libplist/jsmn.h; sourceTree = SOURCE_ROOT; }; - 0EA166642ADFE122003015C1 /* plist.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = plist.h; path = Dependencies/libplist/plist.h; sourceTree = SOURCE_ROOT; }; - 0EA166652ADFE122003015C1 /* hashtable.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = hashtable.h; path = Dependencies/libplist/hashtable.h; sourceTree = SOURCE_ROOT; }; - 0EA166662ADFE122003015C1 /* base64.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = base64.h; path = Dependencies/libplist/base64.h; sourceTree = SOURCE_ROOT; }; - 0EA166672ADFE122003015C1 /* strbuf.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = strbuf.h; path = Dependencies/libplist/strbuf.h; sourceTree = SOURCE_ROOT; }; + 0EA166412ADFE0D1003015C1 /* jplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = jplist.c; path = Dependencies/libplist/src/jplist.c; sourceTree = SOURCE_ROOT; }; + 0EA166422ADFE0D1003015C1 /* Date.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Date.cpp; path = Dependencies/libplist/src/Date.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166432ADFE0D1003015C1 /* Data.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Data.cpp; path = Dependencies/libplist/src/Data.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166442ADFE0D1003015C1 /* bplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = bplist.c; path = Dependencies/libplist/src/bplist.c; sourceTree = SOURCE_ROOT; }; + 0EA166452ADFE0D1003015C1 /* Array.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Array.cpp; path = Dependencies/libplist/src/Array.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166462ADFE0D1003015C1 /* Dictionary.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Dictionary.cpp; path = Dependencies/libplist/src/Dictionary.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166472ADFE0D1003015C1 /* out-limd.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = "out-limd.c"; path = "Dependencies/libplist/src/out-limd.c"; sourceTree = SOURCE_ROOT; }; + 0EA166492ADFE0D1003015C1 /* String.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = String.cpp; path = Dependencies/libplist/src/String.cpp; sourceTree = SOURCE_ROOT; }; + 0EA1664A2ADFE0D1003015C1 /* base64.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = base64.c; path = Dependencies/libplist/src/base64.c; sourceTree = SOURCE_ROOT; }; + 0EA1664B2ADFE0D1003015C1 /* Uid.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Uid.cpp; path = Dependencies/libplist/src/Uid.cpp; sourceTree = SOURCE_ROOT; }; + 0EA1664C2ADFE0D1003015C1 /* time64.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = time64.c; path = Dependencies/libplist/src/time64.c; sourceTree = SOURCE_ROOT; }; + 0EA1664E2ADFE0D1003015C1 /* Boolean.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Boolean.cpp; path = Dependencies/libplist/src/Boolean.cpp; sourceTree = SOURCE_ROOT; }; + 0EA1664F2ADFE0D1003015C1 /* hashtable.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = hashtable.c; path = Dependencies/libplist/src/hashtable.c; sourceTree = SOURCE_ROOT; }; + 0EA166502ADFE0D2003015C1 /* Node.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Node.cpp; path = Dependencies/libplist/src/Node.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166512ADFE0D2003015C1 /* ptrarray.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = ptrarray.c; path = Dependencies/libplist/src/ptrarray.c; sourceTree = SOURCE_ROOT; }; + 0EA166522ADFE0D2003015C1 /* out-default.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = "out-default.c"; path = "Dependencies/libplist/src/out-default.c"; sourceTree = SOURCE_ROOT; }; + 0EA166532ADFE0D2003015C1 /* Integer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Integer.cpp; path = Dependencies/libplist/src/Integer.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166542ADFE0D2003015C1 /* Real.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Real.cpp; path = Dependencies/libplist/src/Real.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166552ADFE0D2003015C1 /* out-plutil.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = "out-plutil.c"; path = "Dependencies/libplist/src/out-plutil.c"; sourceTree = SOURCE_ROOT; }; + 0EA166562ADFE0D2003015C1 /* oplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = oplist.c; path = Dependencies/libplist/src/oplist.c; sourceTree = SOURCE_ROOT; }; + 0EA166572ADFE0D2003015C1 /* jsmn.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = jsmn.c; path = Dependencies/libplist/src/jsmn.c; sourceTree = SOURCE_ROOT; }; + 0EA166582ADFE0D2003015C1 /* Key.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Key.cpp; path = Dependencies/libplist/src/Key.cpp; sourceTree = SOURCE_ROOT; }; + 0EA166592ADFE0D2003015C1 /* xplist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = xplist.c; path = Dependencies/libplist/src/xplist.c; sourceTree = SOURCE_ROOT; }; + 0EA1665A2ADFE0D2003015C1 /* Structure.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Structure.cpp; path = Dependencies/libplist/src/Structure.cpp; sourceTree = SOURCE_ROOT; }; + 0EA1665F2ADFE122003015C1 /* time64_limits.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = time64_limits.h; path = Dependencies/libplist/src/time64_limits.h; sourceTree = SOURCE_ROOT; }; + 0EA166602ADFE122003015C1 /* time64.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = time64.h; path = Dependencies/libplist/src/time64.h; sourceTree = SOURCE_ROOT; }; + 0EA166612ADFE122003015C1 /* bytearray.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = bytearray.h; path = Dependencies/libplist/src/bytearray.h; sourceTree = SOURCE_ROOT; }; + 0EA166622ADFE122003015C1 /* ptrarray.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ptrarray.h; path = Dependencies/libplist/src/ptrarray.h; sourceTree = SOURCE_ROOT; }; + 0EA166632ADFE122003015C1 /* jsmn.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = jsmn.h; path = Dependencies/libplist/src/jsmn.h; sourceTree = SOURCE_ROOT; }; + 0EA166642ADFE122003015C1 /* plist.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = plist.h; path = Dependencies/libplist/src/plist.h; sourceTree = SOURCE_ROOT; }; + 0EA166652ADFE122003015C1 /* hashtable.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = hashtable.h; path = Dependencies/libplist/src/hashtable.h; sourceTree = SOURCE_ROOT; }; + 0EA166662ADFE122003015C1 /* base64.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = base64.h; path = Dependencies/libplist/src/base64.h; sourceTree = SOURCE_ROOT; }; + 0EA166672ADFE122003015C1 /* strbuf.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = strbuf.h; path = Dependencies/libplist/src/strbuf.h; sourceTree = SOURCE_ROOT; }; + 0EA4B9BB2AE4A3F6009209CE /* plist.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = plist.c; path = Dependencies/Custom/libplist/src/plist.c; sourceTree = SOURCE_ROOT; }; 19104DB22909C06C00C49C7B /* libEmotionalDamage.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libEmotionalDamage.a; sourceTree = BUILT_PRODUCTS_DIR; }; 19104DB42909C06D00C49C7B /* EmotionalDamage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EmotionalDamage.swift; sourceTree = ""; }; 191E5FAB290A5D92001A3B7C /* libminimuxer.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libminimuxer.a; sourceTree = BUILT_PRODUCTS_DIR; }; @@ -1192,8 +1192,8 @@ isa = PBXGroup; children = ( 0EA166462ADFE0D1003015C1 /* Dictionary.cpp */, + 0E1A1F902AE36A9600364CAD /* bytearray.c */, 0EA166442ADFE0D1003015C1 /* bplist.c */, - 0EA1664D2ADFE0D1003015C1 /* bytearray.c */, 0EA166432ADFE0D1003015C1 /* Data.cpp */, 0EA166422ADFE0D1003015C1 /* Date.cpp */, 0EA1664F2ADFE0D1003015C1 /* hashtable.c */, @@ -1208,12 +1208,12 @@ 0EA1664A2ADFE0D1003015C1 /* base64.c */, 0EA166572ADFE0D2003015C1 /* jsmn.c */, 0EA1664E2ADFE0D1003015C1 /* Boolean.cpp */, + 0EA4B9BB2AE4A3F6009209CE /* plist.c */, 0EA166412ADFE0D1003015C1 /* jplist.c */, 0EA166582ADFE0D2003015C1 /* Key.cpp */, 0EA166512ADFE0D2003015C1 /* ptrarray.c */, 0EA1664C2ADFE0D1003015C1 /* time64.c */, 0EA166502ADFE0D2003015C1 /* Node.cpp */, - 0EA166482ADFE0D1003015C1 /* plist.c */, 0EA166542ADFE0D2003015C1 /* Real.cpp */, 0EA1664B2ADFE0D1003015C1 /* Uid.cpp */, 0EA166592ADFE0D2003015C1 /* xplist.c */, @@ -2288,10 +2288,10 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( + 0E1A1F912AE36A9700364CAD /* bytearray.c in Sources */, 0EA1666E2ADFE140003015C1 /* ptrarray.c in Sources */, 0EA1665B2ADFE0D2003015C1 /* out-limd.c in Sources */, 0EA166742ADFE140003015C1 /* Date.cpp in Sources */, - 0EA166722ADFE140003015C1 /* bytearray.c in Sources */, 0EA166712ADFE140003015C1 /* Key.cpp in Sources */, 0EA1665C2ADFE0D2003015C1 /* out-default.c in Sources */, 0EA1666A2ADFE140003015C1 /* String.cpp in Sources */, @@ -2305,7 +2305,6 @@ BF45881B2298D3AB00BD7491 /* house_arrest.c in Sources */, 0EA1666F2ADFE140003015C1 /* hashtable.c in Sources */, BF4588232298D3AB00BD7491 /* mobilesync.c in Sources */, - 0EA1667C2ADFE140003015C1 /* plist.c in Sources */, BF4588072298D3AB00BD7491 /* afc.c in Sources */, BF4588082298D3AB00BD7491 /* mobile_image_mounter.c in Sources */, BF4588022298D3AB00BD7491 /* file_relay.c in Sources */, @@ -2355,6 +2354,7 @@ BF4588262298D3AB00BD7491 /* lockdown.c in Sources */, BFD52C2222A1A9EC000B7ED1 /* cnary.c in Sources */, BF45880C2298D3AB00BD7491 /* mobilebackup2.c in Sources */, + 0EA4B9BC2AE4A414009209CE /* plist.c in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -2851,6 +2851,11 @@ PRODUCT_NAME = imobiledevice; SDKROOT = macosx; SKIP_INSTALL = YES; + SYSTEM_HEADER_SEARCH_PATHS = ( + "\"$(SRCROOT)/Dependencies/AltSign/Dependencies\"", + "\"$(SRCROOT)/Dependencies/libplist/include\"", + "\"$(SRCROOT)/Dependencies/libplist/libcnary/include\"", + ); }; name = Debug; }; @@ -2891,6 +2896,11 @@ PRODUCT_NAME = imobiledevice; SDKROOT = macosx; SKIP_INSTALL = YES; + SYSTEM_HEADER_SEARCH_PATHS = ( + "\"$(SRCROOT)/Dependencies/AltSign/Dependencies\"", + "\"$(SRCROOT)/Dependencies/libplist/include\"", + "\"$(SRCROOT)/Dependencies/libplist/libcnary/include\"", + ); }; name = Release; }; diff --git a/Dependencies/Custom/libplist/src/plist.c b/Dependencies/Custom/libplist/src/plist.c new file mode 100644 index 00000000..5af53853 --- /dev/null +++ b/Dependencies/Custom/libplist/src/plist.c @@ -0,0 +1,1729 @@ +/* + * plist.c + * Builds plist XML structures + * + * Copyright (c) 2009-2023 Nikias Bassen, All Rights Reserved. + * Copyright (c) 2010-2015 Martin Szulecki, All Rights Reserved. + * Copyright (c) 2008 Zach C., All Rights Reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE 1 +#include +#include "plist.h" +#include +#include +#include +#include +#include +#include +#include + +#ifdef WIN32 +#include +#else +#include +#endif + +#include +#include +#include "hashtable.h" +#include "ptrarray.h" + +#ifdef _MSC_VER +typedef SSIZE_T ssize_t; +#endif + +extern void plist_xml_init(void); +extern void plist_xml_deinit(void); +extern void plist_bin_init(void); +extern void plist_bin_deinit(void); +extern void plist_json_init(void); +extern void plist_json_deinit(void); +extern void plist_ostep_init(void); +extern void plist_ostep_deinit(void); + +static void internal_plist_init(void) +{ + plist_bin_init(); + plist_xml_init(); + plist_json_init(); + plist_ostep_init(); +} + +static void internal_plist_deinit(void) +{ + plist_bin_deinit(); + plist_xml_deinit(); + plist_json_deinit(); + plist_ostep_deinit(); +} + +#ifdef WIN32 +typedef volatile struct { + LONG lock; + int state; +} thread_once_t; + +static thread_once_t init_once = {0, 0}; +static thread_once_t deinit_once = {0, 0}; + +static void thread_once(thread_once_t *once_control, void (*init_routine)(void)) +{ + while (InterlockedExchange(&(once_control->lock), 1) != 0) { + Sleep(1); + } + if (!once_control->state) { + once_control->state = 1; + init_routine(); + } + InterlockedExchange(&(once_control->lock), 0); +} +#else +static pthread_once_t init_once = PTHREAD_ONCE_INIT; +static pthread_once_t deinit_once = PTHREAD_ONCE_INIT; +#define thread_once pthread_once +#endif + +#ifndef HAVE_ATTRIBUTE_CONSTRUCTOR +#if defined(__llvm__) || defined(__GNUC__) +#define HAVE_ATTRIBUTE_CONSTRUCTOR +#endif +#endif + +#ifdef HAVE_ATTRIBUTE_CONSTRUCTOR +static void __attribute__((constructor)) libplist_initialize(void) +{ + thread_once(&init_once, internal_plist_init); +} + +static void __attribute__((destructor)) libplist_deinitialize(void) +{ + thread_once(&deinit_once, internal_plist_deinit); +} +#elif defined(WIN32) +BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved) +{ + switch (dwReason) { + case DLL_PROCESS_ATTACH: + thread_once(&init_once, internal_plist_init); + break; + case DLL_PROCESS_DETACH: + thread_once(&deinit_once, internal_plist_deinit); + break; + default: + break; + } + return 1; +} +#else +#warning No compiler support for constructor/destructor attributes, some features might not be available. +#endif + +#ifndef HAVE_MEMMEM +// see https://sourceware.org/legacy-ml/libc-alpha/2007-12/msg00000.html + +#ifndef _LIBC +# define __builtin_expect(expr, val) (expr) +#endif + +#undef memmem + +/* Return the first occurrence of NEEDLE in HAYSTACK. */ +void* memmem(const void* haystack, size_t haystack_len, const void* needle, size_t needle_len) +{ + /* not really Rabin-Karp, just using additive hashing */ + char* haystack_ = (char*)haystack; + char* needle_ = (char*)needle; + int hash = 0; /* this is the static hash value of the needle */ + int hay_hash = 0; /* rolling hash over the haystack */ + char* last; + size_t i; + + if (haystack_len < needle_len) + return NULL; + + if (!needle_len) + return haystack_; + + /* initialize hashes */ + for (i = needle_len; i; --i) { + hash += *needle_++; + hay_hash += *haystack_++; + } + + /* iterate over the haystack */ + haystack_ = (char*)haystack; + needle_ = (char*)needle; + last = haystack_+(haystack_len - needle_len + 1); + for (; haystack_ < last; ++haystack_) { + if (__builtin_expect(hash == hay_hash, 0) + && *haystack_ == *needle_ /* prevent calling memcmp, was a optimization from existing glibc */ + && !memcmp (haystack_, needle_, needle_len)) { + return haystack_; + } + /* roll the hash */ + hay_hash -= *haystack_; + hay_hash += *(haystack_+needle_len); + } + return NULL; +} +#endif + +int plist_is_binary(const char *plist_data, uint32_t length) +{ + if (length < 8) { + return 0; + } + + return (memcmp(plist_data, "bplist00", 8) == 0); +} + +#define SKIP_WS(blob, pos, len) \ +while (pos < len && ((blob[pos] == ' ') || (blob[pos] == '\t') || (blob[pos] == '\r') || (blob[pos] == '\n'))) pos++; +#define FIND_NEXT(blob, pos, len, chr) \ +while (pos < len && (blob[pos] != chr)) pos++; + +plist_err_t plist_from_memory(const char *plist_data, uint32_t length, plist_t *plist, plist_format_t *format) +{ + plist_err_t res = PLIST_ERR_UNKNOWN; + if (!plist) { + return PLIST_ERR_INVALID_ARG; + } + *plist = NULL; + if (!plist_data || length == 0) { + return PLIST_ERR_INVALID_ARG; + } + plist_format_t fmt = PLIST_FORMAT_NONE; + if (format) *format = PLIST_FORMAT_NONE; + if (plist_is_binary(plist_data, length)) { + res = plist_from_bin(plist_data, length, plist); + fmt = PLIST_FORMAT_BINARY; + } else { + uint32_t pos = 0; + int is_json = 0; + int is_xml = 0; + /* skip whitespace */ + SKIP_WS(plist_data, pos, length); + if (plist_data[pos] == '<' && (length-pos > 3) && !isxdigit(plist_data[pos+1]) && !isxdigit(plist_data[pos+2]) && !isxdigit(plist_data[pos+3])) { + is_xml = 1; + } else if (plist_data[pos] == '[') { + /* only valid for json */ + is_json = 1; + } else if (plist_data[pos] == '(') { + /* only valid for openstep */ + } else if (plist_data[pos] == '{') { + /* this could be json or openstep */ + pos++; + SKIP_WS(plist_data, pos, length); + if (plist_data[pos] == '"') { + /* still could be both */ + pos++; + do { + FIND_NEXT(plist_data, pos, length, '"'); + if (plist_data[pos-1] != '\\') { + break; + } + pos++; + } while (pos < length); + if (plist_data[pos] == '"') { + pos++; + SKIP_WS(plist_data, pos, length); + if (plist_data[pos] == ':') { + /* this is definitely json */ + is_json = 1; + } + } + } + } + if (is_xml) { + res = plist_from_xml(plist_data, length, plist); + fmt = PLIST_FORMAT_XML; + } else if (is_json) { + res = plist_from_json(plist_data, length, plist); + fmt = PLIST_FORMAT_JSON; + } else { + res = plist_from_openstep(plist_data, length, plist); + fmt = PLIST_FORMAT_OSTEP; + } + } + if (format && res == PLIST_ERR_SUCCESS) { + *format = fmt; + } + return res; +} + +plist_err_t plist_read_from_file(const char *filename, plist_t *plist, plist_format_t *format) +{ + if (!filename || !plist) { + return PLIST_ERR_INVALID_ARG; + } + FILE *f = fopen(filename, "rb"); + if (!f) { + return PLIST_ERR_IO; + } + struct stat fst; + fstat(fileno(f), &fst); + if ((uint64_t)fst.st_size > UINT32_MAX) { + return PLIST_ERR_NO_MEM; + } + uint32_t total = (uint32_t)fst.st_size; + if (total == 0) { + return PLIST_ERR_PARSE; + } + char *buf = (char*)malloc(total); + if (!buf) { + fclose(f); + return PLIST_ERR_NO_MEM; + } + uint32_t done = 0; + while (done < total) { + ssize_t r = fread(buf + done, 1, total - done, f); + if (r <= 0) { + break; + } + done += r; + } + fclose(f); + if (done < total) { + free(buf); + return PLIST_ERR_IO; + } + plist_err_t res = plist_from_memory(buf, total, plist, format); + free(buf); + return res; +} + +plist_t plist_new_node(plist_data_t data) +{ + return (plist_t) node_create(NULL, data); +} + +plist_data_t plist_get_data(plist_t node) +{ + if (!node) + return NULL; + return (plist_data_t)((node_t)node)->data; +} + +plist_data_t plist_new_plist_data(void) +{ + plist_data_t data = (plist_data_t) calloc(sizeof(struct plist_data_s), 1); + return data; +} + +static unsigned int dict_key_hash(const void *data) +{ + plist_data_t keydata = (plist_data_t)data; + unsigned int hash = 5381; + size_t i; + char *str = keydata->strval; + for (i = 0; i < keydata->length; str++, i++) { + hash = ((hash << 5) + hash) + *str; + } + return hash; +} + +static int dict_key_compare(const void* a, const void* b) +{ + plist_data_t data_a = (plist_data_t)a; + plist_data_t data_b = (plist_data_t)b; + if (data_a->strval == NULL || data_b->strval == NULL) { + return FALSE; + } + if (data_a->length != data_b->length) { + return FALSE; + } + return (strcmp(data_a->strval, data_b->strval) == 0) ? TRUE : FALSE; +} + +void plist_free_data(plist_data_t data) +{ + if (data) + { + switch (data->type) + { + case PLIST_KEY: + case PLIST_STRING: + free(data->strval); + break; + case PLIST_DATA: + free(data->buff); + break; + case PLIST_ARRAY: + ptr_array_free((ptrarray_t*)data->hashtable); + break; + case PLIST_DICT: + hash_table_destroy((hashtable_t*)data->hashtable); + break; + default: + break; + } + free(data); + } +} + +static int plist_free_node(node_t node) +{ + plist_data_t data = NULL; + int node_index = node_detach(node->parent, node); + data = plist_get_data(node); + plist_free_data(data); + node->data = NULL; + + node_t ch; + for (ch = node_first_child(node); ch; ) { + node_t next = node_next_sibling(ch); + plist_free_node(ch); + ch = next; + } + + node_destroy(node); + + return node_index; +} + +plist_t plist_new_dict(void) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_DICT; + return plist_new_node(data); +} + +plist_t plist_new_array(void) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_ARRAY; + return plist_new_node(data); +} + +//These nodes should not be handled by users +static plist_t plist_new_key(const char *val) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_KEY; + data->strval = strdup(val); + data->length = strlen(val); + return plist_new_node(data); +} + +plist_t plist_new_string(const char *val) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_STRING; + data->strval = strdup(val); + data->length = strlen(val); + return plist_new_node(data); +} + +plist_t plist_new_bool(uint8_t val) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_BOOLEAN; + data->boolval = val; + data->length = sizeof(uint8_t); + return plist_new_node(data); +} + +plist_t plist_new_uint(uint64_t val) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_INT; + data->intval = val; + data->length = (val > INT_MAX) ? sizeof(uint64_t)*2 : sizeof(uint64_t); + return plist_new_node(data); +} + +plist_t plist_new_int(int64_t val) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_INT; + data->intval = val; + data->length = sizeof(uint64_t); + return plist_new_node(data); +} + +plist_t plist_new_uid(uint64_t val) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_UID; + data->intval = val; + data->length = sizeof(uint64_t); + return plist_new_node(data); +} + +plist_t plist_new_real(double val) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_REAL; + data->realval = val; + data->length = sizeof(double); + return plist_new_node(data); +} + +plist_t plist_new_data(const char *val, uint64_t length) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_DATA; + data->buff = (uint8_t *) malloc(length); + memcpy(data->buff, val, length); + data->length = length; + return plist_new_node(data); +} + +plist_t plist_new_date(int32_t sec, int32_t usec) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_DATE; + data->realval = (double)sec + (double)usec / 1000000; + data->length = sizeof(double); + return plist_new_node(data); +} + +plist_t plist_new_null(void) +{ + plist_data_t data = plist_new_plist_data(); + data->type = PLIST_NULL; + data->intval = 0; + data->length = 0; + return plist_new_node(data); +} + +void plist_free(plist_t plist) +{ + if (plist) + { + plist_free_node((node_t)plist); + } +} + +void plist_mem_free(void* ptr) +{ + if (ptr) + { + free(ptr); + } +} + +static plist_t plist_copy_node(node_t node) +{ + plist_type node_type = PLIST_NONE; + plist_t newnode = NULL; + plist_data_t data = plist_get_data(node); + plist_data_t newdata = plist_new_plist_data(); + + assert(data); // plist should always have data + assert(newdata); + + memcpy(newdata, data, sizeof(struct plist_data_s)); + + node_type = plist_get_node_type(node); + switch (node_type) { + case PLIST_DATA: + newdata->buff = (uint8_t *) malloc(data->length); + memcpy(newdata->buff, data->buff, data->length); + break; + case PLIST_KEY: + case PLIST_STRING: + newdata->strval = strdup(data->strval); + break; + case PLIST_ARRAY: + if (data->hashtable) { + ptrarray_t* pa = ptr_array_new(((ptrarray_t*)data->hashtable)->capacity); + assert(pa); + newdata->hashtable = pa; + } + break; + case PLIST_DICT: + if (data->hashtable) { + hashtable_t* ht = hash_table_new(dict_key_hash, dict_key_compare, NULL); + assert(ht); + newdata->hashtable = ht; + } + break; + default: + break; + } + newnode = plist_new_node(newdata); + + node_t ch; + unsigned int node_index = 0; + for (ch = node_first_child(node); ch; ch = node_next_sibling(ch)) { + /* copy child node */ + plist_t newch = plist_copy_node(ch); + /* attach to new parent node */ + node_attach((node_t)newnode, (node_t)newch); + /* if needed, add child node to lookup table of parent node */ + switch (node_type) { + case PLIST_ARRAY: + if (newdata->hashtable) { + ptr_array_add((ptrarray_t*)newdata->hashtable, newch); + } + break; + case PLIST_DICT: + if (newdata->hashtable && (node_index % 2 != 0)) { + hash_table_insert((hashtable_t*)newdata->hashtable, (node_prev_sibling((node_t)newch))->data, newch); + } + break; + default: + break; + } + node_index++; + } + return newnode; +} + +plist_t plist_copy(plist_t node) +{ + return node ? plist_copy_node((node_t)node) : NULL; +} + +uint32_t plist_array_get_size(plist_t node) +{ + uint32_t ret = 0; + if (node && PLIST_ARRAY == plist_get_node_type(node)) + { + ret = node_n_children((node_t)node); + } + return ret; +} + +plist_t plist_array_get_item(plist_t node, uint32_t n) +{ + plist_t ret = NULL; + if (node && PLIST_ARRAY == plist_get_node_type(node) && n < INT_MAX) + { + ptrarray_t *pa = (ptrarray_t*)((plist_data_t)((node_t)node)->data)->hashtable; + if (pa) { + ret = (plist_t)ptr_array_index(pa, n); + } else { + ret = (plist_t)node_nth_child((node_t)node, n); + } + } + return ret; +} + +uint32_t plist_array_get_item_index(plist_t node) +{ + plist_t father = plist_get_parent(node); + if (PLIST_ARRAY == plist_get_node_type(father)) + { + return node_child_position((node_t)father, (node_t)node); + } + return UINT_MAX; +} + +static void _plist_array_post_insert(plist_t node, plist_t item, long n) +{ + ptrarray_t *pa = (ptrarray_t*)((plist_data_t)((node_t)node)->data)->hashtable; + if (pa) { + /* store pointer to item in array */ + ptr_array_insert(pa, item, n); + } else { + if (((node_t)node)->count > 100) { + /* make new lookup array */ + pa = ptr_array_new(128); + plist_t current = NULL; + for (current = (plist_t)node_first_child((node_t)node); + pa && current; + current = (plist_t)node_next_sibling((node_t)current)) + { + ptr_array_add(pa, current); + } + ((plist_data_t)((node_t)node)->data)->hashtable = pa; + } + } +} + +void plist_array_set_item(plist_t node, plist_t item, uint32_t n) +{ + if (!item) { + return; + } + if (node && PLIST_ARRAY == plist_get_node_type(node) && n < INT_MAX) + { + plist_t old_item = plist_array_get_item(node, n); + if (old_item) + { + int idx = plist_free_node((node_t)old_item); + assert(idx >= 0); + if (idx < 0) { + return; + } + node_insert((node_t)node, idx, (node_t)item); + ptrarray_t* pa = (ptrarray_t*)((plist_data_t)((node_t)node)->data)->hashtable; + if (pa) { + ptr_array_set(pa, item, idx); + } + } + } +} + +void plist_array_append_item(plist_t node, plist_t item) +{ + if (!item) { + return; + } + if (node && PLIST_ARRAY == plist_get_node_type(node)) + { + node_attach((node_t)node, (node_t)item); + _plist_array_post_insert(node, item, -1); + } +} + +void plist_array_insert_item(plist_t node, plist_t item, uint32_t n) +{ + if (!item) { + return; + } + if (node && PLIST_ARRAY == plist_get_node_type(node) && n < INT_MAX) + { + node_insert((node_t)node, n, (node_t)item); + _plist_array_post_insert(node, item, (long)n); + } +} + +void plist_array_remove_item(plist_t node, uint32_t n) +{ + if (node && PLIST_ARRAY == plist_get_node_type(node) && n < INT_MAX) + { + plist_t old_item = plist_array_get_item(node, n); + if (old_item) + { + ptrarray_t* pa = (ptrarray_t*)((plist_data_t)((node_t)node)->data)->hashtable; + if (pa) { + ptr_array_remove(pa, n); + } + plist_free(old_item); + } + } +} + +void plist_array_item_remove(plist_t node) +{ + plist_t father = plist_get_parent(node); + if (PLIST_ARRAY == plist_get_node_type(father)) + { + int n = node_child_position((node_t)father, (node_t)node); + if (n < 0) return; + ptrarray_t* pa = (ptrarray_t*)((plist_data_t)((node_t)father)->data)->hashtable; + if (pa) { + ptr_array_remove(pa, n); + } + plist_free(node); + } +} + +void plist_array_new_iter(plist_t node, plist_array_iter *iter) +{ + if (iter) + { + *iter = malloc(sizeof(node_t)); + *((node_t*)(*iter)) = node_first_child((node_t)node); + } +} + +void plist_array_next_item(plist_t node, plist_array_iter iter, plist_t *item) +{ + node_t* iter_node = (node_t*)iter; + + if (item) + { + *item = NULL; + } + + if (node && PLIST_ARRAY == plist_get_node_type(node) && *iter_node) + { + if (item) + { + *item = (plist_t)(*iter_node); + } + *iter_node = node_next_sibling(*iter_node); + } +} + +uint32_t plist_dict_get_size(plist_t node) +{ + uint32_t ret = 0; + if (node && PLIST_DICT == plist_get_node_type(node)) + { + ret = node_n_children((node_t)node) / 2; + } + return ret; +} + +void plist_dict_new_iter(plist_t node, plist_dict_iter *iter) +{ + if (iter) + { + *iter = malloc(sizeof(node_t)); + *((node_t*)(*iter)) = node_first_child((node_t)node); + } +} + +void plist_dict_next_item(plist_t node, plist_dict_iter iter, char **key, plist_t *val) +{ + node_t* iter_node = (node_t*)iter; + + if (key) + { + *key = NULL; + } + if (val) + { + *val = NULL; + } + + if (node && PLIST_DICT == plist_get_node_type(node) && *iter_node) + { + if (key) + { + plist_get_key_val((plist_t)(*iter_node), key); + } + *iter_node = node_next_sibling(*iter_node); + if (val) + { + *val = (plist_t)(*iter_node); + } + *iter_node = node_next_sibling(*iter_node); + } +} + +void plist_dict_get_item_key(plist_t node, char **key) +{ + plist_t father = plist_get_parent(node); + if (PLIST_DICT == plist_get_node_type(father)) + { + plist_get_key_val( (plist_t) node_prev_sibling((node_t)node), key); + } +} + +plist_t plist_dict_item_get_key(plist_t node) +{ + plist_t ret = NULL; + plist_t father = plist_get_parent(node); + if (PLIST_DICT == plist_get_node_type(father)) + { + ret = (plist_t)node_prev_sibling((node_t)node); + } + return ret; +} + +plist_t plist_dict_get_item(plist_t node, const char* key) +{ + plist_t ret = NULL; + + if (node && PLIST_DICT == plist_get_node_type(node)) + { + plist_data_t data = plist_get_data(node); + hashtable_t *ht = (hashtable_t*)data->hashtable; + if (ht) { + struct plist_data_s sdata; + sdata.strval = (char*)key; + sdata.length = strlen(key); + ret = (plist_t)hash_table_lookup(ht, &sdata); + } else { + plist_t current = NULL; + for (current = (plist_t)node_first_child((node_t)node); + current; + current = (plist_t)node_next_sibling(node_next_sibling((node_t)current))) + { + data = plist_get_data(current); + assert( PLIST_KEY == plist_get_node_type(current) ); + + if (data && !strcmp(key, data->strval)) + { + ret = (plist_t)node_next_sibling((node_t)current); + break; + } + } + } + } + return ret; +} + +void plist_dict_set_item(plist_t node, const char* key, plist_t item) +{ + if (!item) { + return; + } + if (node && PLIST_DICT == plist_get_node_type(node)) { + plist_t old_item = plist_dict_get_item(node, key); + plist_t key_node = NULL; + if (old_item) { + int idx = plist_free_node((node_t)old_item); + assert(idx >= 0); + if (idx < 0) { + return; + } + node_insert((node_t)node, idx, (node_t)item); + key_node = node_prev_sibling((node_t)item); + } else { + key_node = plist_new_key(key); + node_attach((node_t)node, (node_t)key_node); + node_attach((node_t)node, (node_t)item); + } + + hashtable_t *ht = (hashtable_t*)((plist_data_t)((node_t)node)->data)->hashtable; + if (ht) { + /* store pointer to item in hash table */ + hash_table_insert(ht, (plist_data_t)((node_t)key_node)->data, item); + } else { + if (((node_t)node)->count > 500) { + /* make new hash table */ + ht = hash_table_new(dict_key_hash, dict_key_compare, NULL); + /* calculate the hashes for all entries we have so far */ + plist_t current = NULL; + for (current = (plist_t)node_first_child((node_t)node); + ht && current; + current = (plist_t)node_next_sibling(node_next_sibling((node_t)current))) + { + hash_table_insert(ht, ((node_t)current)->data, node_next_sibling((node_t)current)); + } + ((plist_data_t)((node_t)node)->data)->hashtable = ht; + } + } + } +} + +void plist_dict_remove_item(plist_t node, const char* key) +{ + if (node && PLIST_DICT == plist_get_node_type(node)) + { + plist_t old_item = plist_dict_get_item(node, key); + if (old_item) + { + plist_t key_node = node_prev_sibling((node_t)old_item); + hashtable_t* ht = (hashtable_t*)((plist_data_t)((node_t)node)->data)->hashtable; + if (ht) { + hash_table_remove(ht, ((node_t)key_node)->data); + } + plist_free(key_node); + plist_free(old_item); + } + } +} + +void plist_dict_merge(plist_t *target, plist_t source) +{ + if (!target || !*target || (plist_get_node_type(*target) != PLIST_DICT) || !source || (plist_get_node_type(source) != PLIST_DICT)) + return; + + char* key = NULL; + plist_dict_iter it = NULL; + plist_t subnode = NULL; + plist_dict_new_iter(source, &it); + if (!it) + return; + + do { + plist_dict_next_item(source, it, &key, &subnode); + if (!key) + break; + + plist_dict_set_item(*target, key, plist_copy(subnode)); + free(key); + key = NULL; + } while (1); + free(it); +} + +plist_t plist_access_pathv(plist_t plist, uint32_t length, va_list v) +{ + plist_t current = plist; + plist_type type = PLIST_NONE; + uint32_t i = 0; + + for (i = 0; i < length && current; i++) + { + type = plist_get_node_type(current); + + if (type == PLIST_ARRAY) + { + uint32_t n = va_arg(v, uint32_t); + current = plist_array_get_item(current, n); + } + else if (type == PLIST_DICT) + { + const char* key = va_arg(v, const char*); + current = plist_dict_get_item(current, key); + } + } + return current; +} + +plist_t plist_access_path(plist_t plist, uint32_t length, ...) +{ + plist_t ret = NULL; + va_list v; + + va_start(v, length); + ret = plist_access_pathv(plist, length, v); + va_end(v); + return ret; +} + +static void plist_get_type_and_value(plist_t node, plist_type * type, void *value, uint64_t * length) +{ + plist_data_t data = NULL; + + if (!node) + return; + + data = plist_get_data(node); + + *type = data->type; + *length = data->length; + + switch (*type) + { + case PLIST_BOOLEAN: + *((char *) value) = data->boolval; + break; + case PLIST_INT: + case PLIST_UID: + *((uint64_t *) value) = data->intval; + break; + case PLIST_REAL: + case PLIST_DATE: + *((double *) value) = data->realval; + break; + case PLIST_KEY: + case PLIST_STRING: + *((char **) value) = strdup(data->strval); + break; + case PLIST_DATA: + *((uint8_t **) value) = (uint8_t *) malloc(*length * sizeof(uint8_t)); + memcpy(*((uint8_t **) value), data->buff, *length * sizeof(uint8_t)); + break; + case PLIST_ARRAY: + case PLIST_DICT: + default: + break; + } +} + +plist_t plist_get_parent(plist_t node) +{ + return node ? (plist_t) ((node_t) node)->parent : NULL; +} + +plist_type plist_get_node_type(plist_t node) +{ + if (node) + { + plist_data_t data = plist_get_data(node); + if (data) + return data->type; + } + return PLIST_NONE; +} + +void plist_get_key_val(plist_t node, char **val) +{ + if (!node || !val) + return; + plist_type type = plist_get_node_type(node); + uint64_t length = 0; + if (PLIST_KEY != type) + return; + plist_get_type_and_value(node, &type, (void *) val, &length); + if (!*val) + return; + assert(length == strlen(*val)); +} + +void plist_get_string_val(plist_t node, char **val) +{ + if (!node || !val) + return; + plist_type type = plist_get_node_type(node); + uint64_t length = 0; + if (PLIST_STRING != type) + return; + plist_get_type_and_value(node, &type, (void *) val, &length); + if (!*val) + return; + assert(length == strlen(*val)); +} + +const char* plist_get_string_ptr(plist_t node, uint64_t* length) +{ + if (!node) + return NULL; + plist_type type = plist_get_node_type(node); + if (PLIST_STRING != type) + return NULL; + plist_data_t data = plist_get_data(node); + if (length) + *length = data->length; + return (const char*)data->strval; +} + +void plist_get_bool_val(plist_t node, uint8_t * val) +{ + if (!node || !val) + return; + plist_type type = plist_get_node_type(node); + uint64_t length = 0; + if (PLIST_BOOLEAN != type) + return; + plist_get_type_and_value(node, &type, (void *) val, &length); + assert(length == sizeof(uint8_t)); +} + +void plist_get_uint_val(plist_t node, uint64_t * val) +{ + if (!node || !val) + return; + plist_type type = plist_get_node_type(node); + uint64_t length = 0; + if (PLIST_INT != type) + return; + plist_get_type_and_value(node, &type, (void *) val, &length); + assert(length == sizeof(uint64_t) || length == 16); +} + +void plist_get_int_val(plist_t node, int64_t * val) +{ + plist_get_uint_val(node, (uint64_t*)val); +} + +void plist_get_uid_val(plist_t node, uint64_t * val) +{ + if (!node || !val) + return; + plist_type type = plist_get_node_type(node); + uint64_t length = 0; + if (PLIST_UID != type) + return; + plist_get_type_and_value(node, &type, (void *) val, &length); + assert(length == sizeof(uint64_t)); +} + +void plist_get_real_val(plist_t node, double *val) +{ + if (!node || !val) + return; + plist_type type = plist_get_node_type(node); + uint64_t length = 0; + if (PLIST_REAL != type) + return; + plist_get_type_and_value(node, &type, (void *) val, &length); + assert(length == sizeof(double)); +} + +void plist_get_data_val(plist_t node, char **val, uint64_t * length) +{ + if (!node || !val || !length) + return; + plist_type type = plist_get_node_type(node); + if (PLIST_DATA != type) + return; + plist_get_type_and_value(node, &type, (void *) val, length); +} + +const char* plist_get_data_ptr(plist_t node, uint64_t* length) +{ + if (!node || !length) + return NULL; + plist_type type = plist_get_node_type(node); + if (PLIST_DATA != type) + return NULL; + plist_data_t data = plist_get_data(node); + *length = data->length; + return (const char*)data->buff; +} + +void plist_get_date_val(plist_t node, int32_t * sec, int32_t * usec) +{ + if (!node) + return; + plist_type type = plist_get_node_type(node); + uint64_t length = 0; + double val = 0; + if (PLIST_DATE != type) + return; + plist_get_type_and_value(node, &type, (void *) &val, &length); + assert(length == sizeof(double)); + if (sec) + *sec = (int32_t)val; + if (usec) + { + val = fabs((val - (int64_t)val) * 1000000); + *usec = (int32_t)val; + } +} + +int plist_data_compare(const void *a, const void *b) +{ + plist_data_t val_a = NULL; + plist_data_t val_b = NULL; + + if (!a || !b) + return FALSE; + + if (!((node_t) a)->data || !((node_t) b)->data) + return FALSE; + + val_a = plist_get_data((plist_t) a); + val_b = plist_get_data((plist_t) b); + + if (val_a->type != val_b->type) + return FALSE; + + switch (val_a->type) + { + case PLIST_BOOLEAN: + case PLIST_NULL: + case PLIST_INT: + case PLIST_REAL: + case PLIST_DATE: + case PLIST_UID: + if (val_a->length != val_b->length) + return FALSE; + return val_a->intval == val_b->intval; //it is an union so this is sufficient + + case PLIST_KEY: + case PLIST_STRING: + return strcmp(val_a->strval, val_b->strval) == 0; + + case PLIST_DATA: + if (val_a->length != val_b->length) + return FALSE; + return memcmp(val_a->buff, val_b->buff, val_a->length) == 0; + + case PLIST_ARRAY: + case PLIST_DICT: + //compare pointer + return a == b; + + default: + break; + } + return FALSE; +} + +char plist_compare_node_value(plist_t node_l, plist_t node_r) +{ + return plist_data_compare(node_l, node_r); +} + +static void plist_set_element_val(plist_t node, plist_type type, const void *value, uint64_t length) +{ + //free previous allocated buffer + plist_data_t data = plist_get_data(node); + assert(data); // a node should always have data attached + + switch (data->type) + { + case PLIST_KEY: + case PLIST_STRING: + free(data->strval); + data->strval = NULL; + break; + case PLIST_DATA: + free(data->buff); + data->buff = NULL; + break; + default: + break; + } + + //now handle value + + data->type = type; + data->length = length; + + switch (type) + { + case PLIST_BOOLEAN: + data->boolval = *((char *) value); + break; + case PLIST_INT: + case PLIST_UID: + data->intval = *((uint64_t *) value); + break; + case PLIST_REAL: + case PLIST_DATE: + data->realval = *((double *) value); + break; + case PLIST_KEY: + case PLIST_STRING: + data->strval = strdup((char *) value); + break; + case PLIST_DATA: + data->buff = (uint8_t *) malloc(length); + memcpy(data->buff, value, length); + break; + case PLIST_ARRAY: + case PLIST_DICT: + default: + break; + } +} + +void plist_set_key_val(plist_t node, const char *val) +{ + plist_t father = plist_get_parent(node); + plist_t item = plist_dict_get_item(father, val); + if (item) { + return; + } + plist_set_element_val(node, PLIST_KEY, val, strlen(val)); +} + +void plist_set_string_val(plist_t node, const char *val) +{ + plist_set_element_val(node, PLIST_STRING, val, strlen(val)); +} + +void plist_set_bool_val(plist_t node, uint8_t val) +{ + plist_set_element_val(node, PLIST_BOOLEAN, &val, sizeof(uint8_t)); +} + +void plist_set_uint_val(plist_t node, uint64_t val) +{ + plist_set_element_val(node, PLIST_INT, &val, (val > INT64_MAX) ? sizeof(uint64_t)*2 : sizeof(uint64_t)); +} + +void plist_set_int_val(plist_t node, int64_t val) +{ + plist_set_element_val(node, PLIST_INT, &val, sizeof(uint64_t)); +} + +void plist_set_uid_val(plist_t node, uint64_t val) +{ + plist_set_element_val(node, PLIST_UID, &val, sizeof(uint64_t)); +} + +void plist_set_real_val(plist_t node, double val) +{ + plist_set_element_val(node, PLIST_REAL, &val, sizeof(double)); +} + +void plist_set_data_val(plist_t node, const char *val, uint64_t length) +{ + plist_set_element_val(node, PLIST_DATA, val, length); +} + +void plist_set_date_val(plist_t node, int32_t sec, int32_t usec) +{ + double val = (double)sec + (double)usec / 1000000; + plist_set_element_val(node, PLIST_DATE, &val, sizeof(struct timeval)); +} + +int plist_bool_val_is_true(plist_t boolnode) +{ + if (!PLIST_IS_BOOLEAN(boolnode)) { + return 0; + } + uint8_t bv = 0; + plist_get_bool_val(boolnode, &bv); + return (bv == 1); +} + +int plist_int_val_is_negative(plist_t intnode) +{ + if (!PLIST_IS_INT(intnode)) { + return 0; + } + plist_data_t data = plist_get_data(intnode); + if (data->length == 16) { + return 0; + } + if ((int64_t)data->intval < 0) { + return 1; + } + return 0; +} + +int plist_int_val_compare(plist_t uintnode, int64_t cmpval) +{ + if (!PLIST_IS_INT(uintnode)) { + return -1; + } + int64_t uintval = 0; + plist_get_int_val(uintnode, &uintval); + if (uintval == cmpval) { + return 0; + } + + if (uintval < cmpval) { + return -1; + } + + return 1; +} + +int plist_uint_val_compare(plist_t uintnode, uint64_t cmpval) +{ + if (!PLIST_IS_INT(uintnode)) { + return -1; + } + uint64_t uintval = 0; + plist_get_uint_val(uintnode, &uintval); + if (uintval == cmpval) { + return 0; + } + + if (uintval < cmpval) { + return -1; + } + + return 1; +} + +int plist_uid_val_compare(plist_t uidnode, uint64_t cmpval) +{ + if (!PLIST_IS_UID(uidnode)) { + return -1; + } + uint64_t uidval = 0; + plist_get_uid_val(uidnode, &uidval); + if (uidval == cmpval) { + return 0; + } + + if (uidval < cmpval) { + return -1; + } + + return 1; +} + +int plist_real_val_compare(plist_t realnode, double cmpval) +{ + if (!PLIST_IS_REAL(realnode)) { + return -1; + } + double a = 0; + double b = cmpval; + plist_get_real_val(realnode, &a); + double abs_a = fabs(a); + double abs_b = fabs(b); + double diff = fabs(a - b); + if (a == b) { + return 0; + } + + if (a == 0 || b == 0 || (abs_a + abs_b < DBL_MIN)) { + if (diff < (DBL_EPSILON * DBL_MIN)) { + return 0; + } + + if (a < b) { + return -1; + } + } else { + if ((diff / fmin(abs_a + abs_b, DBL_MAX)) < DBL_EPSILON) { + return 0; + } + + if (a < b) { + return -1; + } + } + return 1; +} + +int plist_date_val_compare(plist_t datenode, int32_t cmpsec, int32_t cmpusec) +{ + if (!PLIST_IS_DATE(datenode)) { + return -1; + } + int32_t sec = 0; + int32_t usec = 0; + plist_get_date_val(datenode, &sec, &usec); + uint64_t dateval = ((int64_t)sec << 32) | usec; + uint64_t cmpval = ((int64_t)cmpsec << 32) | cmpusec; + if (dateval == cmpval) { + return 0; + } + + if (dateval < cmpval) { + return -1; + } + + return 1; +} + +int plist_string_val_compare(plist_t strnode, const char* cmpval) +{ + if (!PLIST_IS_STRING(strnode)) { + return -1; + } + plist_data_t data = plist_get_data(strnode); + return strcmp(data->strval, cmpval); +} + +int plist_string_val_compare_with_size(plist_t strnode, const char* cmpval, size_t n) +{ + if (!PLIST_IS_STRING(strnode)) { + return -1; + } + plist_data_t data = plist_get_data(strnode); + return strncmp(data->strval, cmpval, n); +} + +int plist_string_val_contains(plist_t strnode, const char* substr) +{ + if (!PLIST_IS_STRING(strnode)) { + return 0; + } + plist_data_t data = plist_get_data(strnode); + return (strstr(data->strval, substr) != NULL); +} + +int plist_key_val_compare(plist_t keynode, const char* cmpval) +{ + if (!PLIST_IS_KEY(keynode)) { + return -1; + } + plist_data_t data = plist_get_data(keynode); + return strcmp(data->strval, cmpval); +} + +int plist_key_val_compare_with_size(plist_t keynode, const char* cmpval, size_t n) +{ + if (!PLIST_IS_KEY(keynode)) { + return -1; + } + plist_data_t data = plist_get_data(keynode); + return strncmp(data->strval, cmpval, n); +} + +int plist_key_val_contains(plist_t keynode, const char* substr) +{ + if (!PLIST_IS_KEY(keynode)) { + return 0; + } + plist_data_t data = plist_get_data(keynode); + return (strstr(data->strval, substr) != NULL); +} + +int plist_data_val_compare(plist_t datanode, const uint8_t* cmpval, size_t n) +{ + if (!PLIST_IS_DATA(datanode)) { + return -1; + } + plist_data_t data = plist_get_data(datanode); + if (data->length < n) { + return -1; + } + + if (data->length > n) { + return 1; + } + + return memcmp(data->buff, cmpval, n); +} + +int plist_data_val_compare_with_size(plist_t datanode, const uint8_t* cmpval, size_t n) +{ + if (!PLIST_IS_DATA(datanode)) { + return -1; + } + plist_data_t data = plist_get_data(datanode); + if (data->length < n) { + return -1; + } + return memcmp(data->buff, cmpval, n); +} + +int plist_data_val_contains(plist_t datanode, const uint8_t* cmpval, size_t n) +{ + if (!PLIST_IS_DATA(datanode)) { + return -1; + } + plist_data_t data = plist_get_data(datanode); + return (memmem(data->buff, data->length, cmpval, n) != NULL); +} + +extern void plist_xml_set_debug(int debug); +extern void plist_bin_set_debug(int debug); +extern void plist_json_set_debug(int debug); +extern void plist_ostep_set_debug(int debug); + +void plist_set_debug(int debug) +{ + plist_xml_set_debug(debug); + plist_bin_set_debug(debug); + plist_json_set_debug(debug); + plist_ostep_set_debug(debug); +} + +void plist_sort(plist_t plist) +{ + if (!plist) { + return; + } + if (PLIST_IS_ARRAY(plist)) { + uint32_t n = plist_array_get_size(plist); + uint32_t i = 0; + for (i = 0; i < n; i++) { + plist_sort(plist_array_get_item(plist, i)); + } + } else if (PLIST_IS_DICT(plist)) { + node_t node = (node_t)plist; + node_t ch; + for (ch = node_first_child(node); ch; ch = node_next_sibling(ch)) { + ch = node_next_sibling(ch); + plist_sort((plist_t)ch); + } +#define KEY_DATA(x) (x->data) +#define NEXT_KEY(x) (x->next->next) +#define KEY_STRVAL(x) ((plist_data_t)(KEY_DATA(x)))->strval + int swapped = 0; + do { + swapped = 0; + node_t lptr = NULL; + node_t cur_key = node_first_child((node_t)plist); + + while (NEXT_KEY(cur_key) != lptr) { + node_t next_key = NEXT_KEY(cur_key); + if (strcmp(KEY_STRVAL(cur_key), KEY_STRVAL(next_key)) > 0) { + node_t cur_val = cur_key->next; + node_t next_val = next_key->next; + // we need to swap 2 consecutive nodes with the 2 after them + // a -> b -> [c] -> [d] -> [e] -> [f] -> g -> h + // cur next + // swapped: + // a -> b -> [e] -> [f] -> [c] -> [d] -> g -> h + // next cur + node_t tmp_prev = cur_key->prev; + node_t tmp_next = next_val->next; + cur_key->prev = next_val; + cur_val->next = tmp_next; + next_val->next = cur_key; + next_key->prev = tmp_prev; + if (tmp_prev) { + tmp_prev->next = next_key; + } else { + ((node_t)plist)->children->begin = next_key; + } + if (tmp_next) { + tmp_next->prev = cur_val; + } else { + ((node_t)plist)->children->end = cur_val; + } + cur_key = next_key; + swapped = 1; + } + cur_key = NEXT_KEY(cur_key); + } + lptr = cur_key; + } while (swapped); + } +} + +plist_err_t plist_write_to_string(plist_t plist, char **output, uint32_t* length, plist_format_t format, plist_write_options_t options) +{ + plist_err_t err = PLIST_ERR_UNKNOWN; + switch (format) { + case PLIST_FORMAT_XML: + err = plist_to_xml(plist, output, length); + break; + case PLIST_FORMAT_JSON: + err = plist_to_json(plist, output, length, ((options & PLIST_OPT_COMPACT) == 0)); + break; + case PLIST_FORMAT_OSTEP: + err = plist_to_openstep(plist, output, length, ((options & PLIST_OPT_COMPACT) == 0)); + break; + case PLIST_FORMAT_PRINT: + err = plist_write_to_string_default(plist, output, length, options); + break; + case PLIST_FORMAT_LIMD: + err = plist_write_to_string_limd(plist, output, length, options); + break; + case PLIST_FORMAT_PLUTIL: + err = plist_write_to_string_plutil(plist, output, length, options); + break; + default: + // unsupported output format + err = PLIST_ERR_FORMAT; + break; + } + return err; +} + +plist_err_t plist_write_to_stream(plist_t plist, FILE *stream, plist_format_t format, plist_write_options_t options) +{ + if (!plist || !stream) { + return PLIST_ERR_INVALID_ARG; + } + plist_err_t err = PLIST_ERR_UNKNOWN; + char *output = NULL; + uint32_t length = 0; + switch (format) { + case PLIST_FORMAT_BINARY: + err = plist_to_bin(plist, &output, &length); + break; + case PLIST_FORMAT_XML: + err = plist_to_xml(plist, &output, &length); + break; + case PLIST_FORMAT_JSON: + err = plist_to_json(plist, &output, &length, ((options & PLIST_OPT_COMPACT) == 0)); + break; + case PLIST_FORMAT_OSTEP: + err = plist_to_openstep(plist, &output, &length, ((options & PLIST_OPT_COMPACT) == 0)); + break; + case PLIST_FORMAT_PRINT: + err = plist_write_to_stream_default(plist, stream, options); + break; + case PLIST_FORMAT_LIMD: + err = plist_write_to_stream_limd(plist, stream, options); + break; + case PLIST_FORMAT_PLUTIL: + err = plist_write_to_stream_plutil(plist, stream, options); + break; + default: + // unsupported output format + err = PLIST_ERR_FORMAT; + break; + } + if (output && err == PLIST_ERR_SUCCESS) { + if (fwrite(output, 1, length, stream) < length) { + err = PLIST_ERR_IO; + } + free(output); + } + return err; +} + +plist_err_t plist_write_to_file(plist_t plist, const char* filename, plist_format_t format, plist_write_options_t options) +{ + if (!plist || !filename) { + return PLIST_ERR_INVALID_ARG; + } + FILE* f = fopen(filename, "wb"); + if (!f) { + return PLIST_ERR_IO; + } + plist_err_t err = plist_write_to_stream(plist, f, format, options); + fclose(f); + return err; +} + +void plist_print(plist_t plist) +{ + plist_write_to_stream(plist, stdout, PLIST_FORMAT_PRINT, PLIST_OPT_PARTIAL_DATA); +}