Writing UDFs for Firebird Embedded SQL Server

#include <windows.h>
#include <vector>
#include <string>
#include "ibase.h"
#include "ib_util.h"
//------------------------------------------------------------------------------------
typedef void (__stdcall * FCallback)(const char * message);
FCallback g_messageCallback = 0;
FCallback g_errorCallback = 0;
//------------------------------------------------------------------------------------
#define ON_MESSAGE(mess) { if(g_messageCallback) g_messageCallback(mess); }
#define ON_ERROR(mess) { if(g_errorCallback) g_errorCallback(mess); }
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) void RegisterCallbacks(FCallback messageCallback, FCallback errorCallback)
{
	g_messageCallback = messageCallback;
	g_errorCallback = errorCallback;
}
//------------------------------------------------------------------------------------
class SampleParser
{
	std::vector<char> _buffer;
	size_t _pathLen;
	char * _name;
public:
	SampleParser(std::vector<char> & buffer)
	{
		_buffer.swap(buffer);
		char * path = (char*)&_buffer.at(0);
		_pathLen = strlen(path);
		if(_pathLen < 1 ||  _pathLen >= _buffer.size())
			throw std::exception("Invalid buffer format");
		_name = strrchr(path, '\\');
		if(!_name) _name = path;
		else ++_name;
		ON_MESSAGE("--SampleParser created--")
	}
	~SampleParser()
	{
		ON_MESSAGE("--SampleParser destroyed--")
	}

	char * GetName() { return _name; }
	char * GetFullPath() { return (char*)&_buffer.at(0); }
	__int64 * GetCreationTime() { return (__int64*)&_buffer.at(_pathLen + 1); }
	int * GetAttributes() { return (int*)&_buffer.at(_pathLen + 1 + sizeof(__int64)); }
	__int64 * GetSize() { return (__int64*)&_buffer.at(_pathLen + 1 + sizeof(__int64) + sizeof(int)); }

};
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) SampleParser * SampleUdf_CreateParser(BLOBCALLBACK data)
{
	try
	{
		std::vector<char> buffer(data->blob_total_length);
		ISC_UCHAR * p = (ISC_UCHAR*)&buffer.at(0);
		for(ISC_LONG i=0; i < data->blob_number_segments; ++i)
		{
			ISC_USHORT length = 0;
			data->blob_get_segment(data->blob_handle, p, data->blob_max_segment, &length);
			p+= length;
		}
		return new SampleParser(buffer);
	}
	catch(std::exception & ex)
	{
		ON_ERROR(ex.what());
	}
	catch(...)
	{
		ON_ERROR("Unknown error");
	}
	return 0;
}
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) int SampleUdf_DestroyParser(int * ptr)
{
	try
	{
		SampleParser * self = (SampleParser*)(*ptr);
		delete self;
	}
	catch(std::exception & ex)
	{
		ON_ERROR(ex.what());
	}
	catch(...)
	{
		ON_ERROR("Unknown error");
	}
	return 0;
}
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) char * SampleUdf_GetName(int * ptr)
{
	try
	{
		SampleParser * self = (SampleParser*)(*ptr);
		return self->GetName();
	}
	catch(std::exception & ex)
	{
		ON_ERROR(ex.what());
	}
	catch(...)
	{
		ON_ERROR("Unknown error");
	}
	return 0;
}
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) char * SampleUdf_GetFullPath(int * ptr)
{
	try
	{
		SampleParser * self = (SampleParser*)(*ptr);
		return self->GetFullPath();
	}
	catch(std::exception & ex)
	{
		ON_ERROR(ex.what());
	}
	catch(...)
	{
		ON_ERROR("Unknown error");
	}
	return 0;
}
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) ISC_TIMESTAMP * SampleUdf_GetCreationTime(int * ptr)
{
	try
	{
		SampleParser * self = (SampleParser*)(*ptr);

		FILETIME localTime;
		if(!::FileTimeToLocalFileTime((const FILETIME*)self->GetCreationTime(), &localTime))
			return 0;
		SYSTEMTIME st;
		if(!::FileTimeToSystemTime(&localTime, &st))
			return 0;

		ISC_TIMESTAMP * timeStamp = (ISC_TIMESTAMP*)ib_util_malloc(sizeof(ISC_TIMESTAMP));

		timeStamp->timestamp_time = (st.wHour * 3600000 + st.wMinute * 60000 + st.wSecond * 1000 + st.wMilliseconds) * 10;

		WORD day = st.wDay;
		WORD month = st.wMonth;
		WORD year = st.wYear;

		//some magic calculations from ADO.NET Provider code
		if (month > 2)
			month -= 3;
		else
		{
			month += 9;
			year -= 1;
		}
		WORD c = year / 100;
		WORD ya = year - 100 * c;

		timeStamp->timestamp_date = ((146097 * c) / 4 + (1461 * ya) / 4 + (153 * month + 2) / 5 + day + 1721119 - 2400001);
		return timeStamp;
	}
	catch(std::exception & ex)
	{
		ON_ERROR(ex.what());
	}
	catch(...)
	{
		ON_ERROR("Unknown error");
	}
	return 0;
}
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) int * SampleUdf_GetAttributes(int * ptr)
{
	try
	{
		SampleParser * self = (SampleParser*)(*ptr);
		return self->GetAttributes();
	}
	catch(std::exception & ex)
	{
		ON_ERROR(ex.what());
	}
	catch(...)
	{
		ON_ERROR("Unknown error");
	}
	return 0;
}
//------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) __int64 * SampleUdf_GetSize(int * ptr)
{
	try
	{
		SampleParser * self = (SampleParser*)(*ptr);
		return self->GetSize();
	}
	catch(std::exception & ex)
	{
		ON_ERROR(ex.what());
	}
	catch(...)
	{
		ON_ERROR("Unknown error");
	}
	return 0;
}
//------------------------------------------------------------------------------------
BOOL APIENTRY DllMain( HMODULE hModule,
					  DWORD  ul_reason_for_call,
					  LPVOID lpReserved
					  )
{
	return TRUE;
}
//------------------------------------------------------------------------------------