开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email服务器 > 查看源码
DNS.cpp
资源名称：xmail-1.22.rar　[点击查看]
上传用户：woshihumen
上传日期：2013-07-18
资源大小：484k
文件大小：45k
源码类别：

Email服务器

开发平台：

Visual C++

DNS.cpp：源码内容
  1. /*
  2.  *  XMail by Davide Libenzi ( Intranet and Internet mail server )
  3.  *  Copyright (C) 1999,..,2004  Davide Libenzi
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  *  Davide Libenzi <davidel@xmailserver.org>
  20.  *
  21.  */
  23. #include "SysInclude.h"
  24. #include "SysDep.h"
  25. #include "SvrDefines.h"
  26. #include "ShBlocks.h"
  27. #include "StrUtils.h"
  28. #include "BuffSock.h"
  29. #include "SList.h"
  30. #include "MailConfig.h"
  31. #include "MessQueue.h"
  32. #include "MailSvr.h"
  33. #include "MiscUtils.h"
  34. #include "SvrUtils.h"
  35. #include "DNS.h"
  37. #define DNS_PORTNO              53
  38. #define DNS_SOCKET_TIMEOUT      16
  39. #define DNS_QUERY_EXTRA         512
  40. #define DNS_MAX_RESP_PACKET     1024
  41. #define DNS_SEND_RETRIES        3
  42. #define DNS_MAX_RR_DATA         256
  43. #define DNS_RESPDATA_EXTRA      (2 * sizeof(int))
  45. #if defined(BIG_ENDIAN_CPU)
  46. #define DNS_LABEL_LEN_MASK      0x3fff
  47. #else // #if defined(BIG_ENDIAN_CPU)
  48. #define DNS_LABEL_LEN_MASK      0xff3f
  49. #endif // #if defined(BIG_ENDIAN_CPU)
  51. #define DNS_LABEL_LEN_INVMASK   0xc0
  53. #define ROOTS_FILE              "dnsroots"
  55. struct DNSQuery {
  56. DNS_HEADER DNSH;
  57. SYS_UINT8 QueryData[DNS_QUERY_EXTRA];
  58. };
  60. struct DNSResourceRecord {
  61. char szName[MAX_HOST_NAME];
  62. SYS_UINT16 Type;
  63. SYS_UINT16 Class;
  64. SYS_UINT32 TTL;
  65. SYS_UINT16 Lenght;
  66. SYS_UINT8 const *pRespData;
  67. };
  69. struct DNSNameNode {
  70. LISTLINK LL;
  71. char *pszServer;
  72. char *pszQuery;
  73. };
  75. static SYS_UINT8 *DNS_AllocRespData(int iSize);
  76. static int DNS_FreeRespData(SYS_UINT8 * pRespData);
  77. static int DNS_RespDataSize(SYS_UINT8 const *pRespData);
  78. static DNSNameNode *DNS_AllocNameNode(char const *pszServer, char const *pszQuery);
  79. static void DNS_FreeNameNode(DNSNameNode * pDNSNN);
  80. static void DNS_FreeNameList(HSLIST & hNameList);
  81. static DNSNameNode *DNS_GetNameNode(HSLIST & hNameList, char const *pszServer,
  82.     char const *pszQuery);
  83. static int DNS_AddNameNode(HSLIST & hNameList, char const *pszServer, char const *pszQuery);
  84. static int DNS_GetResourceRecord(SYS_UINT8 const *pBaseData, SYS_UINT8 const *pRespData,
  85.  DNSResourceRecord * pRR = NULL, int *piRRLength = NULL);
  86. static int DNS_GetName(SYS_UINT8 const *pBaseData, SYS_UINT8 const *pRespData,
  87.        char *pszInetName = NULL, int *piRRLength = NULL);
  88. static int DNS_GetQuery(SYS_UINT8 const *pBaseData, SYS_UINT8 const *pRespData,
  89. char *pszInetName = NULL, SYS_UINT16 * pType = NULL,
  90. SYS_UINT16 * pClass = NULL, int *piRRLength = NULL);
  91. static int DNS_NameCopy(SYS_UINT8 * pDNSQName, char const *pszInetName);
  92. static SYS_UINT16 DNS_GetUniqueQueryId(void);
  93. static int DNS_RequestSetup(DNSQuery & DNSQ, unsigned int uOpCode,
  94.     unsigned int uQType, char const *pszInetName,
  95.     int &iQueryLenght, bool bQueryRecursion = false);
  96. static SYS_UINT8 *DNS_QueryExec(char const *pszDNSServer, int iPortNo, int iTimeout,
  97. unsigned int uOpCode, unsigned int uQType,
  98. char const *pszInetName, bool bQueryRecursion = false);
  99. static SYS_UINT8 *DNS_QuerySendStream(char const *pszDNSServer, int iPortNo, int iTimeout,
  100.       DNSQuery const &DNSQ, int iQueryLenght);
  101. static SYS_UINT8 *DNS_QuerySendDGram(char const *pszDNSServer, int iPortNo, int iTimeout,
  102.      DNSQuery const &DNSQ, int iQueryLenght, bool & bTruncated);
  103. static int DNS_DecodeResponseMX(SYS_UINT8 * pRespData, char const *pszDomain,
  104. HSLIST & hNameList, char const *pszRespFile,
  105. char *pszCName, SYS_UINT32 * pTTL = NULL);
  106. static int DNS_DecodeDirResponseMX(SYS_UINT8 * pRespData, char const *pszRespFile,
  107.    SYS_UINT32 * pTTL = NULL);
  108. static int DNS_DecodeResponseNS(SYS_UINT8 * pRespData, char const *pszRespFile,
  109. bool & bAuth, char *pszCName, SYS_UINT32 * pTTL = NULL);
  110. static int DNS_FindDomainMX(char const *pszDNSServer, char const *pszDomain,
  111.     HSLIST & hNameList, char const *pszRespFile, char *pszCName,
  112.     SYS_UINT32 * pTTL = NULL);
  113. static int DNS_QueryDomainMX(char const *pszDNSServer, char const *pszDomain,
  114.      char *&pszMXDomains, char *pszCName, SYS_UINT32 * pTTL = NULL);
  115. static int DNS_AppendHosts(FILE *pFile, char const *pszDestPath);
  116. static int DNS_GetNameServersLL(char const *pszDNSServer, char const *pszDomain,
  117. char const *pszRespFile, HSLIST & hNameList,
  118. char *pszCName, SYS_UINT32 * pTTL = NULL);
  119. static char *DNS_GetRootsFile(char *pszRootsFilePath, int iMaxPath);
  121. static SYS_UINT8 *DNS_AllocRespData(int iSize)
  122. {
  124. int iSizeExtra = DNS_RESPDATA_EXTRA;
  125. SYS_UINT8 *pBaseData = (SYS_UINT8 *) SysAlloc(iSize + iSizeExtra);
  127. if (pBaseData == NULL)
  128. return (NULL);
  130. ((int *) pBaseData)[0] = iSize;
  132. return (pBaseData + iSizeExtra);
  134. }
  136. static int DNS_FreeRespData(SYS_UINT8 * pRespData)
  137. {
  139. SYS_UINT8 *pBaseData = pRespData - DNS_RESPDATA_EXTRA;
  141. SysFree(pBaseData);
  143. return (0);
  145. }
  147. static int DNS_RespDataSize(SYS_UINT8 const *pRespData)
  148. {
  150. SYS_UINT8 const *pBaseData = pRespData - DNS_RESPDATA_EXTRA;
  152. return (((int *) pBaseData)[0]);
  154. }
  156. static DNSNameNode *DNS_AllocNameNode(char const *pszServer, char const *pszQuery)
  157. {
  159. DNSNameNode *pDNSNN = (DNSNameNode *) SysAlloc(sizeof(DNSNameNode));
  161. if (pDNSNN == NULL)
  162. return (NULL);
  164. ListLinkInit(pDNSNN);
  166. if ((pDNSNN->pszServer = SysStrDup(pszServer)) == NULL) {
  167. SysFree(pDNSNN);
  168. return (NULL);
  169. }
  171. if ((pDNSNN->pszQuery = SysStrDup(pszQuery)) == NULL) {
  172. SysFree(pDNSNN->pszServer);
  173. SysFree(pDNSNN);
  174. return (NULL);
  175. }
  177. return (pDNSNN);
  179. }
  181. static void DNS_FreeNameNode(DNSNameNode * pDNSNN)
  182. {
  184. SysFree(pDNSNN->pszQuery);
  186. SysFree(pDNSNN->pszServer);
  188. SysFree(pDNSNN);
  190. }
  192. static void DNS_FreeNameList(HSLIST & hNameList)
  193. {
  195. DNSNameNode *pDNSNN;
  197. while ((pDNSNN = (DNSNameNode *) ListRemove(hNameList)) != INVALID_SLIST_PTR)
  198. DNS_FreeNameNode(pDNSNN);
  200. }
  202. static DNSNameNode *DNS_GetNameNode(HSLIST & hNameList, char const *pszServer,
  203.     char const *pszQuery)
  204. {
  206. DNSNameNode *pDNSNN = (DNSNameNode *) ListFirst(hNameList);
  208. for (; pDNSNN != INVALID_SLIST_PTR; pDNSNN = (DNSNameNode *)
  209.      ListNext(hNameList, (PLISTLINK) pDNSNN))
  210. if ((stricmp(pDNSNN->pszServer, pszServer) == 0) &&
  211.     (stricmp(pDNSNN->pszQuery, pszQuery) == 0))
  212. return (pDNSNN);
  214. return (NULL);
  216. }
  218. static int DNS_AddNameNode(HSLIST & hNameList, char const *pszServer, char const *pszQuery)
  219. {
  221. DNSNameNode *pDNSNN = DNS_AllocNameNode(pszServer, pszQuery);
  223. if (pDNSNN == NULL)
  224. return (ErrGetErrorCode());
  226. ListAddTail(hNameList, (PLISTLINK) pDNSNN);
  228. return (0);
  230. }
  232. static int DNS_GetResourceRecord(SYS_UINT8 const *pBaseData, SYS_UINT8 const *pRespData,
  233.  DNSResourceRecord * pRR, int *piRRLength)
  234. {
  236. if (pRR != NULL)
  237. ZeroData(*pRR);
  239. ///////////////////////////////////////////////////////////////////////////////
  240. //  Read name field
  241. ///////////////////////////////////////////////////////////////////////////////
  242. int iRRLen = 0;
  243. char *pszName = (pRR != NULL) ? pRR->szName : NULL;
  245. if (DNS_GetName(pBaseData, pRespData, pszName, &iRRLen) < 0)
  246. return (ErrGetErrorCode());
  248. pRespData += iRRLen;
  250. ///////////////////////////////////////////////////////////////////////////////
  251. //  Read type field
  252. ///////////////////////////////////////////////////////////////////////////////
  253. if (pRR != NULL)
  254. pRR->Type = ntohs(MscReadUint16(pRespData));
  256. pRespData += sizeof(SYS_UINT16);
  257. iRRLen += sizeof(SYS_UINT16);
  259. ///////////////////////////////////////////////////////////////////////////////
  260. //  Read class field
  261. ///////////////////////////////////////////////////////////////////////////////
  262. if (pRR != NULL)
  263. pRR->Class = ntohs(MscReadUint16(pRespData));
  265. pRespData += sizeof(SYS_UINT16);
  266. iRRLen += sizeof(SYS_UINT16);
  268. ///////////////////////////////////////////////////////////////////////////////
  269. //  Read TTL field
  270. ///////////////////////////////////////////////////////////////////////////////
  271. if (pRR != NULL)
  272. pRR->TTL = ntohl(MscReadUint32(pRespData));
  274. pRespData += sizeof(SYS_UINT32);
  275. iRRLen += sizeof(SYS_UINT32);
  277. ///////////////////////////////////////////////////////////////////////////////
  278. //  Read lenght field
  279. ///////////////////////////////////////////////////////////////////////////////
  280. SYS_UINT16 Lenght = ntohs(MscReadUint16(pRespData));
  282. if (pRR != NULL)
  283. pRR->Lenght = Lenght;
  285. pRespData += sizeof(SYS_UINT16);
  286. iRRLen += sizeof(SYS_UINT16);
  288. ///////////////////////////////////////////////////////////////////////////////
  289. //  Read RR data
  290. ///////////////////////////////////////////////////////////////////////////////
  291. if (pRR != NULL)
  292. pRR->pRespData = pRespData;
  294. iRRLen += (int) Lenght;
  296. if (piRRLength != NULL)
  297. *piRRLength = iRRLen;
  299. return (0);
  301. }
  303. static int DNS_GetName(SYS_UINT8 const *pBaseData, SYS_UINT8 const *pRespData,
  304.        char *pszInetName, int *piRRLength)
  305. {
  307. char szNameBuffer[MAX_HOST_NAME] = "";
  309. if (pszInetName == NULL)
  310. pszInetName = szNameBuffer;
  312. int iBaseLength = DNS_RespDataSize(pBaseData);
  313. int iCurrOffset = (int) (pRespData - pBaseData);
  314. int iDataLength = 0;
  315. int iNameLength = 0;
  316. int iBackLink = 0;
  318. while (*pRespData != 0) {
  319. if (*pRespData & DNS_LABEL_LEN_INVMASK) {
  320. ///////////////////////////////////////////////////////////////////////////////
  321. //  Got displacement from base-data ( boundary checked )
  322. ///////////////////////////////////////////////////////////////////////////////
  323. if ((iCurrOffset = (int)
  324.      ntohs(MscReadUint16(pRespData) & DNS_LABEL_LEN_MASK)) >= iBaseLength) {
  325. ErrSetErrorCode(ERR_BAD_DNS_NAME_RECORD);
  326. return (ERR_BAD_DNS_NAME_RECORD);
  327. }
  329. pRespData = pBaseData + iCurrOffset;
  331. if (!iBackLink)
  332. iDataLength += sizeof(SYS_UINT16), ++iBackLink;
  334. continue;
  335. }
  336. ///////////////////////////////////////////////////////////////////////////////
  337. //  Extract label length ( boundary checked )
  338. ///////////////////////////////////////////////////////////////////////////////
  339. int iLabelLength = (int) *pRespData;
  341. if (((iNameLength + iLabelLength + 2) >= MAX_HOST_NAME) ||
  342.     ((iCurrOffset + iLabelLength + 1) >= iBaseLength)) {
  343. ErrSetErrorCode(ERR_BAD_DNS_NAME_RECORD);
  344. return (ERR_BAD_DNS_NAME_RECORD);
  345. }
  346. ///////////////////////////////////////////////////////////////////////////////
  347. //  Append to name and update pointers
  348. ///////////////////////////////////////////////////////////////////////////////
  349. memcpy(pszInetName, pRespData + 1, iLabelLength);
  350. pszInetName[iLabelLength] = '.';
  352. iNameLength += iLabelLength + 1;
  353. pszInetName += iLabelLength + 1;
  355. ///////////////////////////////////////////////////////////////////////////////
  356. //  If we've not got a back-jump, update the data length
  357. ///////////////////////////////////////////////////////////////////////////////
  358. if (!iBackLink)
  359. iDataLength += iLabelLength + 1;
  361. ///////////////////////////////////////////////////////////////////////////////
  362. //  Move pointers
  363. ///////////////////////////////////////////////////////////////////////////////
  364. iCurrOffset += iLabelLength + 1;
  365. pRespData += iLabelLength + 1;
  366. }
  368. *pszInetName = '';
  370. if (piRRLength != NULL)
  371. *piRRLength = (!iBackLink) ? iDataLength + 1 : iDataLength;
  373. return (0);
  375. }
  377. static int DNS_GetQuery(SYS_UINT8 const *pBaseData, SYS_UINT8 const *pRespData,
  378. char *pszInetName, SYS_UINT16 * pType, SYS_UINT16 * pClass,
  379. int *piRRLength)
  380. {
  382. ///////////////////////////////////////////////////////////////////////////////
  383. //  Read name field
  384. ///////////////////////////////////////////////////////////////////////////////
  385. int iQueryLen = 0;
  387. if (DNS_GetName(pBaseData, pRespData, pszInetName, &iQueryLen) < 0)
  388. return (ErrGetErrorCode());
  390. pRespData += iQueryLen;
  392. ///////////////////////////////////////////////////////////////////////////////
  393. //  Read type field
  394. ///////////////////////////////////////////////////////////////////////////////
  395. if (pType != NULL)
  396. *pType = ntohs(MscReadUint16(pRespData));
  398. pRespData += sizeof(SYS_UINT16);
  399. iQueryLen += sizeof(SYS_UINT16);
  401. ///////////////////////////////////////////////////////////////////////////////
  402. //  Read class field
  403. ///////////////////////////////////////////////////////////////////////////////
  404. if (pClass != NULL)
  405. *pClass = ntohs(MscReadUint16(pRespData));
  407. pRespData += sizeof(SYS_UINT16);
  408. iQueryLen += sizeof(SYS_UINT16);
  410. if (piRRLength != NULL)
  411. *piRRLength = iQueryLen;
  413. return (0);
  415. }
  417. static int DNS_NameCopy(SYS_UINT8 * pDNSQName, char const *pszInetName)
  418. {
  420. char *pszNameCopy = SysStrDup(pszInetName);
  422. if (pszNameCopy == NULL)
  423. return (ErrGetErrorCode());
  425. int iNameLen = 0;
  426. char *pszToken = NULL;
  427. char *pszSavePtr = NULL;
  429. pszToken = SysStrTok(pszNameCopy, ".", &pszSavePtr);
  431. while (pszToken != NULL) {
  432. int iTokLen = strlen(pszToken);
  434. *pDNSQName = (SYS_UINT8) iTokLen;
  436. strcpy((char *) pDNSQName + 1, pszToken);
  438. pDNSQName += iTokLen + 1;
  439. iNameLen += iTokLen + 1;
  441. pszToken = SysStrTok(NULL, ".", &pszSavePtr);
  442. }
  444. *pDNSQName = 0;
  446. SysFree(pszNameCopy);
  448. return (iNameLen + 1);
  450. }
  452. static SYS_UINT16 DNS_GetUniqueQueryId(void)
  453. {
  455. static SYS_UINT16 uDnsQueryId = 0;
  457. return ((SYS_UINT16) (++uDnsQueryId * SysGetCurrentThreadId()));
  459. }
  461. static int DNS_RequestSetup(DNSQuery & DNSQ, unsigned int uOpCode,
  462.     unsigned int uQType, char const *pszInetName,
  463.     int &iQueryLenght, bool bQueryRecursion)
  464. {
  466. ///////////////////////////////////////////////////////////////////////////////
  467. //  Setup query header
  468. ///////////////////////////////////////////////////////////////////////////////
  469. ZeroData(DNSQ);
  470. DNSQ.DNSH.Id = DNS_GetUniqueQueryId();
  471. DNSQ.DNSH.QR = 0;
  472. DNSQ.DNSH.RD = (bQueryRecursion) ? 1 : 0;
  473. DNSQ.DNSH.OpCode = uOpCode;
  474. DNSQ.DNSH.QDCount = htons(1);
  475. DNSQ.DNSH.ANCount = htons(0);
  476. DNSQ.DNSH.NSCount = htons(0);
  477. DNSQ.DNSH.ARCount = htons(0);
  479. SYS_UINT8 *pQueryData = DNSQ.QueryData;
  481. ///////////////////////////////////////////////////////////////////////////////
  482. //  Copy name to query
  483. ///////////////////////////////////////////////////////////////////////////////
  484. int iNameLen = DNS_NameCopy(pQueryData, pszInetName);
  486. if (iNameLen < 0)
  487. return (ErrGetErrorCode());
  489. pQueryData += iNameLen;
  491. ///////////////////////////////////////////////////////////////////////////////
  492. //  Set query type
  493. ///////////////////////////////////////////////////////////////////////////////
  494. MscWriteUint16(pQueryData, (SYS_UINT16) htons(uQType));
  495. pQueryData += sizeof(SYS_UINT16);
  497. ///////////////////////////////////////////////////////////////////////////////
  498. //  Set query class
  499. ///////////////////////////////////////////////////////////////////////////////
  500. MscWriteUint16(pQueryData, (SYS_UINT16) htons(QCLASS_IN));
  501. pQueryData += sizeof(SYS_UINT16);
  503. iQueryLenght = (int) (pQueryData - (SYS_UINT8 *) & DNSQ);
  505. return (0);
  507. }
  509. static SYS_UINT8 *DNS_QueryExec(char const *pszDNSServer, int iPortNo, int iTimeout,
  510. unsigned int uOpCode, unsigned int uQType,
  511. char const *pszInetName, bool bQueryRecursion)
  512. {
  514. int iQueryLenght;
  515. DNSQuery DNSQ;
  517. if (DNS_RequestSetup(DNSQ, uOpCode, uQType, pszInetName, iQueryLenght,
  518.      bQueryRecursion) < 0)
  519. return (NULL);
  521. bool bTruncated = false;
  523. SYS_UINT8 *pRespData = DNS_QuerySendDGram(pszDNSServer, iPortNo, iTimeout,
  524.   DNSQ, iQueryLenght, bTruncated);
  526. if ((pRespData == NULL) && bTruncated)
  527. pRespData = DNS_QuerySendStream(pszDNSServer, iPortNo, iTimeout,
  528. DNSQ, iQueryLenght);
  530. return (pRespData);
  532. }
  534. static SYS_UINT8 *DNS_QuerySendStream(char const *pszDNSServer, int iPortNo, int iTimeout,
  535.       DNSQuery const &DNSQ, int iQueryLenght)
  536. {
  538. ///////////////////////////////////////////////////////////////////////////////
  539. //  Open DNS server socket
  540. ///////////////////////////////////////////////////////////////////////////////
  541. SYS_SOCKET SockFD;
  542. SYS_INET_ADDR SvrAddr;
  543. SYS_INET_ADDR SockAddr;
  545. if (MscCreateClientSocket(pszDNSServer, iPortNo, SOCK_STREAM, &SockFD, &SvrAddr,
  546.   &SockAddr, iTimeout) < 0)
  547. return (NULL);
  549. SYS_UINT16 QLenght = (SYS_UINT16) htons(iQueryLenght);
  551. ///////////////////////////////////////////////////////////////////////////////
  552. //  Send packet lenght
  553. ///////////////////////////////////////////////////////////////////////////////
  554. if (SysSend(SockFD, (char *) &QLenght, sizeof(QLenght), iTimeout) != sizeof(QLenght)) {
  555. ErrorPush();
  556. SysCloseSocket(SockFD);
  557. ErrSetErrorCode(ErrorFetch());
  558. return (NULL);
  559. }
  560. ///////////////////////////////////////////////////////////////////////////////
  561. //  Send packet
  562. ///////////////////////////////////////////////////////////////////////////////
  563. if (SysSend(SockFD, (char const *) &DNSQ, iQueryLenght, iTimeout) != iQueryLenght) {
  564. ErrorPush();
  565. SysCloseSocket(SockFD);
  566. ErrSetErrorCode(ErrorFetch());
  567. return (NULL);
  568. }
  569. ///////////////////////////////////////////////////////////////////////////////
  570. //  Receive packet lenght
  571. ///////////////////////////////////////////////////////////////////////////////
  572. if (SysRecv(SockFD, (char *) &QLenght, sizeof(QLenght), iTimeout) != sizeof(QLenght)) {
  573. ErrorPush();
  574. SysCloseSocket(SockFD);
  575. ErrSetErrorCode(ErrorFetch());
  576. return (NULL);
  577. }
  579. int iPacketLenght = (int) ntohs(QLenght);
  581. SYS_UINT8 *pRespData = DNS_AllocRespData(iPacketLenght + 1);
  583. if (pRespData == NULL) {
  584. ErrorPush();
  585. SysCloseSocket(SockFD);
  586. ErrSetErrorCode(ErrorFetch());
  587. return (NULL);
  588. }
  589. ///////////////////////////////////////////////////////////////////////////////
  590. //  Receive packet
  591. ///////////////////////////////////////////////////////////////////////////////
  592. if (SysRecv(SockFD, (char *) pRespData, iPacketLenght, iTimeout) != iPacketLenght) {
  593. ErrorPush();
  594. DNS_FreeRespData(pRespData);
  595. SysCloseSocket(SockFD);
  596. ErrSetErrorCode(ErrorFetch());
  597. return (NULL);
  598. }
  600. SysCloseSocket(SockFD);
  602. DNS_HEADER *pDNSH = (DNS_HEADER *) pRespData;
  604. if (DNSQ.DNSH.RD && !pDNSH->RA) {
  605. DNS_FreeRespData(pRespData);
  606. ErrSetErrorCode(ERR_DNS_RECURSION_NOT_AVAILABLE);
  607. return (NULL);
  608. }
  610. return (pRespData);
  612. }
  614. static SYS_UINT8 *DNS_QuerySendDGram(char const *pszDNSServer, int iPortNo, int iTimeout,
  615.      DNSQuery const &DNSQ, int iQueryLenght, bool & bTruncated)
  616. {
  618. bTruncated = false;
  620. ///////////////////////////////////////////////////////////////////////////////
  621. //  Open DNS server socket
  622. ///////////////////////////////////////////////////////////////////////////////
  623. SYS_SOCKET SockFD;
  624. SYS_INET_ADDR SvrAddr;
  625. SYS_INET_ADDR SockAddr;
  627. if (MscCreateClientSocket(pszDNSServer, iPortNo, SOCK_DGRAM, &SockFD, &SvrAddr,
  628.   &SockAddr, iTimeout) < 0)
  629. return (NULL);
  631. ///////////////////////////////////////////////////////////////////////////////
  632. //  Query loop
  633. ///////////////////////////////////////////////////////////////////////////////
  634. for (int iSendLoops = 0; iSendLoops < DNS_SEND_RETRIES; iSendLoops++) {
  635. ///////////////////////////////////////////////////////////////////////////////
  636. //  Send packet
  637. ///////////////////////////////////////////////////////////////////////////////
  638. if (SysSendData(SockFD, (char const *) &DNSQ, iQueryLenght, iTimeout) !=
  639.     iQueryLenght)
  640. continue;
  642. ///////////////////////////////////////////////////////////////////////////////
  643. //  Receive packet lenght
  644. ///////////////////////////////////////////////////////////////////////////////
  645. SYS_INET_ADDR RecvAddr;
  646. SYS_UINT8 RespBuffer[1024];
  648. ZeroData(RecvAddr);
  650. int iPacketLenght =
  651.     SysRecvDataFrom(SockFD, (struct sockaddr *) &RecvAddr, sizeof(RecvAddr),
  652.     (char *) RespBuffer, sizeof(RespBuffer), iTimeout);
  654. if ((iPacketLenght < 0) || (iPacketLenght < sizeof(DNS_HEADER)))
  655. continue;
  657. DNS_HEADER *pDNSH = (DNS_HEADER *) RespBuffer;
  659. if (pDNSH->Id != DNSQ.DNSH.Id)
  660. continue;
  662. if (DNSQ.DNSH.RD && !pDNSH->RA) {
  663. SysCloseSocket(SockFD);
  664. ErrSetErrorCode(ERR_DNS_RECURSION_NOT_AVAILABLE);
  665. return (NULL);
  666. }
  668. if (pDNSH->TC) {
  669. bTruncated = true;
  671. SysCloseSocket(SockFD);
  672. ErrSetErrorCode(ERR_TRUNCATED_DGRAM_DNS_RESPONSE);
  673. return (NULL);
  674. }
  676. SYS_UINT8 *pRespData = DNS_AllocRespData(iPacketLenght + 1);
  678. if (pRespData == NULL) {
  679. ErrorPush();
  680. SysCloseSocket(SockFD);
  681. ErrSetErrorCode(ErrorFetch());
  682. return (NULL);
  683. }
  685. memcpy(pRespData, RespBuffer, iPacketLenght);
  687. SysCloseSocket(SockFD);
  689. return (pRespData);
  690. }
  692. SysCloseSocket(SockFD);
  694. ErrSetErrorCode(ERR_NO_DGRAM_DNS_RESPONSE);
  696. return (NULL);
  698. }
  700. static int DNS_DecodeResponseMX(SYS_UINT8 * pRespData, char const *pszDomain,
  701. HSLIST & hNameList, char const *pszRespFile,
  702. char *pszCName, SYS_UINT32 * pTTL)
  703. {
  705. SYS_UINT8 *pBaseData = pRespData;
  706. DNSQuery *pDNSQ = (DNSQuery *) pRespData;
  708. if (pDNSQ->DNSH.RCode != 0) {
  709. int iErrorCode = ERR_BAD_DNS_RESPONSE;
  711. if (pDNSQ->DNSH.RCode == RCODE_NXDOMAIN)
  712. iErrorCode = ERR_DNS_NXDOMAIN;
  714. ErrSetErrorCode(iErrorCode);
  715. return (iErrorCode);
  716. }
  718. pDNSQ->DNSH.QDCount = ntohs(pDNSQ->DNSH.QDCount);
  719. pDNSQ->DNSH.ANCount = ntohs(pDNSQ->DNSH.ANCount);
  720. pDNSQ->DNSH.NSCount = ntohs(pDNSQ->DNSH.NSCount);
  721. pDNSQ->DNSH.ARCount = ntohs(pDNSQ->DNSH.ARCount);
  723. FILE *pMXFile = fopen(pszRespFile, "wb");
  725. if (pMXFile == NULL) {
  726. ErrSetErrorCode(ERR_FILE_CREATE, pszRespFile);
  727. return (ERR_FILE_CREATE);
  728. }
  730. pRespData = pDNSQ->QueryData;
  732. ///////////////////////////////////////////////////////////////////////////////
  733. //  Scan query data
  734. ///////////////////////////////////////////////////////////////////////////////
  735. int ii;
  737. for (ii = 0; ii < (int) pDNSQ->DNSH.QDCount; ii++) {
  738. int iQLenght = 0;
  739. SYS_UINT16 Type = 0;
  740. SYS_UINT16 Class = 0;
  741. char szInetName[MAX_HOST_NAME] = "";
  743. if (DNS_GetQuery(pBaseData, pRespData, szInetName, &Type, &Class, &iQLenght) < 0) {
  744. ErrorPush();
  745. fclose(pMXFile);
  746. SysRemove(pszRespFile);
  747. return (ErrorPop());
  748. }
  750. pRespData += iQLenght;
  751. }
  753. ///////////////////////////////////////////////////////////////////////////////
  754. //  Scan answer data
  755. ///////////////////////////////////////////////////////////////////////////////
  756. int iMXRecords = 0;
  757. SYS_UINT32 TTL = 0;
  759. for (ii = 0; ii < (int) pDNSQ->DNSH.ANCount; ii++) {
  760. int iRRLenght = 0;
  761. DNSResourceRecord RR;
  763. if (DNS_GetResourceRecord(pBaseData, pRespData, &RR, &iRRLenght) < 0) {
  764. ErrorPush();
  765. fclose(pMXFile);
  766. SysRemove(pszRespFile);
  767. return (ErrorPop());
  768. }
  770. pRespData += iRRLenght;
  772. SYS_UINT8 const *pRRData = RR.pRespData;
  773. char szRRName[MAX_HOST_NAME] = "";
  775. if (RR.Type == QTYPE_MX) {
  776. SYS_UINT16 Preference = ntohs(MscReadUint16(pRRData));
  778. pRRData += sizeof(SYS_UINT16);
  779. if (DNS_GetName(pBaseData, pRRData, szRRName) < 0) {
  780. ErrorPush();
  781. fclose(pMXFile);
  782. SysRemove(pszRespFile);
  783. return (ErrorPop());
  784. }
  786. if (ii == 0)
  787. fprintf(pMXFile, "%d:%s", (int) Preference, szRRName);
  788. else
  789. fprintf(pMXFile, ",%d:%s", (int) Preference, szRRName);
  791. if ((TTL == 0) || (RR.TTL < TTL))
  792. TTL = RR.TTL;
  794. ++iMXRecords;
  795. } else if (RR.Type == QTYPE_CNAME) {
  796. if (DNS_GetName(pBaseData, pRRData, szRRName) < 0) {
  797. ErrorPush();
  798. fclose(pMXFile);
  799. SysRemove(pszRespFile);
  800. return (ErrorPop());
  801. }
  803. if (pszCName != NULL)
  804. strcpy(pszCName, szRRName);
  805. fclose(pMXFile);
  806. SysRemove(pszRespFile);
  808. ErrSetErrorCode(ERR_DNS_IS_CNAME);
  809. return (ERR_DNS_IS_CNAME);
  810. }
  811. }
  813. fclose(pMXFile);
  815. ///////////////////////////////////////////////////////////////////////////////
  816. //  Got answers ?
  817. ///////////////////////////////////////////////////////////////////////////////
  818. if (iMXRecords) {
  819. if (pTTL != NULL)
  820. *pTTL = TTL;
  821. return (0);
  822. }
  824. SysRemove(pszRespFile);
  826. ///////////////////////////////////////////////////////////////////////////////
  827. //  Scan name servers data
  828. ///////////////////////////////////////////////////////////////////////////////
  829. for (ii = 0; ii < (int) pDNSQ->DNSH.NSCount; ii++) {
  830. int iRRLenght = 0;
  831. DNSResourceRecord RR;
  833. if (DNS_GetResourceRecord(pBaseData, pRespData, &RR, &iRRLenght) < 0)
  834. return (ErrGetErrorCode());
  836. pRespData += iRRLenght;
  838. SYS_UINT8 const *pNSData = RR.pRespData;
  840. char szNSName[MAX_HOST_NAME] = "";
  842. if (DNS_GetName(pBaseData, pNSData, szNSName) < 0)
  843. return (ErrGetErrorCode());
  845. ///////////////////////////////////////////////////////////////////////////////
  846. //  Recursively try authority name servers
  847. ///////////////////////////////////////////////////////////////////////////////
  848. if (DNS_GetNameNode(hNameList, szNSName, pszDomain) == NULL) {
  849. int iFindResult = DNS_FindDomainMX(szNSName, pszDomain,
  850.    hNameList, pszRespFile,
  851.    pszCName, pTTL);
  853. if ((iFindResult == 0) || (iFindResult == ERR_DNS_NXDOMAIN) ||
  854.     (iFindResult == ERR_DNS_IS_CNAME))
  855. return (iFindResult);
  856. }
  857. }
  859. ///////////////////////////////////////////////////////////////////////////////
  860. //  Scan additional records data
  861. ///////////////////////////////////////////////////////////////////////////////
  862. for (ii = 0; ii < (int) pDNSQ->DNSH.ARCount; ii++) {
  863. int iRRLenght = 0;
  864. DNSResourceRecord RR;
  866. if (DNS_GetResourceRecord(pBaseData, pRespData, &RR, &iRRLenght) < 0)
  867. return (ErrGetErrorCode());
  869. pRespData += iRRLenght;
  871. }
  873. ErrSetErrorCode(ERR_BAD_DNS_RESPONSE);
  874. return (ERR_BAD_DNS_RESPONSE);
  876. }
  878. static int DNS_DecodeDirResponseMX(SYS_UINT8 * pRespData, char const *pszRespFile,
  879.    SYS_UINT32 * pTTL)
  880. {
  882. SYS_UINT8 *pBaseData = pRespData;
  883. DNSQuery *pDNSQ = (DNSQuery *) pRespData;
  885. if (pDNSQ->DNSH.RCode != 0) {
  886. int iErrorCode = ERR_BAD_DNS_RESPONSE;
  888. if (pDNSQ->DNSH.RCode == RCODE_NXDOMAIN)
  889. iErrorCode = ERR_DNS_NXDOMAIN;
  891. ErrSetErrorCode(iErrorCode);
  892. return (iErrorCode);
  893. }
  895. pDNSQ->DNSH.QDCount = ntohs(pDNSQ->DNSH.QDCount);
  896. pDNSQ->DNSH.ANCount = ntohs(pDNSQ->DNSH.ANCount);
  897. pDNSQ->DNSH.NSCount = ntohs(pDNSQ->DNSH.NSCount);
  898. pDNSQ->DNSH.ARCount = ntohs(pDNSQ->DNSH.ARCount);
  900. if (pDNSQ->DNSH.ANCount == 0) {
  901. ErrSetErrorCode(ERR_EMPTY_DNS_RESPONSE);
  902. return (ERR_EMPTY_DNS_RESPONSE);
  903. }
  905. FILE *pMXFile = fopen(pszRespFile, "wb");
  907. if (pMXFile == NULL) {
  908. ErrSetErrorCode(ERR_FILE_CREATE);
  909. return (ERR_FILE_CREATE);
  910. }
  912. pRespData = pDNSQ->QueryData;
  914. ///////////////////////////////////////////////////////////////////////////////
  915. //  Scan query data
  916. ///////////////////////////////////////////////////////////////////////////////
  917. int ii;
  919. for (ii = 0; ii < (int) pDNSQ->DNSH.QDCount; ii++) {
  920. int iQLenght = 0;
  921. SYS_UINT16 Type = 0;
  922. SYS_UINT16 Class = 0;
  923. char szInetName[MAX_HOST_NAME] = "";
  925. if (DNS_GetQuery(pBaseData, pRespData, szInetName, &Type, &Class, &iQLenght) < 0) {
  926. ErrorPush();
  927. fclose(pMXFile);
  928. return (ErrorPop());
  929. }
  931. pRespData += iQLenght;
  932. }
  934. ///////////////////////////////////////////////////////////////////////////////
  935. //  Scan answer data
  936. ///////////////////////////////////////////////////////////////////////////////
  937. int iMXRecords = 0;
  938. SYS_UINT32 TTL = 0;
  940. for (ii = 0; ii < (int) pDNSQ->DNSH.ANCount; ii++) {
  941. int iRRLenght = 0;
  942. DNSResourceRecord RR;
  944. if (DNS_GetResourceRecord(pBaseData, pRespData, &RR, &iRRLenght) < 0) {
  945. ErrorPush();
  946. fclose(pMXFile);
  947. return (ErrorPop());
  948. }
  950. pRespData += iRRLenght;
  952. SYS_UINT8 const *pRRData = RR.pRespData;
  954. if (RR.Type == QTYPE_MX) {
  955. SYS_UINT16 Preference = ntohs(MscReadUint16(pRRData));
  956. char szRRName[MAX_HOST_NAME] = "";
  958. pRRData += sizeof(SYS_UINT16);
  959. if (DNS_GetName(pBaseData, pRRData, szRRName) < 0) {
  960. ErrorPush();
  961. fclose(pMXFile);
  962. return (ErrorPop());
  963. }
  965. if (ii == 0)
  966. fprintf(pMXFile, "%d:%s", (int) Preference, szRRName);
  967. else
  968. fprintf(pMXFile, ",%d:%s", (int) Preference, szRRName);
  970. if ((TTL == 0) || (RR.TTL < TTL))
  971. TTL = RR.TTL;
  973. ++iMXRecords;
  974. }
  975. }
  977. fclose(pMXFile);
  979. if (iMXRecords == 0) {
  980. SysRemove(pszRespFile);
  981. ErrSetErrorCode(ERR_EMPTY_DNS_RESPONSE);
  982. return (ERR_EMPTY_DNS_RESPONSE);
  983. }
  985. if (pTTL != NULL)
  986. *pTTL = TTL;
  988. return (0);
  990. }
  992. static int DNS_DecodeResponseNS(SYS_UINT8 * pRespData, char const *pszRespFile,
  993. bool & bAuth, char *pszCName, SYS_UINT32 * pTTL)
  994. {
  996. SYS_UINT8 *pBaseData = pRespData;
  997. DNSQuery *pDNSQ = (DNSQuery *) pRespData;
  999. if (pDNSQ->DNSH.RCode != 0) {
  1000. int iErrorCode = ERR_BAD_DNS_RESPONSE;
  1002. if (pDNSQ->DNSH.RCode == RCODE_NXDOMAIN)
  1003. iErrorCode = ERR_DNS_NXDOMAIN;
  1005. ErrSetErrorCode(iErrorCode);
  1006. return (iErrorCode);
  1007. }
  1009. FILE *pNSFile = fopen(pszRespFile, "wt");
  1011. if (pNSFile == NULL) {
  1012. ErrSetErrorCode(ERR_FILE_CREATE, pszRespFile);
  1013. return (ERR_FILE_CREATE);
  1014. }
  1016. pDNSQ->DNSH.QDCount = ntohs(pDNSQ->DNSH.QDCount);
  1017. pDNSQ->DNSH.ANCount = ntohs(pDNSQ->DNSH.ANCount);
  1018. pDNSQ->DNSH.NSCount = ntohs(pDNSQ->DNSH.NSCount);
  1019. pDNSQ->DNSH.ARCount = ntohs(pDNSQ->DNSH.ARCount);
  1021. pRespData = pDNSQ->QueryData;
  1023. ///////////////////////////////////////////////////////////////////////////////
  1024. //  Scan query data
  1025. ///////////////////////////////////////////////////////////////////////////////
  1026. int ii;
  1028. for (ii = 0; ii < (int) pDNSQ->DNSH.QDCount; ii++) {
  1029. int iQLenght = 0;
  1030. SYS_UINT16 Type = 0;
  1031. SYS_UINT16 Class = 0;
  1032. char szInetName[MAX_HOST_NAME] = "";
  1034. if (DNS_GetQuery(pBaseData, pRespData, szInetName, &Type, &Class, &iQLenght) < 0) {
  1035. ErrorPush();
  1036. fclose(pNSFile);
  1037. return (ErrorPop());
  1038. }
  1040. pRespData += iQLenght;
  1041. }
  1043. ///////////////////////////////////////////////////////////////////////////////
  1044. //  Scan answer data
  1045. ///////////////////////////////////////////////////////////////////////////////
  1046. int iNSRecords = 0;
  1047. SYS_UINT32 TTL = 0;
  1049. for (ii = 0; ii < (int) pDNSQ->DNSH.ANCount; ii++) {
  1050. int iRRLenght = 0;
  1051. DNSResourceRecord RR;
  1053. if (DNS_GetResourceRecord(pBaseData, pRespData, &RR, &iRRLenght) < 0) {
  1054. ErrorPush();
  1055. fclose(pNSFile);
  1056. return (ErrorPop());
  1057. }
  1059. pRespData += iRRLenght;
  1061. SYS_UINT8 const *pNSData = RR.pRespData;
  1063. char szRRName[MAX_HOST_NAME] = "";
  1065. if (DNS_GetName(pBaseData, pNSData, szRRName) < 0) {
  1066. ErrorPush();
  1067. fclose(pNSFile);
  1068. return (ErrorPop());
  1069. }
  1071. if (RR.Type == QTYPE_NS) {
  1072. fprintf(pNSFile, "%sn", szRRName);
  1074. if ((TTL == 0) || (RR.TTL < TTL))
  1075. TTL = RR.TTL;
  1077. ++iNSRecords;
  1078. } else if (RR.Type == QTYPE_CNAME) {
  1079. if (pszCName != NULL)
  1080. strcpy(pszCName, szRRName);
  1081. fclose(pNSFile);
  1083. ErrSetErrorCode(ERR_DNS_IS_CNAME);
  1084. return (ERR_DNS_IS_CNAME);
  1085. }
  1086. }
  1088. ///////////////////////////////////////////////////////////////////////////////
  1089. //  Got answers ?
  1090. ///////////////////////////////////////////////////////////////////////////////
  1091. if (iNSRecords > 0) {
  1092. fclose(pNSFile);
  1093. bAuth = true;
  1094. if (pTTL != NULL)
  1095. *pTTL = TTL;
  1096. return (0);
  1097. }
  1098. ///////////////////////////////////////////////////////////////////////////////
  1099. //  Scan name servers data
  1100. ///////////////////////////////////////////////////////////////////////////////
  1101. for (ii = 0; ii < (int) pDNSQ->DNSH.NSCount; ii++) {
  1102. int iRRLenght = 0;
  1103. DNSResourceRecord RR;
  1105. if (DNS_GetResourceRecord(pBaseData, pRespData, &RR, &iRRLenght) < 0) {
  1106. ErrorPush();
  1107. fclose(pNSFile);
  1108. return (ErrorPop());
  1109. }
  1111. pRespData += iRRLenght;
  1113. SYS_UINT8 const *pNSData = RR.pRespData;
  1115. char szRRName[MAX_HOST_NAME] = "";
  1117. if (DNS_GetName(pBaseData, pNSData, szRRName) < 0) {
  1118. ErrorPush();
  1119. fclose(pNSFile);
  1120. return (ErrorPop());
  1121. }
  1123. if (RR.Type == QTYPE_NS) {
  1124. fprintf(pNSFile, "%sn", szRRName);
  1126. if ((TTL == 0) || (RR.TTL < TTL))
  1127. TTL = RR.TTL;
  1129. ++iNSRecords;
  1130. }
  1131. }
  1133. ///////////////////////////////////////////////////////////////////////////////
  1134. //  Got answers ?
  1135. ///////////////////////////////////////////////////////////////////////////////
  1136. if (iNSRecords > 0) {
  1137. fclose(pNSFile);
  1138. bAuth = false;
  1139. if (pTTL != NULL)
  1140. *pTTL = TTL;
  1141. return (0);
  1142. }
  1143. ///////////////////////////////////////////////////////////////////////////////
  1144. //  Scan additional records data
  1145. ///////////////////////////////////////////////////////////////////////////////
  1146. for (ii = 0; ii < (int) pDNSQ->DNSH.ARCount; ii++) {
  1147. int iRRLenght = 0;
  1148. DNSResourceRecord RR;
  1150. if (DNS_GetResourceRecord(pBaseData, pRespData, &RR, &iRRLenght) < 0) {
  1151. ErrorPush();
  1152. fclose(pNSFile);
  1153. return (ErrorPop());
  1154. }
  1156. pRespData += iRRLenght;
  1158. }
  1160. fclose(pNSFile);
  1162. ErrSetErrorCode(ERR_BAD_DNS_RESPONSE);
  1163. return (ERR_BAD_DNS_RESPONSE);
  1165. }
  1167. static int DNS_FindDomainMX(char const *pszDNSServer, char const *pszDomain,
  1168.     HSLIST & hNameList, char const *pszRespFile,
  1169.     char *pszCName, SYS_UINT32 * pTTL)
  1170. {
  1172. ///////////////////////////////////////////////////////////////////////////////
  1173. //  Send query and read result
  1174. ///////////////////////////////////////////////////////////////////////////////
  1175. SYS_UINT8 *pRespData = DNS_QueryExec(pszDNSServer, DNS_PORTNO, DNS_SOCKET_TIMEOUT,
  1176.      0, QTYPE_MX, pszDomain);
  1178. if (pRespData == NULL)
  1179. return (ErrGetErrorCode());
  1181. ///////////////////////////////////////////////////////////////////////////////
  1182. //  Add this server to the visited list
  1183. ///////////////////////////////////////////////////////////////////////////////
  1184. DNS_AddNameNode(hNameList, pszDNSServer, pszDomain);
  1186. ///////////////////////////////////////////////////////////////////////////////
  1187. //  Decode server response ( recursive )
  1188. ///////////////////////////////////////////////////////////////////////////////
  1189. int iDecodeResult = DNS_DecodeResponseMX(pRespData, pszDomain,
  1190.  hNameList, pszRespFile,
  1191.  pszCName, pTTL);
  1193. DNS_FreeRespData(pRespData);
  1195. return (iDecodeResult);
  1197. }
  1199. static int DNS_QueryDomainMX(char const *pszDNSServer, char const *pszDomain,
  1200.      char *&pszMXDomains, char *pszCName, SYS_UINT32 * pTTL)
  1201. {
  1203. HSLIST hNameList;
  1204. char szMXFileName[SYS_MAX_PATH] = "";
  1206. SysGetTmpFile(szMXFileName);
  1208. ListInit(hNameList);
  1210. if (DNS_FindDomainMX(pszDNSServer, pszDomain, hNameList,
  1211.      szMXFileName, pszCName, pTTL) < 0) {
  1212. ErrorPush();
  1213. DNS_FreeNameList(hNameList);
  1214. SysRemove(szMXFileName);
  1215. return (ErrorPop());
  1216. }
  1218. DNS_FreeNameList(hNameList);
  1220. FILE *pMXFile = fopen(szMXFileName, "rb");
  1222. if (pMXFile == NULL) {
  1223. SysRemove(szMXFileName);
  1225. ErrSetErrorCode(ERR_FILE_OPEN);
  1226. return (ERR_FILE_OPEN);
  1227. }
  1229. fseek(pMXFile, 0, SEEK_END);
  1231. unsigned int uFileSize = (unsigned int) ftell(pMXFile);
  1233. if ((pszMXDomains = (char *) SysAlloc(uFileSize + 1)) == NULL) {
  1234. fclose(pMXFile);
  1235. SysRemove(szMXFileName);
  1236. return (ErrGetErrorCode());
  1237. }
  1239. fseek(pMXFile, 0, SEEK_SET);
  1241. fread(pszMXDomains, uFileSize, 1, pMXFile);
  1242. pszMXDomains[uFileSize] = '';
  1244. fclose(pMXFile);
  1246. SysRemove(szMXFileName);
  1248. return (0);
  1250. }
  1252. int DNS_QueryNameServers(char const *pszDNSServer, char const *pszDomain,
  1253.  char const *pszRespFile, bool & bAuth, char *pszCName, SYS_UINT32 * pTTL)
  1254. {
  1256. ///////////////////////////////////////////////////////////////////////////////
  1257. //  Send query and read result
  1258. ///////////////////////////////////////////////////////////////////////////////
  1259. SYS_UINT8 *pRespData = DNS_QueryExec(pszDNSServer, DNS_PORTNO, DNS_SOCKET_TIMEOUT,
  1260.      0, QTYPE_NS, pszDomain);
  1262. if (pRespData == NULL)
  1263. return (ErrGetErrorCode());
  1265. if (DNS_DecodeResponseNS(pRespData, pszRespFile, bAuth, pszCName, pTTL) < 0) {
  1266. ErrorPush();
  1267. DNS_FreeRespData(pRespData);
  1268. return (ErrorPop());
  1269. }
  1271. DNS_FreeRespData(pRespData);
  1273. return (0);
  1275. }
  1277. static int DNS_AppendHosts(FILE *pFile, char const *pszDestPath)
  1278. {
  1280. FILE *pDest = fopen(pszDestPath, "a+t");
  1282. if (pDest == NULL) {
  1283. ErrSetErrorCode(ERR_FILE_OPEN);
  1284. return (ERR_FILE_OPEN);
  1285. }
  1287. rewind(pFile);
  1289. char szHost[MAX_HOST_NAME] = "";
  1291. while (MscFGets(szHost, sizeof(szHost) - 1, pFile) != NULL)
  1292. fprintf(pDest, "%sn", szHost);
  1294. fclose(pDest);
  1296. return (0);
  1297. }
  1299. static int DNS_GetNameServersLL(char const *pszDNSServer, char const *pszDomain,
  1300. char const *pszRespFile, HSLIST & hNameList,
  1301. char *pszCName, SYS_UINT32 * pTTL)
  1302. {
  1304. char szRespFile[SYS_MAX_PATH] = "";
  1306. SysGetTmpFile(szRespFile);
  1308. bool bAuth = false;
  1310. if (DNS_QueryNameServers(pszDNSServer, pszDomain, szRespFile, bAuth, pszCName, pTTL) < 0) {
  1311. ErrorPush();
  1312. CheckRemoveFile(szRespFile);
  1314. return (ErrorPop());
  1315. }
  1317. if (bAuth) {
  1318. if (MscCopyFile(pszRespFile, szRespFile) < 0) {
  1319. ErrorPush();
  1320. SysRemove(szRespFile);
  1322. return (ErrorPop());
  1323. }
  1325. SysRemove(szRespFile);
  1327. return (0);
  1328. }
  1329. ///////////////////////////////////////////////////////////////////////////////
  1330. //  Add this server to the visited list
  1331. ///////////////////////////////////////////////////////////////////////////////
  1332. DNS_AddNameNode(hNameList, pszDNSServer, pszDomain);
  1334. FILE *pNSFile = fopen(szRespFile, "rt");
  1336. if (pNSFile == NULL) {
  1337. SysRemove(szRespFile);
  1339. ErrSetErrorCode(ERR_FILE_OPEN);
  1340. return (ERR_FILE_OPEN);
  1341. }
  1343. char szNS[MAX_HOST_NAME] = "";
  1345. while (MscFGets(szNS, sizeof(szNS) - 1, pNSFile) != NULL) {
  1346. if (DNS_GetNameNode(hNameList, szNS, pszDomain) == NULL) {
  1347. int iQueryResult = DNS_GetNameServersLL(szNS, pszDomain,
  1348. pszRespFile, hNameList,
  1349. pszCName, pTTL);
  1351. if ((iQueryResult == 0) || (iQueryResult == ERR_DNS_NXDOMAIN) ||
  1352.     (iQueryResult == ERR_DNS_IS_CNAME)) {
  1353. ///////////////////////////////////////////////////////////////////////////////
  1354. //  If the result code is zero (success), add the non-auth servers at the end
  1355. //  of the list. They will be tried only after a failure from all the auth ones
  1356. ///////////////////////////////////////////////////////////////////////////////
  1357. if (iQueryResult == 0)
  1358. iQueryResult = DNS_AppendHosts(pNSFile, pszRespFile);
  1359. fclose(pNSFile);
  1360. SysRemove(szRespFile);
  1361. return (iQueryResult);
  1362. }
  1363. }
  1364. }
  1365. fclose(pNSFile);
  1367. ///////////////////////////////////////////////////////////////////////////////
  1368. //  We have got non-auth servers, better than nothing
  1369. ///////////////////////////////////////////////////////////////////////////////
  1370. if (MscCopyFile(pszRespFile, szRespFile) < 0) {
  1371. ErrorPush();
  1372. SysRemove(szRespFile);
  1374. return (ErrorPop());
  1375. }
  1377. SysRemove(szRespFile);
  1379. return (0);
  1381. }
  1383. int DNS_GetNameServers(char const *pszDNSServer, char const *pszDomain,
  1384.        char const *pszRespFile, char *pszCName, SYS_UINT32 * pTTL)
  1385. {
  1387. HSLIST hNameList;
  1389. ListInit(hNameList);
  1391. int iQueryResult = DNS_GetNameServersLL(pszDNSServer, pszDomain,
  1392. pszRespFile, hNameList, pszCName, pTTL);
  1394. DNS_FreeNameList(hNameList);
  1396. return (iQueryResult);
  1398. }
  1400. int DNS_DomainNameServers(char const *pszDomain, char const *pszRespFile,
  1401.   char *pszCName, SYS_UINT32 * pTTL)
  1402. {
  1404. char szRootsFile[SYS_MAX_PATH] = "";
  1405. char szRespFile[SYS_MAX_PATH] = "";
  1407. DNS_GetRootsFile(szRootsFile, sizeof(szRootsFile));
  1408. StrSNCpy(szRespFile, szRootsFile);
  1410. char **ppszDomains = StrTokenize(pszDomain, ". t");
  1412. if (ppszDomains == NULL)
  1413. return (ErrGetErrorCode());
  1415. int iSubDomains = StrStringsCount(ppszDomains);
  1416. int iLastNSResult = ERR_DNS_NXDOMAIN;
  1417. char szPrevDomain[MAX_HOST_NAME] = "";
  1419. for (--iSubDomains; iSubDomains >= 0; iSubDomains--) {
  1420. char szCurrDomain[MAX_HOST_NAME] = "";
  1422. SysSNPrintf(szCurrDomain, sizeof(szCurrDomain) - 1, "%s.%s",
  1423.     ppszDomains[iSubDomains], szPrevDomain);
  1424. StrSNCpy(szPrevDomain, szCurrDomain);
  1426. FILE *pNSFile = fopen(szRespFile, "rt");
  1428. if (pNSFile == NULL) {
  1429. StrFreeStrings(ppszDomains);
  1430. if (strcmp(szRespFile, szRootsFile) != 0)
  1431. SysRemove(szRespFile);
  1433. ErrSetErrorCode(ERR_FILE_OPEN);
  1434. return (ERR_FILE_OPEN);
  1435. }
  1437. char szRespFile2[SYS_MAX_PATH] = "";
  1439. SysGetTmpFile(szRespFile2);
  1441. int iNSGetResult = -1;
  1442. char szNS[MAX_HOST_NAME] = "";
  1444. while (MscFGets(szNS, sizeof(szNS) - 1, pNSFile) != NULL) {
  1445. iNSGetResult = DNS_GetNameServers(szNS, szCurrDomain,
  1446.   szRespFile2, pszCName, pTTL);
  1448. if ((iNSGetResult == 0) || (iNSGetResult == ERR_DNS_NXDOMAIN))
  1449. break;
  1451. if (iNSGetResult == ERR_DNS_IS_CNAME) {
  1452. fclose(pNSFile);
  1453. StrFreeStrings(ppszDomains);
  1454. if (strcmp(szRespFile, szRootsFile) != 0)
  1455. SysRemove(szRespFile);
  1456. ErrSetErrorCode(iNSGetResult);
  1457. return (iNSGetResult);
  1458. }
  1459. }
  1461. fclose(pNSFile);
  1463. ///////////////////////////////////////////////////////////////////////////////
  1464. //  Not getting a valid response at level N does not mean that we will not
  1465. //  succeed at level N+1. It might happen that mid-level subdomains do not
  1466. //  have NS records while low-level will do
  1467. ///////////////////////////////////////////////////////////////////////////////
  1468. if ((iLastNSResult = iNSGetResult) < 0)
  1469. SysRemove(szRespFile2);
  1470. else {
  1471. if (strcmp(szRespFile, szRootsFile) != 0)
  1472. SysRemove(szRespFile);
  1474. StrSNCpy(szRespFile, szRespFile2);
  1475. }
  1476. }
  1478. StrFreeStrings(ppszDomains);
  1480. ///////////////////////////////////////////////////////////////////////////////
  1481. //  If we did not get any valid response walking down the hierarchy we bounce
  1482. //  back with the latest error that we received
  1483. ///////////////////////////////////////////////////////////////////////////////
  1484. if (strcmp(szRespFile, szRootsFile) == 0) {
  1485. ErrSetErrorCode(iLastNSResult);
  1486. return (iLastNSResult);
  1487. }
  1489. if (MscCopyFile(pszRespFile, szRespFile) < 0) {
  1490. ErrorPush();
  1491. SysRemove(szRespFile);
  1492. return (ErrorPop());
  1493. }
  1495. SysRemove(szRespFile);
  1497. return (0);
  1499. }
  1501. static char *DNS_GetRootsFile(char *pszRootsFilePath, int iMaxPath)
  1502. {
  1504. CfgGetRootPath(pszRootsFilePath, iMaxPath);
  1506. StrNCat(pszRootsFilePath, ROOTS_FILE, iMaxPath);
  1508. return (pszRootsFilePath);
  1510. }
  1512. int DNS_GetRoots(char const *pszDNSServer, char const *pszRespFile)
  1513. {
  1515. return (DNS_GetNameServers(pszDNSServer, ".", pszRespFile, NULL));
  1517. }
  1519. int DNS_GetDomainMX(char const *pszDomain, char *&pszMXDomains, char *pszCName, SYS_UINT32 * pTTL)
  1520. {
  1522. char szRespFile[SYS_MAX_PATH] = "";
  1524. SysGetTmpFile(szRespFile);
  1526. if (DNS_DomainNameServers(pszDomain, szRespFile, pszCName) < 0) {
  1527. ErrorPush();
  1528. SysRemove(szRespFile);
  1530. return (ErrorPop());
  1531. }
  1533. FILE *pNSFile = fopen(szRespFile, "rt");
  1535. if (pNSFile == NULL) {
  1536. SysRemove(szRespFile);
  1538. ErrSetErrorCode(ERR_FILE_OPEN);
  1539. return (ERR_FILE_OPEN);
  1540. }
  1542. char szNS[MAX_HOST_NAME] = "";
  1544. while (MscFGets(szNS, sizeof(szNS) - 1, pNSFile) != NULL) {
  1545. int iQueryResult = DNS_QueryDomainMX(szNS, pszDomain, pszMXDomains,
  1546.      pszCName, pTTL);
  1548. if ((iQueryResult == 0) || (iQueryResult == ERR_DNS_NXDOMAIN) ||
  1549.     (iQueryResult == ERR_DNS_IS_CNAME)) {
  1550. fclose(pNSFile);
  1551. SysRemove(szRespFile);
  1553. return (iQueryResult);
  1554. }
  1555. }
  1557. fclose(pNSFile);
  1559. SysRemove(szRespFile);
  1561. ErrSetErrorCode(ERR_NO_DEFINED_MXS_FOR_DOMAIN);
  1562. return (ERR_NO_DEFINED_MXS_FOR_DOMAIN);
  1564. }
  1566. int DNS_GetDomainMXDirect(char const *pszDNSServer, char const *pszDomain,
  1567.   int iQuerySockType, char *&pszMXDomains, SYS_UINT32 * pTTL)
  1568. {
  1570. ///////////////////////////////////////////////////////////////////////////////
  1571. //  Setup DNS MX query with recursion requested
  1572. ///////////////////////////////////////////////////////////////////////////////
  1573. int iQueryLenght;
  1574. DNSQuery DNSQ;
  1576. if (DNS_RequestSetup(DNSQ, 0, QTYPE_MX, pszDomain, iQueryLenght, true) < 0)
  1577. return (ErrGetErrorCode());
  1579. SYS_UINT8 *pRespData = NULL;
  1581. switch (iQuerySockType) {
  1582. case (DNS_QUERY_TCP):
  1583. {
  1585. if ((pRespData =
  1586.      DNS_QuerySendStream(pszDNSServer, DNS_PORTNO, DNS_SOCKET_TIMEOUT,
  1587.  DNSQ, iQueryLenght)) == NULL)
  1588. return (ErrGetErrorCode());
  1590. }
  1591. break;
  1593. case (DNS_QUERY_UDP):
  1594. default:
  1595. {
  1596. ///////////////////////////////////////////////////////////////////////////////
  1597. //  Try needed UDP query first, if it's truncated switch to TCP query
  1598. ///////////////////////////////////////////////////////////////////////////////
  1599. bool bTruncated = false;
  1601. if (((pRespData =
  1602.       DNS_QuerySendDGram(pszDNSServer, DNS_PORTNO, DNS_SOCKET_TIMEOUT,
  1603.  DNSQ, iQueryLenght, bTruncated)) == NULL) &&
  1604.     bTruncated)
  1605. pRespData =
  1606.     DNS_QuerySendStream(pszDNSServer, DNS_PORTNO,
  1607. DNS_SOCKET_TIMEOUT, DNSQ, iQueryLenght);
  1609. if (pRespData == NULL)
  1610. return (ErrGetErrorCode());
  1612. }
  1613. break;
  1614. }
  1616. char szRespFile[SYS_MAX_PATH] = "";
  1618. SysGetTmpFile(szRespFile);
  1620. if (DNS_DecodeDirResponseMX(pRespData, szRespFile, pTTL) < 0) {
  1621. ErrorPush();
  1622. DNS_FreeRespData(pRespData);
  1623. CheckRemoveFile(szRespFile);
  1625. return (ErrorPop());
  1626. }
  1628. DNS_FreeRespData(pRespData);
  1630. FILE *pMXFile = fopen(szRespFile, "rb");
  1632. if (pMXFile == NULL) {
  1633. ErrorPush();
  1634. SysRemove(szRespFile);
  1636. return (ErrorPop());
  1637. }
  1639. fseek(pMXFile, 0, SEEK_END);
  1641. unsigned int uFileSize = (unsigned int) ftell(pMXFile);
  1643. if ((pszMXDomains = (char *) SysAlloc(uFileSize + 1)) == NULL) {
  1644. ErrorPush();
  1645. fclose(pMXFile);
  1646. SysRemove(szRespFile);
  1648. return (ErrorPop());
  1649. }
  1651. fseek(pMXFile, 0, SEEK_SET);
  1653. fread(pszMXDomains, uFileSize, 1, pMXFile);
  1654. pszMXDomains[uFileSize] = '';
  1656. fclose(pMXFile);
  1657. SysRemove(szRespFile);
  1659. return (0);
  1661. }