MKB 2.x seems to use record type 0x86 for media key verification data.
However, specifications are not available in the public so this should be
considered experimental.

This enables playback of Bus Encryption Enabled discs even without a
valid Host Certificate when cached RDK is available for current drive/disc
combination.

One cached RDK will only work for one drive/disc combination.

Libbdplus needs MK so it should be cached even when it's loaded from a config file.

Title entries from previous file were lost (and memory leaked)

Application expects to get AACS1 SHA1 hash, not AACS2 SHA256 hash.

Instead of the complex cast in various places use a intermediate
variable for mmc, this makes the code a lot easier to read.

The previous way of mounting the disk was flawed which especially
showed after moving to using a dispatch queue that removed long wait
times.

When the exclusive low level access is released, the OS will see the
disk as if it is a "new" device and then try to mount it again, so it
does not work to immediately try to mount the disk again as it would
fail. The disk is not mounted for us, regardless of the failure, thats
done because the OS mounts the disk. Even removing the mount call
completely would still result in the disk getting mounted by the OS,
so calling iokit_mount was unnecessary.

Yet we want to mount the disk ourselves so we know when it is usable
and completely mounted for reading files on it. To do that my approach
is to use a mount approval callback, this callback gets called whenever
a device is to be mounted by someone (usually the OS auto-mounting) and
then the callback can decide to allow or deny mounting.

In this callback we check if the disk is currently not mounted, then we
compare the disk with our disk to know if they match.
Internally what that does is just compare the BSD name so it is not
entirely perfect as the user could unplug the disk and plug a different
one and it could appear as the "same" disk.

If the disks match, we reject the mount attempt and indicate to the
caller that the disk appeared, using the disk_state.

The caller uses a semaphore to wait for a given timeout, currently
20 seconds. Waiting indefinitely is impossible as it could cause
the program to hang if the user unplugs the drive while we wait.

When the disk re-appears we now mount it, during that the state has to
be set to mounting so that the mount approval callback can allow the
request when we try to mount. Just unregistering the mount approval
callback after our disk appeared the first time does not work as
it causes the OS to immediately re-try mounting the disk apparently.

Once the mounting succeeded we can proceed. Even if it fails though,
there is currently not much that can be done about that, so the return
value of the iokit_mount is ignored.

Use a dispatch_semaphore_t to make the mount/unmount functions
wait for the respective callbacks, before returning.

Use a dispatch queue instead of running a runloop for a specific
time to get events.

Instead of initializing DiskArbitration in the unmount function
and release in the mount function, move this to their own
functions, which is a lot less confusing.

Store a reference to the plugin interface in the mmc struct and call
IODestroyPlugInInterface instead of Destroy(), as it is explicitly
documented that IODestroyPlugInInterface should be used and not
Destroy.
As destroying the plugin interface might stop the IOBDService,
call it only when we are done with anything needing it.

Use the kIOBSDNameKey define instead of the magic string with the
same value.

Where appropriate use IO_OBJECT_NULL instead of 0.

Everywhere else in the code mmc is used for the MMCDEV
variables.

Carbon is deprecated and the header is not needed here.