# Concurrent TCP Skanerlar (Optimizatsiya) ## Bu darsda nima qilamiz? Oldingi darsda worker pool bilan ishlashni o'rgandik. Bu darsda skanerga uchta qo'shimcha narsa kiritamiz: **adaptive timeout** (tarmoq holatiga qarab o'zgaruvchi), **retry** (xato bo'lsa qayta urinish), va **streaming natijalar** (65K portni xotira tiqib qolmasdan). Oxirida signal bilan to'g'ri to'xtatish ham ko'ramiz. ## Adaptive timeout **Fixed timeout** muammosi: lokal tarmoqda 2s kutish — 1900ms bekorga sarflangan vaqt. Sekin tarmoqda 2s yetmaydi — xizmat borligini o'tkazib yuboramiz. **Adaptive timeout** — o'tgan ulanishlarning o'rtacha vaqtiga qarab timeout ni avtomatik sozlaydi. ```go package main import ( "fmt" "net" "sync" "time" ) type AdaptiveTimeout struct { current time.Duration history []time.Duration mu sync.Mutex min time.Duration max time.Duration } func newAdaptiveTimeout(initial time.Duration) *AdaptiveTimeout { return &AdaptiveTimeout{ current: initial, min: 200 * time.Millisecond, max: 10 * time.Second, } } // Get — joriy timeout qiymatini qaytaradi func (at *AdaptiveTimeout) Get() time.Duration { at.mu.Lock() defer at.mu.Unlock() return at.current } // Record — muvaffaqiyatli ulanish vaqtini qayd qilib, timeout ni yangilaydi func (at *AdaptiveTimeout) Record(d time.Duration) { at.mu.Lock() defer at.mu.Unlock() at.history = append(at.history, d) // So'nggi 100 ta o'lchov yetarli if len(at.history) > 100 { at.history = at.history[1:] } // O'rtacha × 3 = yangi timeout var total time.Duration for _, h := range at.history { total += h } avg := total / time.Duration(len(at.history)) newTimeout := avg * 3 if newTimeout < at.min { newTimeout = at.min } if newTimeout > at.max { newTimeout = at.max } at.current = newTimeout } ``` Lokal tarmoqda o'rtacha ulanish 30ms bo'lsa, timeout 90ms bo'ladi — sequential skanerdan 20 marta tez. Sekin tarmoqda (o'rtacha 2s) timeout 6s ga chiqadi — false negative yo'q. ## Retry logikasi Ba'zan port vaqtinchalik javob bermaydi (tarmoq muammo). Bir marta urinib, "yopiq" deb belgilash noto'g'ri. **Exponential backoff** — har qayta urinish orasidagi kutish ikki barobar oshadi: ```go type RetryConfig struct { MaxRetries int InitialDelay time.Duration BackoffFactor float64 MaxDelay time.Duration } func scanWithRetry(host string, port int, timeout time.Duration, cfg RetryConfig) bool { delay := cfg.InitialDelay for attempt := 0; attempt <= cfg.MaxRetries; attempt++ { if attempt > 0 { time.Sleep(delay) delay = time.Duration(float64(delay) * cfg.BackoffFactor) if delay > cfg.MaxDelay { delay = cfg.MaxDelay } } conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", host, port), timeout) if err == nil { conn.Close() return true // Port ochiq } // Faqat timeout xatolikda qayta urinamiz, RST (port yopiq) da emas if netErr, ok := err.(net.Error); ok && netErr.Timeout() { continue } break // RST yoki boshqa xatolik — qayta urinsak ham foyda yo'q } return false } ``` Misol: `InitialDelay=100ms, BackoffFactor=2, MaxRetries=2`: - 1-urinish: darhol - 2-urinish: 100ms kutib - 3-urinish: 200ms kutib ## Streaming natijalar Barcha natijalarni slice'ga yig'ish o'rniga, har natija topilganda darhol qayta ishlash — xotira sezilarli kamayadi: | Port soni | Slice (buffered) | Streaming | |---|---|---| | 1 000 | ~100 KB | ~10 KB | | 65 535 | ~6.5 MB | ~10 KB | | 1 000 000 | ~100 MB | ~10 KB | ```go type StreamingScanner struct { Host string Workers int OnResult func(ScanResult) // Har natija uchun callback timeout *AdaptiveTimeout } func (ss *StreamingScanner) Scan(start, end int) { jobs := make(chan int, ss.Workers) var wg sync.WaitGroup for i := 0; i < ss.Workers; i++ { wg.Add(1) go func() { defer wg.Done() for port := range jobs { result := ss.checkPort(port) if ss.OnResult != nil { ss.OnResult(result) // Darhol qayta ishlanadi } } }() } for port := start; port <= end; port++ { jobs <- port } close(jobs) wg.Wait() } func (ss *StreamingScanner) checkPort(port int) ScanResult { timeout := ss.timeout.Get() address := fmt.Sprintf("%s:%d", ss.Host, port) start := time.Now() conn, err := net.DialTimeout("tcp", address, timeout) latency := time.Since(start) if err != nil { return ScanResult{Port: port, Open: false} } defer conn.Close() ss.timeout.Record(latency) // Muvaffaqiyatli ulanish vaqtini qayd qilamiz result := ScanResult{Port: port, Open: true, Latency: latency} return result } ``` ## Real-time progress Uzoq scan paytida holatni ko'rsatish: ```go import "sync/atomic" type Progress struct { total int64 completed int64 open int64 started time.Time } func newProgress(total int) *Progress { return &Progress{total: int64(total), started: time.Now()} } func (p *Progress) record(open bool) { atomic.AddInt64(&p.completed, 1) if open { atomic.AddInt64(&p.open, 1) } } func (p *Progress) show() string { done := atomic.LoadInt64(&p.completed) openCount := atomic.LoadInt64(&p.open) elapsed := time.Since(p.started) rate := float64(done) / elapsed.Seconds() remaining := float64(p.total-done) / rate return fmt.Sprintf("[%5.1f%%] %d/%d | Ochiq: %d | %.0f p/s | Qoldi: %ds", float64(done)/float64(p.total)*100, done, p.total, openCount, rate, int(remaining)) } ``` `atomic.AddInt64` va `atomic.LoadInt64` — mutex'siz thread-safe counter. Ko'p goroutine bir vaqtda yozganda xotirada "yo'qolgan" yangilanishlar bo'lmaydi. ## To'liq skaner (signal bilan to'g'ri to'xtatish) ```go package main import ( "context" "flag" "fmt" "log" "net" "os" "os/signal" "sync" "sync/atomic" "syscall" "time" ) type AdvancedScanner struct { host string ports []int workers int timeout *AdaptiveTimeout progress *Progress ctx context.Context cancel context.CancelFunc } func (as *AdvancedScanner) Run() []ScanResult { // Ctrl+C ushlaymiz sigChan := make(chan os.Signal, 1) signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM) go func() { <-sigChan fmt.Println("\nTo'xtatilmoqda...") as.cancel() }() // Progress har 1 sekundda yangilanadi go func() { ticker := time.NewTicker(time.Second) defer ticker.Stop() for { select { case <-as.ctx.Done(): return case <-ticker.C: fmt.Printf("\r%s", as.progress.show()) } } }() return as.execute() } func (as *AdvancedScanner) execute() []ScanResult { jobs := make(chan int, as.workers) results := make(chan ScanResult, as.workers) var wg sync.WaitGroup for i := 0; i < as.workers; i++ { wg.Add(1) go func() { defer wg.Done() for port := range jobs { select { case <-as.ctx.Done(): return // Signal keldi, to'xtatamiz default: r := as.scanPort(port) results <- r as.progress.record(r.Open) } } }() } go func() { for _, port := range as.ports { select { case <-as.ctx.Done(): break case jobs <- port: } } close(jobs) }() go func() { wg.Wait() close(results) }() var all []ScanResult for r := range results { all = append(all, r) } return all } func (as *AdvancedScanner) scanPort(port int) ScanResult { timeout := as.timeout.Get() address := fmt.Sprintf("%s:%d", as.host, port) start := time.Now() conn, err := net.DialTimeout("tcp", address, timeout) latency := time.Since(start) if err != nil { return ScanResult{Port: port} } defer conn.Close() as.timeout.Record(latency) return ScanResult{Port: port, Open: true, Latency: latency} } type ScanResult struct { Port int Open bool Latency time.Duration } func main() { target := flag.String("target", "", "Maqsad host") startPort := flag.Int("start", 1, "Boshlang'ich port") endPort := flag.Int("end", 1000, "Oxirgi port") workers := flag.Int("workers", 100, "Parallel worker soni") flag.Parse() if *target == "" { log.Fatal("-target kerak") } ports := make([]int, *endPort-*startPort+1) for i := range ports { ports[i] = *startPort + i } ctx, cancel := context.WithCancel(context.Background()) scanner := &AdvancedScanner{ host: *target, ports: ports, workers: *workers, timeout: newAdaptiveTimeout(2 * time.Second), progress: newProgress(len(ports)), ctx: ctx, cancel: cancel, } fmt.Printf("Skanerlanmoqda: %s (%d port, %d worker)\n", *target, len(ports), *workers) results := scanner.Run() fmt.Println() openCount := 0 for _, r := range results { if r.Open { openCount++ fmt.Printf("Port %d: ochiq (%dms)\n", r.Port, r.Latency.Milliseconds()) } } fmt.Printf("Jami: %d ochiq / %d skanerlangan\n", openCount, len(results)) } ``` ## Qisqacha 1. **Adaptive timeout** — o'rtacha ulanish vaqtiga qarab sozlanadi, lokal tarmoqda avtomatik tezlashadi. 2. **Exponential backoff** — vaqtinchalik xatolarda qayta urinish, RST'da darhol to'xtash. 3. **Streaming** — callback bilan natijalarni yig'masdan darhol qayta ishlash, xotira doimiy. 4. `atomic` — mutex'siz thread-safe counter, progress tracking uchun ideal. 5. `context.WithCancel` + signal — Ctrl+C bilan to'g'ri to'xtatish. ## Keyingi qadam Keyingi darsda bu skanerning "akasi" — **TCP proxy** server yozamiz: load balancing, TLS termination va trafik modifikatsiya.

Concurrent TCP Skanerlar (Advanced)