FreeRDP/winpr/libwinpr/rpc/ndr_structure.c

/**
 * WinPR: Windows Portable Runtime
 * Microsoft Remote Procedure Call (MSRPC)
 *
 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>

#include <winpr/rpc.h>

#ifndef _WIN32

#include "ndr_private.h"
#include "ndr_pointer.h"
#include "ndr_structure.h"

/* Structures: http://msdn.microsoft.com/en-us/library/windows/desktop/aa378695/ */

void NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
                               PFORMAT_STRING pFormat)
{
	/**
	 * FC_STRUCT
	 * alignment<1>
	 * memory_size<2>
	 * member_layout<>
	 * FC_END
	 */
	/**
	 * FC_PSTRUCT
	 * alignment<1>
	 * memory_size<2>
	 * pointer_layout<>
	 * member_layout<>
	 * FC_END
	 */
	unsigned char type;
	unsigned char alignment;
	unsigned short memory_size;
	type = pFormat[0];
	alignment = pFormat[1] + 1;
	memory_size = *(unsigned short*)&pFormat[2];
	NdrpAlignLength(&(pStubMsg->BufferLength), alignment);
	NdrpIncrementLength(&(pStubMsg->BufferLength), memory_size);
	pFormat += 4;

	if (*pFormat == FC_PSTRUCT)
		NdrpEmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);

	WLog_ERR(TAG, "warning: NdrSimpleStructBufferSize unimplemented");
}

void NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
                                   PFORMAT_STRING pFormat)
{
	/**
	 * FC_CSTRUCT alignment<1>
	 * memory_size<2>
	 * offset_to_array_description<2>
	 * member_layout<>
	 * FC_END
	 */
	/**
	 * FC_CPSTRUCT alignment<1>
	 * memory_size<2>
	 * offset_to_array_description<2>
	 * pointer_layout<>
	 * member_layout<> FC_END
	 */
	WLog_ERR(TAG, "warning: NdrConformantStructBufferSize unimplemented");
}

void NdrConformantVaryingStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
                                          PFORMAT_STRING pFormat)
{
	/**
	 * FC_CVSTRUCT alignment<1>
	 * memory_size<2>
	 * offset_to_array_description<2>
	 * [pointer_layout<>]
	 * layout<>
	 * FC_END
	 */
	WLog_ERR(TAG, "warning: NdrConformantVaryingStructBufferSize unimplemented");
}

static ULONG NdrComplexStructMemberSize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
{
	ULONG size = 0;

	while (*pFormat != FC_END)
	{
		switch (*pFormat)
		{
			case FC_BYTE:
			case FC_CHAR:
			case FC_SMALL:
			case FC_USMALL:
				size += sizeof(BYTE);
				break;

			case FC_WCHAR:
			case FC_SHORT:
			case FC_USHORT:
			case FC_ENUM16:
				size += sizeof(USHORT);
				break;

			case FC_LONG:
			case FC_ULONG:
			case FC_ENUM32:
				size += sizeof(ULONG);
				break;

			case FC_INT3264:
			case FC_UINT3264:
				size += sizeof(INT_PTR);
				break;

			case FC_FLOAT:
				size += sizeof(FLOAT);
				break;

			case FC_DOUBLE:
				size += sizeof(DOUBLE);
				break;

			case FC_HYPER:
				size += sizeof(ULONGLONG);
				break;

			case FC_ERROR_STATUS_T:
				size += sizeof(error_status_t);
				break;

			case FC_IGNORE:
				break;

			case FC_RP:
			case FC_UP:
			case FC_OP:
			case FC_FP:
			case FC_POINTER:
				size += sizeof(void*);

				if (*pFormat != FC_POINTER)
					pFormat += 4;

				break;

			case FC_ALIGNM2:
				NdrpAlignLength(&size, 2);
				break;

			case FC_ALIGNM4:
				NdrpAlignLength(&size, 4);
				break;

			case FC_ALIGNM8:
				NdrpAlignLength(&size, 8);
				break;

			case FC_STRUCTPAD1:
			case FC_STRUCTPAD2:
			case FC_STRUCTPAD3:
			case FC_STRUCTPAD4:
			case FC_STRUCTPAD5:
			case FC_STRUCTPAD6:
			case FC_STRUCTPAD7:
				size += *pFormat - FC_STRUCTPAD1 + 1;
				break;

			case FC_PAD:
				break;

			case FC_EMBEDDED_COMPLEX:
				WLog_ERR(TAG,
				         "warning: NdrComplexStructMemberSize FC_EMBEDDED_COMPLEX unimplemented");
				break;

			default:
				WLog_ERR(TAG, "warning: NdrComplexStructMemberSize 0x%02X unimplemented", *pFormat);
				break;
		}

		pFormat++;
	}

	return size;
}

void NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
                                PFORMAT_STRING pFormat)
{
	/**
	 * FC_BOGUS_STRUCT
	 * alignment<1>
	 * memory_size<2>
	 * offset_to_conformant_array_description<2>
	 * offset_to_pointer_layout<2>
	 * member_layout<>
	 * FC_END
	 * [pointer_layout<>]
	 */
	ULONG_PTR MaxCount;
	unsigned long Offset;
	unsigned long ActualCount;
	unsigned char* pMemoryCopy;
	unsigned char type;
	unsigned char alignment;
	unsigned short memory_size;
	unsigned char* pointer_layout;
	unsigned char* conformant_array_description;
	unsigned short offset_to_pointer_layout;
	unsigned short offset_to_conformant_array_description;
	type = pFormat[0];
	pMemoryCopy = pMemory;
	pointer_layout = conformant_array_description = NULL;

	if (type != FC_BOGUS_STRUCT)
	{
		WLog_ERR(TAG, "error: expected FC_BOGUS_STRUCT, got 0x%02X", type);
		return;
	}

	alignment = pFormat[1] + 1;
	memory_size = *(unsigned short*)&pFormat[2];
	NdrpAlignLength(&(pStubMsg->BufferLength), alignment);

	if (!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
	{
		unsigned long BufferLengthCopy = pStubMsg->BufferLength;
		int IgnoreEmbeddedPointersCopy = pStubMsg->IgnoreEmbeddedPointers;
		pStubMsg->IgnoreEmbeddedPointers = 1;
		NdrComplexStructBufferSize(pStubMsg, pMemory, pFormat);
		pStubMsg->IgnoreEmbeddedPointers = IgnoreEmbeddedPointersCopy;
		pStubMsg->PointerLength = pStubMsg->BufferLength;
		pStubMsg->BufferLength = BufferLengthCopy;
	}

	pFormat += 4;
	offset_to_conformant_array_description = *(unsigned short*)&pFormat[0];

	if (offset_to_conformant_array_description)
		conformant_array_description =
		    (unsigned char*)pFormat + offset_to_conformant_array_description;

	pFormat += 2;
	offset_to_pointer_layout = *(unsigned short*)&pFormat[0];

	if (offset_to_pointer_layout)
		pointer_layout = (unsigned char*)pFormat + offset_to_pointer_layout;

	pFormat += 2;
	pStubMsg->Memory = pMemory;

	if (conformant_array_description)
	{
		ULONG size;
		unsigned char array_type;
		array_type = conformant_array_description[0];
		size = NdrComplexStructMemberSize(pStubMsg, pFormat);
		WLog_ERR(TAG, "warning: NdrComplexStructBufferSize array_type: 0x%02X unimplemented",
		         array_type);
		NdrpComputeConformance(pStubMsg, pMemory + size, conformant_array_description);
		NdrpComputeVariance(pStubMsg, pMemory + size, conformant_array_description);
		MaxCount = pStubMsg->MaxCount;
		ActualCount = pStubMsg->ActualCount;
		Offset = pStubMsg->Offset;
	}

	if (conformant_array_description)
	{
		unsigned char array_type;
		array_type = conformant_array_description[0];
		pStubMsg->MaxCount = MaxCount;
		pStubMsg->ActualCount = ActualCount;
		pStubMsg->Offset = Offset;
		WLog_ERR(TAG, "warning: NdrComplexStructBufferSize array_type: 0x%02X unimplemented",
		         array_type);
	}

	pStubMsg->Memory = pMemoryCopy;

	if (pStubMsg->PointerLength > 0)
	{
		pStubMsg->BufferLength = pStubMsg->PointerLength;
		pStubMsg->PointerLength = 0;
	}
}

#endif