main.go

package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"net"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/joho/godotenv"
)

var (
	numWorkers int
)

func init() {
	if err := godotenv.Load(); err != nil {
		log.Fatal("Error loading .env file")
	}
}

func checkDomains(words []string, tlds []string) {
	jobs := make(chan string, 100)
	results := make(chan string, 100)

	var wg sync.WaitGroup
	workers := os.Getenv("NUM_WORKERS")
	if workers == "" {
		numWorkers = 20 // default
	} else {
		var err error
		numWorkers, err = strconv.Atoi(workers)
		if err != nil {
			log.Fatal("Invalid NUM_WORKERS value in .env")
		}
	}

	for i := 0; i < numWorkers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for domain := range jobs {
				// Rate limiting
				time.Sleep(500 * time.Millisecond)

				if isDomainAvailable(domain) {
					results <- domain
				}
			}
		}()
	}

	done := make(chan bool)
	go func() {
		for domain := range results {
			saveDomainToFile(domain)
		}
		done <- true
	}()

	for _, word := range words {
		word = strings.ToLower(word)
		for _, tld := range tlds {
			tld = strings.ToLower(tld)
			cleanTld := strings.TrimPrefix(tld, ".")
			if strings.HasSuffix(word, cleanTld) {
				if len(word) < len(tld) {
					continue
				}
				if len(word[:len(word)-len(tld)]) < 3 {
					continue
				}
				domain := word[:len(word)-len(tld)+1] + tld
				jobs <- domain
			}
		}
	}

	close(jobs)
	wg.Wait()
	close(results)
	<-done
}

func loadList(filename string) ([]string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, fmt.Errorf("error opening file %s: %v", filename, err)
	}
	defer file.Close()

	var items []string
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		items = append(items, strings.TrimSpace(scanner.Text()))
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error reading file %s: %v", filename, err)
	}

	return items, nil
}

func getWhoisServer(tld string) string {
	whoisServers := map[string]string{
		".com":  "whois.verisign-grs.com",
		".net":  "whois.verisign-grs.com",
		".org":  "whois.pir.org",
		".info": "whois.afilias.net",
		".biz":  "whois.biz",
		".io":   "whois.nic.io",
		".co":   "whois.nic.co",
		".ai":   "whois.nic.ai",
		".dev":  "whois.nic.google",
		".app":  "whois.nic.google",
	}

	server, exists := whoisServers[strings.ToLower(tld)]
	if !exists {
		return "whois.iana.org"
	}
	return server
}

func isDomainAvailable(domain string) bool {
	tld := "." + strings.Split(domain, ".")[len(strings.Split(domain, "."))-1]
	server := getWhoisServer(tld)

	// First query - might be IANA
	conn, err := net.DialTimeout("tcp", server+":43", 10*time.Second)
	if err != nil {
		return false
	}

	_, err = fmt.Fprintf(conn, "%s\r\n", domain)
	if err != nil {
		conn.Close()
		return false
	}

	buffer, err := io.ReadAll(conn)
	conn.Close()
	if err != nil {
		return false
	}

	response := string(buffer)

	// Check if this is an IANA response with a referral
	if strings.Contains(response, "refer:") {
		// Extract referred server
		for _, line := range strings.Split(response, "\n") {
			if strings.HasPrefix(strings.TrimSpace(line), "whois:") {
				parts := strings.Fields(line)
				if len(parts) > 1 {
					// Query the actual TLD WHOIS server
					return queryWhoisServer(parts[1], domain)
				}
			}
		}
	}

	return checkAvailability(response)
}

func checkAvailability(response string) bool {
	notFoundPhrases := []string{
		"No match for ",
		"NOT FOUND",
		"No entries found",
		"Domain not found",
		"Domain Status: Free",
		"not found...",
		"No Object Found",
	}

	for _, phrase := range notFoundPhrases {
		if strings.Contains(response, phrase) {
			return true
		}
	}
	return false
}

func queryWhoisServer(server string, domain string) bool {
	conn, err := net.DialTimeout("tcp", server+":43", 10*time.Second)
	if err != nil {
		return false
	}
	defer conn.Close()

	_, err = fmt.Fprintf(conn, "%s\r\n", domain)
	if err != nil {
		return false
	}

	buffer, err := io.ReadAll(conn)
	if err != nil {
		return false
	}

	return checkAvailability(string(buffer))
}

func saveDomainToFile(domain string) {
	file, err := os.OpenFile("available_domains.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("Error opening file: %v\n", err)
	}
	writer := bufio.NewWriter(file)
	_, err = writer.WriteString(domain + "\n")
	if err != nil {
		fmt.Printf("Error writing to file: %v\n", err)
	}
	writer.Flush()
	file.Close()

	fmt.Printf("Available: %s\n", domain)
}

func main() {
	words, err := loadList("wordlist.txt")
	if err != nil {
		fmt.Printf("Error loading wordlist: %v\n", err)
		return
	}

	tlds, err := loadList("tlds.txt")
	if err != nil {
		fmt.Printf("Error loading TLDs: %v\n", err)
		return
	}

	checkDomains(words, tlds)
}