Merge pull request #9 from p-x9/feature/binary-parse-lib

Extract generic binary analysis utilities into a shared library

Author: p-x9

Package.resolved

@@ -11,14 +11,27 @@ let package = Package(
         ),
     ],
     dependencies: [
-        .package(url: "https://github.com/p-x9/swift-fileio.git", from: "0.9.0")
+        .package(
+            url: "https://github.com/p-x9/swift-binary-parse-support.git",
+            from: "0.2.1"
+        ),
+        .package(
+            url: "https://github.com/p-x9/swift-fileio.git",
+            from: "0.9.0"
+        ),
+        .package(
+            url: "https://github.com/p-x9/swift-fileio-extra.git",
+            from: "0.2.2"
+        ),
     ],
     targets: [
         .target(
             name: "ELFKit",
             dependencies: [
                 "ELFKitC",
-                .product(name: "FileIO", package: "swift-fileio")
+                .product(name: "BinaryParseSupport", package: "swift-binary-parse-support"),
+                .product(name: "FileIO", package: "swift-fileio"),
+                .product(name: "FileIOBinary", package: "swift-fileio-extra")
             ]
         ),
         .target(

Package.swift

@@ -13,30 +13,9 @@ internal import FileIO
 @_implementationOnly import FileIO
 #endif
 
-public protocol StringTable<Encoding>: Sequence<StringTableEntry> {
-    associatedtype Encoding: _UnicodeEncoding
-}
-
 extension ELFFile {
+    public typealias UnicodeStrings = BinaryParseSupport.UnicodeStrings
     public typealias Strings = UnicodeStrings<UTF8>
-
-    public struct UnicodeStrings<Encoding: _UnicodeEncoding>: StringTable {
-        typealias FileSlice = File.FileSlice
-
-        private let fileSlice: FileSlice
-
-        /// file offset of string table start
-        public let offset: Int
-
-        /// size of string table
-        public let size: Int
-
-        public let isSwapped: Bool
-
-        public func makeIterator() -> Iterator {
-            .init(fileSlice: fileSlice, isSwapped: isSwapped)
-        }
-    }
 }
 
 extension ELFFile.UnicodeStrings {
@@ -51,95 +30,10 @@ extension ELFFile.UnicodeStrings {
             length: size
         )
         self.init(
-            fileSlice: fileSlice,
+            source: fileSlice,
             offset: offset,
             size: size,
             isSwapped: isSwapped
         )
     }
 }
-
-extension ELFFile.UnicodeStrings {
-    public var data: Data? {
-        try? fileSlice.readAllData()
-    }
-}
-
-extension ELFFile.UnicodeStrings {
-    public struct Iterator: IteratorProtocol {
-        public typealias Element = StringTableEntry
-
-        private let fileSice: FileSlice
-        private let tableSize: Int
-        private let isSwapped: Bool
-
-        private var nextOffset: Int
-
-        init(fileSlice: FileSlice, isSwapped: Bool) {
-            self.fileSice = fileSlice
-            self.tableSize = fileSlice.size
-            self.nextOffset = 0
-            self.isSwapped = isSwapped
-        }
-
-        public mutating func next() -> Element? {
-            guard nextOffset < tableSize else { return nil }
-
-            let ptr = UnsafeRawPointer(fileSice.ptr)
-                .advanced(by: nextOffset)
-                .assumingMemoryBound(to: Encoding.CodeUnit.self)
-            var (string, offset) = ptr.readString(as: Encoding.self)
-
-            defer {
-                nextOffset += offset
-            }
-
-            if isSwapped || shouldSwap(ptr) {
-                let data = Data(bytes: ptr, count: offset)
-                    .byteSwapped(Encoding.CodeUnit.self)
-                string = data.withUnsafeBytes {
-                    let baseAddress = $0.baseAddress!
-                        .assumingMemoryBound(to: Encoding.CodeUnit.self)
-                    return .init(
-                        decodingCString: baseAddress,
-                        as: Encoding.self
-                    )
-                }
-            }
-
-            return .init(
-                string: string,
-                offset: nextOffset
-            )
-        }
-    }
-}
-
-extension ELFFile.Strings {
-    func string(at offset: Int) -> Element? {
-        guard fileSlice.size >= offset else { return nil }
-        let string = String(
-            cString: fileSlice.ptr
-                .advanced(by: offset)
-                .assumingMemoryBound(to: CChar.self)
-        )
-        return .init(string: string, offset: offset)
-    }
-}
-
-extension ELFFile.UnicodeStrings.Iterator {
-    // https://github.com/swiftlang/swift-corelibs-foundation/blob/4a9694d396b34fb198f4c6dd865702f7dc0b0dcf/Sources/Foundation/NSString.swift#L1390
-    func shouldSwap(_ ptr: UnsafePointer<Encoding.CodeUnit>) -> Bool {
-        let size = MemoryLayout<Encoding.CodeUnit>.size
-        switch size {
-        case 1:
-            return false
-        case 2:
-            return ptr.pointee == 0xFFFE /* ZERO WIDTH NO-BREAK SPACE (swapped) */
-        case 4:
-            return ptr.pointee == UInt32(0xFFFE0000) // avoid overflows in 32bit env
-        default:
-            return false
-        }
-    }
-}

Sources/ELFKit/ELFFile+Strings.swift

@@ -9,93 +9,25 @@
 import Foundation
 
 extension ELFImage {
+    public typealias UnicodeStrings = BinaryParseSupport.UnicodeStrings
     public typealias Strings = UnicodeStrings<UTF8>
-
-    public struct UnicodeStrings<Encoding: _UnicodeEncoding>: StringTable {
-        public let basePointer: UnsafePointer<Encoding.CodeUnit>
-        public let tableSize: Int
-
-        public let isLittleEndian: Bool
-
-        init(
-            basePointer: UnsafePointer<Encoding.CodeUnit>,
-            tableSize: Int,
-            isLittleEndian: Bool = false
-        ) {
-            self.basePointer = basePointer
-            self.tableSize = tableSize
-            self.isLittleEndian = isLittleEndian
-        }
-
-        public func makeIterator() -> Iterator {
-            Iterator(
-                basePointer: basePointer,
-                tableSize: tableSize,
-                isLittleEndian: isLittleEndian
-            )
-        }
-    }
 }
 
 extension ELFImage.UnicodeStrings {
-    public struct Iterator: IteratorProtocol {
-        public typealias Element = StringTableEntry
-
-        private let basePointer: UnsafePointer<Encoding.CodeUnit>
-        private let tableSize: Int
-        private let isLittleEndian: Bool
-
-        private var nextPointer: UnsafePointer<Encoding.CodeUnit>
-
-        init(
-            basePointer: UnsafePointer<Encoding.CodeUnit>,
-            tableSize: Int,
-            isLittleEndian: Bool
-        ) {
-            self.basePointer = basePointer
-            self.tableSize = tableSize
-            self.isLittleEndian = isLittleEndian
-            self.nextPointer = basePointer
-        }
-
-        public mutating func next() -> Element? {
-            let offset = Int(bitPattern: nextPointer) - Int(bitPattern: basePointer)
-            if offset >= tableSize {
-                return nil
-            }
-            var (string, nextOffset) = nextPointer.readString(
-                as: Encoding.self
-            )
-
-            if isLittleEndian {
-                let data = Data(bytes: nextPointer, count: offset)
-                string = data.withUnsafeBytes {
-                    let baseAddress = $0.baseAddress!
-                        .assumingMemoryBound(to: Encoding.CodeUnit.self)
-                    return .init(
-                        decodingCString: baseAddress,
-                        as: Encoding.self
-                    )
-                }
-            }
-
-            nextPointer = nextPointer.advanced(
-                by: nextOffset / MemoryLayout<Encoding.CodeUnit>.size
-            )
-
-            return .init(string: string, offset: offset)
-        }
-    }
-}
-
-extension ELFImage.Strings {
-    func string(at offset: Int) -> Element? {
-        guard tableSize >= offset else { return nil }
-        let string = String(
-            cString: UnsafeRawPointer(basePointer)
-                .advanced(by: offset)
-                .assumingMemoryBound(to: CChar.self)
+    init(
+        basePointer: UnsafePointer<Encoding.CodeUnit>,
+        offset: Int,
+        tableSize: Int,
+        isLittleEndian: Bool = false
+    ) {
+        self.init(
+            source: MemoryUnicodeStringsSource(
+                ptr: .init(basePointer),
+                size: tableSize
+            ),
+            offset: offset,
+            size: tableSize,
+            isSwapped: !isLittleEndian
         )
-        return .init(string: string, offset: offset)
     }
 }