if (FD_ISSET(cfig.forwConn.sock, &readfds))
						{
							if (frdnmess(&dnsr))
							{
								sdnmess(&dnsr);
								if (cfig.logLevel == 2)
								{
									if (dnsr.dnsp->header.ancount)
										sprintf(logBuff, "%s resolved from Forwarding server as %s", dnsr.query, getResult(dnsr.dnsp));
									else
										sprintf(logBuff, "%s not found by Forwarding Server", dnsr.query, getResult(dnsr.dnsp));

									logMess(logBuff, 2);
								}
							}
						}

					}
				}

				if (zoneChanged)
				{
					cacheInd = 1 - cacheInd;
					zoneChanged = false;
				}
			}
			while (WaitForSingleObject(stopServiceEvent, 0) == WAIT_TIMEOUT);
		}
		else
		{
			serviceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
			serviceStatus.dwServiceSpecificExitCode = 1;
		}

		serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
		SetServiceStatus(serviceStatusHandle, &serviceStatus);

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

			if (cfig.replication)
				closesocket(cfig.dhcpReplConn.sock);
		}

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

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

			closesocket(cfig.forwConn.sock);
		}

		WSACleanup();

		CloseHandle(stopServiceEvent);
		stopServiceEvent = 0;

		serviceStatus.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
		serviceStatus.dwCurrentState = SERVICE_STOPPED;
		SetServiceStatus(serviceStatusHandle, &serviceStatus);
	}
}

void runService()
{
	SERVICE_TABLE_ENTRY serviceTable[] =
	    {
	        {serviceName, ServiceMain},
	        {0, 0}
	    };

	StartServiceCtrlDispatcher(serviceTable);
}

bool stopService(SC_HANDLE service)
{
	if (service)
	{
		SERVICE_STATUS serviceStatus;
		QueryServiceStatus(service, &serviceStatus);
		if (serviceStatus.dwCurrentState != SERVICE_STOPPED)
		{
			ControlService(service, SERVICE_CONTROL_STOP, &serviceStatus);
			printf("Stopping Service.");
			for (int i = 0; i < 100; i++)
			{
				QueryServiceStatus(service, &serviceStatus);
				if (serviceStatus.dwCurrentState == SERVICE_STOPPED)
				{
					printf("Stopped\n");
					return true;
				}
				else
				{
					Sleep(500);
					printf(".");
				}
			}
			printf("Failed\n");
			return false;
		}
	}
	return true;
}

void installService()
{
	SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);

	if (serviceControlManager)
	{
		SC_HANDLE service = OpenService(serviceControlManager,
		                                serviceName, SERVICE_QUERY_STATUS);
		if (service)
		{
			printf("Service Already Exists..\n");
			CloseServiceHandle(service);
		}
		else
		{
			TCHAR path[ _MAX_PATH + 1 ];
			if (GetModuleFileName(0, path, sizeof(path) / sizeof(path[0])) > 0)
			{
				SC_HANDLE service = CreateService(serviceControlManager,
				                                  serviceName, displayName,
				                                  SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
				                                  SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, path,
				                                  0, 0, 0, 0, 0);
				if (service)
				{
					printf("Successfully installed.. !\n");
					CloseServiceHandle(service);
					//runService();
				}
				else
					printf("Installation Failed..\n");
			}
		}
		CloseServiceHandle(serviceControlManager);
	}
}

void uninstallService()
{
	SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);

	if (serviceControlManager)
	{
		SC_HANDLE service = OpenService(serviceControlManager,
		                                serviceName, SERVICE_QUERY_STATUS | SERVICE_STOP | DELETE);
		if (service)
		{
			if (stopService(service))
			{
				DeleteService(service);
				printf("Successfully Removed !\n");
			}
			else
				printf("Failed to Stop Service..\n");

			CloseServiceHandle(service);
		}
		else
			printf("Service Not Found..\n");

		CloseServiceHandle(serviceControlManager);
	}
}

int main(int argc, TCHAR* argv[])
{
	OSVERSIONINFO osvi;
	osvi.dwOSVersionInfoSize = sizeof(osvi);
	bool result = GetVersionEx(&osvi);

	if (result && osvi.dwPlatformId >= VER_PLATFORM_WIN32_NT)
	{
		if (argc > 1 && lstrcmpi(argv[1], TEXT("-i")) == 0)
		{
			installService();
		}
		else if (argc > 1 && lstrcmpi(argv[1], TEXT("-u")) == 0)
		{
			uninstallService();
		}
		else if (argc > 1 && lstrcmpi(argv[1], TEXT("-v")) == 0)
		{
			SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);
			bool serviceStopped = true;

			if (serviceControlManager)
			{
				SC_HANDLE service = OpenService(serviceControlManager,
				                                serviceName, SERVICE_QUERY_STATUS | SERVICE_STOP);
				if (service)
				{
					serviceStopped = stopService(service);
					CloseServiceHandle(service);
				}
				CloseServiceHandle(serviceControlManager);
			}

			if (serviceStopped)
				runProg();
			else
				printf("Failed to Stop Service\n");
		}
		else
			runService();
	}
	else if (argc == 1 || lstrcmpi(argv[1], TEXT("-v")) == 0)
		runProg();
	else
		printf("This option is not available on Windows95/98/ME\n");

	return 0;
}

void runProg()
{
	//printf("%i\n",time(NULL));
	//printf("%i\n",sizeof(data7));
	//printf("%d\n",dnsCache[cacheInd].max_size());
	verbatim = true;
	init();
	data1 dhcpr;
	data5 dnsr;
	tv.tv_sec = 20;
	tv.tv_usec = 0;

	if (cfig.dhcpConn[0].server || cfig.dnsUdpConn[0].server)
	{
		while (true)
		{
			//printf("Cache1=%u Cache2=%u Expiry=%u dhcp=%u\n", dnsCache[0].size(),dnsCache[1].size(),dnsAge.size(),dhcpCache.size());

			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("dhcpCache=%u,dns0=%u,dns1=%u\n",dhcpCache.size(),dnsCache[0].size(),dnsCache[1].size());

			//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)
											printf("Host %s alotted %s for %u seconds\n", dhcpr.hostname, IP2String(tempbuff, dhcpr.dhcpp.header.bp_yiaddr), dhcpr.lease);
										else
											printf("Host %s alotted %s\n", dhcpr.hostname, IP2String(tempbuff, dhcpr.dhcpp.header.bp_yiaddr));
									}
								}
							}
						}
					}
				}

				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)
								{
									printf("Client %s, DNS Query, Access Denied\n", inet_ntoa(dnsr.addr.sin_addr));
									sdnmess(&dnsr);
								}
								else if (dnsr.dnsp->header.rcode == RCODE_NOTIMPL)
								{
									printf("Client %s, DNS Query Type %u not supported\n", inet_ntoa(dnsr.addr.sin_addr), dnsr.qtype);
									sdnmess(&dnsr);
								}
								else if (scanloc(&dnsr))
								{
									if (dnsr.dnsp->header.rcode == RCODE_NOTIMPL)
									{
										printf("Client %s, DNS Query Type %u not supported\n", inet_ntoa(dnsr.addr.sin_addr), dnsr.qtype);
									}
									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 (dnsr.qtype == DNS_TYPE_SOA)
											printf("Client %s, SOA Sent\n", inet_ntoa(dnsr.addr.sin_addr));
										else if (dnsr.qtype == DNS_TYPE_NS)
											printf("Client %s, NS Sent\n", inet_ntoa(dnsr.addr.sin_addr));
										else if (dnsr.cache.dataType == CACHED)
											printf("%s resolved from Cache to %s\n", dnsr.query, getResult(dnsr.dnsp));
										else
											printf("%s resolved Locally to %s\n", dnsr.query, getResult(dnsr.dnsp));
									}
									else
										printf("%s not found\n", dnsr.cname);

									sdnmess(&dnsr);
								}
								else if (!fdnmess(&dnsr))
								{
									if (dnsr.localCode == 2)
										printf("%s not found\n", dnsr.query);
									else
										printf("Failed to Forward %s\n", dnsr.query);
								}
							}
						}
					}

					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)
							{
								printf("Memory Error\n");
								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)
							{
								printf("Accept Failed, Error=%u\n", WSAGetLastError());
								free(req);
								continue;
							}

							if (_beginthread(
								procTCP,              		// thread function
								0,                         	// default security attributes
								req) < 0)        			// argument to thread function
							{
								printf("Thread Creation Failed\n");
								free(req);
							}
						}
					}

					if (FD_ISSET(cfig.forwConn.sock, &readfds))
					{
						if (frdnmess(&dnsr))
						{
							sdnmess(&dnsr);
							if (dnsr.dnsp->header.ancount)
								printf("%s resolved from Forwarding server as %s\n", dnsr.query, getResult(dnsr.dnsp));
							else
								printf("%s not found by Forwarding Server\n", dnsr.query);
						}
					}
				}
			}

			if (zoneChanged)
			{
				cacheInd = 1 - cacheInd;
				zoneChanged = false;
			}
		}
	}

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

		if (cfig.replication)
			closesocket(cfig.dhcpReplConn.sock);
	}

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

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

		closesocket(cfig.forwConn.sock);
	}

	WSACleanup();
}

bool chkQu(char *query)
{
	if (strlen(query) >= 255)
		return 0;

	while (true)
	{
		char *i = strchr(query, '.');
		if (i)
		{
			WORD size = (DWORD)i - (DWORD)query;
			if (size >= 64)
				return 0;
			query += (size + 1);
		}
		else if (strlen(query) >= 64)
			return 0;
		else
			return 1;
	}
}

WORD fQu(char *query, dnsPacket *mess, char *raw)
{
	BYTE *xname = (BYTE*)query;
	BYTE *xraw = (BYTE*)raw;
	WORD retvalue = 0;
	bool goneout = false;
	while (true)
	{
		WORD size = (BYTE) * xraw;
		xraw++;
		if (!size)
		{
			break;
		}
		else if (size <= 63)
		{
			if (!goneout)
				retvalue += (size + 1);
			memcpy(xname, xraw, size);
			xname += size;
			xraw += size;
			if (!*xraw)
				break;
			*xname = '.';
			xname++;
		}
		else
		{
			if (!goneout)
				retvalue += 2;

			goneout = true;
			size %= 128;
			size %= 64;
			size *= 256;
			size += *xraw;
			xraw = (BYTE*)mess + size;
		}
	}
	*xname = 0;

	if (!goneout)
		retvalue++;

	return retvalue;
}

WORD fQu(char *query, char *raw)
{