lcrzo_ipc(3)

NAME
lcrzo_ipc - bibliotheque lcrzo : Inter Processus Communication

CONTENU
/*    Bibliotheque reseau de Laurent Constantin (lcrzo)
                 Module lcrzo_ipc
  Les fonctions presentes dans ce module permettent de communiquer
des donnees entres deux processus.
*/
/************************************************************
 * Note sur les ipc :                                       *
 * Un lcrzo_ipc est utilise pour transmettre des donnees    *
 * entre deux processus.                                    *
 * Par exemple, le premier processus peut ecrire un entier  *
 * dans le "tube", et l'autre processus peut le lire.       *
 ************************************************************/
/*-------------------------------------------------------------*/
/* definition d'un lcrzo_ipc. Vous ne devriez pas utiliser
   directement ses champs. */
typedef struct
{ lcrzo_int16 side;
  int readpipe[2];
  int writepipe[2];
  void *readhandle[2];
  void *writehandle[2];
  lcrzo_bool openforreading;
  lcrzo_bool openforwriting;
  lcrzo_bool dataend;
  lcrzo_data storeddata;
  lcrzo_int32 storeddatasize;
} lcrzo_ipc;
/*-------------------------------------------------------------*/
/* Nom : lcrzo_ipc_init
   Description :
     Initialise un lcrzo_ipc
   Parametre(s) d'entree :
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pipc : lcrzo_ipc initialise
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_ipc_init(lcrzo_ipc *pipc);
/* A est le processus pere, et B le fils */
int lcrzo_ipc_currentprocessissidea(lcrzo_ipc *pipc);
int lcrzo_ipc_currentprocessissideb(lcrzo_ipc *pipc);
/* Nom : lcrzo_ipc_close_xxx
   Description :
     Ferme un lcrzo_ipc.
     Ferme le descripteur de lecture d'un lcrzo_ipc.
     Ferme le descripteur d'ecriture d'un lcrzo_ipc.
   Parametre(s) d'entree :
     ipc : lcrzo_ipc a fermer
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_ipc_close(lcrzo_ipc *pipc);
int lcrzo_ipc_close_read(lcrzo_ipc *pipc);
int lcrzo_ipc_close_write(lcrzo_ipc *pipc);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_ipc_write_uint8
   Description :
     Ecrit un lcrzo_uint8 dans un tube lcrzo_ipc
   Parametre(s) d'entree :
     ipc : lcrzo_ipc ou les donnees sont ecrites
     uint8 : lcrzo_uint8 a ecrire dans ipc
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_ipc_write_uint8(lcrzo_ipc *pipc,
			  lcrzo_uint8 uint8);
/* Nom : lcrzo_ipc_read_uint8
   Description :
     Lit un lcrzo_uint8 depuis un tube lcrzo_ipc
   Parametre(s) d'entree :
     ipc : lcrzo_ipc 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 :
     *puint8 : lcrzo_uint8 lu depuis ipc
   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_ipc_read_uint8(lcrzo_ipc *pipc,
			 lcrzo_time *pmaxwaitingtime,
			 lcrzo_uint8 *puint8);
/* idem, mais travaille sur un lcrzo_uint16 */
int lcrzo_ipc_write_uint16(lcrzo_ipc *pipc,
			   lcrzo_uint16 uint16);
int lcrzo_ipc_read_uint16(lcrzo_ipc *pipc,
			  lcrzo_time *pmaxwaitingtime,
			  lcrzo_uint16 *puint16);
/* idem, mais travaille sur un lcrzo_uint32 */
int lcrzo_ipc_write_uint32(lcrzo_ipc *pipc,
			   lcrzo_uint32 uint32);
int lcrzo_ipc_read_uint32(lcrzo_ipc *pipc,
			  lcrzo_time *pmaxwaitingtime,
			  lcrzo_uint32 *puint32);
/* idem, mais travaille sur un lcrzo_hs */
int lcrzo_ipc_write_hs(lcrzo_ipc *pipc,
		       lcrzo_consths hs);
int lcrzo_ipc_read_hs(lcrzo_ipc *pipc,
		      lcrzo_time *pmaxwaitingtime,
		      lcrzo_hs hs);
/* idem, mais travaille sur un lcrzo_ips */
int lcrzo_ipc_write_ips(lcrzo_ipc *pipc,
			lcrzo_constips ips);
int lcrzo_ipc_read_ips(lcrzo_ipc *pipc,
		       lcrzo_time *pmaxwaitingtime,
		       lcrzo_ips ips);
/* idem, mais travaille sur un lcrzo_ipa */
int lcrzo_ipc_write_ipa(lcrzo_ipc *pipc,
			lcrzo_constipa ipa);
int lcrzo_ipc_read_ipa(lcrzo_ipc *pipc,
		       lcrzo_time *pmaxwaitingtime,
		       lcrzo_ipa ipa);
/* idem, mais travaille sur un lcrzo_ipl */
int lcrzo_ipc_write_ipl(lcrzo_ipc *pipc,
			lcrzo_ipl ipl);
int lcrzo_ipc_read_ipl(lcrzo_ipc *pipc,
		       lcrzo_time *pmaxwaitingtime,
		       lcrzo_ipl *pipl);
/* idem, mais travaille sur un lcrzo_eths */
int lcrzo_ipc_write_eths(lcrzo_ipc *pipc,
			 lcrzo_consteths eths);
int lcrzo_ipc_read_eths(lcrzo_ipc *pipc,
			lcrzo_time *pmaxwaitingtime,
			lcrzo_eths eths);
/* idem, mais travaille sur un lcrzo_etha */
int lcrzo_ipc_write_etha(lcrzo_ipc *pipc,
			 lcrzo_constetha etha);
int lcrzo_ipc_read_etha(lcrzo_ipc *pipc,
			lcrzo_time *pmaxwaitingtime,
			lcrzo_etha etha);
/* idem, mais travaille sur un lcrzo_device */
int lcrzo_ipc_write_device(lcrzo_ipc *pipc,
			   lcrzo_constdevice device);
int lcrzo_ipc_read_device(lcrzo_ipc *pipc,
			  lcrzo_time *pmaxwaitingtime,
			  lcrzo_device device);
/*-------------------------------------------------------------*/
/* idem, mais travaille sur un bloc compose de
   nom_de_device + adresse_Ethernet + adresse_IP + numero_de_port */
int lcrzo_ipc_write_deviceethaiplport(lcrzo_ipc *pipc,
				      lcrzo_constdevice device,
				      lcrzo_constetha etha,
				      lcrzo_ipl ipl,
				      lcrzo_uint16 port);
int lcrzo_ipc_read_deviceethaiplport(lcrzo_ipc *pipc,
				     lcrzo_time *pmaxwaitingtime,
			             lcrzo_device device,
				     lcrzo_etha etha,
				     lcrzo_ipl *pipl,
				     lcrzo_uint16 *pport);
/* idem, mais travaille sur un bloc compose de
   adresse_Ethernet + adresse_IP + numero_de_port */
int lcrzo_ipc_write_ethaiplport(lcrzo_ipc *pipc,
				lcrzo_constetha etha,
				lcrzo_ipl ipl,
				lcrzo_uint16 port);
int lcrzo_ipc_read_ethaiplport(lcrzo_ipc *pipc,
			       lcrzo_time *pmaxwaitingtime,
			       lcrzo_etha etha,
			       lcrzo_ipl *pipl,
			       lcrzo_uint16 *pport);
/* idem, mais travaille sur un bloc compose de
   adresse_IP + numero_de_port */
int lcrzo_ipc_write_iplport(lcrzo_ipc *pipc,
			    lcrzo_ipl ipl,
			    lcrzo_uint16 port);
int lcrzo_ipc_read_iplport(lcrzo_ipc *pipc,
			   lcrzo_time *pmaxwaitingtime,
			   lcrzo_ipl *pipl,
			   lcrzo_uint16 *pport);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_ipc_write_msg
   Description :
     Ecrit un bloc de donnees dans un tube lcrzo_ipc
   Parametre(s) d'entree :
     ipc : lcrzo_ipc 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_ipc_write_msg(lcrzo_ipc *pipc,
			lcrzo_constdata data,
			lcrzo_int32 datasize);
/* Nom : lcrzo_ipc_write
   Description :
     Ecrit un flux de donnees dans un tube lcrzo_ipc
     Si datasize est trop long, les donnees sont ecrites en plusieurs
     fois (employez lcrzo_ipc_write_msg si vous desirez que les
     donnees soient ecrites en une seule fois).
   Parametre(s) d'entree :
     ipc : lcrzo_ipc 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_ipc_write(lcrzo_ipc *pipc,
		    lcrzo_constdata data,
		    lcrzo_int32 datasize);
/* Nom : lcrzo_ipc_readm
   Description :
     Lit des donnees depuis un tube lcrzo_ipc
   Parametre(s) d'entree :
     ipc : lcrzo_ipc 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_ipc_readm(lcrzo_ipc *pipc,
		    lcrzo_time *pmaxwaitingtime,
		    lcrzo_data *pdataout,
		    lcrzo_int32 *pdataoutsize);
/* Nom : lcrzo_ipc_readm_fixed
   Description :
     Lit des donnees depuis un tube lcrzo_ipc
     Les donnees lues ont une taille constante.
   Parametre(s) d'entree :
     ipc : lcrzo_ipc ou les donnees sont lues
     *pmaxwaitingtime : temps maximum d'attente (peut etre un
                        lcrzo_time, LCRZO_WAIT_NODELAY ou
			LCRZO_WAIT_INFINITE)
     datasizetoread : taille exacte 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_ipc_readm_fixed(lcrzo_ipc *pipc,
			  lcrzo_time *pmaxwaitingtime,
			  lcrzo_int32 datasizetoread,
			  lcrzo_data *pdataout);
/* Nom : lcrzo_ipc_readm_line
   Description :
     Lit une ligne (jusqu'a \r\n) depuis un tube lcrzo_ipc
   Parametre(s) d'entree :
     ipc : lcrzo_ipc ou les donnees sont lues
     *pmaxwaitingtime : temps maximum d'attente (peut etre un
                        lcrzo_time, LCRZO_WAIT_NODELAY ou
			LCRZO_WAIT_INFINITE)
     beblocking : si on veut bloquer jusqu'a recevoir des donnees
   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_ipc_readm_line(lcrzo_ipc *pipc,
			 lcrzo_time *pmaxwaitingtime,
			 lcrzo_data *pdataout,
			 lcrzo_int32 *pdataoutsize);

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),