?? dualserver.cpp
字號:
/**************************************************************************
* 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);
}
}
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -