Update main.go

main.go

@@ -1,151 +1,321 @@
 package main
 
 import (
-    "fmt"
-    "io"
-    "log"
-    "net/http"
-    "strings"
-    "time"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"path"
+	"strings"
+	"time"
 )
 
-func main() {
-    // Handler untuk proxy video
-    http.HandleFunc("/proxy", proxyHandler)
-    
-    // Serve HTML generator
-    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-        http.ServeFile(w, r, "index.html")
-    })
 
-    log.Println("🚀 Server running on :7860")
-    log.Println("📡 Proxy endpoint: http://localhost:7860/proxy")
-    log.Println("🌐 CORS enabled for all origins")
-    log.Fatal(http.ListenAndServe(":7860", nil))
+func main() {
+	// Handler untuk download dengan path
+	http.HandleFunc("/download/", downloadPathHandler)
+	
+	// Handler untuk download dengan query parameter (backward compatibility)
+	http.HandleFunc("/download", downloadQueryHandler)
+	
+	// Handler untuk serve HTML generator
+	http.HandleFunc("/", serveHTMLHandler)
+	
+	log.Println("🚀 Server running on http://localhost:7860")
+	log.Println("📥 Generator: http://localhost:7860")
+	log.Println("📥 Download: http://localhost:7860/download/{domain}/{path}")
+	log.Println("📥 Download (with .mp4): http://localhost:7860/download/mp4/{domain}/{path}")
+	log.Fatal(http.ListenAndServe(":7860", nil))
 }
 
-func proxyHandler(w http.ResponseWriter, r *http.Request) {
-    // ============ CORS HEADERS ============
-    // Allow all origins untuk remote upload
-    w.Header().Set("Access-Control-Allow-Origin", "*")
-    w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, HEAD")
-    w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With, Range")
-    w.Header().Set("Access-Control-Expose-Headers", "Content-Length, Content-Range, Content-Disposition, Accept-Ranges")
-    w.Header().Set("Access-Control-Allow-Credentials", "true")
-    w.Header().Set("Access-Control-Max-Age", "86400") // 24 jam cache preflight
-    
-    // Handle preflight OPTIONS request
-    if r.Method == "OPTIONS" {
-        w.WriteHeader(http.StatusOK)
-        return
-    }
-
-    // ============ PARSE PARAMETERS ============
-    query := r.URL.Query()
-    videoParam := query.Get("video")
-    exp := query.Get("exp")
-    sig := query.Get("sig")
-    videoType := query.Get("type") // "mp4" atau "null"
-    domain := query.Get("d")       // domain CDN, misal: cdn.xvdhsy.pro
-
-    if videoParam == "" || exp == "" || sig == "" || domain == "" {
-        http.Error(w, "Missing parameters: video, exp, sig, d required", http.StatusBadRequest)
-        return
-    }
-
-    // ============ REKONSTRUKSI URL ============
-    // Hapus .mp4 dari video parameter
-    videoId := strings.TrimSuffix(videoParam, ".mp4")
-    
-    // Pastikan domain tidak memiliki protocol
-    domain = strings.TrimPrefix(domain, "http://")
-    domain = strings.TrimPrefix(domain, "https://")
-    domain = strings.TrimSuffix(domain, "/")
-    
-    // Rekonstruksi URL asli
-    // Format: https://{domain}/{videoId}?exp={exp}&sig={sig}
-    originalURL := fmt.Sprintf("https://%s/%s?exp=%s&sig=%s", domain, videoId, exp, sig)
-
-    log.Printf("📥 Proxy request: %s -> %s", r.URL.String(), originalURL)
-
-    // ============ BUAT REQUEST ============
-    client := &http.Client{
-        Timeout: 120 * time.Second, // Timeout lebih lama untuk video besar
-    }
-
-    req, err := http.NewRequest("GET", originalURL, nil)
-    if err != nil {
-        http.Error(w, "Failed to create request", http.StatusInternalServerError)
-        return
-    }
+// Handler untuk serve HTML file
+func serveHTMLHandler(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/" {
+		http.NotFound(w, r)
+		return
+	}
+	http.ServeFile(w, r, "index.html")
+}
 
-    // Set headers untuk request ke CDN
-    req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
-    req.Header.Set("Accept", "*/*")
-    req.Header.Set("Accept-Encoding", "gzip, deflate, br")
-    req.Header.Set("Accept-Language", "en-US,en;q=0.9")
-    req.Header.Set("Connection", "keep-alive")
-    req.Header.Set("Sec-Fetch-Dest", "video")
-    req.Header.Set("Sec-Fetch-Mode", "cors")
-    req.Header.Set("Sec-Fetch-Site", "cross-site")
-    
-    // Copy Range header untuk support streaming
-    if rangeHeader := r.Header.Get("Range"); rangeHeader != "" {
-        req.Header.Set("Range", rangeHeader)
-        log.Printf("📊 Range request: %s", rangeHeader)
-    }
+// Handler untuk download dengan path /download/{domain}/{path} atau /download/mp4/{domain}/{path}
+func downloadPathHandler(w http.ResponseWriter, r *http.Request) {
+	// Ambil path setelah /download/
+	pathStr := strings.TrimPrefix(r.URL.Path, "/download/")
+	
+	// Pisahkan berdasarkan slash
+	parts := strings.Split(pathStr, "/")
+	
+	if len(parts) < 2 {
+		http.Error(w, "Invalid URL format. Use: /download/{domain}/{path} or /download/mp4/{domain}/{path}", http.StatusBadRequest)
+		return
+	}
+	
+	var targetURL string
+	hasMp4Format := false
+	
+	// Cek apakah ada format mp4 di awal (penanda bahwa URL asli sudah ada .mp4)
+	if parts[0] == "mp4" {
+		// Format: /download/mp4/{domain}/{path} → URL asli sudah ada .mp4
+		hasMp4Format = true
+		parts = parts[1:] // Hapus "mp4" dari array
+	}
+	
+	// Ambil domain (parts[0]) dan path (sisanya)
+	if len(parts) < 2 {
+		http.Error(w, "Invalid URL format. Need domain and path", http.StatusBadRequest)
+		return
+	}
+	
+	domain := parts[0]
+	pathParts := parts[1:]
+	pathStr2 := strings.Join(pathParts, "/")
+	
+	// Bangun URL target berdasarkan format
+	if hasMp4Format {
+		// Ada /mp4/ di URL → URL asli sudah memiliki .mp4, langsung gunakan
+		targetURL = "https://" + domain + "/" + pathStr2
+	} else {
+		// Tidak ada /mp4/ di URL → URL asli tidak ada .mp4
+		// HAPUS .mp4 dari akhir path (karena proxy URL ditambahi .mp4 untuk remote upload)
+		if strings.HasSuffix(pathStr2, ".mp4") {
+			pathStr2 = strings.TrimSuffix(pathStr2, ".mp4")
+		}
+		targetURL = "https://" + domain + "/" + pathStr2
+	}
+	
+	log.Printf("📥 HasMp4Format: %v, Target URL: %s", hasMp4Format, targetURL)
+	
+	// Proxy download STREAMING dengan HEAD request
+	downloadProxyStreamWithHead(w, r, targetURL)
+}
 
-    // ============ EKSEKUSI REQUEST ============
-    resp, err := client.Do(req)
-    if err != nil {
-        log.Printf("❌ Error fetching video: %v", err)
-        http.Error(w, "Failed to fetch video", http.StatusInternalServerError)
-        return
-    }
-    defer resp.Body.Close()
+// Handler untuk download dengan query parameter (backward compatibility)
+func downloadQueryHandler(w http.ResponseWriter, r *http.Request) {
+	encodedURL := r.URL.Query().Get("url")
+	if encodedURL == "" {
+		http.Error(w, "Parameter 'url' required", http.StatusBadRequest)
+		return
+	}
+	
+	targetURL, err := url.QueryUnescape(encodedURL)
+	if err != nil {
+		http.Error(w, "Invalid URL", http.StatusBadRequest)
+		return
+	}
+	
+	log.Printf("📥 Downloading: %s", targetURL)
+	downloadProxyStreamWithHead(w, r, targetURL)
+}
 
-    log.Printf("✅ Response status: %s, Content-Length: %s", resp.Status, resp.Header.Get("Content-Length"))
+// Fungsi proxy download dengan HEAD request terlebih dahulu
+func downloadProxyStreamWithHead(w http.ResponseWriter, r *http.Request, targetURL string) {
+	// Ambil nama file dari URL
+	filename := path.Base(targetURL)
+	if !strings.HasSuffix(filename, ".mp4") {
+		filename = "video.mp4"
+	}
+	
+	log.Printf("📥 Streaming: %s", targetURL)
+	
+	// STEP 1: HEAD request untuk mendapatkan metadata
+	headReq, err := http.NewRequest("HEAD", targetURL, nil)
+	if err != nil {
+		http.Error(w, "Failed to create HEAD request", http.StatusInternalServerError)
+		return
+	}
+	
+	// Set headers untuk HEAD request
+	headReq.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
+	headReq.Header.Set("Referer", targetURL)
+	headReq.Header.Set("Accept", "*/*")
+	headReq.Header.Set("Accept-Language", "en-GB,en-US;q=0.9,en;q=0.8")
+	headReq.Header.Set("Accept-Encoding", "gzip, deflate, br")
+	headReq.Header.Set("Cache-Control", "no-cache")
+	headReq.Header.Set("Pragma", "no-cache")
+	headReq.Header.Set("Sec-Fetch-Dest", "video")
+	headReq.Header.Set("Sec-Fetch-Mode", "no-cors")
+	headReq.Header.Set("Sec-Fetch-Site", "same-origin")
+	headReq.Header.Set("Connection", "keep-alive")
+	
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:        100,
+			MaxIdleConnsPerHost: 100,
+			IdleConnTimeout:     90 * time.Second,
+			DisableCompression:  false,
+			ResponseHeaderTimeout: 30 * time.Second,
+		},
+	}
+	
+	// Eksekusi HEAD request
+	headResp, err := client.Do(headReq)
+	if err != nil {
+		log.Printf("⚠️ HEAD request failed: %v, fallback to normal GET", err)
+		// Fallback ke GET biasa
+		downloadProxyStream(w, r, targetURL)
+		return
+	}
+	defer headResp.Body.Close()
+	
+	// Ambil Content-Length dari HEAD
+	contentLength := headResp.ContentLength
+	log.Printf("📊 HEAD response - Content-Length: %d bytes (%.2f MB)", contentLength, float64(contentLength)/(1024*1024))
+	
+	// STEP 2: GET request untuk streaming
+	req, err := http.NewRequest("GET", targetURL, nil)
+	if err != nil {
+		http.Error(w, "Failed to create request", http.StatusInternalServerError)
+		return
+	}
+	
+	// Set headers lengkap (sama seperti sebelumnya)
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
+	req.Header.Set("Referer", targetURL)
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Accept-Language", "en-GB,en-US;q=0.9,en;q=0.8")
+	req.Header.Set("Accept-Encoding", "gzip, deflate, br")
+	req.Header.Set("Cache-Control", "no-cache")
+	req.Header.Set("Pragma", "no-cache")
+	req.Header.Set("Sec-Fetch-Dest", "video")
+	req.Header.Set("Sec-Fetch-Mode", "no-cors")
+	req.Header.Set("Sec-Fetch-Site", "same-origin")
+	req.Header.Set("Connection", "keep-alive")
+	
+	// Forward Range header jika ada
+	if rangeHeader := r.Header.Get("Range"); rangeHeader != "" {
+		req.Header.Set("Range", rangeHeader)
+	}
+	
+	// Eksekusi GET request
+	resp, err := client.Do(req)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Download failed: %v", err), http.StatusInternalServerError)
+		log.Printf("❌ Error: %v", err)
+		return
+	}
+	defer resp.Body.Close()
+	
+	// Cek status code
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
+		http.Error(w, fmt.Sprintf("Status: %d", resp.StatusCode), resp.StatusCode)
+		log.Printf("❌ Status: %d", resp.StatusCode)
+		return
+	}
+	
+	log.Printf("✅ Connected, Status: %d", resp.StatusCode)
+	
+	// Set header untuk download
+	w.Header().Set("Content-Type", "video/mp4")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	
+	// Gunakan Content-Length dari HEAD (lebih akurat)
+	if contentLength > 0 {
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", contentLength))
+	} else if resp.ContentLength > 0 {
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", resp.ContentLength))
+	}
+	
+	// Forward header lainnya
+	if resp.Header.Get("Accept-Ranges") != "" {
+		w.Header().Set("Accept-Ranges", resp.Header.Get("Accept-Ranges"))
+	}
+	if resp.Header.Get("Content-Range") != "" {
+		w.Header().Set("Content-Range", resp.Header.Get("Content-Range"))
+	}
+	
+	// Set status code
+	w.WriteHeader(resp.StatusCode)
+	
+	// STREAMING: Kirim langsung
+	buf := make([]byte, 64*1024) // 64KB buffer (lebih besar)
+	written, err := io.CopyBuffer(w, resp.Body, buf)
+	if err != nil {
+		log.Printf("❌ Error streaming: %v", err)
+		return
+	}
+	
+	log.Printf("✅ Stream complete: %s (%.2f MB)", filename, float64(written)/(1024*1024))
+}
 
-    // ============ SET RESPONSE HEADERS ============
-    // CORS headers (already set above)
-    
-    // Content Type untuk video
-    contentType := resp.Header.Get("Content-Type")
-    if contentType == "" || !strings.Contains(contentType, "video") {
-        contentType = "video/mp4"
-    }
-    w.Header().Set("Content-Type", contentType)
-    
-    // Support range requests (streaming & seeking)
-    w.Header().Set("Accept-Ranges", "bytes")
-    
-    // Copy Content-Length jika ada
-    if resp.Header.Get("Content-Length") != "" {
-        w.Header().Set("Content-Length", resp.Header.Get("Content-Length"))
-    }
-    
-    // Set Content-Disposition berdasarkan parameter type
-    filename := videoId
-    if videoType == "mp4" {
-        filename = videoId + ".mp4"
-    }
-    // Gunakan attachment agar bisa di-download oleh remote upload
-    w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
-    
-    // Cache control untuk performance
-    w.Header().Set("Cache-Control", "public, max-age=86400")
-    
-    // Support untuk Doodstream & platform sejenis
-    w.Header().Set("X-Content-Type-Options", "nosniff")
-    w.Header().Set("X-Frame-Options", "SAMEORIGIN")
-    
-    // ============ KIRIM RESPONSE ============
-    // Copy status code
-    w.WriteHeader(resp.StatusCode)
-    
-    // Copy body dengan buffering untuk performance
-    buffer := make([]byte, 32*1024) // 32KB buffer
-    io.CopyBuffer(w, resp.Body, buffer)
-    
-    log.Printf("✅ Stream completed for: %s", videoId)
+// Fallback: Proxy streaming tanpa HEAD (untuk backup)
+func downloadProxyStream(w http.ResponseWriter, r *http.Request, targetURL string) {
+	filename := path.Base(targetURL)
+	if !strings.HasSuffix(filename, ".mp4") {
+		filename = "video.mp4"
+	}
+	
+	log.Printf("📥 Streaming (fallback): %s", targetURL)
+	
+	req, err := http.NewRequest("GET", targetURL, nil)
+	if err != nil {
+		http.Error(w, "Failed to create request", http.StatusInternalServerError)
+		return
+	}
+	
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
+	req.Header.Set("Referer", targetURL)
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Accept-Language", "en-GB,en-US;q=0.9,en;q=0.8")
+	req.Header.Set("Accept-Encoding", "gzip, deflate, br")
+	req.Header.Set("Cache-Control", "no-cache")
+	req.Header.Set("Pragma", "no-cache")
+	req.Header.Set("Sec-Fetch-Dest", "video")
+	req.Header.Set("Sec-Fetch-Mode", "no-cors")
+	req.Header.Set("Sec-Fetch-Site", "same-origin")
+	req.Header.Set("Connection", "keep-alive")
+	
+	if rangeHeader := r.Header.Get("Range"); rangeHeader != "" {
+		req.Header.Set("Range", rangeHeader)
+	}
+	
+	client := &http.Client{
+		Timeout: 15 * time.Minute,
+		Transport: &http.Transport{
+			MaxIdleConns:        100,
+			MaxIdleConnsPerHost: 100,
+			IdleConnTimeout:     90 * time.Second,
+			DisableCompression:  false,
+			ResponseHeaderTimeout: 30 * time.Second,
+		},
+	}
+	
+	resp, err := client.Do(req)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Download failed: %v", err), http.StatusInternalServerError)
+		log.Printf("❌ Error: %v", err)
+		return
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
+		http.Error(w, fmt.Sprintf("Status: %d", resp.StatusCode), resp.StatusCode)
+		log.Printf("❌ Status: %d", resp.StatusCode)
+		return
+	}
+	
+	w.Header().Set("Content-Type", "video/mp4")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	
+	if resp.ContentLength > 0 {
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", resp.ContentLength))
+	}
+	if resp.Header.Get("Accept-Ranges") != "" {
+		w.Header().Set("Accept-Ranges", resp.Header.Get("Accept-Ranges"))
+	}
+	if resp.Header.Get("Content-Range") != "" {
+		w.Header().Set("Content-Range", resp.Header.Get("Content-Range"))
+	}
+	
+	w.WriteHeader(resp.StatusCode)
+	
+	buf := make([]byte, 64*1024)
+	written, err := io.CopyBuffer(w, resp.Body, buf)
+	if err != nil {
+		log.Printf("❌ Error streaming: %v", err)
+		return
+	}
+	
+	log.Printf("✅ Stream complete (fallback): %s (%.2f MB)", filename, float64(written)/(1024*1024))
 }