kxld_splitinfolc.c   [plain text]

/*
 * Copyright (c) 2016 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
#include <string.h>
#include <mach-o/loader.h>
#include <sys/types.h>

#define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
#include <AssertMacros.h>

#include "kxld_util.h"
#include "kxld_splitinfolc.h"

/*******************************************************************************
*******************************************************************************/
void
kxld_splitinfolc_init_from_macho(KXLDsplitinfolc *splitinfolc, struct linkedit_data_command *src)
{
	check(splitinfolc);
	check(src);

	splitinfolc->cmdsize = src->cmdsize;
	splitinfolc->dataoff = src->dataoff;
	splitinfolc->datasize = src->datasize;
	splitinfolc->has_splitinfolc = TRUE;
}

/*******************************************************************************
*******************************************************************************/
void
kxld_splitinfolc_clear(KXLDsplitinfolc *splitinfolc)
{
	bzero(splitinfolc, sizeof(*splitinfolc));
}

/*******************************************************************************
*******************************************************************************/
u_long
kxld_splitinfolc_get_macho_header_size(void)
{
	return sizeof(struct linkedit_data_command);
}

/*******************************************************************************
*******************************************************************************/
kern_return_t
kxld_splitinfolc_export_macho(const KXLDsplitinfolc *splitinfolc,
    splitKextLinkInfo *linked_object,
    u_long *header_offset,
    u_long header_size,
    u_long *data_offset,
    u_long size)
{
	kern_return_t       rval = KERN_FAILURE;
	struct linkedit_data_command *splitinfolc_hdr = NULL;
	u_char *            buf;

	check(splitinfolc);
	check(linked_object);
	check(header_offset);
	check(data_offset);

	buf = (u_char *)(linked_object->linkedKext);
	require_action(sizeof(*splitinfolc_hdr) <= header_size - *header_offset,
	    finish,
	    rval = KERN_FAILURE);
	splitinfolc_hdr = (struct linkedit_data_command *)((void *)(buf + *header_offset));
	*header_offset += sizeof(*splitinfolc_hdr);

	if (buf + *data_offset > buf + size) {
		kxld_log(kKxldLogLinking, kKxldLogErr,
		    "\n OVERFLOW! linkedKext %p to %p (%lu) copy %p to %p (%u) <%s>",
		    (void *) buf,
		    (void *) (buf + size),
		    size,
		    (void *) (buf + *data_offset),
		    (void *) (buf + *data_offset + splitinfolc->datasize),
		    splitinfolc->datasize,
		    __func__);
		goto finish;
	}

	// copy in the split info reloc data from kextExecutable. For example dataoff
	// in LC_SEGMENT_SPLIT_INFO load command points to the reloc data in the
	// __LINKEDIT segment.  In this case 65768 into the kextExecutable file is
	// the split seg reloc info (for 920 bytes)
//    Load command 9
//    cmd LC_SEGMENT_SPLIT_INFO
//    cmdsize 16
//    dataoff 65768
//    datasize 920


	memcpy(buf + *data_offset, linked_object->kextExecutable + splitinfolc->dataoff, splitinfolc->datasize);

#if SPLIT_KEXTS_DEBUG
	u_char *dataPtr = buf + *data_offset;

	kxld_log(kKxldLogLinking, kKxldLogErr,
	    "\n\n linkedKext %p to %p (%lu) copy %p to %p (%u) <%s>",
	    (void *) buf,
	    (void *) (buf + size),
	    size,
	    (void *) (dataPtr),
	    (void *) (dataPtr + splitinfolc->datasize),
	    splitinfolc->datasize,
	    __func__);

	if (*(dataPtr + 0) != 0x7F) {
		kxld_log(kKxldLogLinking, kKxldLogErr,
		    "\n\n bad LC_SEGMENT_SPLIT_INFO: 0x%02X %02X %02X %02X %02X %02X %02X %02X at %p (buf %p + %lu) <%s>",
		    *(dataPtr + 0),
		    *(dataPtr + 1),
		    *(dataPtr + 2),
		    *(dataPtr + 3),
		    *(dataPtr + 4),
		    *(dataPtr + 5),
		    *(dataPtr + 6),
		    *(dataPtr + 7),
		    (void *) dataPtr,
		    (void *) buf,
		    *data_offset, __func__);
	}
#endif

	// update the load command header
	splitinfolc_hdr->cmd = LC_SEGMENT_SPLIT_INFO;
	splitinfolc_hdr->cmdsize = (uint32_t) sizeof(*splitinfolc_hdr);
	splitinfolc_hdr->dataoff = (uint32_t)(*data_offset);
	splitinfolc_hdr->datasize = splitinfolc->datasize;

	*data_offset += splitinfolc->datasize;

	rval = KERN_SUCCESS;

finish:
	return rval;
}