text: /****************
   Contributed by: Krishnan Srinivasan <hsirk_6@yahoo.com>
   License: to be specified.
   TODO:
   
   ****************/
  
  
  #include <freeDiameter/extension.h>
  #include <signal.h>
  #include <time.h>
  #define AUTH_APP_ID				    16777238
  #define VENDOR_ID_3GPP  			    10415
  /* The content of this file follows the same structure as dict_base_proto.c */
  
  #if 0
  #define CHECK_dict_new( _type, _data, _parent, _ref )  \
         CHECK_FCT(  fd_dict_new( fd_g_config->cnf_dict, (_type), (_data), (_parent), (_ref))  );
  #endif
  
  void dump_sess_eyec(struct session *sess, const char *);
  
  static int ccr_cb( struct msg ** msg, struct avp * avp, struct session * sess, void * opaque, enum disp_action * act);
  static int reauth_cb( struct msg ** msg, struct avp * avp, struct session * sess, void * opaque, enum disp_action * act);
  static int cca_cb( struct msg ** msg, struct avp * avp, struct session * sess, void * opaque, enum disp_action * act);
  static struct disp_hdl * ccr_cb_hdl = NULL; /* handler for ccr req cb */
  static struct disp_hdl * cca_cb_hdl = NULL; /* handler for cca req cb */
  static struct disp_hdl * reauth_cb_hdl = NULL; /* handler for cca req cb */
  
  struct dict_object *ccr_cmd = NULL;
  struct dict_object *cca_cmd = NULL;
  struct dict_object *dataobj_re_auth_request_type = NULL;
  struct dict_object * origin_host = NULL;
  struct dict_object * origin_realm = NULL;
  struct dict_object * dest_host = NULL;
  struct dict_object * dest_realm = NULL;
  struct dict_object *reauth_cmd = NULL;
  struct dict_object * auth_app_id    = NULL; 
  struct dict_object * service_cxt_id = NULL ; 
  struct dict_object * cc_req_type    = NULL; 
  struct dict_object * cc_req_num    = NULL; 
  struct dict_object * bearer_usage    = NULL; 
  struct dict_object * pflt_oper    = NULL; 
  struct dict_object * pflt_info    = NULL; 
  struct dict_object * pflt_id	= NULL; 
  struct dict_object * gx_inf;
  struct dict_object * term_cause = NULL;
  
  struct session *g_sess = NULL;
  struct session_handler *g_hdlr = NULL;
  
  enum gx_state {
      STATE_INIT = 0,
      STATE_INTERMEDIATE ,
      STATE_FINAL
  };
  struct gx_sm_t {
      enum gx_state state;
      pthread_t tid;
      struct fifo *events;
      pthread_mutex_t p_sm_mtx;
      int req_num;
      struct session *sess;  
  } g_gx_sm;
  
  int snd_ccr_msg(struct gx_sm_t **gx_sm  , struct dict_object *cmd_r ) ;
  
  void sig_hdlr(void);
  
  void *gx_sm_th(void *sm);
  #define press_key_continue() { printf("%s %d\n", __FUNCTION__, __LINE__);}
  static int app_gx_entry(char * conffile)
  {
  //     TRACE_ENTRY("%p", conffile);	       
         {
  	       application_id_t dcca_id = AUTH_APP_ID;
  	       application_id_t ccr_id = 272;
  	       application_id_t cca_id = 272;
  	       application_id_t reauth_id = 258;
  	       CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_APPLICATION, APPLICATION_BY_ID, &dcca_id, &gx_inf, ENOENT));
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_CODE_R, &ccr_id, &ccr_cmd, ENOENT));
  	CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_CODE_A, &cca_id, &cca_cmd, ENOENT));
    //   CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_CODE_R, &reauth_id, &reauth_cmd, ENOENT));
  
         }
  
         /* Applications section */
  #if 0
       {
  	// Gx interface
  	       {
  	struct dict_application_data data = { AUTH_APP_ID, "3GPP-Gx Application" };
  	 CHECK_dict_new( DICT_APPLICATION, &data, NULL, &gx_inf);
  
  	       }				
    
  	}
  #endif
  
  
  	// Do registeration and init stuff
        {
  	struct disp_when data;
         
         TRACE_DEBUG(FULL, "Initializing dispatch callbacks for Gx interface");
  	   
         memset(&data, 0, sizeof(data));
         data.app = gx_inf;
  	   data.command = ccr_cmd;
         /* Now specific handler for CCR-CMD */
  	   CHECK_FCT( fd_disp_register( ccr_cb, DISP_HOW_CC, &data, NULL, &ccr_cb_hdl ) );
  
   
         memset(&data, 0, sizeof(data));
         data.app = gx_inf;
  	   data.command = cca_cmd;
  
  	   CHECK_FCT( fd_disp_register( cca_cb, DISP_HOW_CC, &data, NULL, &cca_cb_hdl ) );
         
  #ifdef REAUTH
  	CHECK_FCT(fd_dict_search(fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME,
  				       "Re-Auth-Request", &reauth_cmd, ENOENT));
  	memset(&data, 0, sizeof(data));
         data.app = gx_inf;
  	   data.command = reauth_cmd;
  	printf("register REAUTH\n");
  	   CHECK_FCT( fd_disp_register( reauth_cb, DISP_HOW_CC, &data, NULL, &reauth_cb_hdl ) );
  #endif
  
  
       }
  
  	
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, AVP_BY_NAME, 
  			       "Origin-Host", 
  				&origin_host, 
  				ENOENT) );
  
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "Origin-Realm", 
  			       &origin_realm, 
  			       ENOENT) );
  
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "Destination-Host", 
  				&dest_host, 
  				ENOENT) );
  
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "Destination-Realm", 
  			       &dest_realm, 
  			       ENOENT) );
  
  
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "Auth-Application-Id", 
  			       &auth_app_id, 
  				ENOENT) );
  
  
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "Service-Context-Id", 
  			       &service_cxt_id, 
  				ENOENT) );
  
      CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "CC-Request-Type", 
  			       &cc_req_type, 
  				ENOENT) );
  
      CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "Termination-Cause", 
  			       &term_cause, 
  				ENOENT) );
  
      CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  			       DICT_AVP, 
  			       AVP_BY_NAME, 
  			       "CC-Request-Number", 
  			       &cc_req_num, 
  				ENOENT) );
      {
  	struct dict_avp_request req = { VENDOR_ID_3GPP, 0, "Bearer-Usage"}; 
  
  	CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  				   DICT_AVP, 
  				   AVP_BY_NAME_AND_VENDOR, 
  				   &req, 
  				   &bearer_usage, 
  				    ENOENT) );
      }
      {
  	struct dict_avp_request req = { VENDOR_ID_3GPP, 0, "Packet-Filter-Operation"}; 
  
  	CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  				   DICT_AVP, 
  				   AVP_BY_NAME_AND_VENDOR, 
  				   &req, 
  				   &pflt_oper, 
  				    ENOENT) );
      }
      {
  	struct dict_avp_request req = { VENDOR_ID_3GPP, 0, "Packet-Filter-Information"}; 
  
  	CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  				   DICT_AVP, 
  				   AVP_BY_NAME_AND_VENDOR, 
  				   &req, 
  				   &pflt_info, 
  				    ENOENT) );
      }
      {
  	struct dict_avp_request req = { VENDOR_ID_3GPP, 0, "Packet-Filter-Identifier"}; 
  
  	CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, 
  				   DICT_AVP, 
  				   AVP_BY_NAME_AND_VENDOR, 
  				   &req, 
  				   &pflt_id, 
  				    ENOENT) );
      }
  
      CHECK_FCT(fd_sess_handler_create( &g_hdlr, free, NULL));
      CHECK_FCT( fd_fifo_new(&g_gx_sm.events));  
      CHECK_FCT( fd_disp_app_support( gx_inf, NULL, 1 , 0));
  
      CHECK_FCT( fd_event_trig_regcb(SIGUSR1, "app_gx", sig_hdlr ) );
  
  
         TRACE_DEBUG(INFO, "Extension 'Gx' initialized");
         return 0;
  }
  
  void * gx_sm_th(void *sm)
  {
     struct gx_sm_t *gx_sm = (struct gx_sm_t *) sm;
      struct timespec tout;
      int evt_code;
  
  	    CHECK_SYS_DO( clock_gettime( CLOCK_REALTIME, &tout), goto out);
  	    tout.tv_sec =+ 60 ;
     
      while(1) {
   
  	fd_event_timedget(gx_sm->events, &tout , ETIMEDOUT, &evt_code, NULL, NULL );
  	 CHECK_SYS_DO( clock_gettime( CLOCK_REALTIME, &tout), goto out);
  	printf("in tout sec %d\n", tout.tv_sec); 
  	if(evt_code == ETIMEDOUT) {
  	    
  	    snd_ccr_msg(&gx_sm, ccr_cmd);
  	    gx_sm->req_num++ ;
  	    gx_sm->state = STATE_INTERMEDIATE;
  	    CHECK_SYS_DO( clock_gettime( CLOCK_REALTIME, &tout), goto out);
  	    tout.tv_sec += 30 ;
  
  	}
         // printf("press enter\n");
         // getchar();
      }
       
   out: 
   return NULL;
  }
  //TBD
  int init_gx_sm(struct gx_sm_t *sm)
  {
      sm->state = STATE_INIT;
      sm->tid = 0;//
      sm->events = NULL;
      pthread_mutex_t p_sm_mtx;
      sm->req_num = 0;
      sm->sess = NULL;
  
  return 0;
  }
  int free_gx_sm(struct gx_sm_t *sm)
  {
      
    free(sm);
  }
  struct gx_sm_t *gl_gx_sm = NULL;
  
  void sig_hdlr()
  {
  struct gx_sm_t *gx_sm = gl_gx_sm;
  
      if( gx_sm) {
  
  	fd_sess_dump( 0 , g_gx_sm.sess);
  
       } else {
  
  	if(gx_sm= (struct gx_sm_t *)malloc(sizeof(struct gx_sm_t))) {
  	    init_gx_sm(gx_sm);
  	   }
  	   gl_gx_sm = gx_sm;
  	}
  
        snd_ccr_msg( &gx_sm, ccr_cmd);
      return;
  }
  
  static void cr_cb_ans(void *data, struct msg  **msg)
  {
      printf("call back \n");
     return;
  }
  
  /*				     < Session-Id >
  				   { Origin-Host }
  				   { Origin-Realm }
  				   { Destination-Realm }
  				   { Auth-Application-Id }
  				   { Service-Context-Id }
  				   { CC-Request-Type }
  				   { CC-Request-Number }
  */
  
  int snd_ccr_msg(struct gx_sm_t **sm , struct dict_object *cmd_r ) 
  {
         struct msg * req = NULL;
         struct avp * avp = NULL;
         union avp_value val;
         struct ta_mess_info * mi = NULL, *svg;
         struct session *sess = NULL;
      struct gx_sm_t *gx_sm = NULL;
      struct gx_sm_t *ptr = NULL;
  
         TRACE_DEBUG(FULL, "Creating a new CCR message for sending. %p", gx_sm);
         
         /* Create the request from template */
         CHECK_FCT_DO( fd_msg_new( cmd_r, MSGFL_ALLOC_ETEID, &req ), goto out );
         
      gx_sm = *sm;
         /* Create a new session */
      if(!gx_sm->sess) {
  
  	   CHECK_FCT_DO( fd_sess_new( &sess, 
  				   fd_g_config->cnf_diamid, 
  				   fd_g_config->cnf_diamid_len, 
  				    "CCR_SESSION", strlen("CCR_SESSION") ), goto out );
  	
  	printf("statemachine: %p %p %p\n", *(&gx_sm), gx_sm , *sm);
  	gx_sm->sess = sess;
  	printf("new session %p \n", sess);
  	//Hold the session till terminate happens
  	       CHECK_FCT( fd_sess_ref_msg(sess) );
  
        } else {
  
  	sess = gx_sm->sess;
  	printf("use previous session %p \n", sess);
  
        }
       
       fd_sess_dump( 0 , sess);
      
         
  //     dump_sess_eyec( sess, __FUNCTION__);
         /* Now set all AVPs values */
         
         /* Session-Id */
         {
  	       os0_t sid;
  	       size_t sidlen;
  	struct dict_object *sess_id = NULL;
  
         CHECK_FCT( fd_dict_search(   fd_g_config->cnf_dict
  				   , DICT_AVP, AVP_BY_NAME
  				   , "Session-Id"
  				   , &sess_id, ENOENT) );
  
  	       CHECK_FCT_DO( fd_sess_getsid ( sess, &sid, &sidlen ), goto out );
  	       CHECK_FCT_DO( fd_msg_avp_new ( sess_id, 0, &avp ), goto out );
  	       val.os.data = sid;
  	       val.os.len  = sidlen;
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_FIRST_CHILD, avp ), goto out );
         }
  
         /* Set the Destination-Realm AVP */
         {
  	       CHECK_FCT_DO( fd_msg_avp_new ( dest_realm, 0, &avp ), goto out  );
  	       val.os.data = (unsigned char *)("vm");
  	       val.os.len  = strlen("vm");
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
         }
         
  
         /* Set the Destination-Host AVP if needed*/
      {
  	       CHECK_FCT_DO( fd_msg_avp_new ( dest_host, 0, &avp ), goto out  );
  	       val.os.data = (unsigned char *)("192.168.101.3");
  	       val.os.len  = strlen("192.168.101.3");
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
      }
         
  
         /* Set Origin-Host & Origin-Realm */
         CHECK_FCT_DO( fd_msg_add_origin ( req, 0 ), goto out  );
  
  
     /*  Set Auth-Application ID */
      {
         CHECK_FCT_DO( fd_msg_avp_new ( auth_app_id, 0, &avp ), goto out  );
  	       val.i32 =  AUTH_APP_ID; // Auth-App id is 4 for CCR 
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
      }
  
      /*     Set Service Context ID     */
      {
  
         CHECK_FCT_DO( fd_msg_avp_new ( service_cxt_id, 0, &avp ), goto out  );
  	val.os.data = (unsigned char *)("test@tst");
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  
      }
  
      /*     Set Request Type	      */
      {
  #define CCR_INIT_REQUEST		1
  #define CCR_UPDATE_REQUEST		2
  #define CCR_TERMINATION_REQUEST 	3
  #define CCR_EVENT_REQUEST		4
  //TODO Change this to use  enum object
         CHECK_FCT_DO( fd_msg_avp_new ( cc_req_type, 0, &avp ), goto out  );
  	if(gx_sm->state == STATE_INIT)
  	    val.i32 = CCR_INIT_REQUEST;
  	else if(gx_sm->state == STATE_FINAL)
  	    val.i32 = CCR_TERMINATION_REQUEST;
  	 else 
  	    val.i32 = CCR_UPDATE_REQUEST;
  
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  
      }
  
      /*     Set Request Number	      */
      {
         CHECK_FCT_DO( fd_msg_avp_new ( cc_req_num, 0, &avp ), goto out  );
  	val.i32 = gx_sm->req_num;
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  	gx_sm->req_num++; 
      }
  
      switch(gx_sm->state) {
  
       case STATE_INIT:
  
  	{
  	//Set Bearer-Usage
      //TODO Change this to use  enum object
         CHECK_FCT_DO( fd_msg_avp_new ( bearer_usage, 0, &avp ), goto out  );
  	val.i32 = 1;//IMS
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  	} 
         {
  	//Set Packet Filter Operation 
  	//TODO Change this to use  enum object
         CHECK_FCT_DO( fd_msg_avp_new ( pflt_oper, 0, &avp ), goto out  );
  	val.i32 = 1;//ADDITION
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  	 } 
  	struct avp *flt_info = NULL; 
  	{
  	    //Set Packet Filter Information 
  	   CHECK_FCT_DO( fd_msg_avp_new ( pflt_info, 0, &flt_info ), goto out  );
  
     
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, flt_info ), goto out  );
  	} 
  	// Set Packet Filter Identity
  	{
  
  	 CHECK_FCT_DO( fd_msg_avp_new ( pflt_id, 0, &avp ), goto out  );
  	  val.os.data = (unsigned char *)("ID");
  		 val.os.len  = strlen("ID");
  	  CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	  if(flt_info) {
  		   CHECK_FCT_DO( fd_msg_avp_add( flt_info, MSG_BRW_LAST_CHILD, avp ), goto out  );
  	   }else {
  		printf("flt_info NULL\n");
  	    }
  
  	 }
  	CHECK_FCT(fd_sess_state_store(g_hdlr, sess, &gx_sm));
  
  	break;
       case STATE_FINAL:
  	 {
  	//Set Packet Filter Operation 
  	//TODO Change this to use  enum object
         CHECK_FCT_DO( fd_msg_avp_new ( term_cause, 0, &avp ), goto out  );
  	val.i32 = 1;//Diameter logout
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  	 } 
  	break;
       default: 
  	printf("State mismatch \n");
      }
         fflush(stderr);
         
         /* Send the request */
      printf("CCA %p\n",req);
  // Everthing Done Store the state: reply should retreive it 
         CHECK_FCT_DO( fd_msg_send( &req, NULL, NULL ), goto out );
  
  out:
         return;
  }
  
  
  static int reauth_cb( struct msg ** msg, struct avp * avp, struct session * sess, void * opaque, enum disp_action * act)
  {
         struct msg *ans, *qry;
         struct avp * a;
  
         TRACE_ENTRY("%p %p %p %p", msg, avp, sess, act);
         
         if (msg == NULL)
  	       return EINVAL;
         
         
         /* Create answer header */
         qry = *msg;
         CHECK_FCT( fd_msg_new_answer_from_req ( fd_g_config->cnf_dict, msg, 0 ) );
         ans = *msg;
         
         /* Set the Origin-Host, Origin-Realm, Result-Code AVPs */
         CHECK_FCT( fd_msg_rescode_set( ans, "DIAMETER_SUCCESS", NULL, NULL, 1 ) );
         
         /* Send the answer */
         CHECK_FCT( fd_msg_send( msg, NULL, NULL ) );
         
         
  
  }
  static int dcca_ans_from_req( struct dict_object * obj, struct msg *qry, struct msg **msg)
  {
         struct avp *avp  = NULL;
         struct avp_hdr * avpdata;
      int  rc = -1;
  
      CHECK_FCT(fd_msg_search_avp( qry, obj, &avp));
      CHECK_FCT(fd_msg_avp_hdr(avp, &avpdata));
      avp = NULL;
  
         CHECK_FCT_DO( fd_msg_avp_new ( obj, 0, &avp ), goto out  );
         CHECK_FCT_DO( fd_msg_avp_setvalue( avp, avpdata->avp_value ), goto out  );
         CHECK_FCT_DO( fd_msg_avp_add( *msg, MSG_BRW_LAST_CHILD, avp ), goto out  );
  
   rc = 0;
  out:
   return rc;
  
  }
  /* Dummy ccr which :
     Read the cc-req-type && cc-req-number from the msg and stick it back
    in the reply
  
  */
  static int ccr_cb( struct msg ** msg, struct avp * r_avp, struct session * sess, void * opaque, enum disp_action * act)
  {
         struct msg *ans, *qry;
         struct avp *avp  = NULL;
         struct avp_hdr * avp_data;
      int rc  = - 1; 
  
         TRACE_ENTRY("%p %p %p %p", msg, r_avp, sess, act);
         
         if (msg == NULL)
  	       return EINVAL;
         
         
         /* Create answer header */
         qry = *msg;
         CHECK_FCT_DO( fd_msg_new_answer_from_req ( fd_g_config->cnf_dict, msg, 0 ) , goto out);
         ans = *msg;
         
         /* Set the Origin-Host, Origin-Realm, Result-Code AVPs */
         CHECK_FCT_DO( fd_msg_rescode_set( ans, "DIAMETER_SUCCESS", NULL, NULL, 1 ), goto out );
  
  // Get the auth_app_id and from the reply and set it in the reply 
      CHECK_FCT_DO(dcca_ans_from_req( auth_app_id, qry, msg), goto out);
      CHECK_FCT_DO(dcca_ans_from_req( cc_req_type, qry, msg), goto out);
      CHECK_FCT_DO(dcca_ans_from_req( cc_req_num, qry, msg), goto out);
  
         /* Send the answer */
         CHECK_FCT_DO( fd_msg_send( msg, NULL, NULL ), goto out );
      rc  = 0;
    out:
      //Free up the memory
      return rc ;
  
  }
  int send_reauth_req()
  
  {
         struct dict_application_data appdata;
      struct avp *avp = NULL;
      union avp_value val ;
      struct msg *qry, *ans = NULL;
      struct msg *req = NULL;
      struct msg *tst = NULL;
         struct dict_object * auth_app_id = NULL, *reauth_req_type = NULL;
  
  //    qry = *msg;
  
  
      { // Send new reauth request
  
  	   CHECK_FCT_DO( fd_msg_new( reauth_cmd, MSGFL_ALLOC_ETEID, &req ), goto out );
         CHECK_FCT(  fd_dict_getval(gx_inf, &appdata)  );
      
         struct msg_hdr * header = NULL;
  	       CHECK_FCT( fd_msg_hdr ( req, &header ) );
  	       header->msg_appl = appdata.application_id;
  
      }
  
         /* Session-Id */
         {
  	       os0_t sid;
  	       size_t sidlen;
  	struct dict_object *sess_id = NULL;
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Session-Id", &sess_id, ENOENT) );
  
  	       //CHECK_FCT_DO( fd_sess_getsid ( sess, &sid, &sidlen ), goto out );
  	       CHECK_FCT_DO( fd_msg_avp_new ( sess_id, 0, &avp ), goto out );
  	       val.os.data = sid;
  	       val.os.len  = sidlen;
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_FIRST_CHILD, avp ), goto out );
  	       
         }
  
         /* Set the Destination-Realm AVP */
         {
  	       CHECK_FCT_DO( fd_msg_avp_new ( dest_realm, 0, &avp ), goto out  );
  	       val.os.data = (unsigned char *)("vm");
  	       val.os.len  = strlen("vm");
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
         }
         
         /* Set the Destination-Host AVP if needed*/
  //     if (ta_conf->dest_host) {
  	       CHECK_FCT_DO( fd_msg_avp_new ( dest_host, 0, &avp ), goto out  );
  	       val.os.data = (unsigned char *)("cli.vm");
  	       val.os.len  = strlen("cli.vm");
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  //     }
      
         /* Set Origin-Host & Origin-Realm */
         CHECK_FCT_DO( fd_msg_add_origin ( req, 0 ), goto out  );
  
         /* AUTH_Application-ID */
         CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Auth-Application-Id", &auth_app_id, ENOENT) );
  	       CHECK_FCT_DO( fd_msg_avp_new ( auth_app_id, 0, &avp ), goto out  );
  	       val.i32 = appdata.application_id;
  	       CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	       CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  
         /* Re-Auth Request Type */
  	CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Re-Auth-Request-Type", &reauth_req_type, ENOENT) );
  	   CHECK_FCT_DO( fd_msg_avp_new ( reauth_req_type, 0, &avp ), goto out  );
  	val.i32 = 0;
  	CHECK_FCT_DO( fd_msg_avp_setvalue( avp, &val ), goto out  );
  	CHECK_FCT_DO( fd_msg_avp_add( req, MSG_BRW_LAST_CHILD, avp ), goto out  );
  
  
         CHECK_FCT_DO( fd_msg_send( &req, cr_cb_ans, NULL ), goto out );
  out:
      return 0 ;
  
  
  }
  /* Search a given AVP model in an AVP (extracted from libfreediameter/message.c ) */
  int fd_avp_search_avp ( struct avp * groupedavp, struct dict_object * what, struct avp ** avp )
  {
         struct avp * nextavp;
         struct avp_hdr * nextavphdr;
         struct dict_avp_data    dictdata;
         
         
         TRACE_ENTRY("%p %p %p", groupedavp, what, avp);
         
         CHECK_FCT(  fd_dict_getval(what, &dictdata)  );
         
         // Loop only in the group AVP 
         CHECK_FCT(  fd_msg_browse(groupedavp, MSG_BRW_FIRST_CHILD, (void *)&nextavp, NULL)  );
         CHECK_FCT( fd_msg_avp_hdr( nextavp, &nextavphdr )  );
         
         while (nextavphdr) {
  	       
  	       if ( (nextavphdr->avp_code   == dictdata.avp_code) && (nextavphdr->avp_vendor == dictdata.avp_vendor) ) // always 0 if no Vendor flag
  	       {
  		       break;
  	       }
  	       
  	       // Otherwise move to next AVP in the grouped AVP 
  	       CHECK_FCT( fd_msg_browse(nextavp, MSG_BRW_NEXT, (void *)&nextavp, NULL) );
  	       
  	       if(nextavp!=NULL)
  	       {
  		       CHECK_FCT( fd_msg_avp_hdr( nextavp, &nextavphdr )  );
  	       }
  	       else
  		       nextavphdr=NULL;
         }
         if (avp)
  	       *avp = nextavp;
         
         if (avp && nextavp) {
  	       struct dictionary * dict;
  	       CHECK_FCT( fd_dict_getdict( what, &dict) );
  	       CHECK_FCT_DO( fd_msg_parse_dict( nextavp, dict, NULL ),  );
         }
         
         if (avp || nextavp)
  	       return 0;
         else
  	       return ENOENT;
  }
  
  static int cca_cb( struct msg ** msg, 
  		   struct avp * t_avp , 
  		   struct session * sess, 
  		   void * opaque, 
  		   enum disp_action * act)
  {
      struct avp *avp = NULL, *g_avp = NULL;
      struct msg *req = *msg;
      struct dict_object *chrg_rule_name = NULL ;
      struct dict_object *chrg_rule_grp = NULL ;
         struct avp_hdr * avpdata = NULL;
      struct dict_avp_request grule_req =   {VENDOR_ID_3GPP, 0,"Charging-Rule-Install"};
      struct dict_avp_request rule_req =   {VENDOR_ID_3GPP, 0,"Charging-Rule-Name"};
      struct timespec sess_timeout;
      struct gx_sm_t *gx_sm = NULL;
    //  struct session *sess = NULL;
      
      
         CHECK_FCT(fd_sess_state_retrieve( g_hdlr, sess, &gx_sm));
      fd_sess_dump( 0, sess);
      if(gx_sm->state != STATE_FINAL) { 
  
  	       CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict
  				   , DICT_AVP, AVP_BY_NAME_AND_VENDOR
  				   , &grule_req 
  				   , &chrg_rule_grp
  				   , ENOENT));
      
  	   CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict
  				   , DICT_AVP, AVP_BY_NAME_AND_VENDOR
  				   , &rule_req 
  				   , &chrg_rule_name
  				   , ENOENT));
  
  
  	CHECK_FCT(fd_msg_search_avp ( *msg, chrg_rule_grp, &g_avp ));
  	CHECK_FCT(fd_avp_search_avp(g_avp, chrg_rule_name, &avp));
  
  	if(avp) {
  	       CHECK_FCT(fd_msg_avp_hdr(avp, &avpdata));
  	} else {
  	    printf("NULL AVP \n");
  	}
  	printf("charging-rule-name %s\n", avpdata->avp_value->os.data);
  	gx_sm->state = STATE_FINAL;
  	dump_sess_eyec( sess, __FUNCTION__);
  	printf("next dump\n");
  	CHECK_FCT(fd_sess_state_store( g_hdlr, sess, &gx_sm));
  	fd_msg_free(*msg);
  	*msg = NULL;
  
     } else {
  	printf("Session terminated\n");
  	free_gx_sm(gx_sm);
  	fd_msg_free(*msg);
  	fd_sess_reclaim(&sess);
  	*msg = NULL;
      }
      fd_sess_dump( 0 , sess);
  
      return 0;
  }
  
  static int gx_entry(char * conffile)
  {
   return 0;
  }
  EXTENSION_ENTRY( "app_gx", app_gx_entry, "dict_dcca_3gpp");
  //EXTENSION_ENTRY( "app_gx", gx_entry);
  