/**************************************************************************
*   Copyright (C) 2005 by Achal Dhir                                      *
*   achaldhir@gmail.com                                                   *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
*   This program is distributed in the hope that it will be useful,       *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
*   GNU General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
***************************************************************************/
// Dual Service.cpp
#include <stdio.h>
#include <winsock2.h>
#include <time.h>
#include <tchar.h>
#include <ws2tcpip.h>
#include <limits.h>
#include <iphlpapi.h>
#include <process.h>
#include "DualServer.h"

//Function Prototypes
bool addServer(DWORD*, DWORD);
bool chkQu(char*);
BYTE getBaseValue(BYTE);
bool getSection(char*, char*, int, char*);
bool isIP(char*);
BYTE makeLocal(char*);
BYTE makeLocal(DWORD);
BYTE pIP(BYTE*, DWORD);
BYTE pIP(char*, DWORD);
BYTE pLong(BYTE*, DWORD);
BYTE pLong(char*, DWORD);
BYTE pShort(BYTE*, WORD);
BYTE pShort(char*, WORD);
BYTE* addOp(data1*);
BYTE* pvdata(BYTE*, data1*, data3*);
char getRangeInd(DWORD);
char* cleanstr(char*, bool);
char* cloneString(char*);
char* getHexValue(BYTE*, char*, BYTE*);
char* getResult(dnsPacket*);
char* hex2String(BYTE*, BYTE);
char* IP2String(char*, DWORD);
char* myLower(char* string);
char* myUpper(char* string);
char* toBase64(BYTE*, BYTE);
data7* delDhcpEntry(data7*);
data7* delDnsEntry(data7*);
data7* findEntry(BYTE, char*);
data7* findEntry(BYTE, char*, BYTE);
DWORD alad(data1*);
DWORD calcMask(DWORD, DWORD);
DWORD chad(data1*);
DWORD fIP(BYTE*);
DWORD fIP(char*);
DWORD fLong(BYTE*);
DWORD fLong(char*);
DWORD getNetwork(DWORD);
DWORD getRefresh(BYTE);
DWORD getSerial();
DWORD resad(data1*);
DWORD sdmess(data1*);
DWORD sendRepl(data1 *req);
DWORD updateDHCP(data1*);
DWORD* findServer(DWORD*, DWORD);
int getIndex(char, DWORD);
void addAuth(data5*);
void addEntry(BYTE, data7*);
void addRRA(data5*);
void addRRAAFXR(data5*);
void addRRCNAFXR(data5*);
void addRRExt(data5*);
void addRRLocalhostA(data5*);
void addRRLocalhostPtr(data5*);
void addRRMX(data5*);
void addRRMXAFXR(data5*);
void addRRNSA(data5*);
void addRRNSPtr(data5*);
void addRRPtr(data5*);
void addRRServerA(data5*);
void addRRSOA(data5*);
void addRRSTAFXR(data5*);
void addToCache(BYTE, BYTE, char*, DWORD, time_t, BYTE, BYTE, DWORD, bool);
void calcRangeLimits(DWORD, DWORD, DWORD*, DWORD*);
void checkSize();
void fromBase64(BYTE*, char*);
void getDServ();
void getServ();
void init();
void logMess(char*, BYTE);
void recvRepl(data1*);
void refresh(void*);
void runProg();
void setLeaseExpiry(char, DWORD, time_t);
void procTCP(void*);
WORD fdnmess(data5*);
WORD fQu(char*, char*);
WORD fQu(char*, dnsPacket*, char*);
WORD frdnmess(data5*);
WORD fShort(BYTE*);
WORD fShort(char*);
WORD gdmess(data1*, BYTE);
WORD gdnmess(data5*, BYTE);
WORD myRecv(SOCKET, char*, WORD);
WORD listSections(char*, int, char*);
WORD loadOptions(BYTE*, WORD, char*, char*, DWORD*);
WORD pQu(char*, char*);
WORD qLen(char*);
WORD scanloc(data5*);
WORD sdnmess(data5*);
WORD sTCPmess(data5 *req);

//Global Variables
SERVICE_STATUS serviceStatus;
SERVICE_STATUS_HANDLE serviceStatusHandle = 0;
HANDLE stopServiceEvent = 0;
data2 cfig;
BYTE cacheInd = 0;
bool zoneChanged = false;
hostMap dnsCache[2];
dhcpMap dhcpCache;
expiryMap dnsAge;
char serviceName[] = "DUALServer";
char displayName[] = "Dual DHCP DNS Service";
char tempbuff[256];
char logBuff[256];
bool verbatim = false;
char iniFile[_MAX_PATH]; // "DualServer.ini"
char leaFile[_MAX_PATH]; // "DualServer.state"
char logFile[_MAX_PATH]; // "DualServer.state"
char arpa[] = ".in-addr.arpa";
bool dhcpService = true;
bool dnsService = true;
timeval tv;
fd_set readfds;
fd_set writefds;

//constants
const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const data4 opdata[] =
    {
        {"IP_Addr", 0, 0},
        {"DHCP_Range", 0, 255},
        //{"Authorized", 0, 1},
        {"SubNet_Mask", DHCP_OPTION_NETMASK, 0},
        {"Time_Offset", DHCP_OPTION_TIMEOFFSET, 4},
        {"Router", DHCP_OPTION_ROUTER, 0},
        {"Time_Server", DHCP_OPTION_TIMESERVER, 0},
        {"Name_Server", DHCP_OPTION_NAMESERVER, 0},
        {"DNS_Server", DHCP_OPTION_DNS, 0},
        {"Log_Server", DHCP_OPTION_LOGSERVER, 0},
        {"Cookie_Server", DHCP_OPTION_COOKIESERVER, 0},
        {"LPR_Server", DHCP_OPTION_LPRSERVER, 0},
        {"Impress_Server", DHCP_OPTION_IMPRESSSERVER, 0},
        {"RLP_Server", DHCP_OPTION_RESLOCSERVER, 0},
        {"Hostname", DHCP_OPTION_HOSTNAME, 255},
        {"Boot_File_Size", DHCP_OPTION_BOOTFILESIZE, 2},
        //{"Zone_Name", DHCP_OPTION_DOMAINNAME, 255},
        {"Swap_Server", DHCP_OPTION_SWAPSERVER, 0},
        {"Root_Path", DHCP_OPTION_ROOTPATH, 255},
        {"Extension_Path", DHCP_OPTION_EXTSPATH, 255},
        {"Forward_On/Off", DHCP_OPTION_IPFORWARD, 1},
        {"SrcRte_On/Off", DHCP_OPTION_NONLOCALSR, 1},
        {"Policy_Filter_IP", DHCP_OPTION_POLICYFILTER, 0},
        {"Policy_Filter_Mask", DHCP_OPTION_POLICYFILTER, 0},
        {"Default_IP_TTL", DHCP_OPTION_IPTTL, 1},
        {"MTU_Timeout", DHCP_OPTION_PATHMTUAGING, 4},
        {"MTU_Plateau", DHCP_OPTION_PATHMTUPLATEAU, 2},
        {"MTU_Interface", DHCP_OPTION_INTERFACEMTU, 2},
        {"MTU_Subnet", DHCP_OPTION_SUBNETSLOCAL, 1},
        {"Broadcast_Address", DHCP_OPTION_BCASTADDRESS, 0},
        {"Mask_Discovery", DHCP_OPTION_MASKDISCOVERY, 1},
        {"Mask_Supplier", DHCP_OPTION_MASKSUPPLIER, 1},
        {"Router_Discovery", DHCP_OPTION_ROUTERDISCOVERY, 1},
        {"Router_Request", DHCP_OPTION_ROUTERSOLIC, 0},
        {"Static_Route_IP", DHCP_OPTION_STATICROUTE, 0},
        {"Static_Route_Mask", DHCP_OPTION_STATICROUTE, 0},
        {"Trailers", DHCP_OPTION_TRAILERENCAPS, 1},
        {"ARP_Timeout", DHCP_OPTION_ARPTIMEOUT, 4},
        {"Ethernet_Encp", DHCP_OPTION_ETHERNETENCAPS, 1},
        {"Default_TCP_TTL", DHCP_OPTION_TCPTTL, 1},
        {"Keepalive_Time", DHCP_OPTION_TCPKEEPALIVEINT, 4},
        {"Keepalive_Data", DHCP_OPTION_TCPKEEPALIVEGRBG, 1},
        {"NIS_Domain", DHCP_OPTION_NISDOMAIN, 255},
        {"NIS_Servers", DHCP_OPTION_NISSERVERS, 0},
        {"NTP_Servers", DHCP_OPTION_NTPSERVERS, 0},
        {"NETBIOS_Name_Srv", DHCP_OPTION_NETBIOSNAMESERV, 0},
        {"NETBIOS_Dist_Srv", DHCP_OPTION_NETBIOSDGDIST, 0},
        {"NETBIOS_Node_Type", DHCP_OPTION_NETBIOSNODETYPE, 1},
        {"NETBIOS_Scope", DHCP_OPTION_NETBIOSSCOPE, 255},
        {"X_Window_Font", DHCP_OPTION_X11FONTS, 0},
        {"X_Window_Manager", DHCP_OPTION_X11DISPLAYMNGR, 0},
        //{"Max_Lease", DHCP_OPTION_IPADDRLEASE, 4},
        {"Renewal_Time", DHCP_OPTION_RENEWALTIME, 4},
        {"Rebinding_Time", DHCP_OPTION_REBINDINGTIME, 4},
        {"Netware/IP_Domain", 62, 255},
        {"Netware/IP_Option", 63, 0},
        {"NIS+_Domain_Name", DHCP_OPTION_NISPLUSDOMAIN, 255},
        {"NIS+_Server_Addr", DHCP_OPTION_NISPLUSSERVERS, 0},
        {"TFTP_Server_Name", DHCP_OPTION_TFTPSERVER, 255},
        {"Boot_File", DHCP_OPTION_BOOTFILE, 255},
        {"Home_Agent_Addrs", DHCP_OPTION_MOBILEIPHOME, 0},
        {"SMTP_Server", DHCP_OPTION_SMTPSERVER, 0},
        {"POP3_Server", DHCP_OPTION_POP3SERVER, 0},
        {"NNTP_Server", DHCP_OPTION_NNTPSERVER, 0},
        {"WWW_Server", DHCP_OPTION_WWWSERVER, 0},
        {"Finger_Server", DHCP_OPTION_FINGERSERVER, 0},
        {"IRC_Server", DHCP_OPTION_IRCSERVER, 0},
        {"StreetTalk_Server", DHCP_OPTION_STSERVER, 0},
        {"STDA_Server", DHCP_OPTION_STDASERVER, 0},
        {"iSNS", 83, 14},
        {"NDS_Servers", DHCP_OPTION_NDSSERVERS, 0},
        {"NDS_Tree_Name", DHCP_OPTION_NDSTREENAME, 255},
        {"NDS_Context", 87, 255},
        {"LDAP_URL", DHCP_OPTION_LDAP, 255},
        {"Auto_Configure", DHCP_OPTION_AUTO_CONFIG, 1},
        {"Name_Service_Search", DHCP_OPTION_NAMESERVICESEARCH, 2},
        {"Subnet_Selection", DHCP_OPTION_SUBNETSELECTION, 0},
        {"DNS_Domain_Search", DHCP_OPTION_DOMAINSEARCH, 255},
        {"TFTP_Phone_Server", DHCP_OPTION_TFPTSERVERIPADDRESS, 0},
        //{"TFTP_Server", DHCP_OPTION_TFPTSERVERIPADDRESS, 0},
        {"Call_Server", DHCP_OPTION_CALLSERVERIPADDRESS, 0},
        {"Discrimination_String", DHCP_OPTION_DISCRIMINATIONSTRING, 255},
        {"RemoteStatisticsServer", DHCP_OPTION_REMOTESTATISTICSSERVER, 0},
        {"Phone_Http_Proxy", DHCP_OPTION_HTTPPROXYFORPHONE_SPEC, 0},
        {"IP_Phone", 176, 255},
        {"Next_Server", DHCP_OPTION_NEXTSERVER, 0}
    };

void WINAPI ServiceControlHandler(DWORD controlCode)
{
	switch (controlCode)
	{
		case SERVICE_CONTROL_INTERROGATE:
			break;

		case SERVICE_CONTROL_SHUTDOWN:
		case SERVICE_CONTROL_STOP:
			serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
			SetServiceStatus(serviceStatusHandle, &serviceStatus);

			SetEvent(stopServiceEvent);
			return ;

		case SERVICE_CONTROL_PAUSE:
			break;

		case SERVICE_CONTROL_CONTINUE:
			break;

		default:
			if (controlCode >= 128 && controlCode <= UCHAR_MAX)
				break;
			else
				break;
	}

	SetServiceStatus(serviceStatusHandle, &serviceStatus);
}

void WINAPI ServiceMain(DWORD /*argc*/, TCHAR* /*argv*/[])
{
	serviceStatus.dwServiceType = SERVICE_WIN32;
	serviceStatus.dwCurrentState = SERVICE_STOPPED;
	serviceStatus.dwControlsAccepted = 0;
	serviceStatus.dwWin32ExitCode = NO_ERROR;
	serviceStatus.dwServiceSpecificExitCode = NO_ERROR;
	serviceStatus.dwCheckPoint = 0;
	serviceStatus.dwWaitHint = 0;

	serviceStatusHandle = RegisterServiceCtrlHandler(serviceName, ServiceControlHandler);

	if (serviceStatusHandle)
	{
		serviceStatus.dwCurrentState = SERVICE_START_PENDING;
		SetServiceStatus(serviceStatusHandle, &serviceStatus);

		init();
		data1 dhcpr;
		data5 dnsr;
		tv.tv_sec = 20;
		tv.tv_usec = 0;

		stopServiceEvent = CreateEvent(0, FALSE, FALSE, 0);

		serviceStatus.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
		serviceStatus.dwCurrentState = SERVICE_RUNNING;
		SetServiceStatus(serviceStatusHandle, &serviceStatus);

		if (cfig.dhcpConn[0].server || cfig.dnsUdpConn[0].server)
		{
			do
			{
				FD_ZERO(&readfds);

				if (dhcpService)
				{
					for (int i = 0; i < MAX_SERVERS && cfig.dhcpConn[i].server; i++)
						FD_SET(cfig.dhcpConn[i].sock, &readfds);
				}

				if (dnsService)
				{
					for (int i = 0; i < MAX_SERVERS && cfig.dnsUdpConn[i].server; i++)
						FD_SET(cfig.dnsUdpConn[i].sock, &readfds);

					FD_SET(cfig.forwConn.sock, &readfds);

					for (int i = 0; i < MAX_SERVERS && cfig.dnsTcpConn[i].server; i++)
						FD_SET(cfig.dnsTcpConn[i].sock, &readfds);

				}

				//printf("%i\n",select(USHRT_MAX, &readfds, NULL, NULL, &tv));
				if (select(cfig.maxFD, &readfds, NULL, NULL, &tv))
				{
					if (dhcpService)
					{
						for (int i = 0; i < MAX_SERVERS && cfig.dhcpConn[i].server; i++)
						{
							if (FD_ISSET(cfig.dhcpConn[i].sock, &readfds))
							{
								if (gdmess(&dhcpr, i))
								{
									if (sdmess(&dhcpr))
									{
										if (alad(&dhcpr))
										{
											if (dhcpr.lease)
											{
												if (cfig.logLevel == 2)
												{
													sprintf(logBuff, "Host %s alotted %s for %u seconds", dhcpr.hostname, IP2String(tempbuff, dhcpr.dhcpp.header.bp_yiaddr), dhcpr.lease);
													logMess(logBuff, 2);
												}
											}
											else
											{
												if (cfig.logLevel == 2)
												{
													sprintf(logBuff, "Host %s alotted %s", dhcpr.hostname, IP2String(tempbuff, dhcpr.dhcpp.header.bp_yiaddr));
													logMess(logBuff, 2);
												}
											}
										}
									}
								}
							}
						}
					}

					if (dnsService)
					{
						for (int i = 0; i < MAX_SERVERS && cfig.dnsUdpConn[i].server; i++)
						{
							if (FD_ISSET(cfig.dnsUdpConn[i].sock, &readfds))
							{
								if (gdnmess(&dnsr, i))
								{
									if (dnsr.dnsp->header.rcode == RCODE_REFUSED)
									{
										if (cfig.logLevel)
										{
											sprintf(logBuff, "Client %s, DNS Query, Access Denied", inet_ntoa(dnsr.addr.sin_addr));
											logMess(logBuff, 1);
										}
										sdnmess(&dnsr);
									}
									else if (dnsr.dnsp->header.rcode == RCODE_NOTIMPL)
									{
										if (cfig.logLevel)
										{
											sprintf(logBuff, "Client %s, DNS Query Type %u not supported", inet_ntoa(dnsr.addr.sin_addr), dnsr.qtype);
											logMess(logBuff, 1);
										}
										sdnmess(&dnsr);
									}
									else if (scanloc(&dnsr))
									{
										if (dnsr.dnsp->header.rcode == RCODE_NOTIMPL)
										{
											if (cfig.logLevel)
											{
												sprintf(logBuff, "Client %s, DNS Query Type %u not supported", inet_ntoa(dnsr.addr.sin_addr), dnsr.qtype);
												logMess(logBuff, 1);
											}
										}
										else if (dnsr.dnsp->header.rcode == RCODE_NOTAUTH)
										{
											if (cfig.logLevel)
											{
												sprintf(logBuff, "Client %s, Server is not Authorized for Zone %s", inet_ntoa(dnsr.addr.sin_addr), dnsr.query);
												logMess(logBuff, 1);
											}
										}
										else if (htons(dnsr.dnsp->header.ancount))
										{
											if (cfig.logLevel == 2)
											{
												if (dnsr.qtype == DNS_TYPE_SOA)
														sprintf(logBuff, "Client %s, SOA Sent", inet_ntoa(dnsr.addr.sin_addr));
												else if (dnsr.qtype == DNS_TYPE_NS)
														sprintf(logBuff, "Client %s, NS Sent", inet_ntoa(dnsr.addr.sin_addr));
												else if (dnsr.cache.dataType == CACHED)
													sprintf(logBuff, "%s resolved from Cache to %s", dnsr.query, getResult(dnsr.dnsp));
												else
													sprintf(logBuff, "%s resolved Locally to %s", dnsr.query, getResult(dnsr.dnsp));

												logMess(logBuff, 2);
											}
										}
										else
										{
											if (cfig.logLevel == 2)
											{
												sprintf(logBuff, "%s not found", dnsr.cname);
												logMess(logBuff, 2);
											}
										}
										sdnmess(&dnsr);
									}
									else if (!fdnmess(&dnsr))
									{
										if (dnsr.localCode == 2)
										{
											if (cfig.logLevel)
											{
												sprintf(logBuff, "%s not found", dnsr.cname);
												logMess(logBuff, 2);
											}
										}
										else
										{
											if (cfig.logLevel)
											{
												sprintf(logBuff, "Failed to Forward %s", dnsr.cname);
												logMess(logBuff, 1);
											}
										}
									}
								}
							}
						}

						for (int i = 0; i < MAX_SERVERS && cfig.dnsTcpConn[i].server; i++)
						{
							if (FD_ISSET(cfig.dnsTcpConn[i].sock, &readfds))
							{
								data5 *req = (data5*)calloc(sizeof(data5), 1);
								if (!req)
								{
									sprintf(logBuff, "Memory Error");
									logMess(logBuff, 1);
									continue;
								}

								req->sockInd = i;
								req->sockLen = sizeof(req->addr);
								errno = 0;
								req->sock = accept(cfig.dnsTcpConn[i].sock, (sockaddr*)&req->addr, &req->sockLen);

								if (req->sock == -1)
								{
									if (cfig.logLevel)
									{
										sprintf(logBuff, "Accept Failed, Error=%u", WSAGetLastError());
										logMess(logBuff, 1);
										free(req);
									}
									continue;
								}

								if (_beginthread(
								    procTCP,              		// thread function
								    0,                         	// default security attributes
								    req) < 0)        			// argument to thread function
									{
										if (cfig.logLevel)
										{
											sprintf(logBuff, "Thread Creation Failed");
											logMess(logBuff, 1);
										}
										free(req);
									}
							}
						}