Fragment large size data sent and received using NSKeyedArchiver.archivedData in GameCenter

So, there are two parts to this:

• GameKit and its limitations

• Fragmenting messages

I can help with the latter, but I’m not an expert on the former. If, for example, you say:

which, I understand, is the limit for exchanging data in GameCenter

I’m going to take your word on it (-:

In terms of how your fragment large messages, that’s a pretty standard networking technique. There are lots of ways to approach this, but a common technique is:

1. Split the data into chunks.

2. For each chunk, form a fragment by prepending a header that positions the chunk bytes within the larger message.

3. Send it fragment as a separate message.

This assumes that your underlying network is reliable, that is, it guarantees that each fragment will eventually either arrive intact or you’ll be notified of a failure. If the underlying network isn’t reliable, you have to take further steps, like adding a checksum or implementing a retry mechanism.

I’ve included a very cut down example of how you might do this at the end of this post.

Still, I’m concerned about you doing this at all. When a networking API imposes a limit like this, there’s usually a good reason. If you try to get around that limit, you could gain some hard experience as to why the limit is present in the first place.

It might be better to not do this, and instead try to optimise the amount of data that you send. Notably, NSKeyedArchiver is not a compact format. It contains a lot of redundancy. If you switch to a more compact format, like a binary property list, you may find that your data fits under the limit, and that’ll get you out of the fragmentation business entirely. Oh, and Swift has great support for binary property list via Foundation’s Codable mechanism.

Finally…

WARNING When using keyed archiving for network data, you must not disable secure coding. Secure coding was designed to protect you from vulnerabilities that are fundamental to the keyed archiving mechanism. If you disable it, you open yourself up to those vulnerabilities.

Notably, binary properties lists don’t have this problem.

Share and Enjoy
—
Quinn “The Eskimo!” @ Developer Technical Support @ Apple
let myEmail = "eskimo" + "1" + "@" + "apple.com"

import Foundation

// This code requires the `Data` parsing extensions from:
//
// <https://developer.apple.com/forums/thread/652469?answerId=786462022#786462022>.

… elided …

// The follow is an extension of the ideas in the above post.

extension Data {
    
    mutating func appendBigEndian<T>(_ n: T) where T: FixedWidthInteger {
        let bytes = (0..<(T.bitWidth / 8)).reversed().map { byteNumber -> UInt8 in
            UInt8((n >> (byteNumber * 8)) & 0xff)
        }
        self.append(contentsOf: bytes)
    }
    
}

/// Splits a message into fragments.

func fragmentsForMessage(_ message: Data, messageID: UInt32, maxMessageBytesInFragment: Int) -> [Data] {
    precondition(!message.isEmpty)
    precondition(maxMessageBytesInFragment >= 1)
    precondition(UInt16(exactly: maxMessageBytesInFragment) != nil)
    let fragmentCount = (message.count + (maxMessageBytesInFragment - 1)) / maxMessageBytesInFragment
    guard let fragmentCount16 = UInt16(exactly: fragmentCount) else { fatalError() }

    var result: [Data] = []
    var residual = message
    while !residual.isEmpty {
        var fragment = Data()
        fragment.appendBigEndian(messageID)
        fragment.appendBigEndian(UInt16(result.count))
        fragment.appendBigEndian(fragmentCount16)

        let fragmentBytes = residual.prefix(maxMessageBytesInFragment)
        fragment.append(fragmentBytes)
        residual = residual.dropFirst(fragmentBytes.count)

        result.append(fragment)
    }
    return result
}

/// Parses a fragment to extract the header info and the payload.

func infoForFragment(_ fragment: Data) -> (messageID: UInt32, index: Int, count: Int, payload: Data)? {
    var residual = fragment
    guard
        let messageID = residual.parseBigEndian(UInt32.self),
        let fragmentIndex16 = residual.parseBigEndian(UInt16.self),
        let fragmentCount16 = residual.parseBigEndian(UInt16.self)
    else { return nil }
    return (messageID, Int(fragmentIndex16), Int(fragmentCount16), Data(residual))
}

func main() {
    let message = Data("Hello Cruel World".utf8)
    let fragments = fragmentsForMessage(message, messageID: 0xa1a2a3a4, maxMessageBytesInFragment: 6)
    for fragment in fragments {
        print((fragment as NSData).debugDescription)
    }
    // prints:
    // <a1a2a3a4 00000003 48656c6c 6f20>
    // <a1a2a3a4 00010003 43727565 6c20>
    // <a1a2a3a4 00020003 576f726c 64>
    for fragment in fragments {
        print(infoForFragment(fragment)!)
    }
    // prints:
    // (messageID: 2711790500, index: 0, count: 3, payload: 6 bytes)
    // (messageID: 2711790500, index: 1, count: 3, payload: 6 bytes)
    // (messageID: 2711790500, index: 2, count: 3, payload: 5 bytes)
}

main()