Jassif Team Institution

const dns = require('dns');

// Look up a domain name
dns.lookup('example.com', (err, address, family) => {
  if (err) {
    console.error('Lookup error:', err);
    return;
  }
  console.log(`IP address: ${address}`);
  console.log(`IP version: IPv${family}`);
});

// Import the DNS module
const dns = require('dns');

// Example usage
dns.lookup('example.com', (err, address, family) => {
  if (err) throw err;
  console.log(`Resolved: ${address} (IPv${family})`);
});

// Import the promises API
const { promises: dns } = require('dns');
// Or: const dns = require('dns').promises;

// Example with async/await
async function lookupDomain(domain) {
  try {
    const address = await dns.lookup(domain);
    console.log(`Resolved: ${address.address} (IPv${address.family})`);
  } catch (err) {
    console.error('Lookup failed:', err);
  }
}

lookupDomain('example.com');

const dns = require('dns');

// Callback-based API
dns.lookup('www.example.com', (err, address, family) => {
  if (err) throw err;
  console.log('IP address: %s', address);
  console.log('IP version: IPv%s', family);
});

const dns = require('dns').promises;

// Promise-based API
async function lookupExample() {
  try {
    const result = await dns.lookup('www.example.com');
    console.log('IP address:', result.address);
    console.log('IP version: IPv' + result.family);
  } catch (err) {
    console.error('Lookup failed:', err);
  }
}

lookupExample();

const dns = require('dns');

// Get all IPv4 addresses
dns.resolve4('www.google.com', (err, addresses) => {
  if (err) throw err;

  console.log('IPv4 addresses:');
  addresses.forEach(address => {
    console.log(` ${address}`);
  });

  // Perform a reverse lookup on the first IP
  dns.reverse(addresses[0], (err, hostnames) => {
    if (err) throw err;

    console.log(`Reverse lookup for ${addresses[0]}:`);
    hostnames.forEach(hostname => {
      console.log(` ${hostname}`);
    });
  });
});

const dns = require('dns');

// Create a new resolver
const resolver = new dns.Resolver();

// Set custom server (Google's public DNS)
resolver.setServers(['8.8.8.8', '8.8.4.4']);

// Use the custom resolver
resolver.resolve4('www.example.com', (err, addresses) => {
  if (err) throw err;

  console.log('Addresses resolved using Google DNS:');
  addresses.forEach(addr => {
    console.log(` ${addr}`);
  });
});

// See what servers are configured
console.log('Current resolver servers:', resolver.getServers());

const dns = require('dns');

function lookupWithErrorHandling(domain) {
  dns.lookup(domain, (err, address, family) => {
    if (err) {
      console.error(`DNS lookup failed for ${domain}`);

      // Check specific error codes
      switch (err.code) {
        case 'ENOTFOUND':
          console.error(' Domain name not found');
          break;
        case 'ETIMEDOUT':
          console.error(' DNS lookup timed out');
          break;
        case 'ENODATA':
          console.error(' Domain exists but no data of requested type');
          break;
        case 'ESERVFAIL':
          console.error(' DNS server returned general failure');
          break;
        default:
          console.error(` Error code: ${err.code}`);
      }

      return;
    }

    console.log(`DNS lookup successful for ${domain}`);
    console.log(` IP address: ${address}`);
    console.log(` IP version: IPv${family}`);
  });
}

// Test with valid and invalid domains
lookupWithErrorHandling('www.google.com');
lookupWithErrorHandling('this-domain-does-not-exist-123456789.com');

const dns = require('dns');
const util = require('util');
const lookup = util.promisify(dns.lookup);
const dnsCache = new Map();

async function cachedLookup(domain) {
  if (dnsCache.has(domain)) {
    console.log('Cache hit for:', domain);
    return dnsCache.get(domain);
  }
  console.log('Cache miss for:', domain);
  const result = await lookup(domain);
  dnsCache.set(domain, result);
  return result;
}

// Example usage
(async () => {
  const domains = ['google.com', 'facebook.com', 'google.com'];
  for (const domain of domains) {
    const result = await cachedLookup(domain);
    console.log(`${domain} → ${result.address}`);
  }
})();

const dns = require('dns').promises;

async function lookupMultiple(domains) {
  try {
    const lookups = domains.map(domain => dns.lookup(domain));
    const results = await Promise.all(lookups);
    return domains.map((domain, i) => ({
      domain,
      ...results[i]
    }));
  } catch (err) {
    console.error('One or more lookups failed:', err);
    throw err;
  }
}

// Example usage
lookupMultiple(['google.com', 'facebook.com', 'github.com'])
  .then(results => console.log(results))
  .catch(console.error);

const dns = require('dns');
const { Resolver } = dns;

// Create a custom resolver with timeout
const resolver = new Resolver();
resolver.setServers(['8.8.8.8', '1.1.1.1']); // Google and Cloudflare DNS

// Set timeout for all operations (in ms)
const TIMEOUT = 2000;

async function resolveWithTimeout(domain, rrtype = 'A') {
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      reject(new Error(`DNS query timed out after ${TIMEOUT}ms`));
    }, TIMEOUT);

    resolver.resolve(domain, rrtype, (err, addresses) => {
      clearTimeout(timer);
      if (err) return reject(err);
      resolve(addresses);
    });
  });
}

// Example usage
resolveWithTimeout('example.com')
  .then(console.log)
  .catch(console.error);