/* $Id: mcl_proto.h,v 1.5 2003/10/31 14:58:44 chneuman Exp $ */
/*
 *  Copyright (c) 1999-2003 INRIA - Universite Paris 6 - All rights reserved
 *  (main author: Vincent Roca - vincent.roca@inrialpes.fr)
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 *  USA.
 */

#ifndef MCL_PROTO_H  /* { */
#define MCL_PROTO_H

/****** public function prototypes ******/


/*
 * mcl.c
 */
#ifdef STREAM
extern void	mcl_end_init_mclcb	(mclcb_t *mclcb, int nb_level);
#else
extern void	mcl_end_init_mclcb	(mclcb_t *mclcb);
#endif
extern void	mcl_moreabout		(void);
extern void	mcl_exit		(int n);


#if 0
/*
 * mcl_osdep.c
 */
/* functions are in mcl_osdep.c */
extern void	mcl_init_lock		(mcl_mutex_t *lock);
extern void	mcl_lock		(mclcb_t *mclcb);
extern int	mcl_trylock		(mclcb_t *mclcb);
extern void	mcl_unlock		(mclcb_t *mclcb);
extern void	mcl_mutexlock		(mcl_mutex_t *mutex);
extern int	mcl_mutextrylock	(mcl_mutex_t *mutex);
extern void	mcl_mutexunlock		(mcl_mutex_t *mutex);
extern void	mcl_usleep		(unsigned long usec);
extern int	mcl_gettimeofday	(struct timeval*tv);
extern void	mcl_init_random		(void);

#ifdef WIN32
extern void	mcl_winsock_init(void);
extern int IsValidSock(unsigned int);
#endif
#endif


/*
 * mcl_layer.c
 */
#ifdef STREAM
extern int	mcl_init_layer_nb	(mclcb_t *mclcb, int nb_level);
#else
extern int	mcl_init_layer_nb	(mclcb_t *mclcb);
#endif
extern int	mcl_get_nb_fec_layers	(mclcb_t *mclcb, int k);
extern int	mcl_add_layer		(mclcb_t *mclcb, int layer);
extern int	mcl_drop_layer		(mclcb_t *mclcb, int layer, int	check);
extern int	mcl_drop_this_layer	(mclcb_t *mclcb, int layer);


/*
 * mcl_time.c
 */
extern void *	mcl_timer_thread	(void *arg);
extern void	mcl_do_periodic_proc	(mclcb_t *mclcb);
extern struct timeval mcl_norm_tvtime(struct timeval val);
#ifndef ITIME_FUNCTION_DEFINES
extern mcl_itime_t	mcl_usec2it	(int from);
extern int		mcl_it2usec	(mcl_itime_t from);
extern float		mcl_it2sec	(mcl_itime_t from);
extern mcl_itime_t	mcl_itime_sub	(mcl_itime_t val, mcl_itime_t decr);
extern mcl_itime_t	mcl_itime_add	(mcl_itime_t val, mcl_itime_t incr);
#endif /* !ITIME_FUNCTION_DEFINES */
extern mcl_itime_t	mcl_get_itime	(void);
extern struct timeval	mcl_get_tvtime	(void);


/*
 * mcl_tx.c
 */
extern void	mcl_try_to_send		(mclcb_t *mclcb);
extern void	mcl_tx_cleanup		(mclcb_t *mclcb);


/*
 * mcl_sched.c
 */
extern void	UpdateTxPlanning	(mclcb_t *mclcb, adu_t *adu_start,
					 adu_t *adu_end);
extern void	AnticipTx_UpdateTxPlanning (mclcb_t *mclcb, adu_t *adu);


/*
 * mcl_txtab.c
 */
extern void	mcl_register_du		(mclcb_t *mclcb, txlvl_t *tl, du_t *du,
					 int nb_tx);
extern du_t*	mcl_get_next_du		(mclcb_t *mclcb, txlvl_t *tl);
extern int	mcl_new_tx_cycle	(mclcb_t *mclcb, txlvl_t *tl);
extern void	mcl_mark_adus_in_txtab	(mclcb_t *mclcb, txlvl_t *tl);
extern void	mcl_free_all_txtab	(mclcb_t *mclcb);
extern void 	mcl_free_all_adu_from_txtab(mclcb_t *mclcb);

#ifdef LCT_SCHED4
/*
 * mcl_sda_txtab.c
 */
extern void	mcl_sda_register_du (mclcb_t	*mclcb, du_t	*du);
extern du_t*	mcl_sda_get_next_du (mclcb_t	*mclcb);
#endif


/*
 * mcl_rx.c
 */
extern void*	mcl_rx_thread	(void *arg);
extern void	mcl_process_pkt	(mclcb_t* mclcb, mcl_rx_pkt *pkt,
				 mcl_addr *saddr);
extern int	mcl_return_adu_to_appli	(mclcb_t *mclcb, char *userbuf,
				 u_int userlen,
				 struct sockaddr *saddr, int *saddr_len);
extern int	mcl_return_adu_to_appli_flute(mclcb_t *mclcb, char *userbuf,
				 u_int userlen,
				 struct sockaddr *saddr, int *saddr_len, 
				 u_int32_t *toi);

/*
 * mcl_sig.c
 */
extern int	SendNONEWADU	(mclcb_t *mclcb, int max_adu);
extern int	SendCLOSE	(mclcb_t *mclcb);
extern int	AddSigToTab	(mclcb_t *mclcb, sig_tab_t *new_sig);
extern int	RemSigFromTab	(mclcb_t *mclcb, int level, int type, int ext_type);
extern void	CopySigReset	(mclcb_t *mclcb);
extern int	CanCopyMoreSig	(mclcb_t *mclcb, int level);
extern int	CopySigToLCTinfos(mclcb_t *mclcb, int level,
				hdr_infos_t *hdr_infos,
				int len);
extern int	CleanupSigTab	(mclcb_t *mclcb);
extern void	mcl_sig_close	(mclcb_t *mclcb);


/*
 * mcl_network.c
 */
extern int	mcl_send_pkt	(mclcb_t *mclcb,int level, du_t *du, adu_t *adu);
extern void	mcl_recv_pkt	(mclcb_t *mclcb);
#ifdef NO_LONGER_NEEDED /* { */
extern int	mcl_add_in_our_fds (int id, fd_set *fds);
extern void	mcl_set_in_fds	(int fd, fd_set *fds, int sender);
extern void	mcl_print_fds	(char *msg, int nfds, fd_set *fds);
#endif /* } NO_LONGER_NEEDED */

#ifdef WIN32
  extern int	mcl_sock_buf_mgmt (SOCKET fd, int buf, int op, int val);
#else
  extern int	mcl_sock_buf_mgmt (int fd, int buf, int op, int val);
#endif

extern int	mcl_init_sockets (mclcb_t *mclcb);
extern int	mcl_layer_sock_init (mclcb_t *mclcb, int level, mcgroup_t *mg,
				 mcl_addr *addr);
extern int	mcl_close_sockets (mclcb_t *mclcb);


/*
 * mcl_du.c
 */
extern du_t*	CreateDU	(mclcb_t *mclcb);
extern du_t*	LastDU		(mclcb_t *mclcb, du_t *list);
extern int	InsertDU	(mclcb_t *mclcb, du_t *du, du_t **list);
extern int	mcl_rx_enough_du(mclcb_t *mclcb, block_t *blk);


/*
 * mcl_adu.c
 */
extern adu_t*	CreateADU	(mclcb_t *mclcb);
extern void	InsertADU	(mclcb_t *mclcb, adu_t *adu, adu_t **list);
extern int	mcl_rx_new_completed_adu (mclcb_t *mclcb, adu_t *adu);
extern int	mcl_rx_all_adu_completed(mclcb_t *mclcb, adu_t *list);
extern adu_t*	FindADU		(mclcb_t *mclcb, u_int seq, u_int FDTinstanceID, adu_t *list);
extern block_t*	FindBlock	(mclcb_t *mclcb, u_int seq, block_t *list,
				 adu_t *adu);
extern int	LastADUSeq	(mclcb_t *mclcb, adu_t *list);
extern void	mcl_tx_segment_adu (mclcb_t *mclcb, adu_t *adu);
extern void	mcl_tx_free_this_adu (mclcb_t *mclcb, adu_t *adu);
extern void	mcl_free_all_adu(mclcb_t *mclcb);


/*
 * mcl_lib.c
 */
/* MCL private function */
extern int	mcl_ctl2	(mclcb_t *mclcb, int optname, void *optvalue,
				int optlen);
/* other (public) functions are in mcl_lib.h */


/*
 * mcl_tx_prof.c
 */
extern int	mcl_set_tx_profile	(mclcb_t *mclcb, int profile);


/*
 * mcl_debug.c
 */
#ifdef DEBUG
extern void	mcl_assert	();
extern void	mcl_break	();
#endif /* DEBUG */
extern void	DumpBuffer	(char *buf, int len, int to_dump);
extern void	PrintRcvdDU	(mclcb_t *mclcb, int type, int level,
				 hdr_infos_t *hdr_infos);
extern void	PrintSentDU	(mclcb_t *mclcb, int type, int val,
				 hdr_infos_t *hdr_infos);


/*
 * mcl_stats.c
 */
extern void	mcl_print_tx_profile	(mclcb_t *mclcb);
extern void	mcl_print_tx_stats		(mclcb_t *mclcb);
extern void	mcl_print_rx_stats		(mclcb_t *mclcb);
extern void	mcl_print_final_stats		(mclcb_t *mclcb);
#ifdef GET_SYSINFO
extern void	mcl_print_sysinfo		(mclcb_t *mclcb);
#endif


#if 0
/*
 * mcl_fec.c
 */
extern int	mcl_fec_encode		(mclcb_t *mclcb, block_t *blk);
extern int	mcl_fec_decode		(mclcb_t *mclcb, block_t *blk);
#endif


#ifdef RLC
/*
 * mcl_rlc.c
 */
extern void	rlc_init_session	(mclcb_t *mclcb);
extern void	rlc_reset_tx_sp		(mclcb_t *mclcb);
extern void	rlc_end_session		(mclcb_t *mclcb );
extern int	rlc_ctl			(mclcb_t *mclcb, int optname,
					 void *optvalue, int optlen);
extern int	rlc_tx_fill_header	(mclcb_t *mclcb, rlc_hdr_t *hdr_buff,
					 u_int8_t pkt_layer );
extern int	rlc_rx_analyze_packet	(mclcb_t *mclcb, rlc_hdr_t *hdr_buff );
extern int	rlc_rx_timer		(mclcb_t *mclcb);
#endif /* RLC */


#ifdef FLIDS
/*
 * mcl_flid_sl.c
 */
extern void FLIDs_InitSession	(mclcb_t *mclcb);
extern void FLIDs_EndSession	(mclcb_t *mclcb);

extern void FLIDs_TxTimer		(mclcb_t *mclcb);
extern void	FLIDs_NewTimeSlot	(mclcb_t *mclcb);
extern int	FLIDs_tx_FillHeader	(mclcb_t *mclcb, flids_hdr_t *hdr_buff, u_int8_t grp_idx);
extern int	FLIDs_ctl			(mclcb_t *mclcb, int optname, void *optvalue, int optlen);
extern int	FLIDs_rx_AnalyzePacket(mclcb_t *mclcb, flids_hdr_t *hdr_buff);
#endif /* FLIDS */


/*
 * mcl_alc_hdr.c
 */
extern int	alc_hdr_create	(mclcb_t *mclcb, fixed_lct_hdr_t *lct_hdr,
				hdr_infos_t *hdr_infos);
extern int	alc_hdr_parse	(mclcb_t *mclcb, fixed_lct_hdr_t *lct_hdr,
				hdr_infos_t *hdr_infos, int plen);


/*
 * mcl_lct_hdr.c
 */
extern int	lct_hdr_create	(mclcb_t *mclcb, fixed_lct_hdr_t *lct_hdr,
				hdr_infos_t *hdr_infos);
extern int	lct_hdr_parse	(mclcb_t *mclcb, fixed_lct_hdr_t *lct_hdr,
				hdr_infos_t *hdr_infos);


/*
 * mcl_fsm.c
 */
extern int	mcl_fsm_get_state	(mclcb_t *mclcb, int sender);
extern char	*mcl_fsm_print_state	(mclcb_t *mclcb, int sender);
extern int	mcl_fsm_opened		(mclcb_t *mclcb, int sender);
extern int	mcl_fsm_can_send_data	(mclcb_t *mclcb);
extern int	mcl_fsm_can_recv_data	(mclcb_t *mclcb);
extern int	mcl_fsm_no_new_adu	(mclcb_t *mclcb, int sender);
extern int	mcl_fsm_no_new_undup_du	(mclcb_t *mclcb);
extern int	mcl_fsm_close_already_rx(mclcb_t *mclcb);
extern int	mcl_fsm_closed		(mclcb_t *mclcb, int sender);
extern int	mcl_fsm_close_can_return (mclcb_t *mclcb, int sender);
extern void	mcl_fsm_update_state	(mclcb_t *mclcb, int sender,
						 tx_events_t tevent,
						 rx_events_t revent);


#ifdef VIRTUAL_TX_MEM
/*
 * mcl_vtmem.c
 */
extern int	mcl_vtm_can_store_in_vtm(mclcb_t *mclcb, int len);
extern int	mcl_vtm_store_data	(mclcb_t *mclcb, adu_t *adu, du_t *du,
					 char *data, int len, int padded_len);
extern void	mcl_vtm_register_du	(mclcb_t *mclcb, du_t *du, u_int off);
extern void	mcl_vtm_register_in_ptm (mclcb_t *mclcb, adu_t *adu, du_t *du,
					int len);
extern char*	mcl_vtm_get_data	(mclcb_t *mclcb, du_t *du);
extern int	mcl_vtm_close		(mclcb_t *mclcb);
#endif /* VIRTUAL_TX_MEM */


#ifdef VIRTUAL_RX_MEM
/*
 * mcl_vrmem.c
 */
extern int	mcl_vrm_can_store_in_vrm(mclcb_t *mclcb, int len);
extern int	mcl_vrm_store_data	(mclcb_t *mclcb, du_t *du, char *data,
					int len);
extern void mcl_vrm_remove_from_prm (mclcb_t *mclcb, du_t *du, int len);

extern void	mcl_vrm_register_in_prm (mclcb_t *mclcb, du_t *du, int len);
#ifdef DEBUG
extern int	mcl_vrm_in_vrm		(mclcb_t *mclcb, du_t *du);
#endif /* DEBUG */
extern char*	mcl_vrm_get_data	(mclcb_t *mclcb, du_t *du, char *data,
					int len);
extern int	mcl_vrm_close		(mclcb_t *mclcb);
#endif /* VIRTUAL_RX_MEM */


/*
 * mcl_var.c
 */
extern mclcb_t*	mcl_alloc_mclcb		(void);
extern void	mcl_free_mclcb		(mclcb_t *mclcb);

/*
 * mcl_flute.c
 */
extern int 	requestedtoi_flute	(mclcb_t *mclcb, u_int32_t tio);
extern void 	addrequestedtoi_flute	(mclcb_t *mclcb,u_int32_t tio);

/****** global variables (declared in mcl_var.c) ******/

extern int	mcl_tx_thread_usleep;
extern const u_int mcl_iss;
extern u_int	mcl_time_count;
//extern u_int	mcl_timer_period;
//extern u_int	mcl_tx_period;
//extern u_int	mcl_tx_count;
#ifdef RLC
extern u_int	mcl_rlc_rx_period;
//extern u_int	mcl_rlc_rx_count;
#endif


extern mcl_thread_t	mcl_timer_thread_id;
extern mcl_mutex_t	mcl_mutex_lock;

extern char mcl_tmp_dir_name[MAX_FILE_NAME_LEN];

extern mclcb_t* mclcbs[];

#endif /* }  MCL_PROTO_H */