/**
 * WinPR: Windows Portable Runtime
 * ASN.1 Encoding & Decoding Engine
 *
 * 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 <winpr/asn1.h>

#include <winpr/crt.h>

#ifndef _WIN32

ASN1module_t ASN1_CreateModule(ASN1uint32_t nVersion, ASN1encodingrule_e eRule,
                               ASN1uint32_t dwFlags, ASN1uint32_t cPDU,
                               const ASN1GenericFun_t apfnEncoder[],
                               const ASN1GenericFun_t apfnDecoder[],
                               const ASN1FreeFun_t apfnFreeMemory[],
                               const ASN1uint32_t acbStructSize[], ASN1magic_t nModuleName)
{
	ASN1module_t module = NULL;

	if (!((apfnEncoder) && (apfnDecoder) && (apfnFreeMemory) && (acbStructSize)))
		return NULL;

	module = (ASN1module_t)calloc(1, sizeof(struct tagASN1module_t));

	if (module)
	{
		module->nModuleName = nModuleName;
		module->dwFlags = dwFlags;
		module->eRule = eRule;
		module->cPDUs = cPDU;
		module->apfnFreeMemory = apfnFreeMemory;
		module->acbStructSize = acbStructSize;

		if (eRule & ASN1_BER_RULE)
		{
			module->BER.apfnEncoder = (const ASN1BerEncFun_t*)apfnEncoder;
			module->BER.apfnDecoder = (const ASN1BerDecFun_t*)apfnDecoder;
		}
	}

	return module;
}

void ASN1_CloseModule(ASN1module_t pModule)
{
	free(pModule);
}

ASN1error_e ASN1_CreateEncoder(ASN1module_t pModule, ASN1encoding_t* ppEncoderInfo,
                               ASN1octet_t* pbBuf, ASN1uint32_t cbBufSize, ASN1encoding_t pParent)
{
	ASN1error_e status;
	ASN1encoding_t encoder;
	ASN1encodingrule_e rule;

	if (pModule && ppEncoderInfo)
	{
		*ppEncoderInfo = 0;
		encoder = (ASN1encoding_t)calloc(1, sizeof(struct ASN1encoding_s));

		if (encoder)
		{
			encoder->magic = 0x44434E45;
			encoder->err = ASN1_SUCCESS;
			encoder->dwFlags = pModule->dwFlags;
			encoder->module = pModule;

			if (pbBuf && cbBufSize)
			{
				encoder->dwFlags |= ASN1ENCODE_SETBUFFER;
				encoder->buf = pbBuf;
				encoder->pos = pbBuf;
				encoder->size = cbBufSize;
			}

			if (pParent)
			{
				encoder[1].magic = (ASN1magic_t)pParent;
				rule = pParent->eRule;
			}
			else
			{
				encoder[1].magic = (ASN1magic_t)encoder;
				rule = pModule->eRule;
			}

			encoder->eRule = rule;

			if (encoder->dwFlags & ASN1ENCODE_SETBUFFER)
				goto LABEL_SET_BUFFER;

			if (!pParent)
			{
			LABEL_ENCODER_COMPLETE:
				*ppEncoderInfo = encoder;
				return ASN1_SUCCESS;
			}

			if (rule & ASN1_BER_RULE)
			{
				// if (ASN1BEREncCheck(encoder, 1))
				{
					if (encoder->buf)
						*encoder->buf = 0;
				LABEL_SET_BUFFER:
					if (pParent)
						pParent[1].version = (ASN1uint32_t)encoder;

					goto LABEL_ENCODER_COMPLETE;
				}

				status = ASN1_ERR_MEMORY;
			}
			else
			{
				status = ASN1_ERR_RULE;
			}

			free(encoder);
		}
		else
		{
			status = ASN1_ERR_MEMORY;
		}
	}
	else
	{
		status = ASN1_ERR_BADARGS;
	}

	return status;
}

ASN1error_e ASN1_Encode(ASN1encoding_t pEncoderInfo, void* pDataStruct, ASN1uint32_t nPduNum,
                        ASN1uint32_t dwFlags, ASN1octet_t* pbBuf, ASN1uint32_t cbBufSize)
{
	int flags;
	ASN1error_e status;
	ASN1module_t module;
	ASN1BerEncFun_t pfnEncoder;

	if (!pEncoderInfo)
		return ASN1_ERR_BADARGS;

	ASN1EncSetError(pEncoderInfo, ASN1_SUCCESS);

	if (dwFlags & 8)
	{
		pEncoderInfo->dwFlags |= 8;
		pEncoderInfo->buf = pbBuf;
		pEncoderInfo->pos = pbBuf;
		pEncoderInfo->size = cbBufSize;
	}
	else
	{
		flags = dwFlags | pEncoderInfo->dwFlags;

		if (flags & 0x10)
		{
			pEncoderInfo->dwFlags &= 0xFFFFFFF7;
			pEncoderInfo->buf = 0;
			pEncoderInfo->pos = 0;
			pEncoderInfo->size = 0;
		}
		else
		{
			if (!(dwFlags & ASN1ENCODE_REUSEBUFFER) && (flags & ASN1ENCODE_APPEND))
				goto LABEL_MODULE;

			pEncoderInfo->pos = pEncoderInfo->buf;
		}
	}

	pEncoderInfo->len = 0;
	pEncoderInfo->bit = 0;

LABEL_MODULE:
	module = pEncoderInfo->module;

	if (nPduNum >= module->cPDUs)
		goto LABEL_BAD_PDU;

	if (!(pEncoderInfo->eRule & ASN1_BER_RULE))
	{
		status = ASN1_ERR_RULE;
		return ASN1EncSetError(pEncoderInfo, status);
	}

	pfnEncoder = module->BER.apfnEncoder[nPduNum];

	if (!pfnEncoder)
	{
	LABEL_BAD_PDU:
		status = ASN1_ERR_BADPDU;
		return ASN1EncSetError(pEncoderInfo, status);
	}

	if (pfnEncoder(pEncoderInfo, 0, pDataStruct))
	{
		// ASN1BEREncFlush(pEncoderInfo);
	}
	else
	{
		if (pEncoderInfo[1].err >= 0)
			ASN1EncSetError(pEncoderInfo, ASN1_ERR_CORRUPT);
	}

	if (pEncoderInfo[1].err < 0)
	{
		if (((dwFlags & 0xFF) | (pEncoderInfo->dwFlags & 0xFF)) & 0x10)
		{
			ASN1_FreeEncoded(pEncoderInfo, pEncoderInfo->buf);
			pEncoderInfo->buf = 0;
			pEncoderInfo->pos = 0;
			pEncoderInfo->bit = 0;
			pEncoderInfo->len = 0;
			pEncoderInfo->size = 0;
		}
	}

	return pEncoderInfo[1].err;
}

void ASN1_CloseEncoder(ASN1encoding_t pEncoderInfo)
{
	ASN1magic_t magic;

	if (pEncoderInfo)
	{
		magic = pEncoderInfo[1].magic;

		if (pEncoderInfo != (ASN1encoding_t)magic)
			pEncoderInfo[1].version = 0;

		free(pEncoderInfo);
	}
}

ASN1error_e ASN1EncSetError(ASN1encoding_t enc, ASN1error_e err)
{
	ASN1error_e status;
	ASN1encoding_t encoder;
	ASN1encoding_t nextEncoder;

	status = err;
	encoder = enc;

	while (encoder)
	{
		nextEncoder = (ASN1encoding_t)&encoder[1];

		encoder->err = err;

		if (encoder == nextEncoder)
			break;

		encoder = nextEncoder;
	}

	return status;
}

ASN1error_e ASN1DecSetError(ASN1decoding_t dec, ASN1error_e err)
{
	ASN1error_e status;
	ASN1decoding_t decoder;
	ASN1decoding_t nextDecoder;

	status = err;
	decoder = dec;

	while (decoder)
	{
		nextDecoder = (ASN1decoding_t)&decoder[1];

		decoder->err = err;

		if (decoder == nextDecoder)
			break;

		decoder = nextDecoder;
	}

	return status;
}

void ASN1_FreeEncoded(ASN1encoding_t pEncoderInfo, void* pBuf)
{
	return;
}

void ASN1_FreeDecoded(ASN1decoding_t pDecoderInfo, void* pDataStruct, ASN1uint32_t nPduNum)
{
	return;
}

ASN1error_e ASN1_CreateDecoder(ASN1module_t pModule, ASN1decoding_t* ppDecoderInfo,
                               ASN1octet_t* pbBuf, ASN1uint32_t cbBufSize, ASN1decoding_t pParent)
{
	return ASN1_ERR_BADARGS;
}

ASN1error_e ASN1_Decode(ASN1decoding_t pDecoderInfo, void** ppDataStruct, ASN1uint32_t nPduNum,
                        ASN1uint32_t dwFlags, ASN1octet_t* pbBuf, ASN1uint32_t cbBufSize)
{
	return ASN1_ERR_BADARGS;
}

#endif
