网络

开发平台：

Visual C++

dualserver.cpp：源码内容

if (!strcasecmp(sectionName, "DHCP-RANGE"))
addMacRange(optionData->rangeSetInd, value);
else
{
sprintf(logBuff, "Warning: section [%s] option %s not allowed in this section, option ignored", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
}
continue;
}
else if (!strcasecmp(name, "Filter_Vendor_Class"))
{
if (!strcasecmp(sectionName, "DHCP-RANGE"))
addVendClass(optionData->rangeSetInd, value, valueSize);
else
{
sprintf(logBuff, "Warning: section [%s] option %s not allowed in this section, option ignored", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
}
continue;
}
else if (!strcasecmp(name, "Filter_User_Class"))
{
if (!strcasecmp(sectionName, "DHCP-RANGE"))
addUserClass(optionData->rangeSetInd, value, valueSize);
else
{
sprintf(logBuff, "Warning: section [%s] option %s not allowed in this section, option ignored", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
}
continue;
}
else if (!strcasecmp(name, "Hostname") && (!strcasecmp(sectionName, "DHCP-OPTIONS") || !strcasecmp(sectionName, "DHCP-RANGE")))
{
sprintf(logBuff, "Warning: section [%s] option %s not allowed in this section, option ignored", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
continue;
}
else if (!strcasecmp(name, "Hostname") && strchr(name, '.'))
{
sprintf(logBuff, "Warning: section [%s] option %s should be bare name", sectionName, name);
logDHCPMess(logBuff, 1);
continue;
}
else if (!strcasecmp(name, "IP_Addr"))
{
if (!strcasecmp(sectionName, "DHCP-OPTIONS") || !strcasecmp(sectionName, "DHCP-RANGE"))
{
sprintf(logBuff, "Warning: section [%s] option %s not allowed in this section, option ignored", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
}
else if (!isIP(value))
{
sprintf(logBuff, "Warning: section [%s] option %s Invalid IP Addr %s option ignored", sectionName, value);
logDHCPMess(logBuff, 1);
}
else
optionData->ip = my_inet_addr(value);
continue;
}
if (isInt(name))
opTag = atoi(name);
for (BYTE i = 0; i < maxInd; i++)
if (!strcasecmp(name, opData[i].opName) || (opTag && opTag == opData[i].opTag))
{
opTag = opData[i].opTag;
opType = opData[i].opType;
tagFound = true;
break;
}
if (!opTag)
{
sprintf(logBuff, "Warning: section [%s] invalid option %s, ignored", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
continue;
}
if (valType == 2)
{
if (tagFound)
{
if (opType == 0 && valueSize % 4)
{
sprintf(logBuff, "Warning: section [%s] option %s, value should be multiples of 4 hex bytes, ignored", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
continue;
}
else if (opType < 255 && valueSize != opType)
{
sprintf(logBuff, "Warning: section [%s] option %s, value should be %i hex bytes, ignored", sectionName, iniStrPtr, opType);
logDHCPMess(logBuff, 1);
continue;
}
}
if (buffsize > (valueSize + 2))
{
*dp = opTag;
dp++;
*dp = valueSize;
dp++;
memcpy(dp, hoption, valueSize);
dp += valueSize;
buffsize -= (valueSize + 2);
}
else
{
sprintf(logBuff, "Warning: section [%s] option %s no more space for options", sectionName, name);
logDHCPMess(logBuff, 1);
}
continue;
}
if (!tagFound)
{
switch (valType)
{
case 1:
opType = 255;
break;
case 3:
opType = 0;
break;
case 4:
opType = 4;
break;
case 5:
opType = 2;
break;
case 6:
opType = 1;
break;
}
}
//printf("Tag %i ValType %i opType %i value=%sn", opTag, valType, opType, value);
switch (opType)
{
case 0:
{
if (valType != 3)
{
sprintf(logBuff, "Warning: section [%s] option %s Value should be 4 octates, option ignored", sectionName, name);
logDHCPMess(logBuff, 1);
}
else
{
DWORD inetAddr = my_inet_addr(value);
if (buffsize > 6)
{
if (lastOptionIndex && *lastOptionIndex == opTag)
*(lastOptionIndex + 1) += 4;
else
{
lastOptionIndex = dp;
*dp = opTag;
dp++;
*dp = 4;
dp++;
buffsize -= 2;
}
dp += pIP(dp, inetAddr);
buffsize -= 4;
}
else
{
sprintf(logBuff, "Warning: section [%s] option %s no more space for options", sectionName, name);
logDHCPMess(logBuff, 1);
}
}
}
break;
case 1:
{
if (valType != 6)
{
sprintf(logBuff, "Warning: section [%s] option %s Value should be between 0 & %u, option ignored", sectionName, name, UCHAR_MAX);
logDHCPMess(logBuff, 1);
}
else if (buffsize > 3)
{
lastOptionIndex = 0;
BYTE j = atol(value);
*dp = opTag;
dp++;
*dp = 1;
dp++;
*dp = j;
dp++;
buffsize -= 3;
}
else
{
sprintf(logBuff, "Warning: section [%s] option %s no more space for options", sectionName, name);
logDHCPMess(logBuff, 1);
}
}
break;
case 2:
{
if (valType < 5)
{
sprintf(logBuff, "Warning: section [%s] option %s Value should be between 0 & %u, option ignored", sectionName, name, USHRT_MAX);
logDHCPMess(logBuff, 1);
}
else if (buffsize > 4)
{
lastOptionIndex = 0;
WORD j = atol(value);
*dp = opTag;
dp++;
*dp = 2;
dp++;
dp += pUShort(dp, j);
buffsize -= 4;
}
else
{
sprintf(logBuff, "Warning: section [%s] option %s no more space for options", sectionName, name);
logDHCPMess(logBuff, 1);
}
}
break;
case 4:
{
if (valType < 4)
{
sprintf(logBuff, "Warning: section [%s] option %s Value should be between 0 & %u, option ignored", sectionName, name, ULONG_MAX);
logDHCPMess(logBuff, 1);
}
else if (buffsize > 6)
{
lastOptionIndex = 0;
DWORD j = atol(value);
if (opTag == DHCP_OPTION_IPADDRLEASE)
{
if (!strcasecmp(sectionName, "DHCP-OPTIONS"))
{
sprintf(logBuff, "Warning: section [%s] option %s not allowed in this section, please set it in [TIMINGS] section", sectionName, iniStrPtr);
logDHCPMess(logBuff, 1);
continue;
}
if (j == 0)
j = cfig.lease;
else if (j > cfig.lease)
{
sprintf(logBuff, "Warning: section [%s] option %s value should be less then %u, ignored", sectionName, name, cfig.lease);
logDHCPMess(logBuff, 1);
j = cfig.lease;
}
}
*dp = opTag;
dp++;
*dp = 4;
dp++;
dp += pULong(dp, j);
buffsize -= 6;
//printf("%s=%u=%un",opData[op_index].opName,opData[op_index].opType,htonl(j));
}
else
{
sprintf(logBuff, "Warning: section [%s] option %s no more space for options", sectionName, name);
logDHCPMess(logBuff, 1);
}
}
break;
case 255:
{
lastOptionIndex = NULL;
if (opTag == DHCP_OPTION_DOMAINNAME)
{
sprintf(logBuff, "Warning: section [%s] option %u should be under [DOMAIN-NAME], ignored", sectionName, opTag);
logDHCPMess(logBuff, 1);
continue;
}
if (valType != 1)
{
sprintf(logBuff, "Warning: section [%s] option %s, invalid value, option ignored", sectionName, name);
logDHCPMess(logBuff, 1);
}
else if (buffsize > strlen(value) + 2)
{
*dp = opTag;
dp++;
*dp = strlen(value);
dp++;
memcpy(dp, value, strlen(value));
dp += (strlen(value));
buffsize -= (strlen(value) + 2);
}
else
{
sprintf(logBuff, "Warning: section [%s] option %s no more space for options", sectionName, name);
logDHCPMess(logBuff, 1);
}
}
break;
}
}
//printf("%s=%sn", sectionName, optionData->vendClass);
*dp = DHCP_OPTION_END;
dp++;
WORD optionSize = ((DWORD)dp - (DWORD)options);
if (optionSize > 2)
{
optionData->options = (BYTE*)calloc(1, optionSize);
if (!optionData->options)
{
sprintf(logBuff, "DHCP Option Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
}
memcpy(optionData->options, options, optionSize);
}
}
void lockOptions(char *iniStr)
{
char name[512];
char value[512];
char *iniStrPtr = myGetToken(iniStr, 0);
for (; iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
mySplit(name, value, iniStrPtr, '=');
if (!name[0])
continue;
int op_index;
BYTE n = sizeof(opData) / sizeof(data4);
for (op_index = 0; op_index < n; op_index++)
if (!strcasecmp(name, opData[op_index].opName) || (opData[op_index].opTag && atoi(name) == opData[op_index].opTag))
break;
if (op_index >= n)
continue;
if (opData[op_index].opType == 0)
{
//printf("Tag %s Lockedn", value);
DWORD inetAddr = my_inet_addr(value);
if (inetAddr != INADDR_ANY && inetAddr != INADDR_NONE)
setLeaseExpiry(inetAddr, LONG_MAX);
}
}
}
void addDHCPRange(char *iniStrPtr)
{
DWORD rs = 0;
DWORD re = 0;
char name[512];
char value[512];
mySplit(name, value, iniStrPtr, '-');
if (name[0] && value[0] && isIP(name) && isIP(value))
{
rs = htonl(my_inet_addr(name));
re = htonl(my_inet_addr(value));
if (rs && rs != INADDR_NONE && re && re != INADDR_NONE && rs <= re)
{
data13 *range;
BYTE m = 0;
BYTE rangeOK = 1;
for (; m < 32 && cfig.dhcpRanges[m].rangeStart; m++)
{
range = &cfig.dhcpRanges[m];
if ((rs >= range->rangeStart && rs <= range->rangeEnd)
|| (re >= range->rangeStart && re <= range->rangeEnd)
|| (range->rangeStart >= rs && range->rangeStart <= re)
|| (range->rangeEnd >= rs && range->rangeEnd <= re))
{
sprintf(logBuff, "Warning: DHCP Range %s overlaps with another range, ignored", iniStrPtr);
logDHCPMess(logBuff, 1);
rangeOK = 0;
break;
}
}
if (cfig.rangeStart && (rs < cfig.rangeStart || re > cfig.rangeEnd))
{
sprintf(logBuff, "Warning: DHCP Range %s not in zone %s, ignored", iniStrPtr, cfig.authority);
logDHCPMess(logBuff, 1);
rangeOK = 0;
}
if (m < 32 && rangeOK)
{
cfig.dhcpSize += (re - rs + 1);
range = &cfig.dhcpRanges[m];
range->rangeStart = rs;
range->rangeEnd = re;
range->expiry = (time_t*)calloc((re - rs + 1), sizeof(time_t));
range->dhcpEntry = (data7**)calloc((re - rs + 1), sizeof(data7*));
if (!range->expiry || !range->dhcpEntry)
{
if (range->expiry)
free(range->expiry);
if (range->dhcpEntry)
free(range->dhcpEntry);
sprintf(logBuff, "DHCP Ranges Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
return;
}
}
}
else
{
sprintf(logBuff, "Section [DHCP-dhcpRanges] Invalid DHCP range %s in ini file, ignored", iniStrPtr);
logDHCPMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [DHCP-dhcpRanges] Invalid DHCP range %s in ini file, ignored", iniStrPtr);
logDHCPMess(logBuff, 1);
}
}
void addVendClass(BYTE rangeSetInd, char *vendClass, BYTE vendClassSize)
{
data14 *rangeSet = &cfig.rangeSet[rangeSetInd];
BYTE i = 0;
for (; i <= 32 && rangeSet->vendClassSize[i]; i++);
if (i >= 32)
return;
rangeSet->vendClass[i] = (BYTE*)calloc(vendClassSize, 1);
if(!rangeSet->vendClass[i])
{
sprintf(logBuff, "Vendor Class Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
}
else
{
cfig.hasFilter = true;
rangeSet->vendClassSize[i] = vendClassSize;
memcpy(rangeSet->vendClass[i], vendClass, vendClassSize);
//printf("Loaded Vendor Class %s Size=%i rangeSetInd=%i Ind=%in", hex2String(tempbuff, rangeSet->vendClass[i], rangeSet->vendClassSize[i], ':'), rangeSet->vendClassSize[i], rangeSetInd, i);
}
}
void addUserClass(BYTE rangeSetInd, char *userClass, BYTE userClassSize)
{
data14 *rangeSet = &cfig.rangeSet[rangeSetInd];
BYTE i = 0;
for (; i <= 32 && rangeSet->userClassSize[i]; i++);
if (i >= 32)
return;
rangeSet->userClass[i] = (BYTE*)calloc(userClassSize, 1);
if(!rangeSet->userClass[i])
{
sprintf(logBuff, "Vendor Class Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
}
else
{
cfig.hasFilter = true;
rangeSet->userClassSize[i] = userClassSize;
memcpy(rangeSet->userClass[i], userClass, userClassSize);
//printf("Loaded User Class %s Size=%i rangeSetInd=%i Ind=%in", hex2String(tempbuff, rangeSet->userClass[i], rangeSet->userClassSize[i], ':'), rangeSet->vendClassSize[i], rangeSetInd, i);
}
}
void addMacRange(BYTE rangeSetInd, char *macRange)
{
if (macRange[0])
{
data14 *rangeSet = &cfig.rangeSet[rangeSetInd];
BYTE i = 0;
for (; i <= 32 && rangeSet->macSize[i]; i++);
if (i >= 32)
return;
char name[256];
char value[256];
mySplit(name, value, macRange, '-');
if(!name[0] || !value[0])
{
sprintf(logBuff, "Section [DHCP-RANGE], invalid Filter_Mac_Range %s, ignored", macRange);
logDHCPMess(logBuff, 1);
}
else
{
BYTE macSize1 = 16;
BYTE macSize2 = 16;
BYTE *macStart = (BYTE*)calloc(1, macSize1);
BYTE *macEnd = (BYTE*)calloc(1, macSize2);
if(!macStart || !macEnd)
{
sprintf(logBuff, "DHCP Range Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
}
else if (getHexValue(macStart, name, &macSize1) || getHexValue(macEnd, value, &macSize2))
{
sprintf(logBuff, "Section [DHCP-RANGE], Invalid character in Filter_Mac_Range %s", macRange);
logDHCPMess(logBuff, 1);
free(macStart);
free(macEnd);
}
else if (memcmp(macStart, macEnd, 16) > 0)
{
sprintf(logBuff, "Section [DHCP-RANGE], Invalid Filter_Mac_Range %s, (higher bound specified on left), ignored", macRange);
logDHCPMess(logBuff, 1);
free(macStart);
free(macEnd);
}
else if (macSize1 != macSize2)
{
sprintf(logBuff, "Section [DHCP-RANGE], Invalid Filter_Mac_Range %s, (start/end size mismatched), ignored", macRange);
logDHCPMess(logBuff, 1);
free(macStart);
free(macEnd);
}
else
{
cfig.hasFilter = true;
rangeSet->macSize[i] = macSize1;
rangeSet->macStart[i] = macStart;
rangeSet->macEnd[i] = macEnd;
//printf("Mac Loaded, Size=%i Start=%s rangeSetInd=%i Ind=%in", rangeSet->macSize[i], hex2String(tempbuff, rangeSet->macStart[i], rangeSet->macSize[i], ':'), rangeSetInd, i);
}
}
}
}
char* myGetToken(char* buff, BYTE index)
{
while (*buff)
{
if (index)
index--;
else
break;
buff += strlen(buff) + 1;
}
return buff;
}
WORD myTokenize(char *target, char *source, char *sep, bool whiteSep)
{
bool found = true;
char *dp = target;
WORD kount = 0;
while (*source)
{
if (sep && sep[0] && strchr(sep, (*source)))
{
found = true;
source++;
continue;
}
else if (whiteSep && *source <= 32)
{
found = true;
source++;
continue;
}
if (found)
{
if (target != dp)
{
*dp = 0;
dp++;
}
kount++;
}
found = false;
*dp = *source;
dp++;
source++;
}
*dp = 0;
dp++;
*dp = 0;
//printf("%sn", target);
return kount;
}
char* myTrim(char *target, char *source)
{
while ((*source) && (*source) <= 32)
source++;
int i = 0;
for (; i < 511 && source[i]; i++)
target[i] = source[i];
target[i] = source[i];
i--;
for (; i >= 0 && target[i] <= 32; i--)
target[i] = 0;
return target;
}
void mySplit(char *name, char *value, char *source, char splitChar)
{
int i = 0;
int j = 0;
int k = 0;
for (; source[i] && j <= 510 && source[i] != splitChar; i++, j++)
{
name[j] = source[i];
}
if (source[i])
{
i++;
for (; k <= 510 && source[i]; i++, k++)
{
value[k] = source[i];
}
}
name[j] = 0;
value[k] = 0;
myTrim(name, name);
myTrim(value, value);
//printf("%s %sn", name, value);
}
char *strqtype(char *buff, BYTE qtype)
{
switch (qtype)
{
case 1:
strcpy(buff, "A");
break;
case 2:
strcpy(buff, "NS");
break;
case 3:
strcpy(buff, "MD");
break;
case 4:
strcpy(buff, "MF");
break;
case 5:
strcpy(buff, "CNAME");
break;
case 6:
strcpy(buff, "SOA");
break;
case 7:
strcpy(buff, "MB");
break;
case 8:
strcpy(buff, "MG");
break;
case 9:
strcpy(buff, "MR");
break;
case 10:
strcpy(buff, "NULL");
break;
case 11:
strcpy(buff, "WKS");
break;
case 12:
strcpy(buff, "PTR");
break;
case 13:
strcpy(buff, "HINFO");
break;
case 14:
strcpy(buff, "MINFO");
break;
case 15:
strcpy(buff, "MX");
break;
case 16:
strcpy(buff, "TXT");
break;
case 28:
strcpy(buff, "AAAA");
break;
case 251:
strcpy(buff, "IXFR");
break;
case 252:
strcpy(buff, "AXFR");
break;
case 253:
strcpy(buff, "MAILB");
break;
case 254:
strcpy(buff, "MAILA");
break;
default:
strcpy(buff, "ANY");
break;
}
return buff;
}
WORD listSections(char *buffer, int sizeofbuffer, char *fileName)
{
WORD kount = 0;
char buff[512];
FILE *f = fopen(fileName, "rt");
while (f && fgets(buff, 511, f))
{
if (strchr(buff, '[') == buff)
{
char *secend = strchr(buff, ']');
if (secend)
{
*secend = 0;
buffer += sprintf(buffer, "%s", &buff[1]);
buffer++;
kount++;
}
}
}
if (f)
fclose(f);
else if (iniFile[0])
{
sprintf(logBuff, "Warning: Failed to open ini File %s", iniFile);
logMess(logBuff, 1);
}
*buffer = 0;
buffer++;
*buffer = 0;
return kount;
}
bool getSection(char *sectionName, char *buffer, BYTE serial, char *fileName)
{
//printf("%s=%sn",fileName,sectionName);
char section[128];
sprintf(section, "[%s]", sectionName);
myUpper(section);
FILE *f = fopen(fileName, "rt");
char buff[512];
BYTE found = 0;
if (f)
{
while (fgets(buff, 511, f))
{
myUpper(buff);
myTrim(buff, buff);
if (strstr(buff, section) == buff)
{
found++;
if (found == serial)
{
//printf("%s=%sn",fileName,sectionName);
while (fgets(buff, 511, f))
{
myTrim(buff, buff);
if (strstr(buff, "[") == buff)
break;
if ((*buff) >= '0' && (*buff) <= '9' || (*buff) >= 'A' && (*buff) <= 'Z' || (*buff) >= 'a' && (*buff) <= 'z' || ((*buff) && strchr("/\?*", (*buff))))
{
buffer += sprintf(buffer, "%s", buff);
buffer++;
}
}
break;
}
}
}
fclose(f);
}
*buffer = 0;
*(buffer + 1) = 0;
return (found == serial);
}
DWORD getClassNetwork(DWORD ip)
{
data15 data;
data.ip = ip;
data.octate[3] = 0;
if (data.octate[0] < 192)
data.octate[2] = 0;
if (data.octate[0] < 128)
data.octate[1] = 0;
return data.ip;
}
/*
char *IP2Auth(DWORD ip)
{
data15 data;
data.ip = ip;
if (data.octate[0] >= 192)
sprintf(tempbuff, "%u.%u.%u", data.octate[2], data.octate[1], data.octate[0]);
else if (data.octate[0] >= 128)
sprintf(tempbuff, "%u.%u", data.octate[1], data.octate[0]);
else
sprintf(tempbuff, "%u", data.octate[0]);
strcat(tempbuff, arpa);
return tempbuff;
}
*/
char *IP2String(char *target, DWORD ip)
{
data15 inaddr;
inaddr.ip = ip;
sprintf(target, "%u.%u.%u.%u", inaddr.octate[0], inaddr.octate[1], inaddr.octate[2], inaddr.octate[3]);
return target;
}
bool addServer(DWORD *array, DWORD ip)
{
for (BYTE i = 0; i < MAX_SERVERS; i++)
{
if (!ip || array[i] == ip)
return 0;
else if (!array[i])
{
array[i] = ip;
return 1;
}
}
return 0;
}
DWORD *findServer(DWORD *array, DWORD ip)
{
if (ip)
{
for (BYTE i = 0; i < MAX_SERVERS && array[i]; i++)
{
if (array[i] == ip)
return &(array[i]);
}
}
return 0;
}
bool isIP(char *string)
{
int j = 0;
for (; *string; string++)
{
if (*string == '.' && *(string + 1) != '.')
j++;
else if (*string < '0' || *string > '9')
return 0;
}
if (j == 3)
return 1;
else
return 0;
}
bool isInt(char *string)
{
if (!(*string))
return false;
for(; *string; string++)
if (*string < '0' || *string > '9')
return false;
return true;
}
char *toBase64(BYTE *source, BYTE length)
{
BYTE a = 0, b = 0, i = 0;
char *dp = tempbuff;
for (; length; length--, source++)
{
i += 2;
a = (*source) >> i;
*dp = base64[a + b];
dp++;
b = (*source) << (8 - i);
b >>= 2;
if (i == 6)
{
*dp = base64[b];
dp++;
i = b = 0;
}
}
if (i)
{
*dp = base64[b];
dp++;
}
*dp = 0;
//printf("%sn",tempbuff);
return tempbuff;
}
BYTE getBaseValue(BYTE a)
{
if (a >= 'A' && a <= 'Z')
a -= 'A';
else if (a >= 'a' && a <= 'z')
a = a - 'a' + 26;
else if (a >= '0' && a <= '9')
a = a - '0' + 52;
else if (a == '+')
a = 62;
else if (a == '/')
a = 63;
else
a = 255;
return a;
}
BYTE fromBase64(BYTE *target, char *source)
{
//printf("SOURCE=%sn", source);
BYTE b = 0;
BYTE shift = 4;
BYTE bp_hlen = (3*strlen(source))/4;
if (*source)
{
b = getBaseValue(*source);
*target = b << 2;
source++;
while (*source)
{
b = getBaseValue(*source);
(*target) += (b >> (8 - shift));
target++;
(*target) = (b << shift);
shift += 2;
if (shift > 8)
{
source++;
if (*source)
{
b = getBaseValue(*source);
*target = b << 2;
shift = 4;
}
else
break;
}
source++;
}
}
//printf("SIZE=%un", bp_hlen);
return bp_hlen;
}
char *toUUE(char *tempbuff, BYTE *source, BYTE length)
{
BYTE a = 0, b = 0, i = 0;
char *dp = tempbuff;
for (; length; length--, source++)
{
i += 2;
a = (*source) >> i;
*dp = a + b + 32;
dp++;
b = (*source) << (8 - i);
b >>= 2;
if (i == 6)
{
*dp = b + 32;
dp++;
i = b = 0;
}
}
if (i)
{
*dp = b + 32;
dp++;
}
*dp = 0;
//printf("%sn",tempbuff);
return tempbuff;
}
BYTE fromUUE(BYTE *target, char *source)
{
//printf("SOURCE=%sn", source);
BYTE b = 0;
BYTE shift = 4;
BYTE bp_hlen = (3 * strlen(source))/4;
*target = 0;
if (*source)
{
b = *source - 32;
*target = b << 2;
source++;
while (*source)
{
b = *source - 32;
(*target) += (b >> (8 - shift));
target++;
(*target) = (b << shift);
shift += 2;
if (shift > 8)
{
source++;
if (*source)
{
b = *source - 32;
*target = b << 2;
shift = 4;
}
else
break;
}
source++;
}
}
//printf("SIZE=%un", bp_hlen);
return bp_hlen;
}
char *hex2String(char *target, BYTE *hex, BYTE bytes, char sepChar)
{
char *dp = target;
if (bytes)
dp += sprintf(target, "%02x", *hex);
else
*target = 0;
for (BYTE i = 1; i < bytes; i++)
if (sepChar)
dp += sprintf(dp, "%c%02x", sepChar, *(hex + i));
else
dp += sprintf(dp, "%02x", *(hex + i));
return target;
}
char *IP62String(char *target, BYTE *source)
{
BYTE i = 0;
*target = 0;
bool thisZero = false;
bool prevZero = false;
char *dp;
while (true)
{
prevZero = thisZero;
thisZero = true;
if (*(source + i))
{
thisZero = false;
dp = target + strlen(target);
sprintf(dp, "%x", *(source + i));
}
i++;
if (*(source + i))
{
thisZero = false;
dp = target + strlen(target);
sprintf(dp, "%x", *(source + i));
}
i++;
if (i >= 15)
break;
if (!thisZero || !prevZero)
{
dp = target + strlen(target);
strcat(dp, ":");
}
}
return target;
}
char *getHexValue(BYTE *target, char *source, BYTE *size)
{
if (*size)
memset(target, 0, (*size));
if (*source == ':')
source++;
for ((*size) = 0; (*source) && (*size) < UCHAR_MAX; (*size)++, target++)
{
if ((*source) >= '0' && (*source) <= '9')
{
(*target) = (*source) - '0';
}
else if ((*source) >= 'a' && (*source) <= 'f')
{
(*target) = (*source) - 'a' + 10;
}
else if ((*source) >= 'A' && (*source) <= 'F')
{
(*target) = (*source) - 'A' + 10;
}
else
{
return source;
}
source++;
if ((*source) >= '0' && (*source) <= '9')
{
(*target) *= 16;
(*target) += ((*source) - '0');
}
else if ((*source) >= 'a' && (*source) <= 'f')
{
(*target) *= 16;
(*target) += (((*source) - 'a') + 10);
}
else if ((*source) >= 'A' && (*source) <= 'F')
{
(*target) *= 16;
(*target) += (((*source) - 'A') + 10);
}
else if ((*source) == ':')
{
source++;
continue;
}
else if (*source)
return source;
else
continue;
source++;
if ((*source) == ':')
source++;
else if (*source)
return source;
}
if (*source)
return source;
return NULL;
}
char *myUpper(char *string)
{
char diff = 'a' - 'A';
WORD len = strlen(string);
for (int i = 0; i < len; i++)
if (string[i] >= 'a' && string[i] <= 'z')
string[i] -= diff;
return string;
}
char *myLower(char *string)
{
char diff = 'a' - 'A';
WORD len = strlen(string);
for (int i = 0; i < len; i++)
if (string[i] >= 'A' && string[i] <= 'Z')
string[i] += diff;
return string;
}
bool wildcmp(char *string, char *wild)
{
// Written by Jack Handy - jakkhandy@hotmail.com
// slightly modified
char *cp = NULL;
char *mp = NULL;
while ((*string) && (*wild != '*'))
{
if ((*wild != *string) && (*wild != '?'))
{
return 0;
}
wild++;
string++;
}
while (*string)
{
if (*wild == '*')
{
if (!*++wild)
return 1;
mp = wild;
cp = string + 1;
}
else if ((*wild == *string) || (*wild == '?'))
{
wild++;
string++;
}
else
{
wild = mp;
string = cp++;
}
}
while (*wild == '*')
wild++;
return !(*wild);
}
BYTE makeLocal(DWORD ip)
{
if (cfig.rangeStart && htonl(ip) >= cfig.rangeStart && htonl(ip) <= cfig.rangeEnd)
return 1;
else if (getRangeInd(ip) >= 0)
return 1;
else
return 0;
}
BYTE makeLocal(char *query)
{
if (!strcasecmp(query, cfig.zone))
return 3;
else
{
char *dp = strchr(query, '.');
if (dp)
{
if (!strcasecmp(dp + 1, cfig.zone))
{
*dp = 0;
return 2;
}
return 0;
}
return 1;
}
return 0;
}
void checkSize(BYTE ind)
{
//printf("Start %u=%un",dnsCache[ind].size(),dnsAge[ind].size());
time_t t = time(NULL);
data7 *cache = NULL;
//BYTE maxDelete = 3;
expiryMap::iterator p = dnsAge[ind].begin();
expiryMap::iterator q;
//while (p != dnsAge[ind].end() && p->first < t && maxDelete > 0)
while (p != dnsAge[ind].end() && p->first < t)
{
cache = p->second;
//printf("processing %s=%in", cache->mapname, p->first - t);
if (cache->expiry < t)
{
q = p;
p++;
dnsAge[ind].erase(q);
if (cache->expiry)
{
if (cache->dnsIndex < MAX_SERVERS)
{
if (cfig.currentDNS == cache->dnsIndex)
{
if (cfig.dns[1])
{
cfig.currentDNS++;
if (cfig.currentDNS >= MAX_SERVERS || !cfig.dns[cfig.currentDNS])
cfig.currentDNS = 0;
}
}
}
else if (cache->dnsIndex >= 128 && cache->dnsIndex < 192)
{
data6 *dnsRoute = &cfig.dnsRoutes[(cache->dnsIndex - 128) / 2];
BYTE currentDNS = cache->dnsIndex % 2;
if (dnsRoute->currentDNS == currentDNS && dnsRoute->dns[1])
{
dnsRoute->currentDNS = 1 - dnsRoute->currentDNS;
}
}
}
delDnsEntry(ind, cache);
//maxDelete--;
}
else if (cache->expiry > p->first)
{
q = p;
p++;
dnsAge[ind].erase(q);
dnsAge[ind].insert(pair<long, data7*>(cache->expiry, cache));
}
else
p++;
}
if (ind == cacheInd && dhcpService)
{
//printf("dhcpAge=%un", dhcpAge.size());
p = dhcpAge.begin();
while (p != dhcpAge.end() && p->first < t)
{
cache = p->second;
//printf("processing %s=%in", cache->mapname, p->first - t);
if (cache->active && cache->expiry < t)
{
q = p;
p++;
cache->active = 0;
dhcpAge.erase(q);
cfig.serial1 = time(NULL);
cfig.serial2 = time(NULL);
if (cfig.expire > (DWORD)(LONG_MAX - t))
cfig.expireTime = LONG_MAX;
else
cfig.expireTime = t + cfig.expire;
sendRepl(cache);
//printf("Lease releasedn");
}
else if (cache->expiry > p->first)
{
q = p;
p++;
dhcpAge.erase(q);
dhcpAge.insert(pair<long, data7*>(cache->expiry, cache));
}
else
p++;
}
}
//printf("Done %u=%un",dnsCache[ind].size(),dnsAge[ind].size());
}
void calcRangeLimits(DWORD ip, DWORD mask, DWORD *rangeStart, DWORD *rangeEnd)
{
*rangeStart = htonl(ip & mask) + 1;
*rangeEnd = htonl(ip | (~mask)) - 1;
}
bool checkMask(DWORD mask)
{
mask = htonl(mask);
while (mask)
{
if (mask < (mask << 1))
return false;
mask <<= 1;
}
return true;
}
DWORD calcMask(DWORD rangeStart, DWORD rangeEnd)
{
data15 ip1, ip2, mask;
ip1.ip = htonl(rangeStart);
ip2.ip = htonl(rangeEnd);
for (BYTE i = 0; i < 4; i++)
{
mask.octate[i] = ip1.octate[i] ^ ip2.octate[i];
if (i && mask.octate[i - 1] < 255)
mask.octate[i] = 0;
else if (mask.octate[i] == 0)
mask.octate[i] = 255;
else if (mask.octate[i] < 2)
mask.octate[i] = 254;
else if (mask.octate[i] < 4)
mask.octate[i] = 252;
else if (mask.octate[i] < 8)
mask.octate[i] = 248;
else if (mask.octate[i] < 16)
mask.octate[i] = 240;
else if (mask.octate[i] < 32)
mask.octate[i] = 224;
else if (mask.octate[i] < 64)
mask.octate[i] = 192;
else if (mask.octate[i] < 128)
mask.octate[i] = 128;
else
mask.octate[i] = 0;
}
return mask.ip;
}
data7 *findEntry(BYTE ind, char *key, BYTE entryType)
{
myLower(key);
hostMap::iterator it = dnsCache[ind].find(key);
while (it != dnsCache[ind].end() && !strcasecmp(it->second->mapname, key))
if (it->second->dataType == entryType)
return it->second;
else
it++;
return NULL;
}
data7 *findEntry(BYTE ind, char *key)
{
//printf("finding %u=%sn",ind,key);
myLower(key);
hostMap::iterator it = dnsCache[ind].find(key);
if (it != dnsCache[ind].end())
return it->second;
else
return NULL;
}
void addEntry(BYTE ind, data7 *entry)
{
myLower(entry->mapname);
dnsCache[ind].insert(pair<string, data7*>(entry->mapname, entry));
if (entry->expiry && entry->expiry < LONG_MAX)
dnsAge[ind].insert(pair<long, data7*>(entry->expiry, entry));
}
void delDnsEntry(BYTE ind, data7* cache)
{
if (cache)
{
//printf("CacheIndex=%u Size=%u, Entry %s being deletedn", cache->cacheInd, dnsCache[cache->cacheInd].size(), cache->mapname);
if (ind <= 1)
{
dnsCache[ind].erase(cache->mapname);
switch (cache->dataType)
{
case QUEUE:
if (cache->addr)
free(cache->addr);
if (cache->query)
free(cache->query);
if (cache->mapname)
free(cache->mapname);
break;
case LOCAL_PTR_AUTH:
case LOCAL_PTR_NAUTH:
case LOCALHOST_PTR:
case SERVER_PTR_AUTH:
case SERVER_PTR_NAUTH:
case STATIC_PTR_AUTH:
case STATIC_PTR_NAUTH:
case LOCAL_CNAME:
case EXT_CNAME:
case CACHED:
if (cache->hostname)
free(cache->hostname);
if (cache->mapname)
free(cache->mapname);
break;
default:
if (cache->mapname)
free(cache->mapname);
break;
}
free(cache);
}
}
return ;
}
char *cloneString(char *string)
{
char *s = (char*)calloc(1, strlen(string) + 1);
if (s)
{
strcpy(s, string);
}
return s;
}
void *refresh(void *lpParam)
{
bool repeat = !lpParam;
time_t t = time(NULL);
char tempbuff[256];
char logBuff[256];
while (true)
{
sprintf(logBuff, "Checking Serial from Primary Server %s", IP2String(tempbuff, cfig.zoneServers[0]));
logDNSMess(logBuff, 2);
DWORD serial1 = getSerial(cfig.zone);
DWORD serial2 = getSerial(cfig.authority);
if (!serial1 || !serial2)
{
sprintf(logBuff, "Failed to get Serial from %s", IP2String(tempbuff, cfig.zoneServers[0]));
logDNSMess(logBuff, 1);
sleep((cfig.retry));
continue;
}
else if (cfig.serial1 && cfig.serial1 == serial1 && cfig.serial2 && cfig.serial2 == serial2)
{
sprintf(logBuff, "Zone Refresh not required");
logDNSMess(logBuff, 2);
if (cfig.expire > (DWORD)(LONG_MAX - t))
cfig.expireTime = LONG_MAX;
else
cfig.expireTime = t + cfig.expire;
sleep((cfig.refresh));
}
else
{
serial1 = getRefresh(1 - cacheInd, cfig.zone);
serial2 = getRefresh(1 - cacheInd, cfig.authority);
if (!serial1 || !serial2)
{
sprintf(logBuff, "Waiting %i seconds to retry", cfig.retry);
logDNSMess(logBuff, 1);
sleep((cfig.retry));
}
else
{
newInd = 1 - cacheInd;
cfig.serial1 = serial1;
cfig.serial2 = serial2;
if (cfig.expire > (DWORD)(LONG_MAX - t))
cfig.expireTime = LONG_MAX;
else
cfig.expireTime = t + cfig.expire;
if (!repeat)
break;
sleep((cfig.refresh));
}
}
}
}
DWORD getSerial(char *zone)
{
time_t t = time(NULL);
char tempbuff[256];
char logBuff[256];
DWORD serial1 = 0;
data5 req;
memset(&req, 0, sizeof(data5));
req.addr.sin_family = AF_INET;
req.addr.sin_port = htons(IPPORT_DNS);
timeval tv1;
fd_set readfds1;
if (cfig.replication == 2)
req.addr.sin_addr.s_addr = cfig.zoneServers[0];
else
req.addr.sin_addr.s_addr = cfig.zoneServers[1];
req.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
req.dnsp = (dnsPacket*)req.raw;
req.dnsp->header.qdcount = htons(1);
req.dnsp->header.xid = (t % USHRT_MAX);
req.data = &req.dnsp->data;
req.data += pQu(req.data, zone);
req.data += pUShort(req.data, DNS_TYPE_SOA);
req.data += pUShort(req.data, DNS_CLASS_IN);
req.bytes = (DWORD)req.data - (DWORD)req.raw;
//pUShort(req.raw, req.bytes - 2);
if ((req.bytes = sendto(req.sock, req.raw, req.bytes, 0, (sockaddr*)&req.addr, sizeof(req.addr))) <= 0)
{
closesocket(req.sock);
sprintf(logBuff, "Failed to send request to Primary Server %s", IP2String(tempbuff, req.addr.sin_addr.s_addr));
logDNSMess(logBuff, 1);
return 0;
}
FD_ZERO(&readfds1);
tv1.tv_sec = 3;
tv1.tv_usec = 0;
FD_SET(req.sock, &readfds1);
select(USHRT_MAX, &readfds1, NULL, NULL, &tv1);
if (FD_ISSET(req.sock, &readfds1))
{
req.sockLen = sizeof(req.addr);
req.bytes = recvfrom(req.sock, req.raw, sizeof(req.raw), 0, (sockaddr*)&req.addr, &req.sockLen);
if (req.bytes > 0 && req.dnsp->header.qr && !req.dnsp->header.rcode && ntohs(req.dnsp->header.ancount))
{
req.data = &req.dnsp->data;
for (int j = 1; j <= ntohs(req.dnsp->header.qdcount); j++)
{
req.data += fQu(tempbuff, req.dnsp, req.data);
req.data += 4;
}
for (int i = 1; i <= ntohs(req.dnsp->header.ancount); i++)
{
req.data += fQu(tempbuff, req.dnsp, req.data);
req.qtype = fUShort(req.data);
req.data += 2; //type
req.qclass = fUShort(req.data);
req.data += 2; //class
fULong(req.data);
req.data += 4; //ttl
req.data += 2; //datalength
if (req.qtype == DNS_TYPE_SOA)
{
req.data += fQu(tempbuff, req.dnsp, req.data);
req.data += fQu(tempbuff, req.dnsp, req.data);
serial1 = fULong(req.data);
}
}
}
}
closesocket(req.sock);
return serial1;
}
void checkDNS(BYTE dnsIndex)
{
time_t t = time(NULL);
//printf("DNS Index %un", dnsIndex);
data5 req;
memset(&req, 0, sizeof(data5));
strcpy(req.query, "1.0.0.127.in-addr.arpa");
req.addr.sin_family = AF_INET;
req.addr.sin_port = htons(IPPORT_DNS);
if (dnsIndex < MAX_SERVERS)
{
if (cfig.currentDNS == dnsIndex)
req.addr.sin_addr.s_addr = cfig.dns[dnsIndex];
else
return;
}
else if (dnsIndex >= 128 && dnsIndex < 192)
{
BYTE childIndex = (dnsIndex - 128) / 2;
data6 *dnsRoute = &cfig.dnsRoutes[childIndex];
BYTE currentDNS = dnsIndex % 2;
if (dnsRoute->currentDNS == currentDNS)
req.addr.sin_addr.s_addr = dnsRoute->dns[currentDNS];
else
return;
}
else
return;
req.dnsp = (dnsPacket*)req.raw;
req.dnsp->header.qdcount = htons(1);
req.dnsp->header.xid = (t % USHRT_MAX);
req.data = &req.dnsp->data;
req.data += pQu(req.data, req.query);
req.data += pUShort(req.data, DNS_TYPE_PTR);
req.data += pUShort(req.data, DNS_CLASS_IN);
req.bytes = (DWORD)req.data - (DWORD)req.raw;
char mapname[8];
sprintf(mapname, "%u", req.dnsp->header.xid);
data7 *queue = findEntry(cacheInd, mapname, DNS_CHECK);
if (!queue)
{
if ((req.bytes = sendto(cfig.forwConn.sock, req.raw, req.bytes, 0, (sockaddr*)&req.addr, sizeof(req.addr))) > 0)
{
queue = (data7*)calloc(1, sizeof(data7));
if (queue)
{
queue->mapname = cloneString(mapname);
if (!queue->mapname)
{
free(queue);
return;
}
queue->expiry = 2 + t;
queue->dataType = DNS_CHECK;
queue->sockInd = 255;
queue->dnsIndex = dnsIndex;
addEntry(cacheInd, queue);
}
else
return;
if (cfig.dnsLogLevel)
{
if (dnsIndex < MAX_SERVERS)
sprintf(logBuff, "Verification sent to Forwarding DNS Server %s", IP2String(tempbuff, req.addr.sin_addr.s_addr));
else
sprintf(logBuff, "Verification sent to Child DNS Server %s", IP2String(tempbuff, req.addr.sin_addr.s_addr));
logDNSMess(logBuff, 1);
}
}
}
}
char *getServerName(char *target, DWORD ip)
{
time_t t = time(NULL);
data5 req;
memset(&req, 0, sizeof(data5));
req.addr.sin_family = AF_INET;
req.addr.sin_port = htons(IPPORT_DNS);
req.addr.sin_addr.s_addr = ip;
timeval tv1;
fd_set readfds1;
req.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
req.dnsp = (dnsPacket*)req.raw;
req.dnsp->header.qdcount = htons(1);
req.dnsp->header.xid = (t % USHRT_MAX);
req.data = &req.dnsp->data;
IP2String(target, htonl(ip));
strcat(target, arpa);
req.data += pQu(req.data, target);
req.data += pUShort(req.data, DNS_TYPE_PTR);
req.data += pUShort(req.data, DNS_CLASS_IN);
req.bytes = (DWORD)req.data - (DWORD)req.raw;
//pUShort(req.raw, req.bytes - 2);
if ((req.bytes = sendto(req.sock, req.raw, req.bytes, 0, (sockaddr*)&req.addr, sizeof(req.addr))) <= 0)
{
closesocket(req.sock);
return NULL;
}
FD_ZERO(&readfds1);
tv1.tv_sec = 5;
tv1.tv_usec = 0;
FD_SET(req.sock, &readfds1);
select(USHRT_MAX, &readfds1, NULL, NULL, &tv1);
if (FD_ISSET(req.sock, &readfds1))
{
req.sockLen = sizeof(req.addr);
req.bytes = recvfrom(req.sock, req.raw, sizeof(req.raw), 0, (sockaddr*)&req.addr, &req.sockLen);
if (req.bytes > 0 && req.dnsp->header.qr && !req.dnsp->header.rcode && ntohs(req.dnsp->header.ancount))
{
closesocket(req.sock);
return getResult(&req);
}
}
closesocket(req.sock);
return NULL;
}
WORD recvTcpDnsMess(SOCKET sock, char *target, bool ready)
{
timeval tv1;
fd_set readfds1;
if (!ready)
{
FD_ZERO(&readfds1);
tv1.tv_sec = 5;
tv1.tv_usec = 0;
FD_SET(sock, &readfds1);
if (!select(sock + 1, &readfds1, NULL, NULL, &tv1))
return 0;
}
errno = 0;
WORD rcd = recv(sock, target, 2, 0);
//errno = WSAGetLastError();
if (errno)
return 0;
if (rcd == 2)
{
WORD bytes = fUShort(target) + rcd;
char *ptr;
while (rcd < bytes)
{
FD_ZERO(&readfds1);
tv1.tv_sec = 5;
tv1.tv_usec = 0;
FD_SET(sock, &readfds1);
ptr = target + rcd;
if (select(sock + 1, &readfds1, NULL, NULL, &tv1))
{
errno = 0;
rcd += recv(sock, ptr, bytes - rcd, 0);
//errno = WSAGetLastError();
if (errno)
return 0;
}
else
return 0;
}
return rcd;
}
return 0;
}
DWORD getRefresh(BYTE updateCache, char *zone)
{
char tempbuff[256];
char logBuff[256];
char hostname[256];
char cname[256];
DWORD serial1 = 0;
DWORD serial2 = 0;
DWORD hostExpiry = 0;
DWORD refresh = 0;
DWORD retry = 0;
DWORD expire = 0;
DWORD expiry;
DWORD minimum = 0;
int added = 0;
char *data;
char *dp;
DWORD ip;
data5 req;
memset(&req, 0, sizeof(data5));
req.addr.sin_family = AF_INET;
req.addr.sin_port = htons(IPPORT_DNS);
req.addr.sin_addr.s_addr = cfig.zoneServers[0];
req.sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (req.sock == INVALID_SOCKET)
{
sprintf(logBuff, "Failed to Create Socket, Zone Transfer Failed", IP2String(tempbuff, req.addr.sin_addr.s_addr));
logDNSMess(logBuff, 1);
return 0;
}
req.sockLen = sizeof(req.addr);
time_t t = time(NULL);
if (connect(req.sock, (sockaddr*)&req.addr, req.sockLen) >= 0)
{
req.data = req.raw;
req.data += 2;
req.dnsp = (dnsPacket*)req.data;
req.dnsp->header.qdcount = htons(1);
req.dnsp->header.xid = (t % USHRT_MAX);
req.data = &req.dnsp->data;
req.data += pQu(req.data, zone);
req.data += pUShort(req.data, DNS_TYPE_AXFR);
req.data += pUShort(req.data, DNS_CLASS_IN);
req.bytes = (DWORD)req.data - (DWORD)req.raw;
pUShort(req.raw, req.bytes - 2);
if (send(req.sock, req.raw, req.bytes, 0) < req.bytes)
{
closesocket(req.sock);
sprintf(logBuff, "Failed to send request to Replication Server %s, Zone Transfer Failed", IP2String(tempbuff, req.addr.sin_addr.s_addr));
logDNSMess(logBuff, 1);
return 0;
}
if (!strcasecmp(zone, cfig.zone))
{
for (; cfig.mxCount[updateCache]; cfig.mxCount[updateCache]--)
strcpy(cfig.mxServers[updateCache][cfig.mxCount[updateCache]].hostname, "");
}
while (true)
{
req.bytes = recvTcpDnsMess(req.sock, req.raw, false);
//printf("bytes = %un", req.bytes);
if (req.bytes < 2)
break;
WORD pktSize = fUShort(req.raw);
if ((WORD)req.bytes < pktSize + 2)
break;
req.dnsp = (dnsPacket*)(req.raw + 2);
req.data = &req.dnsp->data;
if (!req.dnsp->header.qr || req.dnsp->header.rcode || !ntohs(req.dnsp->header.ancount))
break;
for (int j = 1; j <= ntohs(req.dnsp->header.qdcount); j++)
{
req.data += fQu(hostname, req.dnsp, req.data);
req.data += 4;
}
for (int i = 1; i <= ntohs(req.dnsp->header.ancount); i++)
{
//char *dp = req.data;
req.data += fQu(hostname, req.dnsp, req.data);
//printf("%sn", hostname);
req.qtype = fUShort(req.data);
req.data += 2; //type
req.qclass = fUShort(req.data);
req.data += 2; //class
expiry = fULong(req.data);
req.data += 4; //ttl
int zLen = fUShort(req.data);
req.data += 2; //datalength
data = req.data;
req.data += zLen;
switch (req.qtype)
{
case DNS_TYPE_SOA:
data += fQu(hostname, req.dnsp, data);
data += fQu(cname, req.dnsp, data);
if (!serial1)
{
hostExpiry = expiry;
serial1 = fULong(data);
data += 4;
refresh = fULong(data);
data += 4;
retry = fULong(data);
data += 4;
expire = fULong(data);
data += 4;
minimum = fULong(data);
data += 4;
added++;
}
else if (!serial2)
serial2 = fULong(data);
break;
case DNS_TYPE_A:
ip = fIP(data);
makeLocal(hostname);
if (dhcpService && expiry < hostExpiry)
{
char rInd = getRangeInd(ip);
int ind = getIndex(rInd, ip);
if (expiry > LONG_MAX)
expiry = LONG_MAX;
if (ind >= 0 && cfig.dhcpRanges[rInd].dhcpEntry[ind])
setLeaseExpiry(cfig.dhcpRanges[rInd].dhcpEntry[ind], expiry, false);
else
setLeaseExpiry(ip, 0);
if (expiry < (DWORD)(LONG_MAX - t))
expiry += t;
addToCache(updateCache, hostname, ip, expiry, LOCAL_A, NONE, serial1);
added++;
}
else
{
setLeaseExpiry(ip, LONG_MAX);
addToCache(updateCache, hostname, ip, LONG_MAX, STATIC_A_AUTH, NONE, serial1);
added++;
}
break;
case DNS_TYPE_PTR:
myLower(hostname);
dp = strstr(hostname, arpa);
if (dp)
{
*dp = 0;
ip = ntohl(inet_addr(hostname));
fQu(hostname, req.dnsp, data);
makeLocal(hostname);
if (dhcpService && expiry < hostExpiry)
{
char rInd = getRangeInd(ip);
int ind = getIndex(rInd, ip);
if (expiry > LONG_MAX)
expiry = LONG_MAX;
if (ind >= 0 && cfig.dhcpRanges[rInd].dhcpEntry[ind])
setLeaseExpiry(cfig.dhcpRanges[rInd].dhcpEntry[ind], expiry, false);
else
setLeaseExpiry(ip, 0);
if (expiry < (DWORD)(LONG_MAX - t))
expiry += t;
addToCache(updateCache, hostname, ip, expiry, NONE, LOCAL_PTR_AUTH, serial1);
added++;
}
else
{
setLeaseExpiry(ip, LONG_MAX);
addToCache(updateCache, hostname, ip, LONG_MAX, NONE, STATIC_PTR_AUTH, serial1);
added++;
}
}
break;
case DNS_TYPE_MX:
if (cfig.replication == 2 && makeLocal(hostname) == 3)
{
cfig.mxServers[updateCache][cfig.mxCount[updateCache]].pref = fUShort(data);
data += sizeof(WORD);
fQu(cname, req.dnsp, data);
strcpy(cfig.mxServers[updateCache][cfig.mxCount[updateCache]].hostname, cname);
cfig.mxCount[updateCache]++;
added++;
}
break;
case DNS_TYPE_NS:
if (cfig.replication == 2)
fQu(cfig.ns, req.dnsp, data);
break;
case DNS_TYPE_CNAME:
if (cfig.replication == 2)
{
fQu(cname, req.dnsp, data);
BYTE cname_type = 0;
if (makeLocal(cname))
cname_type = LOCAL_CNAME;
else
cname_type = EXT_CNAME;
makeLocal(hostname);
data7 *cache = findEntry(updateCache, hostname, cname_type);
if (!cache)
{
cache = (data7*)calloc(1, sizeof(data7));
if (cache)
{
cache->mapname = cloneString(hostname);
cache->dataType = cname_type;
cache->hostname = cloneString(cname);
if (cache->mapname && cache->hostname)
{
addEntry(updateCache, cache);
}
else
{
sprintf(logBuff, "Memory Error");
logDNSMess(logBuff, 1);
continue;
}
}
else
{
sprintf(logBuff, "Memory Error");
logDNSMess(logBuff, 1);
continue;
}
}
else
{
if (strcasecmp(cname, cache->hostname))
{
free(cache->hostname);
cache->hostname = cloneString(cname);
}
}
cache->expiry = LONG_MAX;
cache->serial = serial1;
added++;
}
break;
}
//printf("serial=%u %u %un", serial1, serial2, hostExpiry);
}
}
strcpy(hostname, cfig.ns);
makeLocal(hostname);
data7 *cache = findEntry(updateCache, hostname, STATIC_A_AUTH);
if (!cache)
cache = findEntry(updateCache, hostname, STATIC_A_NAUTH);
if (cache)
cfig.nsIP = cache->ip;
closesocket(req.sock);
if (serial1 && serial1 == serial2 && hostExpiry)
{
if (cfig.replication == 2)
{
//printf("Here %u %u %u %u %u n",hostExpiry,refresh,retry,expire,minimum);
cfig.lease = hostExpiry;
cfig.refresh = refresh;
cfig.retry = retry;
cfig.expire = expire;
cfig.minimum = minimum;
}
if (cacheInd != updateCache)
{
if (!strcasecmp(zone, cfig.zone))
{
hostMap::iterator q = dnsCache[updateCache].begin();
while (q != dnsCache[updateCache].end())
{
//printf("%s=%un", q->second->mapname,q->second->serial);
switch (q->second->dataType)
{
case LOCAL_A:
case SERVER_A:
case STATIC_A_AUTH:
case LOCAL_CNAME:
case EXT_CNAME:
if (q->second->serial < serial1)
q->second->expiry = 0;
}
q++;
}
}
else if (!strcasecmp(zone, cfig.authority))
{
hostMap::iterator q = dnsCache[updateCache].begin();
while (q != dnsCache[updateCache].end())
{
//printf("%s=%un", q->second->mapname,q->second->serial);
switch (q->second->dataType)
{
case LOCAL_PTR_AUTH:
case STATIC_PTR_AUTH:
case SERVER_PTR_AUTH:
if (q->second->serial < serial1)
q->second->expiry = 0;
}
q++;
}
}
checkSize(updateCache);
}
//printf("Refresh ind %i serial %u size %in", updateCache, serial1, dnsCache[updateCache].size());
sprintf(logBuff, "Zone %s Transferred from %s, %u RRs imported", zone, IP2String(tempbuff, req.addr.sin_addr.s_addr), added);
logDNSMess(logBuff, 2);
return serial1;
}
else if (!serial1)
{
sprintf(logBuff, "Replication Server %s, Missing Serial", IP2String(tempbuff, req.addr.sin_addr.s_addr));
logDNSMess(logBuff, 1);
}
else if (serial1 != serial2)
{
sprintf(logBuff, "Replication Server %s, Serial Changed %u %u", IP2String(tempbuff, req.addr.sin_addr.s_addr), serial1, serial2);
logDNSMess(logBuff, 1);
}
else
{
sprintf(logBuff, "Replication Server %s, Invalid AXFR data", IP2String(tempbuff, req.addr.sin_addr.s_addr));
logDNSMess(logBuff, 1);
}
}
else
{
//errno = WSAGetLastError();
sprintf(logBuff, "Server %s, Error %s", IP2String(tempbuff, req.addr.sin_addr.s_addr), strerror(errno));
logDNSMess(logBuff, 1);
closesocket(req.sock);
}
return 0;
}
void getSecondary()
{
char hostname[256];
DWORD ip;
DWORD hostExpiry;
DWORD expiry;
char *data;
char *dp;
WORD rr = 0;
data5 req;
memset(&req, 0, sizeof(data5));
req.addr.sin_family = AF_INET;
req.addr.sin_port = htons(IPPORT_DNS);
req.addr.sin_addr.s_addr = cfig.zoneServers[1];
req.sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (req.sock == INVALID_SOCKET)
return;
req.sockLen = sizeof(req.addr);
time_t t = time(NULL);
if (connect(req.sock, (sockaddr*)&req.addr, req.sockLen) >= 0)
{
req.data = req.raw;
req.data += 2;
req.dnsp = (dnsPacket*)req.data;
req.dnsp->header.qdcount = htons(1);
req.dnsp->header.xid = (t % USHRT_MAX);
req.data = &req.dnsp->data;
req.data += pQu(req.data, cfig.authority);
req.data += pUShort(req.data, DNS_TYPE_AXFR);
req.data += pUShort(req.data, DNS_CLASS_IN);
req.bytes = (DWORD)req.data - (DWORD)req.raw;
pUShort(req.raw, req.bytes - 2);
if (send(req.sock, req.raw, req.bytes, 0) < req.bytes)
{
closesocket(req.sock);
return;
}
while (true)
{
req.bytes = recvTcpDnsMess(req.sock, req.raw, false);
//printf("bytes = %un", req.bytes);
if (req.bytes < 2)
break;
WORD pktSize = fUShort(req.raw);
if ((WORD)req.bytes < pktSize + 2)
break;
req.dnsp = (dnsPacket*)(req.raw + 2);
req.data = &req.dnsp->data;
if (!req.dnsp->header.qr || req.dnsp->header.rcode || !ntohs(req.dnsp->header.ancount))
break;
for (int j = 1; j <= ntohs(req.dnsp->header.qdcount); j++)
{
req.data += fQu(hostname, req.dnsp, req.data);
req.data += 4;
}
for (int i = 1; i <= ntohs(req.dnsp->header.ancount); i++)
{
//char *dp = req.data;
req.data += fQu(hostname, req.dnsp, req.data);
//printf("%sn", hostname);
req.qtype = fUShort(req.data);
req.data += 2; //type
req.qclass = fUShort(req.data);
req.data += 2; //class
expiry = fULong(req.data);
req.data += 4; //ttl
int zLen = fUShort(req.data);
req.data += 2; //datalength
data = req.data;
req.data += zLen;
switch (req.qtype)
{
case DNS_TYPE_PTR:
myLower(hostname);
dp = strstr(hostname, arpa);
if (dp)
{
*dp = 0;
ip = ntohl(inet_addr(hostname));
fQu(hostname, req.dnsp, data);
makeLocal(hostname);
if (dhcpService && expiry < hostExpiry)
{
char rInd = getRangeInd(ip);
int ind = getIndex(rInd, ip);
if (expiry > LONG_MAX)
expiry = LONG_MAX;
if (ind >= 0 && cfig.dhcpRanges[rInd].dhcpEntry[ind])
setLeaseExpiry(cfig.dhcpRanges[rInd].dhcpEntry[ind], expiry, false);
else
setLeaseExpiry(ip, 0);
if (expiry < (DWORD)(LONG_MAX - t))
expiry += t;
addToCache(cacheInd, hostname, ip, expiry, LOCAL_A, NONE, cfig.serial1);
addToCache(cacheInd, hostname, ip, expiry, NONE, LOCAL_PTR_AUTH, cfig.serial2);
rr++;
}
}
break;
}
}
}
sprintf(logBuff, "%u RRs imported from Secondary Server", rr);
logDNSMess(logBuff, 2);
}
else
{
//errno = WSAGetLastError();
sprintf(logBuff, "Server %s, Error %s", IP2String(tempbuff, req.addr.sin_addr.s_addr), strerror(errno));
logDNSMess(logBuff, 1);
}
closesocket(req.sock);
}
void init()
{
time_t t = time(NULL);
memset(&cfig, 0, sizeof(cfig));
char iniStr[16384];
char name[512];
char value[512];
if (verbatim)
{
cfig.dnsLogLevel = 2;
cfig.dhcpLogLevel = 2;
printf("%snn", sVersion);
}
else if (getSection("LOGGING", iniStr, 1, iniFile))
{
cfig.dnsLogLevel = 1;
cfig.dhcpLogLevel = 2;
char *iniStrPtr = myGetToken(iniStr, 0);
tempbuff[0] = 0;
for (; iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
printf("%sn", iniStrPtr);
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
if (!strcasecmp(name, "DNSLogLevel"))
{
if (!strcasecmp(value, "None"))
cfig.dnsLogLevel = 0;
else if (!strcasecmp(value, "Errors"))
cfig.dnsLogLevel = 1;
else if (!strcasecmp(value, "All"))
cfig.dnsLogLevel = 2;
else
sprintf(tempbuff, "Section [LOGGING], Invalid DNSLogLevel: %s", value);
}
else if (!strcasecmp(name, "DHCPLogLevel"))
{
if (!strcasecmp(value, "None"))
cfig.dhcpLogLevel = 0;
else if (!strcasecmp(value, "Errors"))
cfig.dhcpLogLevel = 1;
else if (!strcasecmp(value, "All"))
cfig.dhcpLogLevel = 2;
else
sprintf(tempbuff, "Section [LOGGING], Invalid DHCPLogLevel: %s", value);
}
else
sprintf(tempbuff, "Section [LOGGING], Invalid Entry %s ignored", iniStrPtr);
}
else
sprintf(tempbuff, "Section [LOGGING], Invalid Entry %s ignored", iniStrPtr);
}
}
if (!verbatim && (cfig.dnsLogLevel || cfig.dhcpLogLevel) && logFile[0])
{
tm *ttm = localtime(&t);
loggingDay = ttm->tm_yday;
strftime(currentLogFile, sizeof(extbuff), logFile, ttm);
cfig.logfile = fopen(currentLogFile, "at");
if (cfig.logfile)
{
sprintf(logBuff, "%s Starting..", sVersion);
logMess(logBuff, 1);
if (tempbuff[0])
logMess(tempbuff, 0);
}
else
{
sprintf(name, "Warning: faled to open log file %s", extbuff);
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), name);
if (tempbuff[0])
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), tempbuff);
}
}
if (getSection("SERVICES", iniStr, 1, iniFile))
{
dhcpService = false;
dnsService = false;
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 0; i < 2 && iniStrPtr[0]; i++, iniStrPtr = myGetToken(iniStrPtr, 1))
if (!strcasecmp(iniStrPtr, "DNS"))
dnsService = true;
else if (!strcasecmp(iniStrPtr, "DHCP"))
dhcpService = true;
if (!dhcpService && !dnsService)
{
dhcpService = true;
dnsService = true;
}
}
cfig.lease = 360000;
cfig.refresh = 3600;
cfig.retry = 100;
cfig.expire = 360000;
cfig.minimum = 100;
if (getSection("TIMINGS", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (; iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
if (atol(value) || !strcasecmp(value,"0"))
{
if (!strcasecmp(name, "Lease_Time"))
{
cfig.lease = atol(value);
if (!cfig.lease)
cfig.lease = ULONG_MAX;
cfig.refresh = cfig.lease / 10;
if (cfig.refresh > 36000)
cfig.refresh = 36000;
cfig.retry = cfig.refresh / 10;
if (ULONG_MAX/24 > cfig.lease)
cfig.expire = 24 * cfig.lease;
else
cfig.expire = ULONG_MAX;
cfig.minimum = cfig.retry;
}
else if (!strcasecmp(name, "Refresh"))
cfig.refresh = atol(value);
else if (!strcasecmp(name, "Retry"))
cfig.retry = atol(value);
else if (!strcasecmp(name, "Expire"))
cfig.expire = atol(value);
else if (!strcasecmp(name, "Minimum"))
cfig.minimum = atol(value);
else if (!strcasecmp(name, "MinCacheTime"))
cfig.minCache = atol(value);
else if (!strcasecmp(name, "MaxCacheTime"))
cfig.maxCache = atol(value);
else
{
sprintf(logBuff, "Section [TIMINGS], Invalid Entry: %s ignored", name);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [TIMINGS], Invalid value: %s ignored", value);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [TIMINGS], Missing value, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
if (!cfig.refresh)
{
cfig.refresh = ULONG_MAX;
if (!cfig.retry)
cfig.retry = 100;
}
else if (!cfig.retry)
cfig.retry = cfig.refresh / 10;
if (!cfig.expire)
cfig.expire = ULONG_MAX;
if (!cfig.minimum)
cfig.minimum = cfig.retry;
if (getSection("DOMAIN-NAME", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
data15 mask;
data15 network;
char left[64];
cfig.authority[0] = 0;
myLower(value);
mask.ip = 0;
network.ip = 0;
for (BYTE octateNum = 0; octateNum < 3; octateNum++)
{
mySplit(left, value, value, '.');
if (left[0] == '0' || (atoi(left) && atoi(left) < 256))
{
for (int j = 2; j >= 0; j--)
{
network.octate[j + 1] = network.octate[j];
mask.octate[j + 1] = mask.octate[j];
}
mask.octate[0] = 255;
network.octate[0] = atoi(left);
strcat(cfig.authority, left);
strcat(cfig.authority, ".");
}
else
break;
if (!strcasecmp(value, arpa + 1))
break;
}
if (!strcasecmp(value, arpa + 1))
{
strcat(cfig.authority, arpa + 1);
cfig.aLen = strlen(cfig.authority);
calcRangeLimits(network.ip, mask.ip, &cfig.rangeStart, &cfig.rangeEnd);
cfig.authorized = 1;
}
else
{
sprintf(logBuff, "Warning: Invalid Domain Name (Part %s), ignored", cfig.authority);
cfig.aLen = 0;
cfig.authority[0] = 0;
logDNSMess(logBuff, 1);
}
}
if (chkQu(name))
{
strcpy(cfig.zone, name);
strcpy(cfig.zoneSmall, name);
myLower(cfig.zoneSmall);
cfig.zLen = strlen(cfig.zone);
}
else
{
cfig.aLen = 0;
cfig.authority[0] = 0;
sprintf(logBuff, "Warning: Invalid Domain Name %s, ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
getServ();
getDServ();
sprintf(cfig.servername_fqn, "%s.%s", cfig.servername, cfig.zone);
strcpy(cfig.ns, cfig.servername_fqn);
cfig.zLen = strlen(cfig.zone);
bool ifSpecified = false;
if (getSection("LISTEN-ON", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 0; i < MAX_SERVERS && iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
ifSpecified = true;
DWORD addr = my_inet_addr(iniStrPtr);
if (isIP(iniStrPtr) && addr)
{
for (BYTE m = 0; ; m++)
{
if (m >= MAX_SERVERS || !cfig.staticServers[m])
{
if (findServer(cfig.allServers, addr))
{
sprintf(logBuff, "Warning: Section [LISTEN-ON], Interface %s is not Static, ignored", iniStrPtr);
logMess(logBuff, 1);
}
else
{
sprintf(logBuff, "Warning: Section [LISTEN-ON], Interface %s not available, ignored", iniStrPtr);
logMess(logBuff, 1);
}
break;
}
else if (cfig.staticServers[m] == addr)
{
for (BYTE n = 0; n < MAX_SERVERS; n++)
{
if (cfig.listenServers[n] == addr)
break;
else if (!cfig.listenServers[n])
{
cfig.listenServers[n] = cfig.staticServers[m];
cfig.listenMasks[n] = cfig.staticMasks[m];
break;
}
}
break;
}
}
}
else
{
sprintf(logBuff, "Warning: Section [LISTEN-ON], Invalid Interface Address %s, ignored", iniStrPtr);
logMess(logBuff, 1);
}
}
}
if (!ifSpecified)
{
BYTE k = 0;
for (BYTE m = 0; m < MAX_SERVERS && cfig.allServers[m]; m++)
{
for (BYTE n = 0; n < MAX_SERVERS; n++)
{
if (cfig.allServers[m] == cfig.staticServers[n])
{
cfig.listenServers[k] = cfig.staticServers[n];
cfig.listenMasks[k] = cfig.staticMasks[n];
k++;
break;
}
else if (!cfig.staticServers[n])
{
sprintf(logBuff, "Warning: Interface %s is not Static, not used", IP2String(tempbuff, cfig.allServers[m]));
logMess(logBuff, 2);
break;
}
}
}
}
if (getSection("ZONE-REPLICATION", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 2; i < MAX_SERVERS && iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
if (!cfig.authorized)
{
sprintf(logBuff, "Section [REPLICATION-SERVERS], Server is not authorized, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
continue;
}
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
if (chkQu(name) && !isIP(name) && isIP(value))
{
if (!strcasecmp(name, "Primary"))
cfig.zoneServers[0] = my_inet_addr(value);
else if (!strcasecmp(name, "Secondary"))
cfig.zoneServers[1] = my_inet_addr(value);
else if (!strcasecmp(name, "AXFRClient"))
{
cfig.zoneServers[i] = my_inet_addr(value);
i++;
}
else
{
sprintf(logBuff, "Section [REPLICATION-SERVERS] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [REPLICATION-SERVERS] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [REPLICATION-SERVERS], Missing value, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
if (!cfig.zoneServers[0] && cfig.zoneServers[1])
{
sprintf(logBuff, "Section [REPLICATION-SERVERS] Missing Primary Server");
logMess(logBuff, 1);
}
else if (cfig.zoneServers[0] && !cfig.zoneServers[1])
{
sprintf(logBuff, "Section [REPLICATION-SERVERS] Missing Secondary Server");
logMess(logBuff, 1);
}
else if (cfig.zoneServers[0] && cfig.zoneServers[1])
{
if (findServer(cfig.staticServers, cfig.zoneServers[0]) && findServer(cfig.staticServers, cfig.zoneServers[1]))
{
sprintf(logBuff, "Section [REPLICATION-SERVERS] Primary & Secondary should be Different Boxes");
logMess(logBuff, 1);
}
else if (findServer(cfig.staticServers, cfig.zoneServers[0]))
cfig.replication = 1;
else if (findServer(cfig.staticServers, cfig.zoneServers[1]))
cfig.replication = 2;
else
{
sprintf(logBuff, "Section [REPLICATION-SERVERS] No Server IP not found on this Machine");
logMess(logBuff, 1);
}
}
if (dhcpService)
{
int i = 0;
for (int j = 0; j < MAX_SERVERS && cfig.listenServers[j]; j++)
{
cfig.dhcpConn[i].sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (cfig.dhcpConn[i].sock == INVALID_SOCKET)
{
sprintf(logBuff, "Failed to Create Socket");
logDHCPMess(logBuff, 1);
continue;
}
cfig.dhcpConn[i].addr.sin_family = AF_INET;
cfig.dhcpConn[i].addr.sin_addr.s_addr = cfig.listenServers[j];
cfig.dhcpConn[i].addr.sin_port = htons(IPPORT_DHCPS);
cfig.dhcpConn[i].reUseVal = true;
cfig.dhcpConn[i].reUseSize = sizeof(cfig.dhcpConn[i].reUseVal);
setsockopt(cfig.dhcpConn[i].sock, SOL_SOCKET, SO_REUSEADDR, (char*)&cfig.dhcpConn[i].reUseVal, cfig.dhcpConn[i].reUseSize);
cfig.dhcpConn[i].broadCastVal = true;
cfig.dhcpConn[i].broadCastSize = sizeof(cfig.dhcpConn[i].broadCastVal);
setsockopt(cfig.dhcpConn[i].sock, SOL_SOCKET, SO_BROADCAST, (char*)&cfig.dhcpConn[i].broadCastVal, cfig.dhcpConn[i].broadCastSize);
int nRet = bind(cfig.dhcpConn[i].sock, (sockaddr*)&cfig.dhcpConn[i].addr, sizeof(struct sockaddr_in));
if (nRet == SOCKET_ERROR)
{
close(cfig.dhcpConn[i].sock);
sprintf(logBuff, "%s Port 67 already in use", IP2String(tempbuff, cfig.listenServers[j]));
logDHCPMess(logBuff, 1);
continue;
}
if (cfig.maxFD < cfig.dhcpConn[i].sock)
cfig.maxFD = cfig.dhcpConn[i].sock;
cfig.dhcpConn[i].server = cfig.listenServers[j];
cfig.dhcpConn[i].mask = cfig.listenMasks[j];
i++;
}
cfig.dhcpListener.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (cfig.dhcpListener.sock == INVALID_SOCKET)
{
sprintf(logBuff, "Failed to Creat DHCP Socket");
logDHCPMess(logBuff, 1);
}
else
{
cfig.dhcpListener.reUseVal = true;
cfig.dhcpListener.reUseSize = sizeof(cfig.dhcpListener.reUseVal);
setsockopt(cfig.dhcpListener.sock, SOL_SOCKET, SO_REUSEADDR, (char*)&cfig.dhcpListener.reUseVal, cfig.dhcpListener.reUseSize);
cfig.dhcpListener.pktinfoVal = true;
cfig.dhcpListener.pktinfoSize = sizeof(cfig.dhcpListener.pktinfoVal);
setsockopt(cfig.dhcpListener.sock, SOL_IP, IP_PKTINFO, &cfig.dhcpListener.pktinfoVal, cfig.dhcpListener.pktinfoSize);
cfig.dhcpListener.addr.sin_family = AF_INET;
cfig.dhcpListener.addr.sin_addr.s_addr = INADDR_ANY;
cfig.dhcpListener.addr.sin_port = htons(IPPORT_DHCPS);
int nRet = bind(cfig.dhcpListener.sock,
(sockaddr*)&cfig.dhcpListener.addr,
sizeof(struct sockaddr_in)
);
if (nRet == SOCKET_ERROR)
{
close(cfig.dhcpListener.sock);
sprintf(logBuff, "DHCP Port 67 already in use");
logDHCPMess(logBuff, 1);
}
if (cfig.maxFD < cfig.dhcpListener.sock)
cfig.maxFD = cfig.dhcpListener.sock;
}
if (cfig.replication)
{
//printf("Heren");
cfig.dhcpReplConn.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (cfig.dhcpReplConn.sock == INVALID_SOCKET)
{
sprintf(logBuff, "Failed to Create DHCP Replication Socket");
logDHCPMess(logBuff, 1);
}
else
{
//printf("Socket %un", cfig.dhcpReplConn.sock);
cfig.dhcpReplConn.addr.sin_family = AF_INET;
if (cfig.replication == 1)
cfig.dhcpReplConn.addr.sin_addr.s_addr = cfig.zoneServers[0];
else
cfig.dhcpReplConn.addr.sin_addr.s_addr = cfig.zoneServers[1];
cfig.dhcpReplConn.addr.sin_port = 0;
int nRet = bind(cfig.dhcpReplConn.sock, (sockaddr*)&cfig.dhcpReplConn.addr, sizeof(struct sockaddr_in));
if (nRet == INVALID_SOCKET)
{
sprintf(logBuff, "DHCP Replication Server, Bind Failed");
logDHCPMess(logBuff, 1);
}
else if (cfig.maxFD < cfig.dhcpReplConn.sock)
cfig.maxFD = cfig.dhcpReplConn.sock;
/*
else
cfig.dhcpReplConn.server = cfig.dhcpReplConn.addr.sin_addr.s_addr;
*/
}
}
if (getSection("DHCP-OPTIONS", iniStr, 1, iniFile))
{
data20 optionData;
loadOptions(iniStr, "DHCP-OPTIONS", &optionData);
cfig.options = optionData.options;
cfig.mask = optionData.mask;
}
for (BYTE i = 1; i <= 32 ; i++)
{
if (getSection("DHCP-RANGE", iniStr, i, iniFile))
{
BYTE m = 0;
for (; m < 32 && cfig.dhcpRanges[m].rangeStart; m++);
data20 optionData;
optionData.rangeSetInd = i - 1;
loadOptions(iniStr, "DHCP-RANGE", &optionData);
cfig.rangeSet[optionData.rangeSetInd].active = true;
for (; m < 32 && cfig.dhcpRanges[m].rangeStart; m++)
{
//printf("Range Start=%s rangeSetInd=%in", IP2String(tempbuff, htonl(cfig.dhcpRanges[m].rangeStart)), optionData.rangeSetInd);
cfig.dhcpRanges[m].rangeSetInd = optionData.rangeSetInd;
cfig.dhcpRanges[m].options = optionData.options;
cfig.dhcpRanges[m].mask = optionData.mask;
}
}
else
break;
}
//printf("%sn", IP2String(tempbuff, cfig.mask));
if (!cfig.mask)
{
cfig.mask = inet_addr("255.255.255.0");
/*
for (BYTE m = 0; m < 32 && cfig.dhcpRanges[m].rangeStart; m++)
{
DWORD mask = cfig.dhcpRanges[m].mask;
if (!mask)
mask = calcMask(cfig.dhcpRanges[m].rangeStart, cfig.dhcpRanges[m].rangeEnd);
if (htonl(mask) < htonl(cfig.mask))
cfig.mask = mask;
}
*/
}
for (char rangeInd = 0; rangeInd < 32 && cfig.dhcpRanges[rangeInd].rangeStart; rangeInd++)
{
if (!cfig.dhcpRanges[rangeInd].mask)
cfig.dhcpRanges[rangeInd].mask = cfig.mask;
for (DWORD iip = cfig.dhcpRanges[rangeInd].rangeStart; iip <= cfig.dhcpRanges[rangeInd].rangeEnd; iip++)
{
DWORD ip = htonl(iip);
if ((cfig.dhcpRanges[rangeInd].mask | (~ip)) == ULONG_MAX || (cfig.dhcpRanges[rangeInd].mask | ip) == ULONG_MAX)
cfig.dhcpRanges[rangeInd].expiry[iip - cfig.dhcpRanges[rangeInd].rangeStart] = LONG_MAX;
}
}
for (BYTE m = 0; m < MAX_SERVERS && cfig.allServers[m]; m++)
setLeaseExpiry(cfig.allServers[m], LONG_MAX);
for (BYTE m = 0; m < MAX_SERVERS && cfig.dns[m]; m++)
setLeaseExpiry(cfig.dns[m], LONG_MAX);
if (getSection("DHCP-OPTIONS", iniStr, 1, iniFile))
lockOptions(iniStr);
for (BYTE i = 1; i <= 32 ;i++)
{
if (getSection("DHCP-RANGE", iniStr, i, iniFile))
lockOptions(iniStr);
}
FILE *f = fopen(iniFile, "rt");
if (f)
{
char sectionName[512];
while (fgets(sectionName, 511, f))
{
if (*sectionName == '[')
{
char *secend = strchr(sectionName, ']');
if (secend)
{
*secend = 0;
sectionName[0] = 32;
myTrim(sectionName, sectionName);
}
else
continue;
}
else
continue;
BYTE hexValue[255];
BYTE hexValueSize = sizeof(hexValue);
data20 optionData;
if (!getHexValue(hexValue, sectionName, &hexValueSize))
{
data7 *dhcpEntry = dhcpCache[toUUE(tempbuff, hexValue, hexValueSize)];
if (!dhcpEntry)
{
getSection(sectionName, iniStr, 1, iniFile);
loadOptions(iniStr, sectionName, &optionData);
lockOptions(iniStr);
if (optionData.ip)
{
dhcpMap::iterator p = dhcpCache.begin();
for (; p != dhcpCache.end(); p++)
{
if (p->second && p->second->ip == optionData.ip)
break;
}
if (p == dhcpCache.end())
{
dhcpEntry = (data7*)calloc(1, sizeof(data7));
if (!dhcpEntry)
{
sprintf(logBuff, "Client Options Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
return;
}
dhcpEntry->mapname = cloneString(toUUE(tempbuff, hexValue, hexValueSize));
if (!dhcpEntry->mapname)
{
sprintf(logBuff, "Client Data Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
return;
}
DWORD tmask = htonl(optionData.mask);
while (tmask)
{
(dhcpEntry->bitmask)++;
tmask = tmask << 1;
}
dhcpEntry->ip = optionData.ip;
dhcpEntry->options = optionData.options;
dhcpEntry->rangeInd = getRangeInd(optionData.ip);
dhcpEntry->fixed = 1;
setLeaseExpiry(optionData.ip, LONG_MAX);
dhcpCache[dhcpEntry->mapname] = dhcpEntry;
//printf("%s=%s=%sn", sectionName, dhcpEntry->mapname, IP2String(tempbuff, optionData.ip));
}
else
{
sprintf(logBuff, "Static DHCP Host [%s] Duplicate IP Address %s, Entry ignored", sectionName, IP2String(tempbuff, optionData.ip));
logDHCPMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "IP Address is missing in Static DHCP Host [%s], Entry ignored", sectionName);
logDHCPMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Duplicate Static DHCP Host [%s] ignored", sectionName);
logDHCPMess(logBuff, 1);
}
}
else if (strchr(sectionName, ':'))
{
sprintf(logBuff, "Invalid Static DHCP Host MAC Addr [%s] ignored", sectionName);
logDHCPMess(logBuff, 1);
}
}
fclose(f);
}
}
if (dnsService)
{
addToCache(0, "localhost", my_inet_addr("127.0.0.1"), LONG_MAX, LOCALHOST_A, LOCALHOST_PTR, LONG_MAX);
addToCache(1, "localhost", my_inet_addr("127.0.0.1"), LONG_MAX, LOCALHOST_A, LOCALHOST_PTR, LONG_MAX);
for (int i = 0; cfig.replication != 2 && i < MAX_SERVERS && cfig.allServers[i]; i++)
if (cfig.authorized && makeLocal(cfig.allServers[i]))
{
addToCache(0, cfig.servername, cfig.allServers[i], LONG_MAX, SERVER_A, SERVER_PTR_AUTH, LONG_MAX);
addToCache(1, cfig.servername, cfig.allServers[i], LONG_MAX, SERVER_A, SERVER_PTR_AUTH, LONG_MAX);
}
else
{
addToCache(0, cfig.servername, cfig.allServers[i], LONG_MAX, SERVER_A, SERVER_PTR_NAUTH, LONG_MAX);
addToCache(1, cfig.servername, cfig.allServers[i], LONG_MAX, SERVER_A, SERVER_PTR_NAUTH, LONG_MAX);
}
if (getSection("DNS-ALLOWED-HOSTS", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 0; i < 32 && iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
DWORD rs = 0;
DWORD re = 0;
mySplit(name, value, iniStrPtr, '-');
if (value[0])
{
rs = htonl(my_inet_addr(name));
re = htonl(my_inet_addr(value));
}
else
{
rs = htonl(my_inet_addr(name));
re = rs;
}
if (rs && rs != INADDR_NONE && re && re != INADDR_NONE && rs <= re)
{
cfig.dnsRanges[i].rangeStart = rs;
cfig.dnsRanges[i].rangeEnd = re;
i++;
}
else
{
sprintf(logBuff, "Section [DNS-ALLOWED-HOSTS] Invalid entry %s in ini file, ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
if (cfig.replication != 2 && getSection("HOSTS", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (; iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
if (chkQu(name) && !isIP(name) && isIP(value))
{
DWORD inetAddr = my_inet_addr(value);
if (!inetAddr)
{
sprintf(logBuff, "Section [HOSTS] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
else if (cfig.authorized && makeLocal(name) && makeLocal(inetAddr))
{
addToCache(cacheInd, name, inetAddr, LONG_MAX, STATIC_A_AUTH, STATIC_PTR_AUTH, cfig.serial1);
setLeaseExpiry(inetAddr, 0);
}
else if (cfig.authorized && makeLocal(name))
{
addToCache(cacheInd, name, inetAddr, LONG_MAX, STATIC_A_AUTH, STATIC_PTR_NAUTH, cfig.serial1);
setLeaseExpiry(inetAddr, 0);
}
else if (cfig.authorized && makeLocal(inetAddr))
{
addToCache(cacheInd, name, inetAddr, LONG_MAX, STATIC_A_NAUTH, STATIC_PTR_AUTH, cfig.serial1);
setLeaseExpiry(inetAddr, 0);
}
else
{
makeLocal(name);
addToCache(cacheInd, name, inetAddr, LONG_MAX, STATIC_A_NAUTH, STATIC_PTR_NAUTH, cfig.serial1);
setLeaseExpiry(inetAddr, 0);
}
}
else
{
sprintf(logBuff, "Section [HOSTS] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [HOSTS], Missing IP, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
if (cfig.replication != 2 && getSection("ALIASES", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 0; iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
if (chkQu(name) && chkQu(value))
{
if (makeLocal(name))
{
data7 *cache = findEntry(cacheInd, name);
if (!cache)
{
cache = (data7*)calloc(1, sizeof(data7));
if (cache)
{
if (!makeLocal(value))
cache->dataType = EXT_CNAME;
else
cache->dataType = LOCAL_CNAME;
cache->mapname = cloneString(name);
cache->hostname = cloneString(value);
if (!cache->mapname || !cache->hostname)
{
sprintf(logBuff, "Section [ALIASES] entry %s memory error", iniStrPtr);
logDNSMess(logBuff, 1);
}
else
{
cache->expiry = LONG_MAX;
cache->serial = cfig.serial1;
addEntry(cacheInd, cache);
i++;
}
}
else
{
sprintf(logBuff, "Section [ALIASES] entry %s memory error", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [ALIASES] duplicate entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [ALIASES] alias %s should be bare/local name, entry ignored", name);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [ALIASES] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [ALIASES], Missing value, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
if (cfig.replication != 2 && getSection("MAIL-SERVERS", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (cfig.mxCount[cacheInd] = 0; cfig.mxCount[cacheInd] < MAX_SERVERS && iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
if (chkQu(name) && atoi(value))
{
cfig.mxServers[0][cfig.mxCount[cacheInd]].pref = atoi(value);
cfig.mxServers[1][cfig.mxCount[cacheInd]].pref = atoi(value);
if (!strchr(name, '.'))
{
strcat(name, ".");
strcat(name, cfig.zone);
}
strcpy(cfig.mxServers[0][cfig.mxCount[cacheInd]].hostname, name);
strcpy(cfig.mxServers[1][cfig.mxCount[cacheInd]].hostname, name);
cfig.mxCount[cacheInd]++;
}
else
{
sprintf(logBuff, "Section [MAIL-SERVERS] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [MAIL-SERVERS], Missing value, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
cfig.mxCount[1] = cfig.mxCount[0];
}
if (getSection("CHILD-ZONES", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 0; i < 32 && iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
/*
if (cfig.authorized)
{
char *dp = strstr(name, arpa);
if (dp)
{
dp = strchr(name, '.');
if (!dp || strcasecmp(dp + 1, cfig.authority))
{
sprintf(logBuff, "Section [CHILD-ZONES], Zone %s is not child of %s, Entry ignored", name, cfig.authority);
logDNSMess(logBuff, 1);
continue;
}
}
else
{
dp = strchr(name, '.');
if (!dp || strcasecmp(dp + 1, cfig.zone))
{
sprintf(logBuff, "Section [CHILD-ZONES], Zone %s is not child of %s, Entry ignored", name, cfig.zone);
logDNSMess(logBuff, 1);
continue;
}
}
}
*/
int j = 0;
for (; j < 32 && cfig.dnsRoutes[j].zone[0]; j++)
{
if (!strcasecmp(cfig.dnsRoutes[j].zone, name))
{
sprintf(logBuff, "Section [CHILD-ZONES], Duplicate Entry for Child Zone %s ignored", name);
logDNSMess(logBuff, 1);
break;
}
}
if (j < 32 && !cfig.dnsRoutes[j].zone[0])
{
if (name[0] && chkQu(name) && value[0])
{
char *value1 = strchr(value, ',');
if (value1)
{
*value1 = 0;
value1++;
DWORD ip = my_inet_addr(myTrim(value, value));
DWORD ip1 = my_inet_addr(myTrim(value1, value1));
if (isIP(value) && ip && isIP(value1) && ip1)
{
strcpy(cfig.dnsRoutes[i].zone, name);
cfig.dnsRoutes[i].zLen = strlen(cfig.dnsRoutes[i].zone);
cfig.dnsRoutes[i].dns[0] = ip;
cfig.dnsRoutes[i].dns[1] = ip1;
i++;
}
else
{
sprintf(logBuff, "Section [CHILD-ZONES] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
DWORD ip = my_inet_addr(value);
if (isIP(value) && ip)
{
strcpy(cfig.dnsRoutes[i].zone, name);
cfig.dnsRoutes[i].zLen = strlen(cfig.dnsRoutes[i].zone);
cfig.dnsRoutes[i].dns[0] = ip;
i++;
}
else
{
sprintf(logBuff, "Section [CHILD-ZONES] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
else
{
sprintf(logBuff, "Section [CHILD-ZONES] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
else
{
sprintf(logBuff, "Section [CHILD-ZONES], Missing value, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
if (getSection("WILD-HOSTS", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 0; i < 32 && iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
mySplit(name, value, iniStrPtr, '=');
if (name[0] && value[0])
{
if (chkQu(name) && isIP(value))
{
DWORD ip = my_inet_addr(value);
strcpy(cfig.wildHosts[i].wildcard, name);
myLower(cfig.wildHosts[i].wildcard);
cfig.wildHosts[i].ip = ip;
i++;
}
else
{
sprintf(logBuff, "Section [WILD-HOSTS] Invalid Entry: %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
else
{
sprintf(logBuff, "Section [WILD-HOSTS], Missing value, entry %s ignored", iniStrPtr);
logDNSMess(logBuff, 1);
}
}
}
int i = 0;
for (int j = 0; j < MAX_SERVERS && cfig.listenServers[j]; j++)
{
cfig.dnsUdpConn[i].sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (cfig.dnsUdpConn[i].sock == INVALID_SOCKET)
{
sprintf(logBuff, "Failed to Create Socket");
logDNSMess(logBuff, 1);
continue;
}
//printf("Socket %un", cfig.dnsUdpConn[i].sock);
cfig.dnsUdpConn[i].addr.sin_family = AF_INET;
cfig.dnsUdpConn[i].addr.sin_addr.s_addr = cfig.listenServers[j];
cfig.dnsUdpConn[i].addr.sin_port = htons(IPPORT_DNS);
int nRet = bind(cfig.dnsUdpConn[i].sock,
(sockaddr*)&cfig.dnsUdpConn[i].addr,
sizeof(struct sockaddr_in)
);
if (nRet == SOCKET_ERROR)
{
closesocket(cfig.dnsUdpConn[i].sock);
sprintf(logBuff, "%s UDP Port 53 already in use", IP2String(tempbuff, cfig.listenServers[j]));
logDNSMess(logBuff, 1);
continue;
}
if (cfig.maxFD < cfig.dnsUdpConn[i].sock)
cfig.maxFD = cfig.dnsUdpConn[i].sock;
cfig.dnsUdpConn[i].server = cfig.listenServers[j];
if (!cfig.nsIP)
cfig.nsIP = cfig.listenServers[j];
i++;
}
cfig.forwConn.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (cfig.forwConn.sock == INVALID_SOCKET)
{
sprintf(logBuff, "Failed to Create Socket");
logDNSMess(logBuff, 1);
}
else
{
cfig.forwConn.addr.sin_family = AF_INET;
//bind(cfig.forwConn.sock, (sockaddr*)&cfig.forwConn.addr, sizeof(struct sockaddr_in));
if (cfig.maxFD < cfig.forwConn.sock)
cfig.maxFD = cfig.forwConn.sock;
}
i = 0;
for (int j = 0; j < MAX_SERVERS && cfig.listenServers[j]; j++)
{
cfig.dnsTcpConn[i].sock = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (cfig.dnsTcpConn[i].sock == INVALID_SOCKET)
{
sprintf(logBuff, "Failed to Create Socket");
logDNSMess(logBuff, 1);
}
else
{
//printf("Socket %un", cfig.dnsTcpConn[i].sock);
cfig.dnsTcpConn[i].addr.sin_family = AF_INET;
cfig.dnsTcpConn[i].addr.sin_addr.s_addr = cfig.listenServers[j];
cfig.dnsTcpConn[i].addr.sin_port = htons(IPPORT_DNS);
int nRet = bind(cfig.dnsTcpConn[i].sock,
(sockaddr*)&cfig.dnsTcpConn[i].addr,
sizeof(struct sockaddr_in));
if (nRet == SOCKET_ERROR)
{
closesocket(cfig.dnsTcpConn[i].sock);
sprintf(logBuff, "%s TCP Port 53 already in use", IP2String(tempbuff, cfig.listenServers[j]));
logDNSMess(logBuff, 1);
}
else
{
nRet = listen(cfig.dnsTcpConn[i].sock, SOMAXCONN);
if (nRet == SOCKET_ERROR)
{
closesocket(cfig.dnsTcpConn[i].sock);
sprintf(logBuff, "TCP Port 53 Error on Listen");
logDNSMess(logBuff, 1);
}
else
{
cfig.dnsTcpConn[i].server = cfig.listenServers[j];
if (cfig.maxFD < cfig.dnsTcpConn[i].sock)
cfig.maxFD = cfig.dnsTcpConn[i].sock;
i++;
}
}
}
}
}
if (dhcpService)
{
FILE *f = fopen(leaFile, "rb");
if (f)
{
data8 dhcpData;
while (fread(&dhcpData, sizeof(data8), 1, f))
{
char rangeInd = -1;
int ind = -1;
if (!findServer(cfig.staticServers, dhcpData.ip) && !findServer(cfig.dns, dhcpData.ip))
{
data7 *dhcpEntry = dhcpCache[toUUE(tempbuff, dhcpData.bp_chaddr, dhcpData.bp_hlen)];
if (dhcpEntry)
{
if (dhcpEntry->ip != dhcpData.ip)
continue;
}
else
{
dhcpMap::iterator p = dhcpCache.begin();
for (; p != dhcpCache.end(); p++)
{
if (p->second && p->second->ip == dhcpData.ip)
break;
}
if (p != dhcpCache.end())
{
if (p->second && (p->second->fixed || p->second->expiry > dhcpData.expiry))
continue;
else
dhcpCache.erase(p);
}
}
rangeInd = getRangeInd(dhcpData.ip);
if(rangeInd >= 0)
{
ind = getIndex(rangeInd, dhcpData.ip);
if (ind >= 0 && !dhcpEntry)
{
dhcpEntry = (data7*)calloc(1, sizeof(data7));
if (!dhcpEntry)
{
sprintf(logBuff, "Loading Existing Leases, Memory Allocation Error");
logDHCPMess(logBuff, 1);
return;
}
dhcpEntry->mapname = cloneString(toUUE(tempbuff, dhcpData.bp_chaddr, dhcpData.bp_hlen));
if (!dhcpEntry->mapname)
{
sprintf(logBuff, "Loading Existing Leases, Memory Allocation Error");
free(dhcpEntry);
logDHCPMess(logBuff, 1);
return ;
}
//dhcpEntry->dataType = DHCP;
dhcpCache[dhcpEntry->mapname] = dhcpEntry;
}
}
if (dhcpEntry)
{
dhcpEntry->ip = dhcpData.ip;
dhcpEntry->rangeInd = rangeInd;
if (!dhcpEntry->fixed)
dhcpEntry->source = dhcpData.source;
if (dhcpData.expiry > t)
{
setLeaseExpiry(dhcpEntry, dhcpData.expiry - t, dhcpData.active);
addToCache(cacheInd, dhcpData.hostname, dhcpEntry->ip, dhcpData.expiry, LOCAL_A, NONE, cfig.serial1);
if (makeLocal(dhcpEntry->ip))
addToCache(cacheInd, dhcpData.hostname, dhcpEntry->ip, dhcpData.expiry, NONE, LOCAL_PTR_AUTH, cfig.serial2);
else
addToCache(cacheInd, dhcpData.hostname, dhcpEntry->ip, dhcpData.expiry, NONE, LOCAL_PTR_NAUTH, cfig.serial2);
}
else
setLeaseExpiry(dhcpEntry, 0, false);
}
}
}
fclose(f);
f = fopen(leaFile, "wb");
cfig.dhcpIndex = 0;
if (f)
{
dhcpMap::iterator p = dhcpCache.begin();
for (; p != dhcpCache.end(); p++)
{
if (p->second && p->second->expiry)
{
memset(&dhcpData, 0, sizeof(data8));
dhcpData.bp_hlen = fromUUE(dhcpData.bp_chaddr, p->second->mapname);
dhcpData.ip = p->second->ip;
dhcpData.expiry = p->second->expiry;
dhcpData.active = p->second->active;
if (!p->second->fixed)
dhcpData.source = p->second->source;
data7 *cache = findEntry(cacheInd, IP2String(tempbuff, htonl(p->second->ip)));
if (cache && cache->hostname)
strcpy(dhcpData.hostname, cache->hostname);
cfig.dhcpIndex++;
dhcpData.dhcpInd = cfig.dhcpIndex;
p->second->dhcpInd = cfig.dhcpIndex;
fwrite(&dhcpData, sizeof(data8), 1, f);
}
}
fclose(f);
}
}
}
if ((dhcpService && !cfig.dhcpConn[0].server) || (dnsService && !cfig.dnsUdpConn[0].server && !cfig.dnsTcpConn[0].server))
{
sprintf(logBuff, "Error: Static Interfaces/Listening Ports not available, Stopped..");
logMess(logBuff, 1);
kRunning = false;
exit(EXIT_FAILURE);
}
if (dhcpService)
{
cfig.httpConn.port = 6789;
cfig.httpConn.server = cfig.dhcpConn[0].server;
if (getSection("HTTP-INTERFACE", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
if(iniStrPtr[0])
{
mySplit(name, value, iniStrPtr, ':');
if (name[0] && isIP(name) && my_inet_addr(name))
cfig.httpConn.server = my_inet_addr(name);
else
{
sprintf(logBuff, "Warning: Section [HTTP-INTERFACE], Invalid IP Address %s, ignored", name);
logDHCPMess(logBuff, 1);
}
if (value[0])
{
if (atoi(value))
cfig.httpConn.port = atoi(value);
else
{
sprintf(logBuff, "Warning: Section [HTTP-INTERFACE], Invalid port %s, ignored", value);
logDHCPMess(logBuff, 1);
}
}
}
}
cfig.httpConn.sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (cfig.httpConn.sock == INVALID_SOCKET)
{
cfig.httpConn.server = 0;
sprintf(logBuff, "Failed to Create Socket");
logDHCPMess(logBuff, 1);
}
else
{
//printf("Socket %un", cfig.httpConn.sock);
cfig.httpConn.addr.sin_family = AF_INET;
cfig.httpConn.addr.sin_addr.s_addr = cfig.httpConn.server;
cfig.httpConn.addr.sin_port = htons(cfig.httpConn.port);
int nRet = bind(cfig.httpConn.sock,
(sockaddr*)&cfig.httpConn.addr,
sizeof(struct sockaddr_in));
if (nRet == SOCKET_ERROR)
{
sprintf(logBuff, "Http Interface %s TCP Port %u not available", IP2String(tempbuff, cfig.httpConn.server), cfig.httpConn.port);
logDHCPMess(logBuff, 1);
cfig.httpConn.server = 0;
closesocket(cfig.httpConn.sock);
}
else
{
nRet = listen(cfig.httpConn.sock, SOMAXCONN);
if (nRet == SOCKET_ERROR)
{
sprintf(logBuff, "%s TCP Port %u Error on Listen", IP2String(tempbuff, cfig.httpConn.server), cfig.httpConn.port);
logDHCPMess(logBuff, 1);
close(cfig.httpConn.sock);
cfig.httpConn.server = 0;
}
else if (cfig.httpConn.sock > cfig.maxFD)
cfig.maxFD = cfig.httpConn.sock;
}
}
}
cfig.maxFD++;
if (verbatim)
{
if (dhcpService)
printf("Starting DHCP...n");
if (dnsService)
{
printf("Starting DNS...n");
if (cfig.replication == 1 && dhcpService)
{
cfig.serial1 = t;
cfig.serial2 = t;
cfig.expireTime = LONG_MAX;
DWORD serial1 = getSerial(cfig.authority);
if (serial1)
{
getSecondary();
}
}
else if (cfig.replication == 2)
{
bool temp = false;
refresh(&temp);
}
else
{
cfig.serial1 = t;
cfig.serial2 = t;
cfig.expireTime = LONG_MAX;
}
if (!dhcpService && cfig.replication == 2)
{
pthread_t threadId;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
int errcode = pthread_create(&threadId, &attr, refresh, NULL);
pthread_attr_destroy(&attr);
if(errcode)
{
if (cfig.dnsLogLevel)
{
sprintf(logBuff, "Thread Creation Failed");
logDHCPMess(logBuff, 1);
}
exit(1);
}
//if(errcode)
//pthread_create(&threadId, 0, refresh, NULL);
}
}
printf("n");
}
else
{
if (dhcpService)
{
sprintf(logBuff, "Starting DHCP Service");
logDHCPMess(logBuff, 1);
}
if (dnsService)
{
sprintf(logBuff, "Starting DNS Service");
logDNSMess(logBuff, 1);
if (cfig.replication == 1 && dhcpService)
{
cfig.serial1 = t;
cfig.serial2 = t;
cfig.expireTime = LONG_MAX;
DWORD serial1 = getSerial(cfig.authority);
if (serial1)
{
getSecondary();
}
}
else if (cfig.replication == 2)
{
bool temp = false;
refresh(&temp);
}
else
{
cfig.serial1 = t;
cfig.serial2 = t;
cfig.expireTime = LONG_MAX;
}
if (!dhcpService && cfig.replication == 2)
{
pthread_t threadId;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
int errcode = pthread_create(&threadId, &attr, refresh, NULL);
pthread_attr_destroy(&attr);
if(errcode)
{
if (cfig.dnsLogLevel)
{
sprintf(logBuff, "Thread Creation Failed");
logDNSMess(logBuff, 1);
}
}
//pthread_create(&threadId, 0, refresh, NULL);
}
}
}
if (dnsService)
{
for (int i = 0; i < 32 && cfig.dnsRoutes[i].dns[0]; i++)
{
char temp[256];
if (!cfig.dnsRoutes[i].dns[1])
sprintf(logBuff, "Child DNS Server: %s for Zone %s", IP2String(tempbuff, cfig.dnsRoutes[i].dns[0]), cfig.dnsRoutes[i].zone);
else
sprintf(logBuff, "Child DNS Servers: %s, %s for Zone %s", IP2String(temp, cfig.dnsRoutes[i].dns[0]), IP2String(tempbuff, cfig.dnsRoutes[i].dns[1]), cfig.dnsRoutes[i].zone);
logDNSMess(logBuff, 1);
}
for (int i = 0; i < MAX_SERVERS && cfig.dns[i]; i++)
{
sprintf(logBuff, "Forwarding DNS Server: %s", IP2String(tempbuff, cfig.dns[i]));
logDNSMess(logBuff, 1);
}
}
if (dhcpService)
{
for (int i = 0; i < 32 && cfig.dhcpRanges[i].rangeStart;i++)
{
char *logPtr = logBuff;
logPtr += sprintf(logPtr, "DHCP Range: ");
logPtr += sprintf(logPtr, "%s", IP2String(tempbuff, htonl(cfig.dhcpRanges[i].rangeStart)));
logPtr += sprintf(logPtr, "-%s", IP2String(tempbuff, htonl(cfig.dhcpRanges[i].rangeEnd)));
logPtr += sprintf(logPtr, "/%s", IP2String(tempbuff, cfig.dhcpRanges[i].mask));
logDHCPMess(logBuff, 1);
}
}
if (dnsService)
{
char temp[128];
for (int i = 0; i <= 32 && cfig.dnsRanges[i].rangeStart; i++)
{
char *logPtr = logBuff;
logPtr += sprintf(logPtr, "%s", "DNS Service Permitted Hosts: ");
logPtr += sprintf(logPtr, "%s-", IP2String(tempbuff, htonl(cfig.dnsRanges[i].rangeStart)));
logPtr += sprintf(logPtr, "%s", IP2String(tempbuff, htonl(cfig.dnsRanges[i].rangeEnd)));
logDNSMess(logBuff, 1);
}
if (cfig.lease >= LONG_MAX)
sprintf(logBuff, "Default Host Expiry: Infinity");
else
sprintf(logBuff, "Default Host Expiry: %u (sec)", cfig.lease);
logDNSMess(logBuff, 1);
}
if (dhcpService)
{
if (cfig.lease >= LONG_MAX)
sprintf(logBuff, "Max Lease: Infinity");
else
sprintf(logBuff, "Max Lease: %u (sec)", cfig.lease);
logDHCPMess(logBuff, 1);
}
if (dnsService && cfig.replication)
{
sprintf(logBuff, "Refresh: %u (sec)", cfig.refresh);
logMess(logBuff, 1);
sprintf(logBuff, "Retry: %u (sec)", cfig.retry);
logMess(logBuff, 1);
if (cfig.expire == ULONG_MAX)
sprintf(logBuff, "Expire: Infinity");
else
sprintf(logBuff, "Expire: %u (sec)", cfig.expire);
logMess(logBuff, 1);
sprintf(logBuff, "Min: %u (sec)", cfig.minimum);
logMess(logBuff, 1);
}
if (cfig.replication == 1)
sprintf(logBuff, "Server Name: %s (Primary)", cfig.servername);
else if (cfig.replication == 2)
sprintf(logBuff, "Server Name: %s (Secondary)", cfig.servername);
else
sprintf(logBuff, "Server Name: %s", cfig.servername);
logMess(logBuff, 1);
if (dnsService)
{
if (cfig.authorized)
sprintf(logBuff, "Authority for Zone: %s (%s)", cfig.zone, cfig.authority);
else
sprintf(logBuff, "Domain Name: %s", cfig.zone);
}
else
sprintf(logBuff, "Domain Name: %s", cfig.zone);
logDNSMess(logBuff, 1);
for (int i = 0; i < MAX_SERVERS && cfig.staticServers[i]; i++)
{
for (BYTE j = 0; j < MAX_SERVERS; j++)
{
if (cfig.dhcpConn[j].server == cfig.staticServers[i] || cfig.dnsUdpConn[j].server == cfig.staticServers[i])
{
sprintf(logBuff, "Listening On: %s", IP2String(tempbuff, cfig.staticServers[i]));
logMess(logBuff, 1);
break;
}
}
}
if (dhcpService && cfig.httpConn.server)
{
sprintf(logBuff, "Lease Status URL: http://%s:%u", IP2String(tempbuff, cfig.httpConn.server), cfig.httpConn.port);
logDHCPMess(logBuff, 1);
}
if (!verbatim)
{
if (cfig.dnsLogLevel > 1)
sprintf(logBuff, "DNS Logging: All");
else if (cfig.dnsLogLevel)
sprintf(logBuff, "DNS Logging: Errors");
else
sprintf(logBuff, "DNS Logging: None");
logMess(logBuff, 1);
if (cfig.dhcpLogLevel > 1)
sprintf(logBuff, "DHCP Logging: All");
else if (cfig.dhcpLogLevel)
sprintf(logBuff, "DHCP Logging: Errors");
else
sprintf(logBuff, "DHCP Logging: None");
logMess(logBuff, 1);
}
else
{
printf("nAccepting requests..n");
}
}
void getServ()
{
for (int i = 0; i < MAX_SERVERS; i++)
{
cfig.allServers[i] = 0;
cfig.listenServers[i] = 0;
cfig.listenMasks[i] = 0;
}
struct ifconf Ifc;
struct ifreq IfcBuf[2*MAX_SERVERS];
struct ifreq *pIfr;
int num_ifreq, fd, i;
DWORD addr, mask;
short flags;
Ifc.ifc_len = sizeof(IfcBuf);
Ifc.ifc_buf = (char *) IfcBuf;
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0)
{
if ( ioctl(fd, SIOCGIFCONF, &Ifc) >= 0)
{
num_ifreq = Ifc.ifc_len / sizeof(struct ifreq);
for ( pIfr = Ifc.ifc_req, i = 0 ; i < num_ifreq; pIfr++, i++ )
{
if (!ioctl(fd, SIOCGIFADDR, pIfr))
addr = ((struct sockaddr_in*)&pIfr->ifr_addr)->sin_addr.s_addr;
else
addr = 0;
if (!ioctl(fd, SIOCGIFNETMASK, pIfr))
mask = ((struct sockaddr_in*)&pIfr->ifr_addr)->sin_addr.s_addr;
else
mask = 0;
if (!ioctl(fd, SIOCGIFFLAGS, pIfr))
flags = pIfr->ifr_flags;
else
flags = 0;
if (addr && !(flags & IFF_LOOPBACK))
addServer(cfig.allServers, addr);
//if (addr && mask && !(flags & IFF_POINTOPOINT) && !(flags & IFF_DYNAMIC))
if (addr && mask && !(flags & IFF_POINTOPOINT) && !(flags & IFF_LOOPBACK) && !(flags & IFF_DYNAMIC))
{
for (BYTE m = 0; m < MAX_SERVERS; m++)
{
if (cfig.staticServers[m] == addr)
break;
else if (!cfig.staticServers[m])
{
cfig.staticServers[m] = addr;
cfig.staticMasks[m] = mask;
break;
}
}
}
}
}
close(fd);
}
/*
FILE *f = popen("/sbin/route", "r");
char buff[256];
while (f && fgets(buff, sizeof(buff), f))
{
myTokenize(buff, buff, NULL, true);
if (!strcasecmp(myGetToken(buff, 0), "default") || !strcasecmp(myGetToken(buff, 0), "0.0.0.0"))
{
char *value = myGetToken(buff, 1);
int addr = my_inet_addr(value);
if (!addr)
{
char *dot = strchr(value, 46);
if (dot)
*dot = 0;
hostent *ent = gethostbyname(value);
if (ent)
addr = fIP(ent->h_addr_list[0]);
}
//printf("router=%sn", IP2String(tempbuff, addr));
addServer(cfig.routers, addr);
}
}
if (f)
pclose(f);
*/
}
void getDServ()
{
gethostname(cfig.servername, sizeof(cfig.servername));
if (!cfig.zone[0])
{
getdomainname(cfig.zone, sizeof(cfig.zone));
cfig.zLen = strlen(cfig.zone);
}
if (!strncmp(cfig.zone, "(none)", 6) || !cfig.zone[0])
{
strcpy(cfig.zone, "workgroup");
cfig.zLen = strlen(cfig.zone);
}
char iniStr[9192];
DWORD dservers[MAX_SERVERS];
for (int i = 0; i < MAX_SERVERS; i++)
{
dservers[i] = 0;
cfig.dns[i] = 0;
}
if (getSection("DNS-SERVERS", iniStr, 1, iniFile))
{
char *iniStrPtr = myGetToken(iniStr, 0);
for (int i = 0; i < MAX_SERVERS && iniStrPtr[0]; iniStrPtr = myGetToken(iniStrPtr, 1))
{
DWORD addr = my_inet_addr(iniStrPtr);
if (addr && addr != INADDR_NONE)
{
if (addServer(dservers, addr))
i++;
}
else
{
sprintf(logBuff, "Warning Section [DNS-SERVERS], Invalid DNS Server %s", iniStrPtr);
logMess(logBuff, 1);
}
}
}
if (!dservers[0])
{
FILE *f = fopen("/etc/resolv.conf", "rt");
char buff[256];
DWORD addr;
while (f && fgets(buff, 255, f))
{
myTokenize(buff, buff, NULL, true);
if (!strcasecmp(myGetToken(buff, 0), "nameserver"))
{
DWORD addr = my_inet_addr(myGetToken(buff, 1));
addServer(dservers, addr);
}
}
if (f)
fclose(f);
}
for (int i = 0; i < MAX_SERVERS && dservers[i]; i++)
{
if (dnsService)
{
if (findServer(cfig.staticServers, dservers[i]))
continue;
addServer(cfig.dns, dservers[i]);
}
else
addServer(cfig.dns, dservers[i]);
}
return;
}
void *updateStateFile(void *lparam)
{
data8 *dhcpData = (data8*)lparam;
pthread_mutex_lock( &mutStateFile );
if (dhcpData->dhcpInd)
{
FILE *f = fopen(leaFile, "rb+");
if (f)
{
if (fseek(f, (dhcpData->dhcpInd - 1)*sizeof(data8), SEEK_SET) >= 0)
{
fwrite(dhcpData, sizeof(data8), 1, f);
}
fclose(f);
}
}
else
{
dhcpData->dhcpInd = cfig.dhcpIndex;
FILE *f = fopen(leaFile, "ab");
if (f)
{
fwrite(dhcpData, sizeof(data8), 1, f);
fclose(f);
}
}
free(dhcpData);
pthread_mutex_unlock( &mutStateFile );
pthread_exit(NULL);
}
DWORD my_inet_addr(char* str)
{
if (str == NULL)
return INADDR_ANY;
else
return inet_addr(str);
}
WORD gdmess(data1 *req, BYTE sockInd)
{
//printf("%un", sockInd);
memset(req, 0, sizeof(data1));
errno = 0;
if (sockInd == 255)
{
int msgflags = 0;
req->iov[0].iov_base = req->raw;
req->iov[0].iov_len = sizeof(dhcp_packet);
req->msg.msg_iov = req->iov;
req->msg.msg_iovlen = 1;
req->msg.msg_name = &req->addr;
req->msg.msg_namelen = sizeof(sockaddr_in);
req->msg.msg_control = &req->msgcontrol;
req->msg.msg_controllen = sizeof(msg_control);
req->msg.msg_flags = msgflags;
int flags = 0;
req->bytes = recvmsg(cfig.dhcpListener.sock, &req->msg, flags);
if (errno || req->bytes <= 0)
{
return 0;
}
//printf("%un", req->msg.msg_controllen);
//msgcontrol = (msg_control*)msg.msg_control;
//struct in_addr local_addr;
//struct in_addr rem_addr;
//local_addr = msgcontrol->pktinfo.ipi_addr;
//rem_addr = msgcontrol->pktinfo.ipi_spec_dst;
//printf("IF = %un", req->msgcontrol.pktinfo.ipi_ifindex);
//printf("LADDR = %sn", inet_ntoa(req->msgcontrol.pktinfo.ipi_addr));
//printf("RADDR = %sn", inet_ntoa(req->msgcontrol. pktinfo.ipi_spec_dst));
DWORD addr = req->msgcontrol.pktinfo.ipi_spec_dst.s_addr;
//printf("%sn",IP2String(tempbuff, addr));
if (!addr)
return 0;
for (int i = 0; ; i++)
{
if ( i == MAX_SERVERS || (!cfig.dhcpConn[i].server))
return 0;
else if (addr == cfig.dhcpConn[i].server)
{
req->sockInd = i;
break;
}
}
}
else
{
req->sockInd = sockInd;
req->sockLen = sizeof(req->addr);
errno = 0;
req->bytes = recvfrom(cfig.dhcpConn[sockInd].sock,
req->raw,
sizeof(dhcp_packet),
0,
(sockaddr*)&req->addr,
&req->sockLen);
if (errno || req->bytes <= 0)
return 0;
}
if (req->dhcpp.header.bp_op != BOOTP_REQUEST)
return 0;
data3 *op;
BYTE *raw = req->dhcpp.vend_data;
BYTE *rawEnd = raw + (req->bytes - sizeof(dhcp_header));
for (; raw < rawEnd && *raw != DHCP_OPTION_END;)
{
op = (data3*)raw;
//printf("OpCode=%u,MessSize=%un", op->opt_code, op->size);
switch (op->opt_code)
{
case DHCP_OPTION_PAD:
raw++;
continue;
case DHCP_OPTION_PARAMREQLIST:
for (int ix = 0; ix < op->size; ix++)
req->paramreqlist[op->value[ix]] = 1;
break;
case DHCP_OPTION_MESSAGETYPE:
req->req_type = op->value[0];
break;
case DHCP_OPTION_SERVERID:
req->server = fIP(op->value);
break;
case DHCP_OPTION_IPADDRLEASE:
req->lease = fULong(op->value);
break;
case DHCP_OPTION_MAXDHCPMSGSIZE:
req->messsize = fUShort(op->value);
break;
case DHCP_OPTION_REQUESTEDIPADDR:
req->reqIP = fIP(op->value);
break;
case DHCP_OPTION_HOSTNAME:
if (op->size && strcasecmp((char*)op->value, "(none)") && strcasecmp((char*)op->value, cfig.servername))
{
memcpy(req->hostname, op->value, op->size);
req->hostname[op->size] = 0;
}
break;
case DHCP_OPTION_VENDORCLASSID:
memcpy(req->vendClass, op->value, op->size);
req->vendClassSize = op->size;
break;
case DHCP_OPTION_USERCLASS:
memcpy(req->userClass, op->value, op->size);
req->userClassSize = op->size;
break;
case DHCP_OPTION_RELAYAGENTINFO:
memcpy(&req->agentOption, op, op->size + 2);
break;
case DHCP_OPTION_CLIENTID:
memcpy(&req->clientId, op, op->size + 2);
break;
case DHCP_OPTION_SERIAL:
req->serial = fULong(op->value);
break;
}
raw += 2;
raw += op->size;
}
req->vp = req->dhcpp.vend_data;
memset(req->vp, 0, sizeof(dhcp_packet) - sizeof(dhcp_header));
//printf("MsgType=%un",req->req_type);
return 1;
}
void logDNSMess(char *logBuff, BYTE logLevel)
{
// pthread_mutex_lock( &mutLogFile );
if (verbatim)
printf("%sn", logBuff);
else if (cfig.logfile && logLevel <= cfig.dnsLogLevel)
{
time_t t = time(NULL);
tm *ttm = localtime(&t);
if (ttm->tm_yday != loggingDay)
{
loggingDay = ttm->tm_yday;
strftime(extbuff, sizeof(extbuff), logFile, ttm);
if (strcasecmp(currentLogFile, extbuff))
{
strcpy(currentLogFile, extbuff);
fprintf(cfig.logfile, "Logging Continued on file %sn", currentLogFile);
fclose(cfig.logfile);
cfig.logfile = fopen(currentLogFile, "at");
if (cfig.logfile)
fprintf(cfig.logfile, "%snn", sVersion);
else
{
sprintf(tempbuff, "Warning: faled to open log file %s", currentLogFile);
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), tempbuff);
if (logLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
return;
}
}
}
strftime(extbuff, sizeof(extbuff), "%d-%b-%y %X", ttm);
fprintf(cfig.logfile, "[%s] %sn", extbuff, logBuff);
fflush(cfig.logfile);
}
else if (logLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
// pthread_mutex_unlock( &mutLogFile );
}
void logMess(char *logBuff, BYTE logLevel)
{
// pthread_mutex_lock( &mutLogFile );
if (verbatim)
printf("%sn", logBuff);
else if (cfig.logfile && (logLevel <= cfig.dnsLogLevel || logLevel <= cfig.dhcpLogLevel))
{
time_t t = time(NULL);
tm *ttm = localtime(&t);
if (ttm->tm_yday != loggingDay)
{
loggingDay = ttm->tm_yday;
strftime(extbuff, sizeof(extbuff), logFile, ttm);
if (strcasecmp(currentLogFile, extbuff))
{
strcpy(currentLogFile, extbuff);
fprintf(cfig.logfile, "Logging Continued on file %sn", currentLogFile);
fclose(cfig.logfile);
cfig.logfile = fopen(currentLogFile, "at");
if (cfig.logfile)
fprintf(cfig.logfile, "%snn", sVersion);
else
{
sprintf(tempbuff, "Warning: faled to open log file %s", currentLogFile);
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), tempbuff);
if (logLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
return;
}
}
}
strftime(extbuff, sizeof(extbuff), "%d-%b-%y %X", ttm);
fprintf(cfig.logfile, "[%s] %sn", extbuff, logBuff);
fflush(cfig.logfile);
}
else if (logLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
// pthread_mutex_unlock( &mutLogFile );
}
void logDHCPMess(char *logBuff, BYTE dhcpLogLevel)
{
// pthread_mutex_lock( &mutLogFile );
if (verbatim)
printf("%sn", logBuff);
else if (cfig.logfile && dhcpLogLevel <= cfig.dhcpLogLevel)
{
time_t t = time(NULL);
tm *ttm = localtime(&t);
if (ttm->tm_yday != loggingDay)
{
loggingDay = ttm->tm_yday;
strftime(extbuff, sizeof(extbuff), logFile, ttm);
if (strcasecmp(currentLogFile, extbuff))
{
strcpy(currentLogFile, extbuff);
fprintf(cfig.logfile, "Logging Continued on file %sn", currentLogFile);
fclose(cfig.logfile);
cfig.logfile = fopen(currentLogFile, "at");
if (cfig.logfile)
fprintf(cfig.logfile, "%snn", sVersion);
else
{
sprintf(tempbuff, "Warning: faled to open log file %s", currentLogFile);
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), tempbuff);
if (dhcpLogLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
return;
}
}
}
strftime(extbuff, sizeof(extbuff), "%d-%b-%y %X", ttm);
fprintf(cfig.logfile, "[%s] %sn", extbuff, logBuff);
fflush(cfig.logfile);
}
else if (dhcpLogLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
// pthread_mutex_unlock( &mutLogFile );
}
void logDNSMess(data5 *req, char *logBuff, BYTE dnsLogLevel)
{
// pthread_mutex_lock( &mutLogFile );
if (verbatim)
printf("%sn", logBuff);
else if (cfig.logfile && dnsLogLevel <= cfig.dnsLogLevel)
{
time_t t = time(NULL);
tm *ttm = localtime(&t);
if (ttm->tm_yday != loggingDay)
{
loggingDay = ttm->tm_yday;
strftime(extbuff, sizeof(extbuff), logFile, ttm);
if (strcasecmp(currentLogFile, extbuff))
{
strcpy(currentLogFile, extbuff);
fprintf(cfig.logfile, "Logging Continued on file %sn", currentLogFile);
fclose(cfig.logfile);
cfig.logfile = fopen(currentLogFile, "at");
if (cfig.logfile)
fprintf(cfig.logfile, "%snn", sVersion);
else
{
sprintf(tempbuff, "Warning: faled to open log file %s", currentLogFile);
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), tempbuff);
if (dnsLogLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
return;
}
}
}
strftime(extbuff, sizeof(extbuff), "%d-%b-%y %X", ttm);
fprintf(cfig.logfile, "[%s] Client %s, %sn", extbuff, inet_ntoa(req->addr.sin_addr), logBuff);
fflush(cfig.logfile);
}
else if (dnsLogLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
// pthread_mutex_unlock( &mutLogFile );
}
void logTCPMess(data5 *req, char *logBuff, BYTE dnsLogLevel)
{
// pthread_mutex_lock( &mutLogFile );
if (verbatim)
printf("%sn", logBuff);
else if (cfig.logfile && dnsLogLevel <= cfig.dnsLogLevel)
{
time_t t = time(NULL);
tm *ttm = localtime(&t);
if (ttm->tm_yday != loggingDay)
{
loggingDay = ttm->tm_yday;
strftime(extbuff, sizeof(extbuff), logFile, ttm);
if (strcasecmp(currentLogFile, extbuff))
{
strcpy(currentLogFile, extbuff);
fprintf(cfig.logfile, "Logging Continued on file %sn", currentLogFile);
fclose(cfig.logfile);
cfig.logfile = fopen(currentLogFile, "at");
if (cfig.logfile)
fprintf(cfig.logfile, "%snn", sVersion);
else
{
sprintf(tempbuff, "Warning: faled to open log file %s", currentLogFile);
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), tempbuff);
if (dnsLogLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
return;
}
}
}
strftime(extbuff, sizeof(extbuff), "%d-%b-%y %X", ttm);
fprintf(cfig.logfile, "[%s] TCP Client %s, %sn", extbuff, inet_ntoa(req->addr.sin_addr), logBuff);
fflush(cfig.logfile);
}
else if (dnsLogLevel <= 1)
syslog(LOG_MAKEPRI(LOG_LOCAL1, LOG_CRIT), logBuff);
// pthread_mutex_unlock( &mutLogFile );
}