lcrzo_process(3)

NAME
lcrzo_process - bibliotheque lcrzo : gestion de processus

CONTENU
/*    Bibliotheque reseau de Laurent Constantin (lcrzo)
                 Module lcrzo_process
  Les fonctions presentes dans ce module assurent la gestion de
  processus(unix) ou threads(Windows).
*/
/*-------------------------------------------------------------*/
/***************************************************************
 * Note sur les processus et les threads :                     *
 *  - Sous Unix, un processus est cree (fork).                 *
 *  - Sous Windows, ce n'est pas possible d'employer des       *
 *    processus, donc un thread est cree. Dans ce cas, il faut *
 *    prendre garde aux variables globales et statiques.       *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* definition d'un lcrzo_process. Vous ne devriez pas utiliser
   directement ses champs. */
typedef struct
{ lcrzo_uint32 processid;
  lcrzo_uint32 threadid;
  void *threadhandle;
  lcrzo_data pfuncinfos;
  lcrzo_bool hasended;
  int returnedvalue;
  int (*punixreturn_uint82int)(lcrzo_uint8 ret);
} lcrzo_process;
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_current_init
   Description :
     Initialise un lcrzo_process afin qu'il contienne le processus
     courant.
   Parametre(s) d'entree :
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pprocess : lcrzo_process qui contient le processus courant
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_current_init(lcrzo_process *pprocess);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_current_exit
   Description :
     Quitte le processus courant.
     Attention : sous Unix, returnvalue est tronque a 8 bits.
                 Les fonctions lcrzo_process_other_init2 and
	         lcrzo_process_int2uint8_std peuvent vous aider
		 si cela pose un probleme pour votre code.
   Parametre(s) d'entree :
     returnvalue : valeur retournee par le processus
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_current_exit(int returnvalue);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_current_priority_set
   Description :
     Change le niveau de priorite du processus courant.
   Parametre(s) d'entree :
     priority : priorite a affecter :
                    -127 = faible priorite
                      0  = priorite normale
                    +127 = priorite haute (necessite d'etre root)
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_current_priority_set(lcrzo_int8 priority);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_current_priority_get
   Description :
     Obtient le niveau de priorite du processus courant.
   Parametre(s) d'entree :
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *ppriority : priorite
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_current_priority_get(lcrzo_int8 *ppriority);
/*-------------------------------------------------------------*/
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_other_init
   Description :
     Cree un nouveau processus qui execute *pfuns puis quitte.
     Sous Unix, la valeur retournee par pfunc est tronquee a 8
     bits : employer alors lcrzo_process_other_init2.
   Parametre(s) d'entree :
     *pfunc : fonction executee par le nouveau processus :
                infos : affecte avec infos
		infossize : affecte avec infossize
		*pparentprocess : informe qui est le processus pere
     infos : donnees a passer au processus fils (infos est un void*
             a cause de Wcast-align sur Sparc, qui cause un sigbus)
     infossize : taille de infos
     *pchidprocess : processus cree
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_other_init(int (*pfunc)(void *infos,
					  lcrzo_int32 infossize,
					  lcrzo_process *pparentprocess),
			     void *infos,
                             lcrzo_int32 infossize,
			     lcrzo_process *pchildprocess);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_other_init2
   Description :
     Cree un nouveau processus qui execute *pfuns puis quitte.
     Sous Unix, la valeur retournee par pfunc est tronquee a 8
     bits. Alors, les fonctions punixreturn_int2uint8 et
     punixreturn_uint82int peuvent etre employees pour compresser
     un entier, puis l'etendre. Vous pouvez par exemple employer
     lcrzo_process_int2uint8_std ou creer votre propre fonction
     de conversion.
   Parametre(s) d'entree :
     *pfunc : fonction executee par le nouveau processus :
                infos : affecte avec infos
		infossize : affecte avec infossize
		*pparentprocess : informe qui est le processus pere
     infos : donnees a passer au processus fils
     infossize : taille de infos
     *punixreturn_int2uint8 : fonction employee pour compresser la
                              valeur retournee en 8 bits
     *punixreturn_uint82int : function employee pour convertir les
                              8 bits en entier
     *pchidprocess : processus cree
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_other_init2(int (*pfunc)(void *infos,
					   lcrzo_int32 infossize,
					   lcrzo_process *pparentprocess),
			      void *infos,
			      lcrzo_int32 infossize,
			      lcrzo_uint8 (*punixreturn_int2uint8)(int ret),
			      int (*punixreturn_uint82int)(lcrzo_uint8 ret),
			      lcrzo_process *pchildprocess);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_other_exit
   Description :
     Termine brutalement un processus : a n'employer que si il
     n'y a rien a fermer avant de terminer.
   Parametre(s) d'entree :
     *pprocess : processus a terminer
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_other_exit(lcrzo_process *pprocess);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_other_wait_end
   Description :
     Attend la fin d'un processus.
   Parametre(s) d'entree :
     *pprocess : processus a attendre
     *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 :
     *phasended : vrai si le processus a termine
     *preturnvalue : valeur retournee par le processus
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKTEMPDATAEND : la fonction n'a pas recu de donnees
                               avant pmaxwaitingtime
*/
int lcrzo_process_other_wait_end(lcrzo_process *pprocess,
                                 lcrzo_time *pmaxwaitingtime,
                                 lcrzo_bool *phasended,
                                 int *preturnvalue);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_process_close
   Description :
     Libere la memoire employee par un lcrzo_process.
     Note : cette fonction ne termine pas le processus.
   Parametre(s) d'entree :
     *pprocess : processus a liberer
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_process_close(lcrzo_process *pprocess);
/*-------------------------------------------------------------*/
/*-------------------------------------------------------------*/
/*
  Ces fonctions ont le meme emploi que les fonctions precedentes,
  excepte :
   - elles gerent plusieurs sous-processus
   - chaque sous-processus est reference par son index
*/
typedef struct
{ lcrzo_list waitlist;
  lcrzo_list processlist;
} lcrzo_multiprocess;
int lcrzo_multiprocess_init(lcrzo_multiprocess *pmultiprocess);
int lcrzo_multiprocess_close(lcrzo_multiprocess *pmultiprocess);
int lcrzo_multiprocess_process_init(lcrzo_multiprocess *pmultiprocess,
                                    lcrzo_int32 processindex,
                                    int (*pfunc)(void *infos,
						 lcrzo_int32 infossize,
						lcrzo_process *pparentprocess),
			            void *infos,
                                    lcrzo_int32 infossize);
int lcrzo_multiprocess_process_init2(lcrzo_multiprocess *pmultiprocess,
				     lcrzo_int32 processindex,
				     int (*pfunc)(void *infos,
						  lcrzo_int32 infossize,
						lcrzo_process *pparentprocess),
				     void *infos,
				     lcrzo_int32 infossize,
			      lcrzo_uint8 (*punixreturn_int2uint8)(int ret),
			      int (*punixreturn_uint82int)(lcrzo_uint8 ret));
int lcrzo_multiprocess_process_count(lcrzo_multiprocess *pmultiprocess,
                                     lcrzo_int32 *pnumberofprocesses);
int lcrzo_multiprocess_process_exit(lcrzo_multiprocess *pmultiprocess,
                                    lcrzo_int32 processindex);
int lcrzo_multiprocess_process_wait_end(lcrzo_multiprocess *pmultiprocess,
                                        lcrzo_time *pmaxwaitingtime,
                                        lcrzo_bool *paprocesshasended,
                                        lcrzo_int32 *pindexoftheendedprocess,
                                        int *preturnedvalue);
/*-------------------------------------------------------------*/
/* Sous Unix, la valeur retournee par un processus est
   tronquee a 8 bits. Ces fonctions sont utilisees par
   lcrzo_process_other_init2.
     lcrzo_process_int2uint8_std : convertit de 32 bits a 8 bits
     lcrzo_process_uint82int_std : convertit de 8 bits a 32 bits
*/
lcrzo_uint8 lcrzo_process_int2uint8_std(int ret);
int lcrzo_process_uint82int_std(lcrzo_uint8 ret);
/*-------------------------------------------------------------*/
/* Idem, mais gere differemment la troncature */
lcrzo_uint8 lcrzo_process_int2uint8_socktcp(int ret);
int lcrzo_process_uint82int_socktcp(lcrzo_uint8 ret);

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