&L_error);
                            
                            
							if(G_redir) {
                              
                              sip_msg_header_t * contact = 
                                sip_msg_new_contact_header(G_redir);
                              
                              if((!contact) || 
                                 ((sip_msg_insert_header
                                   (L_Message_rsp -> headers, 
                                    contact) != SIP_NORMAL))) {
								std::cerr << "==  Unable to insert the contact "
                                          << "header in 302 response"<<std::endl;
								break;
                              }
                              
                              sip_msg_free_header(contact);
                            }
                            
                            sip_msg_free_body(L_body);
                            
                            L_response = buildRsp(L_RecvEvent,L_Message_rsp);
                            getProbe().send(P_service,P_session,*L_response);
                          }
                          break;
						default :
                          throw std::runtime_error
							("UA_AppProbe::receive bad response scenario");
						}
		            
					break;
				}
			case SIP_MSG_BYE: 
				{
				printf("in receive SIP_MSG_BYE!!\n");
				if (G_trace >= 1) {
				std::cerr << "== Received a call-stateless BYE Request"<<std::endl;
				}
				// Send a 200 OK response 
				L_Message_rsp = sip_msg_new_response(200,
													NULL,
													NULL,
													NULL,
													NULL,
													NULL,
													&L_error);
	            
				L_response = buildRsp(L_RecvEvent,L_Message_rsp);
				getProbe().send(P_service,P_session,*L_response);
				L_session.setState(UA_Session::CALL_RELEASING);
	            
				break;
				}
			default:
				{
				printf("in receive default!!\n");       
				sip_msg_body_t * L_body = sip_msg_new_body_copy
				(L_Message_recv->body,
				SIP_MSG_PHYSICAL_COPY, 
				0);
	            
				if (G_trace >= 1)
				std::cerr << "== Received a unknown Request"<<std::endl;
	            
	               
				// Send a 200 OK response 
				L_Message_rsp = sip_msg_new_response(200,
													NULL,
													NULL,
													NULL,
													L_body,
													NULL,
													&L_error);

				sip_msg_free_body(L_body);
	                  
	               
				L_response = buildRsp(L_RecvEvent,L_Message_rsp);
				getProbe().send(P_service,P_session,*L_response);
				L_session.setState(UA_Session::CALL_CONFIRMED);
				if (std::string(L_Message_recv->start_line.request.extension_method) == "REFER")
					{
					sleep(1); 
					// silent subscrition
                    SIP_MessageContainer* L_silentSubscribe = 
                      dynamic_cast<SIP_MessageContainer*>(buildReqInDialog(L_RecvEvent,0));

					L_silentSubscribe->setSubscriptionId
                      (FF_Identifier(1,SIP_SRVC_NEW_SUBSCRIPTION));

					L_silentSubscribe->silentSubscribeRequired
                      (sip_msg_new_event_header((char*)"refer",
                                                (char*)"0",
                                                0,
                                                0),
                       SIP_CALL_EVT_ROLE_NOTIFIER);

					if (G_trace >= 1)
						std::cerr << "== sending silent subscribe notifier side"
								<<std::endl;   

					getProbe().send(P_service,P_session,*L_silentSubscribe);
					//end silent subscription
					//send notify
					sip_msg_header_t* VP_contact_header = L_Message_recv -> 
                      headers -> vector[sip_msg_find_and_parse_header
                                       (L_Message_recv -> headers,
                                        SIP_MSG_HDR_FROM,
                                        0, NULL)];
					if (VP_contact_header == 0)
                      {
						std::cerr<< "can't find contact header"<<std::endl;
						exit(0);
                      }

					sip_msg_message_t* VP_msg_notify =  sip_msg_new_request 
																(SIP_MSG_NOTIFY,
																VP_contact_header -> structured_header ->
																content.contact.uri,
																NULL,
																0,
																0,
																0,
																0,
																0);
	    
					if(!VP_msg_notify) {
					fprintf(stderr, "== Error creating new NOTIFY message\n");
					}
			    
					sip_msg_header_t* VP_subscription_state = sip_msg_new_subscription_state_header
					((char *)"active", NULL, -1, -1, NULL, NULL);	    
					sip_msg_insert_header(VP_msg_notify -> headers,
										VP_subscription_state,
										-1);
					sip_msg_free_header(VP_subscription_state);
					
					sip_msg_insert_header(VP_msg_notify -> headers,
										sip_msg_new_event_header((char *)"refer",(char *)"0",0,0),
										-1);
		            
					L_response = buildReqInDialog(L_RecvEvent,VP_msg_notify);
					dynamic_cast<SIP_MessageContainer*>(L_response)->setSubscriptionId(FF_Identifier(1,1)); //work around jeh
					getProbe().send(P_service,
									P_session,
									*L_response);
					//end notify
					}

          
		
				}
			break;
			}
		break;
		case UA_Session::CALL_SUCCESS :
			{
		       printf("in UA_Session::CALL_SUCCESS!!\n");
			if (L_Message_recv->kind==SIP_MSG_REQUEST)
				{
				// IF ACK session state a CONFIRMED
				if (L_Message_recv->start_line.request.method==SIP_MSG_ACK)
                  {
					if (G_trace >= 1)
                      std::cerr << "== Received a ACK Request"<<std::endl;
					L_session.setState(UA_Session::CALL_CONFIRMED);
                    if(G_server_close) {
                      L_session.storeProviderId(L_RecvEvent);
                      L_session.setService(P_service);
                      closeSession(L_session);
                    }
                  }
				else
					throw std::runtime_error 
					("UA_AppProbe::receive ACK expected !");
				// End of ACK
				}
			}
		break;
		case UA_Session::CALL_CONFIRMED :
			{
			 printf("in UA_Session::CALL_CONFIRMED!!\n");
			// IF BYE session delete
			if (L_Message_recv->start_line.request.method==SIP_MSG_BYE)
				{
				if (G_trace >= 1)
					std::cerr << "== Received a BYE Request"<<std::endl;
				L_Message_rsp = sip_msg_new_response
					(200,
					L_Message_recv->start_line.request.version,
					NULL,
					NULL,
					0,
					NULL,
					&L_error);
				L_response = buildRsp(L_RecvEvent,L_Message_rsp);
		      
				getProbe().send(P_service,P_session,*L_response);
				G_nfinishedCalls++;
		      
				} // End of BYE
			else if (L_Message_recv->start_line.request.method==SIP_MSG_INVITE) {
				// This is a re-invite: we send a 200 OK and simulate initial call
				// processing.
	                  
				if (G_trace >= 1) {
				std::cerr << "== Received a REINVITE Request"<<std::endl;
				}
	            
				// Send a 200 OK response 
				L_Message_rsp = sip_msg_new_response(200,
													NULL,
													NULL,
													NULL,
													sip_msg_new_body_copy
													(L_Message_recv->body,
													SIP_MSG_PHYSICAL_COPY, 
													0),
													NULL,
													&L_error);
	                  
				L_response = buildRsp(L_RecvEvent,L_Message_rsp);
				getProbe().send(P_service,P_session,*L_response);
				L_session.setState(UA_Session::CALL_SUCCESS);
			} else {
				throw std::runtime_error ("UA_AppProbe::receive BYE expected !");
			}
			}
		break;
		case UA_Session::CALL_CALLING :
			{
				 printf("in UA_Session::CALL_CALLING!!\n");
			if (L_Message_recv->start_line.response.status_code == 200 )
				{
				printf("if L_Message_recv->start_line.response.status_code\n");
				sip_msg_header_t * cseq_header  = L_Message_recv -> headers -> 
        vector[sip_msg_find_and_parse_header
               (L_Message_recv -> headers,
                SIP_MSG_HDR_CSEQ,
                0, NULL)];

      if(cseq_header-> structured_header -> content.cseq.method 
         == SIP_MSG_INVITE)
		  {
				if (G_trace >= 1)
					std::cerr << "== Received a 200 Request, send ACK "
							<<std::endl;   
				L_Message_rsp =  sip_msg_new_request 
					(SIP_MSG_ACK,
                     sip_msg_new_empty_uri(),
                     NULL,
                     0,
                     0,
                     0,
                     0,
                     &L_error);
		      
				if (!L_Message_rsp) {
					std::cerr <<"== Unable to build new Request "
							<<L_error.status<<std::endl;
					getProbe().destroySession(P_session,SIP_CAUSE_NORMAL);
					return SIP_INTERNAL_FAILURE;
				}

				L_response = buildRsp(L_RecvEvent,L_Message_rsp);
				getProbe().send(P_service,P_session,*L_response);
		
		  }
				
	  if((cseq_header-> structured_header -> content.cseq.extension_method != 0 )
		  && (std::string(cseq_header-> structured_header -> content.cseq.extension_method ) == "REFER"))
		  {
		 SIP_MessageContainer* L_silentSubscribe = dynamic_cast<SIP_MessageContainer*>(buildReqInDialog(L_RecvEvent,0));
		 L_silentSubscribe->setSubscriptionId(FF_Identifier(-1,SIP_SRVC_NEW_SUBSCRIPTION));
		 L_silentSubscribe->silentSubscribeRequired(sip_msg_new_event_header((char *)"refer",(char *)"0",0,0),SIP_CALL_EVT_ROLE_SUBSCRIBER);
		if (G_trace >= 1)
					std::cerr << "== sending silent subscribe server side"
							<<std::endl;   

		 getProbe().send(P_service,P_session,*L_silentSubscribe);
 
		  }

				L_session.storeProviderId(L_RecvEvent);
				L_session.setState(UA_Session::CALL_CONFIRMED);
				L_session.setService(P_service);
	        
				callQueue.push_back(&L_session);
				if (!G_subscribe)
					{        
					//callQueue.push_back(&L_session);
					}
				else
					{
					sendSubscriptionMessage(P_service, L_session, *L_response);
					}  

				}
			break;
			case UA_Session::CALL_RELEASING :
			{
				printf("in UA_Session::CALL_RELEASING!!\n");
				if (G_trace >= 1)
				std::cerr << "== Received a 200 ok for the BYE Request"
							<<std::endl;
			}
			break;
			default :
			std::cerr << "==  UASppProbe::receive unknown state" << std::endl;
	      	
			}
		}
		
	}
  }

  catch (std::exception& e)
    {
      std::cerr << "== UA_AppProbe::receive, exception ["
                <<e.what()<<"]"<<std::endl;
      getProbe().destroySession(P_session,SIP_CAUSE_NORMAL);
      return SIP_INTERNAL_FAILURE;
    }
	
  return SIP_SUCCESS;
}

SIP_Event* UA_AppProbe::buildRsp (FF_SipMessageContainer& P_initialRequest, 
                                  sip_msg_message_t * P_Message_rsp)
{
  if (G_trace >= 1) std::cerr << "== Entering buildRsp" << std::endl;

  SIP_MessageContainer* L_Rsp = new SIP_MessageContainer;

  print_message_info(P_Message_rsp, "Sending");

  L_Rsp->setPayload(P_Message_rsp);
      
  // set the call with 1 for the User and the Provider value set by the stack
  L_Rsp->setCallId
    (FF_Identifier(1,
                       P_initialRequest.getCallId().
                       getProviderIdentifier()));

  // set the dialogId with 1 for the User and the Provider value set by 
  // the stack
  L_Rsp->setDialogId(FF_Identifier(1,P_initialRequest.getDialogId().
                                         getProviderIdentifier()));

  // if (P_initialRequest.getPayload()->kind ==SIP_MSG_REQUEST )

  // set the TransactionId with 1 for the User and the Provider value 
  // set by the stack
  L_Rsp->setTransactionId(FF_Identifier
                          (1,P_initialRequest.getTransactionId().
                           getProviderIdentifier()));
  
  // Set also the subscription IF if available
  if(P_initialRequest.getSubscriptionId().
     getProviderIdentifier() != -1) {
    L_Rsp->setSubscriptionId(FF_Identifier
                             (1,P_initialRequest.getSubscriptionId().
                              getProviderIdentifier()));
  }
  if (G_trace >= 1) {
    fprintf(stderr,
            "== Building response '%d %s'message with provider IDs:\n"
            "==   Call-ID   = %d,\n"
            "==   Dialog-ID = %d,\n"
            "==   Trans-ID  = %d,\n"
            "==   Sub-ID    = %d.\n",
            P_Message_rsp -> start_line.response.status_code,
            P_Message_rsp -> start_line.response.reason_phrase,
            L_Rsp->getCallId().getProviderIdentifier(),
            L_Rsp->getDialogId().getProviderIdentifier(),
            L_Rsp->getTransactionId().getProviderIdentifier(),
            L_Rsp->getSubscriptionId().getProviderIdentifier());
  }
  
  if (G_trace >= 2) std::cerr << "== Returning from buildRsp" << std::endl;
  
  return L_Rsp;
}

SIP_Event* UA_AppProbe::buildReqInDialog
(FF_SipMessageContainer& P_initialRequest, 
 sip_msg_message_t * P_Message_rsp)