lcrzo_sock(3)

NAME
lcrzo_sock - bibliotheque lcrzo : clients et servers

CONTENU
/*    Bibliotheque reseau de Laurent Constantin (lcrzo)
                 Module lcrzo_sock
  Les fonctions presentes dans ce module permettent de creer des
  clients ou des serveurs reels, ainsi que virtuels.
*/
/*-------------------------------------------------------------*/
/* definition d'un lcrzo_sock. Vous ne devriez pas utiliser
   directement ses champs. */
typedef struct
{ lcrzo_int16 type;
  int socknum;
  lcrzo_process sniffprocess;
  lcrzo_process spoofprocess;
  lcrzo_bool sniffprocesshasended;
  lcrzo_bool spoofprocesshasended;
  int sniffprocessreturnedvalue;
  int spoofprocessreturnedvalue;
  lcrzo_ipc ipcsniff;
  lcrzo_ipc ipcspoof;
  lcrzo_ipc ipcsniffend;
  lcrzo_ipc ipcspoofend;
  lcrzo_ipc ipcoptions;
  lcrzo_ipc ipccontrol1;
  lcrzo_ipc ipccontrol2;
  lcrzo_ipopt ipopt;
  lcrzo_uint8 ipoptsize;
  lcrzo_device here_device;
  lcrzo_etha here_etha;
  lcrzo_ipl here_ipl;
  lcrzo_uint16 here_port;
  lcrzo_etha there_etha;
  lcrzo_ipl there_ipl;
  lcrzo_uint16 there_port;
  lcrzo_data storeddata;
  lcrzo_int32 storeddatasize;
  lcrzo_bool dataend;
  lcrzo_bool udpcanwrite;
  lcrzo_int16 tcpstate;
} lcrzo_sock;
/*-------------------------------------------------------------*/
/***************************************************************
 * Note sur "reel" et "virtuel" :                              *
 *                                                             *
 * Les clients/serveurs reels emploient les adresses ip et     *
 * ethernet de la machine courante (ce sont les sockets        *
 * classiques telles que tout le monde les connait).           *
 *                                                             *
 * Les clients/serveurs virtuels utilisent des adresses        *
 * ip/ethernet spoofees. En quelques mots, prenons l'exemple   *
 * d'un client virtuel tcp :                                   *
 *  - on spoofe un packet syn                                  *
 *  - on sniffe le reseau a la recherche du syn-ack            *
 *  - on spoofe un packet ack pour terminer le handshake       *
 *  - ensuite, on peut lire et ecrire des donnees, comme on le *
 *    ferait avec un client tcp reel (en utilisant le          *
 *    lcrzo_sock)                                              *
 * Cette pile IP virtuelle n'implemente pas de maniere         *
 * rigoureuse les RFC 768 et RFC 793 : ca marche, mais tous    *
 * les cas particuliers ne sont pas traites.                   *
 ***************************************************************/
/*-------------------------------------------------------------*/
/*                          clients UDP                          */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_sock_udpcli_real
   Description :
     Initialise un client udp reel
   Parametre(s) d'entree :
     serveripl : adresse IP du serveur ou se connecter
     serverport : port du serveur ou se connecter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpcli_real(lcrzo_ipl    serveripl,
			   lcrzo_uint16 serverport,
			   lcrzo_sock   *psock);
/* Nom : lcrzo_sock_udpcli_virt
   Description :
     Initialise un client udp virtuel
   Parametre(s) d'entree :
     device : device ou l'on sniffe et spoofe
     clientetha : adresse Ethernet a spoofer
     serveretha : adresse Ethernet du serveur (ou routeur)
     clientipl : adresse IP a spoofer
     serveripl : adresse IP du serveur ou se connecter
     clientport : numero de port local
     serverport : port du serveur ou se connecter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpcli_virt(lcrzo_constdevice device,
			   lcrzo_constetha clientetha,
			   lcrzo_constetha serveretha,
			   lcrzo_ipl clientipl,
			   lcrzo_ipl serveripl,
			   lcrzo_uint16 clientport,
			   lcrzo_uint16 serverport,
			   lcrzo_sock *psock);
/* Nom : lcrzo_sock_udpcli_real2
   Description :
     Initialise un client udp reel
   Parametre(s) d'entree :
     clientipl : adresse IP locale a employer (cette adresse IP
                 doit etre configuree sur la machine).
		 Si 0, la fonction utilise l'adresse par defaut
     serveripl : adresse IP du serveur ou se connecter
     client port : port source a utiliser
                   si 0, la machine choisit un numero disponible
		   et superieur a 1024
     serverport : port du serveur ou se connecter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpcli_real2(lcrzo_ipl    clientipl,
			    lcrzo_ipl    serveripl,
			    lcrzo_uint16 clientport,
			    lcrzo_uint16 serverport,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock   *psock);
/* Nom : lcrzo_sock_udpcli_virt2
   Description :
     Initialise un client udp virtuel
   Parametre(s) d'entree :
     device : device ou l'on sniffe et spoofe
     clientetha : adresse Ethernet a spoofer
     serveretha : adresse Ethernet du serveur (ou routeur)
     clientipl : adresse IP a spoofer
     serveripl : adresse IP du serveur ou se connecter
     clientport : numero de port local
     serverport : port du serveur ou se connecter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpcli_virt2(lcrzo_constdevice device,
			    lcrzo_constetha clientetha,
			    lcrzo_constetha serveretha,
			    lcrzo_ipl clientipl,
			    lcrzo_ipl serveripl,
			    lcrzo_uint16 clientport,
			    lcrzo_uint16 serverport,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock *psock);
/*-------------------------------------------------------------*/
/*                          clients TCP                          */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_sock_tcpcli_real
   Description :
     Initialise un client tcp reel
   Parametre(s) d'entree :
     serveripl : adresse IP du serveur ou se connecter
     serverport : port du serveur ou se connecter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpcli_real(lcrzo_ipl    serveripl,
			   lcrzo_uint16 serverport,
			   lcrzo_sock   *psock);
/* Nom : lcrzo_sock_tcpcli_virt
   Description :
     Initialise un client tcp virtuel
   Parametre(s) d'entree :
     device : device ou l'on sniffe et spoofe
     clientetha : adresse Ethernet a spoofer
     serveretha : adresse Ethernet du serveur (ou routeur)
     clientipl : adresse IP a spoofer
     serveripl : adresse IP du serveur ou se connecter
     clientport : numero de port local
     serverport : port du serveur ou se connecter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpcli_virt(lcrzo_constdevice device,
			   lcrzo_constetha clientetha,
			   lcrzo_constetha serveretha,
			   lcrzo_ipl clientipl,
			   lcrzo_ipl serveripl,
			   lcrzo_uint16 clientport,
			   lcrzo_uint16 serverport,
			   lcrzo_sock *psock);
/* Nom : lcrzo_sock_tcpcli_real2
   Description :
     Initialise un client tcp reel
   Parametre(s) d'entree :
     clientipl : adresse IP locale a employer (cette adresse IP
                 doit etre configuree sur la machine).
		 Si 0, la fonction utilise l'adresse par defaut
     serveripl : adresse IP du serveur ou se connecter
     clientport : port source a utiliser
                  si 0, la machine choisit un numero disponible
		  et superieur a 1024
     serverport : port du serveur ou se connecter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpcli_real2(lcrzo_ipl    clientipl,
			    lcrzo_ipl    serveripl,
			    lcrzo_uint16 clientport,
			    lcrzo_uint16 serverport,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock   *psock);
/* Nom : lcrzo_sock_tcpcli_virt2
   Description :
     Initialise un client tcp virtuel
   Parametre(s) d'entree :
     device : device ou l'on sniffe et spoofe
     clientetha : adresse Ethernet a spoofer
     serveretha : adresse Ethernet du serveur (ou routeur)
     clientipl : adresse IP a spoofer
     serveripl : adresse IP du serveur ou se connecter
     clientport : numero de port local
     serverport : port du serveur ou se connecter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpcli_virt2(lcrzo_constdevice device,
			    lcrzo_constetha clientetha,
			    lcrzo_constetha serveretha,
			    lcrzo_ipl clientipl,
			    lcrzo_ipl serveripl,
			    lcrzo_uint16 clientport,
			    lcrzo_uint16 serverport,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock *psock);
/*-------------------------------------------------------------*/
/*                          serveurs UDP                         */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_sock_udpser_real
   Description :
     Initialise un serveur udp reel
   Parametre(s) d'entree :
     port : port sur lequel ecouter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpser_real(lcrzo_uint16 port,
			   lcrzo_sock *psock);
/* Nom : lcrzo_sock_udpser_virt
   Description :
     Initialise un serveur udp virtuel
   Parametre(s) d'entree :
     device : device sur lequel sniffer et spoofer
     serveretha : adresse Ethernet spoofee sur laquelle on ecoute
     serveripl : adresse IP spoofee sur laquelle on ecoute
     serverport : port sur lequel ecouter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpser_virt(lcrzo_constdevice device,
			   lcrzo_constetha serveretha,
			   lcrzo_ipl serveripl,
			   lcrzo_uint16 serverport,
			   lcrzo_sock *psock);
/* Nom : lcrzo_sock_udpser_real2
   Description :
     Initialise un serveur udp reel
   Parametre(s) d'entree :
     ipl : adresse IP sur laquelle ecouter
     port : port sur lequel ecouter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpser_real2(lcrzo_ipl ipl,
			    lcrzo_uint16 port,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock *psock);
/* Nom : lcrzo_sock_udpser_virt2
   Description :
     Initialise un serveur udp virtuel
   Parametre(s) d'entree :
     device : device sur lequel sniffer et spoofer
     serveretha : adresse Ethernet spoofee sur laquelle on ecoute
     serveripl : adresse IP spoofee sur laquelle on ecoute
     serverport : port sur lequel ecouter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpser_virt2(lcrzo_constdevice device,
			    lcrzo_constetha serveretha,
			    lcrzo_ipl serveripl,
			    lcrzo_uint16 serverport,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock *psock);
/*-------------------------------------------------------------*/
/*                    serveurs UDP multiclients                  */
/*-------------------------------------------------------------*/
/***************************************************************
 * Note sur les serveurs UDP multiclients :                    *
 * On ne peut que lire les donnees envoyees par les clients.   *
 * On ne peut pas ecrire des donnees vers les clients.         *
 ***************************************************************/
/* Nom : lcrzo_sock_udpmulser_real
   Description :
     Initialise un serveur udp reel multiclient
   Parametre(s) d'entree :
     port : port sur lequel ecouter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpmulser_real(lcrzo_uint16 port,
			      lcrzo_sock *psock);
/* Nom : lcrzo_sock_udpmulser_virt
   Description :
     Initialise un serveur udp virtuel multiclients
   Parametre(s) d'entree :
     device : device sur lequel sniffer et spoofer
     serveretha : adresse Ethernet spoofee sur laquelle on ecoute
     serveripl : adresse IP spoofee sur laquelle on ecoute
     serverport : port sur lequel ecouter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpmulser_virt(lcrzo_constdevice device,
			      lcrzo_constetha serveretha,
			      lcrzo_ipl serveripl,
			      lcrzo_uint16 serverport,
			      lcrzo_sock *psock);
/* Nom : lcrzo_sock_udpmulser_real2
   Description :
     Initialise un serveur udp reel multiclient
   Parametre(s) d'entree :
     ipl : adresse IP sur laquelle ecouter
     port : port sur lequel ecouter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_udpmulser_real2(lcrzo_ipl ipl,
			       lcrzo_uint16 port,
			       lcrzo_sock *psock);
/*-------------------------------------------------------------*/
/*                          serveurs TCP                         */
/*-------------------------------------------------------------*/
/***************************************************************
 * Note sur les serveurs TCP :                                 *
 * On ne quitte la fonction que lorsqu'un client s'est         *
 * connecte.                                                   *
 ***************************************************************/
/* Nom : lcrzo_sock_tcpser_real
   Description :
     Initialise un serveur tcp reel
   Parametre(s) d'entree :
     port : port sur lequel ecouter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpser_real(lcrzo_uint16 port,
			   lcrzo_sock *psock);
/* Nom : lcrzo_sock_tcpser_virt
   Description :
     Initialise un serveur tcp virtuel
   Parametre(s) d'entree :
     device : device sur lequel sniffer et spoofer
     serveretha : adresse Ethernet spoofee sur laquelle on ecoute
     serveripl : adresse IP spoofee sur laquelle on ecoute
     serverport : port sur lequel ecouter
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpser_virt(lcrzo_constdevice device,
			   lcrzo_constetha serveretha,
			   lcrzo_ipl serveripl,
			   lcrzo_uint16 serverport,
			   lcrzo_sock *psock);
/* Nom : lcrzo_sock_tcpser_real2
   Description :
     Initialise un serveur tcp reel
   Parametre(s) d'entree :
     ipl : adresse IP sur laquelle ecouter
     port : port sur lequel ecouter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpser_real2(lcrzo_ipl ipl,
			    lcrzo_uint16 port,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock *psock);
/* Nom : lcrzo_sock_tcpser_virt2
   Description :
     Initialise un serveur tcp virtuel
   Parametre(s) d'entree :
     device : device sur lequel sniffer et spoofer
     serveretha : adresse Ethernet spoofee sur laquelle on ecoute
     serveripl : adresse IP spoofee sur laquelle on ecoute
     serverport : port sur lequel ecouter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *psock : lcrzo_sock initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpser_virt2(lcrzo_constdevice device,
			    lcrzo_constetha serveretha,
			    lcrzo_ipl serveripl,
			    lcrzo_uint16 serverport,
			    lcrzo_constipopt ipopt,
			    lcrzo_uint8 ipoptsize,
			    lcrzo_sock *psock);
/*-------------------------------------------------------------*/
/*                    serveusr TCP multiclients                  */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_sock_tcpser_real
   Description :
     Gere un serveur tcp reel multiclient
   Parametre(s) d'entree :
     port : port sur lequel ecouter
     pfunc : adresse memoire de la fonction appelee pour chaque
             client. Lors de
             chaque appel, le premier parametre ('sock') est
             affecte avec le socket courant, et le deuxieme
             parametre ('pinfos') est affecte avec la valeur
             de pinfos ci-dessous.
   Parametre(s) d'entree-sortie :
     pinfos : parametre optionnel (peut mettre NULL) qui sera
              passe en deuxieme parametre de pfunc. Il peut
              servir a envoyer des informations a pfunc.
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpmulser_real(lcrzo_uint16 port,
			      int (*pfunc)(lcrzo_sock *psock,
					   void *pinfos),
			      void *pinfos);
/* Nom : lcrzo_sock_tcpser_real2
   Description :
     Gere un serveur tcp reel multiclient
   Parametre(s) d'entree :
     ipl : adresse IP sur laquelle ecouter
     port : port sur lequel ecouter
     ipopt : options IP a employer
     ipoptsize : taille de ipopt
     pfunc : adresse memoire de la fonction appelee pour chaque
             client. Lors de
             chaque appel, le premier parametre ('sock') est
             affecte avec le socket courant, et le deuxieme
             parametre ('pinfos') est affecte avec la valeur
             de pinfos ci-dessous.
   Parametre(s) d'entree-sortie :
     pinfos : parametre optionnel (peut mettre NULL) qui sera
              passe en deuxieme parametre de pfunc. Il peut
              servir a envoyer des informations a pfunc.
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_tcpmulser_real2(lcrzo_ipl ipl,
			       lcrzo_uint16 port,
			       lcrzo_constipopt ipopt,
			       lcrzo_uint8 ipoptsize,
			       int (*pfunc)(lcrzo_sock *psock,
					    void *pinfos),
			       void *pinfos);
/*-------------------------------------------------------------*/
/*                          options IP                           */
/*-------------------------------------------------------------*/
/* les fonctions suivantes ajoutent des options IP a une
   connexion. Consultez l'aide du module lcrzo_ipopt pour
   connaitre la signification des parametres*/
/* set/get raw options */
int lcrzo_sock_ipopt_set(lcrzo_sock *psock,
			 lcrzo_constipopt ipopt,
			 lcrzo_uint8 ipoptsize);
int lcrzo_sock_ipopt_get(lcrzo_sock *psock,
			 lcrzo_ipopt ipopt,
			 lcrzo_uint8 *pipoptsize);
/* no operation */
int lcrzo_sock_ipopt_noop(lcrzo_sock *psock);
/* loose source routing */
int lcrzo_sock_ipopt_lsrr(lcrzo_sock *psock,
			  lcrzo_ipl ipl1,
			  lcrzo_ipl ipl2,
			  lcrzo_ipl ipl3,
			  lcrzo_ipl ipl4,
			  lcrzo_ipl ipl5,
			  lcrzo_ipl ipl6,
			  lcrzo_ipl ipl7,
			  lcrzo_ipl ipl8,
			  lcrzo_ipl ipl9,
			  lcrzo_int8 numberofsetipl);
/* strict source routing */
int lcrzo_sock_ipopt_ssrr(lcrzo_sock *psock,
			  lcrzo_ipl ipl1,
			  lcrzo_ipl ipl2,
			  lcrzo_ipl ipl3,
			  lcrzo_ipl ipl4,
			  lcrzo_ipl ipl5,
			  lcrzo_ipl ipl6,
			  lcrzo_ipl ipl7,
			  lcrzo_ipl ipl8,
			  lcrzo_ipl ipl9,
			  lcrzo_int8 numberofsetipl);
/* record route */
int lcrzo_sock_ipopt_rr(lcrzo_sock *psock,
			lcrzo_int8 numberofroutestosave);
/* timestamp */
int lcrzo_sock_ipopt_time(lcrzo_sock *psock,
			  lcrzo_int8 numberoftimestamptosave);
int lcrzo_sock_ipopt_timeip(lcrzo_sock *psock,
			    lcrzo_int8 numberoftimestamptosave);
int lcrzo_sock_ipopt_timeipp(lcrzo_sock *psock,
			     lcrzo_ipl ipl1,
			     lcrzo_ipl ipl2,
			     lcrzo_ipl ipl3,
			     lcrzo_ipl ipl4,
			     lcrzo_int8 numberofsetipl);
/*-------------------------------------------------------------*/
/*                       lecture et ecriture                     */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_sock_write
   Description :
     Ecrit des donnees dans un lcrzo_sock.
     Si datasize est trop long, les donnees sont ecrites en plusieurs
     fois (employez lcrzo_sock_write_msg si vous desirez que les
     donnees soient ecrites en une seule fois).
   Parametre(s) d'entree :
     sock : lcrzo_sock ou les donnees sont ecrites
     data : donnees a ecrire
     datasize : taille de data
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_write(lcrzo_sock *psock,
		     lcrzo_constdata data,
		     lcrzo_int32 datasize);
int lcrzo_sock_write_msg(lcrzo_sock *psock,
			 lcrzo_constdata data,
			 lcrzo_int32 datasize);
/* Nom : lcrzo_sock_readm
   Description :
     Lit des donnees depuis un lcrzo_sock
   Parametre(s) d'entree :
     sock : lcrzo_sock ou les donnees sont lues
     *pmaxwaitingtime : temps maximum d'attente (peut etre un
                        lcrzo_time, LCRZO_WAIT_NODELAY ou
                        LCRZO_WAIT_INFINITE)
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pdataout : pointeur qui sera alloue (la memoire
                 devra etre liberee par l'utilisateur
                 avec 'free(*pdataout)').
                 Cette memoire allouee recevra les donnees lues
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKTEMPDATAEND : la fonction n'a pas recu de donnees
                               avant pmaxwaitingtime, donc on
                               retourne sans donnees.
*/
int lcrzo_sock_readm(lcrzo_sock *psock,
  		     lcrzo_time *pmaxwaitingtime,
		     lcrzo_data *pdataout,
		     lcrzo_int32 *pdataoutsize);
/* Nom : lcrzo_sock_readm_fixed
   Description :
     Lit des donnees de taille constante depuis un lcrzo_sock.
   Parametre(s) d'entree :
     sock : lcrzo_sock ou les donnees sont lues
     *pmaxwaitingtime : temps maximum d'attente (peut etre un
                        lcrzo_time, LCRZO_WAIT_NODELAY ou
                        LCRZO_WAIT_INFINITE)
     datasizetoread : taille des donnees a lire
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pdataout : pointeur qui sera alloue (la memoire
                 devra etre liberee par l'utilisateur
                 avec 'free(*pdataout)').
                 Cette memoire allouee recevra les donnees lues
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKTEMPDATAEND : la fonction n'a pas recu de donnees
                               avant pmaxwaitingtime, donc on
                               retourne sans donnees.
*/
int lcrzo_sock_readm_fixed(lcrzo_sock *psock,
    		           lcrzo_time *pmaxwaitingtime,
			   lcrzo_int32 datasizetoread,
			   lcrzo_data *pdataout);
/* Nom : lcrzo_sock_readm_line
   Description :
     Lit des donnees depuis un lcrzo_sock. On s'arrete de lire
     au premier '\r' ou '\n' (qui n'est pas stocke dans
     *pdataout).
   Parametre(s) d'entree :
     sock : lcrzo_sock ou les donnees sont lues
     *pmaxwaitingtime : temps maximum d'attente (peut etre un
                        lcrzo_time, LCRZO_WAIT_NODELAY ou
                        LCRZO_WAIT_INFINITE)
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pdataout : pointeur qui sera alloue (la memoire
                 devra etre liberee par l'utilisateur
                 avec 'free(*pdataout)').
                 Cette memoire allouee recevra les donnees lues
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKTEMPDATAEND : la fonction n'a pas recu de donnees
                               avant pmaxwaitingtime, donc on
                               retourne sans donnees.
*/
int lcrzo_sock_readm_line(lcrzo_sock *psock,
			  lcrzo_time *pmaxwaitingtime,
			  lcrzo_data *pdataout,
			  lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/*                           fermeture                           */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_sock_close
   Description :
     Ferme un lcrzo_sock
   Parametre(s) d'entree :
     sock : lcrzo_sock a fermer
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_sock_close(lcrzo_sock *psock);
/*-------------------------------------------------------------*/
/*                          informations                         */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_sock_get_infos
   Description :
     Obtient les informations d'un lcrzo_sock
   Parametre(s) d'entree :
     sock : lcrzo_sock sur lequel obtenir des informations
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     here_device : device local
     here_etha : adresse Ethernet locale
     *phere_ipl : adresse IP locale
     *phere_port : port local
     there_etha : adresse Ethernet distante
     *pthere_ipl : adresse IP distante
     *pthere_port : port distant
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
   Note : here_device, here_etha et there_etha sont uniquement
          affectes dans les clients/serveurs virtuels.
*/
int lcrzo_sock_get_infos(lcrzo_sock *psock,
			 lcrzo_device here_device,
			 lcrzo_etha here_etha,
			 lcrzo_ipl *phere_ipl,
			 lcrzo_uint16 *phere_port,
			 lcrzo_etha there_etha,
			 lcrzo_ipl *pthere_ipl,
			 lcrzo_uint16 *pthere_port);
/* ecrit ces informations */
int lcrzo_sock_fprint_infos(LCRZOFILE *pf,
			    lcrzo_sock *psock);
/* idem, mais sur stdout */
#define lcrzo_sock_print_infos(a) lcrzo_sock_fprint_infos(stdout, a)
/*-------------------------------------------------------------*/
/*                      reponses virtuelles                      */
/*-------------------------------------------------------------*/
/* Nom : lcrzo_virtual_answer_arp
   Description :
     Repond a une requete ARP
     Si ethpacket contient une requete ARP pour ipl, cette
     fonction spoofe une reponse
   Parametre(s) d'entree :
     ethpacket : paquet a analyser
     ethpacketsize : taille de ethpacket
     device : device sur lequel spoofer les reponses
     etha : adresse Ethernet de ipl
     ipl : adresse IP recherchee
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_virtual_answer_arp(lcrzo_constdata ethpacket,
			     lcrzo_uint32 ethpacketsize,
			     lcrzo_constdevice device,
			     lcrzo_constetha etha,
			     lcrzo_ipl ipl);
/* Nom : lcrzo_virtual_answer_rarp
   Description :
     Repond a une requete RARP
     Si ethpacket contient une requete RARP pour etha, cette
     fonction spoofe une reponse
   Parametre(s) d'entree :
     ethpacket : paquet a analyser
     ethpacketsize : taille de ethpacket
     device : device sur lequel spoofer les reponses
     etha : adresse Ethernet recherchee
     ipl : adresse IP de etha
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_virtual_answer_rarp(lcrzo_constdata ethpacket,
			      lcrzo_uint32 ethpacketsize,
			      lcrzo_constdevice device,
			      lcrzo_constetha etha,
			      lcrzo_ipl ipl);
/* Nom : lcrzo_virtual_answer_ping
   Description :
     Repond a une requete ping (icmp echo).
     Si ethpacket contient une requete ping pour ipl, cette
     fonction spoofe une reponse
   Parametre(s) d'entree :
     ethpacket : paquet a analyser
     ethpacketsize : taille de ethpacket
     device : device sur lequel spoofer les reponses
     etha : adresse Ethernet de ipl
     ipl : adresse IP recherchee
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_virtual_answer_ping(lcrzo_constdata ethpacket,
			      lcrzo_uint32 ethpacketsize,
			      lcrzo_constdevice device,
			      lcrzo_constetha etha,
			      lcrzo_ipl ipl);
/* Nom : lcrzo_virtual_answer_alive
   Description :
     Repond a une requete arp/rarpping.
     Si ethpacket contient une requete arp/rarp/ping
     pour ipl, cette fonction spoofe une reponse
   Parametre(s) d'entree :
     ethpacket : paquet a analyser
     ethpacketsize : taille de ethpacket
     device : device sur lequel spoofer les reponses
     etha : adresse Ethernet de ipl
     ipl : adresse IP recherchee
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_virtual_answer_alive(lcrzo_constdata ethpacket,
			       lcrzo_uint32 ethpacketsize,
			       lcrzo_constdevice device,
			       lcrzo_constetha etha,
			       lcrzo_ipl ipl);

VOIR AUSSI
lcrzo(3), lcrzo_types(3), lcrzo_data(3), lcrzo_string(3), lcrzo_time(3), lcrzo_file(3), lcrzo_address(3), lcrzo_device(3), lcrzo_list(3), lcrzo_process(3), lcrzo_ipc(3), lcrzo_header(3), lcrzo_ipopt(3), lcrzo_tcpopt(3), lcrzo_packet(3), lcrzo_icmp(3), lcrzo_print(3), lcrzo_record(3), lcrzo_conf(3), lcrzo_spoof(3), lcrzo_sniff(3), lcrzo_sock(3), lcrzo_wait(3), lcrzo_global(3), lcrzo_error(3) lcrzo_misc(3),