/*
 * DnsRecordCreator.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2010/1/16  DNS_RECORD creator in a client side. 

#pragma once
#include <sol/dns/DnsObject.h>

#include <sol/net/IPv4Address.h>
#include <sol/net/IPv4String.h>
#include <sol/net/IPv6String.h>
#include <sol/net/IPv6Address.h>

#include <sol/dns/DnsData.h>
#include <sol/dns/DnsRecord.h>


namespace SOL {
/**
 * DnsRecordCreator creates a list of  DNS_RECORDs allocated by using C++ new operator.
 * To free the list, we cannot use DnsRecordListFree API, because we are in a different world from the
 * memory space allocated by Windows DLLs.
 */

class DnsRecordCreator :public DnsRecord {
private:
    //Default Dns record flags;
    DNS_RECORD_FLAGS flags;

//private:
    //Pointer to the first element of DNS_RECORDs linked list 
    //DNS_RECORD* pRecord;

public:
    /**
     * Constructor
     */
    DnsRecordCreator()
    :DnsRecord()
    {
        memset(&flags, 0, sizeof(flags));

        flags.Section = DnsSectionAnswer;
#ifdef UNICODE
        flags.CharSet = DnsCharSetUnicode;
#else
        flags.CharSet = DnsCharSetAnsi;
#endif
    }


public:
    ~DnsRecordCreator()
    {
        clear();
    }

public:
    void clear()
    {
        DNS_RECORD* pRecord = getRecord();

        if (pRecord) {
            DNS_RECORD* ptr = pRecord;
            while (ptr) {
                DNS_RECORD* current = ptr;
                ptr = ptr ->pNext;
                //Delete each DNS_RECORD, but doesn't delete fields of the DNS_RECORD
                delete [] (BYTE*)current;
            }    
        }
    }

private:
    DNS_RECORD* alloc(const TCHAR* name, WORD type, int dataSize)
    {
        DNS_RECORD* aRecord =NULL;

        if (dataSize > 0) {
            DNS_RECORD r;
            int headerSize = sizeof(r) - sizeof(r.Data);
            
            //Record size(in bytes) for DNS_RECORD 
            int recordSize = sizeof(DNS_RECORD);
            
            int requiredSize = headerSize + dataSize;
            if (requiredSize > recordSize) {
                recordSize = requiredSize;
            }
            //printf("RecordSize=%d \n", recordSize);            
            aRecord = (DNS_RECORD*) new BYTE[recordSize];
            memset(aRecord, 0, recordSize);
            
            addRecord(aRecord);

            aRecord->pNext = NULL;
            aRecord->pName = (TCHAR*)name;//strdup(name);
            aRecord->wType = type;
            aRecord->dwTtl  = 0;
            aRecord->wDataLength = dataSize;
            aRecord->Flags.S = this->flags;

        } else {
            throw ERROR_INVALID_PARAMETER;
        }
        return aRecord;
    }

public:
    const DNS_RECORD* create(const DNS_A_DATA& data, const TCHAR* name, WORD type,
        const TCHAR* ipString)
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_A_DATA* pData = (DNS_A_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, ipString);

        return aRecord; 
    }

public:
    DNS_RECORD* create(const DNS_AAAA_DATA& data, const TCHAR* name, WORD type,
        const TCHAR* ip6String)
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_AAAA_DATA* pData = (DNS_AAAA_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, ip6String);

        return aRecord;
    }


public:
    const DNS_RECORD* create(DNS_MX_DATA& data, const TCHAR* name, WORD type,
        TCHAR* nameExchange, WORD preference)
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_MX_DATA* pData = (DNS_MX_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, nameExchange, preference);

        return aRecord; 
    }

public:
    const DNS_RECORD* create(DNS_NULL_DATA& data, const TCHAR* name, WORD type,
            const BYTE* bytes, int byteCount)
    {
        //The size of DNS_NULL_DATA
        int dataSize = sizeof(data.dwByteCount) + sizeof(data.Data) * byteCount;
        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_NULL_DATA* pData = (DNS_NULL_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, bytes, byteCount);

        return aRecord;
    }


public:
    const DNS_RECORD* create(const DNS_PTR_DATA& data, const TCHAR* name, WORD type,
        TCHAR* nameHost)
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_PTR_DATA* pData = (DNS_PTR_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, nameHost);

        return aRecord; 
    }



public:
    //WKS=Well Known Service
    const DNS_RECORD*  create(DNS_WKS_DATA& data, const TCHAR* name, WORD type,
        const TCHAR* ipString, 
        UCHAR chProtocol, 
        BYTE* bmask, 
        WORD maskCount)
    {
        int dataSize = sizeof(data.IpAddress) + sizeof(data.chProtocol) + sizeof(data.BitMask) * maskCount;

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_WKS_DATA* pData = (DNS_WKS_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, ipString, 
            chProtocol, 
            bmask, 
            maskCount);
        return aRecord;
    }

public:
    const DNS_RECORD* create(DNS_TXT_DATA& data, const TCHAR* name, WORD type,
            TCHAR** strings, 
            int stringCount)
    {
        int dataSize = sizeof(data.dwStringCount) +  sizeof(data.pStringArray) * stringCount;

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_TXT_DATA* pData = (DNS_TXT_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, strings, 
            stringCount);
        return aRecord;
    }

public:
    // SOA=Start Of Authority
    const DNS_RECORD* create(DNS_SOA_DATA& data, const TCHAR* name, WORD type,
        TCHAR* namePrimaryServer,
        TCHAR* nameAdministrator,
        DWORD serialNo,
        DWORD refresh,
        DWORD retry,
        DWORD expire,
        DWORD defaultTtl)
    {
        int dataSize = sizeof(data);
        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_SOA_DATA* pData = (DNS_SOA_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            namePrimaryServer,
            nameAdministrator,
            serialNo,
            refresh,
            retry,
            expire,
            defaultTtl);

        return aRecord;
    }

public:
    const DNS_RECORD* create(DNS_MINFO_DATA& data, const TCHAR* name, WORD type,
        TCHAR* nameMailbox,
        TCHAR* nameErrorsMailbox) 
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_MINFO_DATA* pData = (DNS_MINFO_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            nameMailbox,
            nameErrorsMailbox); 

        return aRecord;
    }

public:
    const DNS_RECORD* create(DNS_ATMA_DATA& data, const TCHAR* name, WORD type,
        BYTE addressType,
        int addressLength,            //DNS_ATMA_MAX_ADDR_LENGTH 
        BYTE* address)
    {
        int dataSize = sizeof(data.AddressType) + sizeof(data.Address);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_ATMA_DATA* pData = (DNS_ATMA_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData, 
            addressType,
            addressLength,
            address);
        return aRecord;
    }

public:
    const DNS_RECORD* create(DNS_KEY_DATA& data, const TCHAR* name, WORD type,
        WORD flags,
        BYTE protocol,
        BYTE algorithm,
        int keyLength,
        BYTE* key)
    {
        int dataSize = sizeof(data) - sizeof(data.Key) + sizeof(data.Key) * keyLength;

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_KEY_DATA* pData = (DNS_KEY_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            flags,
            protocol,
            algorithm,
            keyLength,
            key);
        return aRecord;
    }

public:
    const DNS_RECORD* create(DNS_SIG_DATA& data, const TCHAR* name, const WORD type,
        TCHAR* nameSigner,
        WORD typeConvered,
        BYTE algorithm,
        BYTE labelCount,
        DWORD originalTtl,
        DWORD expiration,
        DWORD timeSigned,
        WORD keyTag,
        //WORD pad,
        int sigLength,
        BYTE* signature)
    {
        int dataSize = sizeof(data) - sizeof(data.Signature) +  sizeof(data.Signature) * sigLength;

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_SIG_DATA* pData = (DNS_SIG_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            nameSigner,
            typeConvered,
            algorithm,
            labelCount,
            originalTtl,
            expiration,
            timeSigned,
            keyTag,
            //pad,
            sigLength,
            signature);

            return aRecord;
    }


public:
    const DNS_RECORD* create(DNS_NXT_DATA& data, const TCHAR* name, WORD type,
        TCHAR* nameNext, 
        WORD numTypes, 
        WORD* types) 
    {
        int dataSize = sizeof(data.pNameNext) + sizeof(data.wNumTypes) + sizeof(data.wTypes) * numTypes;

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_NXT_DATA* pData = (DNS_NXT_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            nameNext, 
            numTypes, 
            types);
        return aRecord;
    }

public:
    DNS_RECORD* create(DNS_SRV_DATA& data, const TCHAR* name, WORD type,
        TCHAR* nameTarget, 
        WORD priority, 
        WORD weight, 
        WORD port) 
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_SRV_DATA* pData = (DNS_SRV_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            nameTarget, 
            priority, 
            weight, 
            port);
        
        return aRecord;
    }


public:
    DNS_RECORD* create(DNS_NAPTR_DATA& data, const TCHAR* name, WORD type,
        WORD order,
        WORD preference,
        TCHAR* flags, 
        TCHAR* service,
        TCHAR* regularExpression,
        TCHAR* replacement)
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_NAPTR_DATA* pData = (DNS_NAPTR_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            order,
            preference,
            flags,
            service,
            regularExpression,
            replacement);

        return aRecord;
    }


public:
    DNS_RECORD* create(DNS_TKEY_DATA& data, const TCHAR* name, WORD type,
        TCHAR* nameAlgorithm,
        BYTE* algorithmPacket,
        BYTE* key,
        //BYTE* otherData,
        DWORD createTime,
        DWORD expireTime,
        WORD mode,
        WORD error,
        WORD keyLength,
        //WORD otherLength,
        UCHAR algNameLength)
        //BOOL packetPointers)
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_TKEY_DATA* pData = (DNS_TKEY_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            nameAlgorithm,
            algorithmPacket,
            key,
            //otherData,
            createTime,
            expireTime,
            mode,
            error,
            keyLength,
            //otherLength,
            algNameLength);
            //packetPointers);

        return aRecord;
    }

public:
    DNS_RECORD* create(DNS_TSIG_DATA& data, const TCHAR* name, WORD type,
        TCHAR* nameAlgorithm,
        BYTE* algorithmPacket,
        BYTE* signature,
        //BYTE* otherData,
        LONGLONG createTime,
        WORD fudgeTime,
        WORD originalXid,
        WORD error,
        WORD sigLength,
        //WORD otherLength,
        UCHAR algNameLength)
        //BOOL packetPointers)
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_TSIG_DATA* pData = (DNS_TSIG_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            nameAlgorithm,
            algorithmPacket,
            signature,
            //otherData,
            createTime,
            fudgeTime,
            originalXid,
            error,
            sigLength,
            //otherLength,
            algNameLength);
            //packetPointers);

        return aRecord;
    }


public:
    DNS_RECORD* create(DNS_WINS_DATA& data, const TCHAR* name, WORD type,
        DWORD mappingFlag, 
        DWORD lookupTimeout, 
        DWORD cacheTimeout,
        DWORD winsServerCount, 
        TCHAR* ipServers[]) 
    {
        int dataSize = sizeof(data.dwMappingFlag) + 
                sizeof( data.dwLookupTimeout) + sizeof(data.dwCacheTimeout) +
                sizeof(data.cWinsServerCount) + sizeof(data.WinsServers) * winsServerCount;

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_WINS_DATA* pData = (DNS_WINS_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            mappingFlag, 
            lookupTimeout, 
            cacheTimeout,
            winsServerCount, 
            ipServers);

        return aRecord;
    }


public:
    DNS_RECORD* create(DNS_WINSR_DATA& data, const TCHAR* name, WORD type,
        DWORD mappingFlag, 
        DWORD lookupTimeout, 
        DWORD cacheTimeout,
        TCHAR* nameResultDomain) 
    {
        int dataSize = sizeof(data);

        DNS_RECORD* aRecord = alloc(name, type, dataSize);

        DNS_WINSR_DATA* pData = (DNS_WINSR_DATA*)&(aRecord->Data);
        DnsData dnsData;
        dnsData.setValues(*pData,
            mappingFlag,
            lookupTimeout,
            cacheTimeout,
            nameResultDomain);

        return aRecord;
    }
};

}