PureBasic

Bonjour à vous (ça faisait longtemps =) ) !

Aujourd'hui j'essaye de sniffer les données qui transitent sur mon PC. Pour cela j'ai réadapté un code trouvé ici: http://www.purebasic.fr/english/viewtop ... it=sniffer . Mais voilà, problème il y a ...

Il se trouve que pour sniffer de simples pages web, il n'y a aucun problème. Le problème survient quand il y a un gros débit de données à sniffer (comme pour une musique ou une video). En effet, le traitement des données prend beaucoup trop de temps et je perds des paquets en cours de route. Pour palier a ce problème, j'ai conçu 2 threads: l'un s'occupant seulement de récupérer les données et de les mettre dans une file et le deuxième qui se charge de traiter les données de la file lorsqu'il y en a. Cette technique a plutot bien marché puisque je perds moins de données mais ... j'ai toujours des pertes ... Et je ne sais pas comment régler cela.

Je vous laisse un code. Pour le tester, il faut compiler avec les droits d'administrateur, se rendre sur le site de grooveshark (http://grooveshark.com) et charger un titre. Normalement le programme est censé enregistrer le titre (avec pour nom gdxxxxx) dans le dossier de l’exécutable. Le problème, c'est qu'il manque certaines données (ca s'entend d'ailleurs ...)

Code : Tout sélectionner

#BufferSize = 4096
#WSA_VER = $202
#SIO_RCVALL=$98000001

Structure IpHeader
  IhlVersion.b
  typeOfService.b
  totalLength.w
  ID.w
  flagOffset.b
  fragOffset.b
  timeToLive.b
  protocol.b
  checksum.w
  source.l
  destination.l
EndStructure

Structure TcpHeader
  portSource.w
  portDestination.w
  seqNum.l
  ackNum.l
  dataOffset.b
  flags.a
  window.w
  checksum.w
  urgentPointer.w
EndStructure

Structure PortToFile
  file.i
  port.l
  received.i
EndStructure

Structure Memory
  buffer.i
  size.l
EndStructure

Structure ProcessData
  List dataQueue.Memory()
  mutex.i
  semaphore.i
EndStructure

Procedure sniff(*processFunction)
  Protected ip.i, wsaData.WSADATA, sock.i, sin.SOCKADDR_IN, promiscuous_mode.l, size.l, mutex.i, semaphore.i, processData.ProcessData
  promiscuous_mode = 1
  
  ;ip du client
  ExamineIPAddresses()
  ip = NextIPAddress()
  
  If WSAStartup_(#WSA_VER, @wsaData) And *processFunction
    WSACleanup_()
    ProcedureReturn 0
  EndIf
  
  ;creation du socket
  sock = SOCKET_(#AF_INET, #SOCK_RAW, #IPPROTO_IP)
  If sock = #INVALID_SOCKET
    WSACleanup_()
    ProcedureReturn 0
  EndIf
  sin\sin_family = #AF_INET 
  sin\sin_addr = ip
  
  ;mode sniffing
  If bind_(sock, @sin, SizeOf(SOCKADDR_IN))
    WSACleanup_()
    ProcedureReturn 0
  EndIf
  If ioctlsocket_(sock, #SIO_RCVALL, @promiscuous_mode)
    WSACleanup_()
    ProcedureReturn 0
  EndIf
  
  mutex = CreateMutex()
  semaphore = CreateSemaphore()
  processData\mutex = mutex
  processData\semaphore = semaphore
  CreateThread(*processFunction, @processData)
  
  *buffer = AllocateMemory(#BufferSize) ;allocation de la memoire de reception 
  Repeat
    size = recv_(sock, *buffer, #BufferSize, 0)
    If size > 40 ;en-tete TCP/IP complet
      ;Ajout des données à la file
      LockMutex(mutex)
      LastElement(processData\dataQueue())
      AddElement(processData\dataQueue())
      processData\dataQueue()\buffer = *buffer
      processData\dataQueue()\size = size
      UnlockMutex(mutex)
      SignalSemaphore(semaphore) ;on envoi un signal à l'autre thread pour qu'il traite les données
      
      *buffer = AllocateMemory(#BufferSize) ;on alloue une nouvelle zone de mémoire (l'ancienne étant dans la file, il ne faut pas la remplacer)
    EndIf
    
  ForEver
  
  FreeMutex(mutex)
  FreeSemaphore(semaphore)
EndProcedure

Procedure processData(*processData.ProcessData)
  Protected save.i, httpHeader.s, file.i, *buffer, *datas, size.l, dataSize.i, ipData.IpHeader, tcpData.TcpHeader
  Static i.i, j
  Static NewList files.PortToFile() ;liste contenant la liste associant les ports à ecouter et les fichiers de sauvegarde
  
  Repeat
    WaitSemaphore(*processData\semaphore) ;attente d'un traitement
    
    ;récupération des infos de la file (threadsafe)
    LockMutex(*processData\mutex)
    FirstElement(*processData\dataQueue())
    *buffer = *processData\dataQueue()\buffer
    size = *processData\dataQueue()\size
    DeleteElement(*processData\dataQueue())
    UnlockMutex(*processData\mutex)
    
    ;séparation des données
    CopyMemory(*buffer, @ipData, SizeOf(IpHeader))
    CopyMemory(*buffer+SizeOf(IpHeader), @tcpData, SizeOf(TcpHeader))
    dataSize = size - SizeOf(IpHeader) - SizeOf(TcpHeader)
    *datas = AllocateMemory(dataSize)
    CopyMemory(*buffer+SizeOf(IpHeader)+SizeOf(TcpHeader), *datas, dataSize)
    FreeMemory(*buffer) ;on libere la memoire allouée par le processus de sniff
    
    ;on regarde si le paquet doit etre enregistré ou non
    save = 0
    ForEach files()
      If files()\port = tcpData\portSource Or files()\port = tcpData\portDestination
        save = @files()
        Break
      EndIf
    Next
    
    ;ce paquet nous interesse
    If save
      ChangeCurrentElement(files(), save)
      
      If files()\port = tcpData\portDestination ;paquet en reception: il doit etre enregistré
        test + 1
        WriteData(files()\file, *datas, dataSize)
      EndIf
      
      If tcpData\flags & 1 ;signal FIN
        CloseFile(files()\file)
        DeleteElement(files())
        Debug "Fin du download"
      EndIf
    
    Else ;le paquet n'est pas dans la liste
      httpHeader = PeekS(*datas, dataSize)
  
      ;Ce paquet provient de grooveshark
      If Left(httpHeader, Len("POST /stream.php HTTP/1.1")) = "POST /stream.php HTTP/1.1" And FindString(httpHeader, "grooveshark.com", 1)
        file = CreateFile(#PB_Any, "gd"+Str(ElapsedMilliseconds()))
        If file
          Debug "Ajout d'un fichier"
          AddElement(files()) ;ajout du port à écouter
          files()\file = file
          files()\port = tcpData\portSource
        EndIf
      EndIf
    EndIf
    
    FreeMemory(*datas) ;liberation de la memoire allouée pour stocker les données
  ForEver
EndProcedure

InitNetwork()
thread = CreateThread(@sniff(), @processData())
Debug ThreadPriority(thread, 31)
OpenConsole()
Repeat 
  Input()
ForEver

Voilà donc si quelqu'un comprend pourquoi je perds des paquets, je suis preneur de toute aide . Merci

Bon à priori je suis alone sur ce coup ... :/
Merci quand même à ceux qui sont passé par là

C'est intéressant mais je peux pas t'aider.
Désolé.

Le reseau....c'est super interessant..j'y connais vraiment rien, mais j'adore ça
Mais y'a pas trop de monde qui touche vraiment dans ce domaine ici

En fait moi je compte souvent sur toi, CLS, BOMBSEB, et quelques autres trop peu nombreux et c'est dommage.

Pour moi sniffer n'appelle pas immediatement dans mon esprit un travail WEB...alors t'imagine

Je te souhaite de trouver, ou qu'un copain qui sniffe autre chose que de la farine, puisse te donner un coup de main

C'est un sujet qui m'intéresse beaucoup mais mes connaissances très limitées dans ce domaine m'empêchent de t'aider. Désolé.

Salut,

je viens de tester ton code, il y a effectivement un problème.

A première vue, 2 choses me paraissent étranges :
1. la fonction de process des données qui est passée au thread d'écoute : quel est l'intérêt ? Pourquoi ne pas lancer les 2 threads dès le début en les synchronisant avec des sémaphores (comme tu l'as fait) ?
2. en réseau il n'est jamais garanti que les packets reçus soient correctement ordonnancés. Dans les packet TCP il existe un flag qui te donne la position des données dans le flux afin de les réordonnancer correctement.

Je vais essayer de faire un petit correctif si j'ai le temps.
++

Cls a écrit : 1. la fonction de process des données qui est passée au thread d'écoute : quel est l'intérêt ? Pourquoi ne pas lancer les 2 threads dès le début en les synchronisant avec des sémaphores (comme tu l'as fait) ?

Ben je ne sais pas trop en fait (c'etait pour que le 1er thread ait du "controle" sur le second mais je m'en sert pas vraiment ^^) ^^ De toutes facons ca ne change pas grand chose les deux threads sont lancés quoi qu'il arrive.

Cls a écrit : 2. en réseau il n'est jamais garanti que les packets reçus soient correctement ordonnancés. Dans les packet TCP il existe un flag qui te donne la position des données dans le flux afin de les réordonnancer correctement.

Oui je le sais , mais bon là c'etait juste un petit test, à la limite je m'en fiche de savoir si les données sont dans l'ordre, c'est juste pour voir si j'arrive à tous les récupérer (ce qui n'est pas le cas ...).

En tout cas merci de ton aide =)

Je poste un code, il ne résout pas le problème mais comme je ne suis pas sûr de pouvoir travailler dessus aujourd'hui, ça sera fait.

J'ai simplement supprimer le thread de process et filtré les données dans une fonction séparée. Le fichier reçu est de l'ordre de 500ko pour une chanson de 3mn ce qui est plutôt cohérent pour du streaming. Cela étant, le fichier ne fonctionne pas.

Les chansons sont-elles cryptées ou compressées ? Affaire à suivre..

Code : Tout sélectionner



; Sniff un fichier grooveshark

; Structures
; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Structure IpHeader
  version.a
  tos.a
  totalLength.w
  ID.w
  flagOffset.w
  ttl.a
  protocol.a
  checkSum.w
  source.l
  destination.l
EndStructure

Structure TcpHeader
  sourcePort.w
  destinationPort.w
  sequenceNumber.l
  acknowledgeNumber.l
  dataOffset.a
  flags.a
  windows.w
  checkSum.w
  pointer.w
EndStructure

Structure UdpHeader
  sourcePort.w
  destinationPort.w
  length.w
  checkSum.w
EndStructure


; Type du protocole dans l'entête IP
#PROTOCOL_TCP = 6
#PROTOCOL_UDP = 17

#BUFFER_SIZE = 4096


#SIO_RCVALL = $98000001

; Données passées au thread LISTEN
Structure THREAD
  ip.i  
EndStructure


; Données passées au thread PACKET
Structure PACKET
  ip.i  
  protocol.a
  ipsource.i
  ipdestination.i
  portsource.w
  portdestination.w
  tcpheader.TcpHeader
  ipheader.IpHeader
  datas.s{#BUFFER_SIZE}
EndStructure


; Association port TCP <=> fichier sur disque 
Structure PortToFile
  port.l
  file.i
  ipserver.i
  content_length.i
  current_length.i
EndStructure


; Décrit une zone mémoire
Structure Memory
  *buffer.i
  size.i
EndStructure





; Stocke les threads
Global NewMap Thread.i()


; Associe les fichiers à écouter et les ports TCP
Global NewList Files.PortToFile()


; Données à traiter
Global NewList QueuedDatas.Memory()


; Protocoles
Global NewMap ProtocolName.s()
ProtocolName(Str(#PROTOCOL_TCP)) = "TCP"
ProtocolName(Str(#PROTOCOL_UDP)) = "UDP"


; Procédures et fonctions
; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

; Procédure permettant de filtrer les packets de données reçus
Procedure Filters(*packet.PACKET)
  
  ; Pré filtre : requête de début de téléchargement vers grooveshark
  ;              serveur correspondant à groovechark
  ; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  cool_packet.b = #False;
  
  ; Laisse passer la requête HTTP Post de téléchargement
  If FindString(*packet\datas, "POST /stream.php HTTP/1.1", 1) And FindString(*packet\datas, "grooveshark.com", 1)
    cool_packet = #True
  EndIf
  
  ; Laisse passer les requêtes en provenance des serveurs Grooveshark
  ForEach Files()
    If Files()\ipserver = *packet\ipsource
      cool_packet = #True
      Break
    EndIf
  Next
  
  ; Ce packet nous intéresse ou pas ?
  If cool_packet = #False
    
    ; Nettoie la mémoire et quitte la fonction
    ClearStructure(*packet, PACKET)
    FreeMemory(*packet)
    
    ProcedureReturn #False 
  EndIf
    
  
  
  ; Intercepte la requête de demande de téléchargement de fichier
  ; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  If FindString(*packet\datas, "POST /stream.php HTTP/1.1", 1) And FindString(*packet\datas, "grooveshark.com", 1)
    
    file = CreateFile(#PB_Any, "D:\test.mp3")
    If file
      
      Debug "________________________________________________________"
      Debug "Ajout d'un fichier : " + *packet\datas
      Debug "¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯"
      Debug "Recu sur le port local : " + Str(*packet\portsource)
      Debug IPString(*packet\ipsource) + ":" + Str(*packet\portsource) + " => " + IPString(*packet\ipdestination) + ":" + Str(*packet\portdestination) + " >>> " + ProtocolName(Str(*packet\protocol))
      Debug ""
      
      AddElement(Files()) ;ajout du port à écouter
      Files()\file = file
      Files()\port = *packet\portsource ; Stocke le port d'envoi en local car c'est sur celui-ci que le serveur va envoyer les données
      Files()\ipserver = *packet\ipdestination ; Stocke le serveur GS qui va nous envoyer le fichier
    EndIf  
    
    
  Else  
    
    ; Intercepte la requête de réponse du serveur afin de connaitre la taille totale du fichier
    ; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
    If FindString(*packet\datas, "audio/mpeg", 1) And FindString(*packet\datas, "Content-Length", 1)
      
      Debug "________________________________________________________"
      Debug "Taille du fichier : " + *packet\datas
      Debug "¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯"
      Debug ""
      
      content_length_start.i = FindString(*packet\datas, "Content-Length", 1) + Len("Content-Length") + 2
      content_length_str.s = Mid(*packet\datas, content_length_start, FindString(*packet\datas, #CRLF$, content_length_start) - content_length_start)
      
      Files()\content_length = Val(content_length_str)
      
      
    Else 
      
      ; Intercepte les données du fichier
      ; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
      
      FileSeek(Files()\file, Lof(Files()\file))
      WriteData(Files()\file, @*packet\datas, Len(*packet\datas))
      
      ; Incrémente la taille écrite sur disque
      Files()\current_length + Len(*packet\datas)

      
    EndIf 
    
    
  EndIf
  
  
  ; Vérifie si le fichier est complet
  ; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  If Files()\content_length > 0 And Files()\current_length = Files()\content_length
    
    Debug "________________________________________________________"
    Debug "Fichier reçu ! (taille : " + Str(Files()\current_length) + ")"
    Debug "¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯"
    Debug ""
    
    
    CloseFile(Files()\file)
    DeleteElement(Files())

  EndIf
  
  
  ; Libère la mémoire
  ClearStructure(*packet, PACKET)
  FreeMemory(*packet)
    
  
EndProcedure


Procedure Listen(*param.THREAD)
  Protected ipNet.l, wsa.WSADATA, socket.l, sin.SOCKADDR_IN, promiscuous_mode.l=1, *buffer, ip.IPHeader, tcp.TcpHeader, udp.UdpHeader, dat.s
  Protected received.i, sourcePort.u, destinationPort.u, ipSource.s, ipDestination.s
  
  ; Affecte l'IP 
  ipNet = *param\ip
  
  
  ; Libère la mémoire
  ClearStructure(*param, THREAD)
  FreeMemory(*param)
  
  Debug "Démarrage d'une écoute sur l'IP : " + IPString(ipNet)
  
  
  ; Initialise les sockets
  If WSAStartup_($202, @wsa)
    Debug "Impossible d'acceder au réseau"
    ProcedureReturn 0
  EndIf
  
  socket = SOCKET_(#AF_INET, #SOCK_RAW, #IPPROTO_IP)
  If socket = #INVALID_SOCKET
    WSACleanup_()
    Debug "Impossible de créer le socket"
    ProcedureReturn 0
  EndIf
  
  sin\sin_addr = ipNet
  sin\sin_family = #AF_INET
  If bind_(socket, @sin, SizeOf(SOCKADDR_IN))
    WSACleanup_()
    Debug "Ecoute impossible"
    ProcedureReturn 0
  EndIf
  
  If ioctlsocket_(socket, #SIO_RCVALL, @promiscuous_mode)
    WSACleanup_()
    Debug "Impossible de passer en mode promiscuous"
    ProcedureReturn 0
  EndIf
  
  
  ;Buffer 
  *buffer = AllocateMemory(#BUFFER_SIZE)
  
  Repeat
    
    ; Récupère des données
    received = recv_(socket, *buffer, #BUFFER_SIZE, 0)
    
    If received > 0
            
      ; Entête IP
      CopyMemory(*buffer, @ip, SizeOf(IpHeader))
      
      ; Adresse source et destination
      ipSource = IPString(ip\source)
      ipDestination = IPString(ip\destination)
      
      
      Select ip\protocol
        Case #PROTOCOL_TCP
        
          ; Entête TCP
          CopyMemory(*buffer + SizeOf(IpHeader), @tcp, SizeOf(TcpHeader))
        
          ; Données
          dat = Space(received - SizeOf(IpHeader) - SizeOf(TcpHeader))
          CopyMemory(*buffer + SizeOf(IpHeader) + SizeOf(TcpHeader), @dat, Len(dat))
          
          ; Ports
          sourcePort = ntohs_(tcp\sourcePort)
          destinationPort = ntohs_(tcp\destinationPort)
          
          
        Case #PROTOCOL_UDP
          
          ; Entête UDP
          CopyMemory(*buffer + SizeOf(IpHeader), @udp, SizeOf(UdpHeader))
          
          ; Données
          dat = Space(received - SizeOf(IpHeader) - SizeOf(UdpHeader))
          CopyMemory(*buffer + SizeOf(IpHeader) + SizeOf(UdpHeader), @dat, Len(dat))
          
          ; Ports
          sourcePort = ntohs_(tcp\sourcePort)
          destinationPort = ntohs_(tcp\destinationPort)
          
          
        Default  
          
      EndSelect
      
      
      ; Appel à la fonction d'analyse du packet
      *filter.PACKET = AllocateMemory(SizeOf(PACKET))
      *filter\ip = ipNet
      *filter\protocol = ip\protocol
      *filter\ipdestination = ip\destination
      *filter\ipsource = ip\source
      *filter\portdestination = destinationPort
      *filter\portsource = sourcePort
      
      ; Redondance mais pas le temps de refaire proprement ;)
      *filter\tcpheader = tcp
      *filter\ipheader = ip
      
      ; Copie les données
      CopyMemory(@dat, @*filter\datas, Len(dat))

      ; Filtre les packets à traiter
      Filters(*filter)
      
      
      
    EndIf
    
  ForEver
  
  closesocket_(socket)
  WSACleanup_()
  
  ProcedureReturn 0
EndProcedure





;- Début du programme
; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

; Libraires requises
If Not InitNetwork() 
  End
EndIf


; Démarre la boucle de traitement des données
;CreateThread(@Process(), #True)


; Pour chaque interface réseau, on lance un thread
ExamineIPAddresses()
Repeat 
  
  ip_address.i = NextIPAddress()  
  
  If ip_address
    
    ; Paramètres passés au thread
    *param.THREAD = AllocateMemory(SizeOf(THREAD))
    *param\ip = ip_address
    
    Thread(IPString(ip_address)) = CreateThread(@Listen(), *param)
    Break ; ne lance qu'un seul thread
    
  EndIf
Until ip_address = 0



; Boucle d'attente pendant que les threads sont en cours
Repeat
  
  ; On sort si aucun thread n'est encore en route
  thread_running.b = #False
  ForEach Thread()
    If IsThread(Thread())
      thread_running = #True
    EndIf
  Next
  
  ; Test d'arrêt
  If Not thread_running
    Break
  EndIf
  
  ; On ne charge pas le processeur
  Delay(10)  
  
ForEver
  
End

Non les fichiers ne sont pas cryptés. J'ai testé avec le logiciel Wireshark et les sons font entre 3 et 5 Mo ! Ce sont des MP3 classiques en fait. (D'ailleurs le Content-Length de l'en-tete HTTP indique bien la taille à recevoir). Avec mon code j'arrive grosso modo à récupérer 80 à 90 % de la totalité des données.

Et je ne comprends pas du tout pourquoi j'ai des "fuites" de données :/
Faudra que je me replonge plus sérieusement dans le code.

Humm c'est bizarre cette affaire, je vais fouiller dans mes codes, voir si j'ai pas quelque chose du genre.

Dans le cas d'une connexion TCP, la fonction recv attend que des données arrivent et les gardent en file d'attente jusqu'à ce qu'elles soient traitées. Je ne vois pas comment le programme pourrait oublier des packets.

http://msdn.microsoft.com/en-us/library ... s.85).aspx

Je continue à fouiller, ça m'intéresse de comprendre ce qu'il se passe.

Je continue de chercher également mais je suis à court d'idée ...

EDIT: Grooveshark m'envoie des paquets de 1452 octets (en enlevant les en-tetes TCP et IP). Or à chaque fois, il me manque une quantité de données qui est un multiple de 1452. Donc c'est bien des pertes de paquets entiers. (Je sais pas si c'est utile mais bon j'indique tout ce que je trouve).
J'ai l'impression que la file de recv est dépassée lors d'un trop grand débit de données ... ca serait pas mal de pouvoir augmenter cette file.

Bonsoir,

Juste une chose ; une trame ethernet ne peut contenir que 1500 bit maximum de data. Cela voudrait dire que vous attrapez bien la première trame mais pas les autres. Là je parle au niveau de la première couche OSI : Physique.
Pour le reste je ne suis pas callé ,) Et beaucoup trop de travail pour pouvoir me pencher avec vous sur ce problème.
Bon courage.

Cordialement.

Atlante

PureBasic

Probleme de sniffing

Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing

Re: Probleme de sniffing