mg_user.c

一个Megaco实现源代码

}



Megaco_SessionUser_handleDisconnect__rs* 
Megaco_SessionUser_handleDisconnect__cb(Megaco_SessionUser oe_obj, 
					CORBA_long *ref, 
					erlang_pid *pid, 
					Megaco_ConnHandle *handle, 
					CORBA_unsigned_short *XXX, 
					CORBA_char *XXX2, 
					CORBA_Environment *oe_env) {
    
  V( ("(session) received handleDisconnect\n") );
  P( print_pid("pid:    ", pid) );
  P( print_conn_handle("handle: ", handle) );


  delete_pending(*ref); // Ignore returned data

  if (state != MgsDisconnecting) {
    /* Assume that the MGC has died, so we can just as well quit */
    I( ("disconnect while in state %d => exit\n", state) );
    mg_exit(send_env, receive_env);
  }

  free((void*)handle);
  free((void*)XXX2);
  return (Megaco_SessionUser_handleDisconnect__rs*)NULL;
}


Megaco_SessionUser_handleSyntaxError__rs* 
Megaco_SessionUser_handleSyntaxError__cb(Megaco_SessionUser oe_obj, 
					 CORBA_long *ref, 
					 erlang_pid *pid, 
					 Megaco_ReceiveHandle *handle, 
					 CORBA_unsigned_short *XXX, 
					 MegacoMessage_ErrorDescriptor *error, 
					 CORBA_Environment *oe_env) {
  
  W( ("(session) received handleSyntaxError\n") );
  print_pid("pid: ", pid);
  print_error_desc("syntax error: ", error);

  delete_pending(*ref); // Ignore returned data

  free((void*)handle);
  free((void*)error);
  return (Megaco_SessionUser_handleSyntaxError__rs*)NULL;
}


Megaco_SessionUser_handleMessageError__rs* 
Megaco_SessionUser_handleMessageError__cb(Megaco_SessionUser oe_obj, 
					  CORBA_long *ref,
					  erlang_pid *pid, 
					  Megaco_ConnHandle *handle, 
					  CORBA_unsigned_short *XXX, 
					  MegacoMessage_ErrorDescriptor *error, 
					  CORBA_Environment *oe_env) {
    
  W( ("(session) received handleMessageError\n") );
  print_pid("pid:       ", pid);
  print_conn_handle("localMid:  ", handle);

  delete_pending(*ref); // Ignore returned data

  print_error_desc("message error: ", error);

  free((void*)handle);
  free((void*)error);
  return (Megaco_SessionUser_handleMessageError__rs*)NULL;
}


Megaco_SessionUser_handleTransRequest__rs* 
Megaco_SessionUser_handleTransRequest__cb(Megaco_SessionUser oe_obj, 
					  CORBA_long *ref, 
					  erlang_pid *pid, 
					  Megaco_ConnHandle *handle, 
					  CORBA_unsigned_short *XXX, 
					  Megaco_ActionRequests *action, 
					  CORBA_Environment *oe_env) {

  W( ("(session) received handleTransRequest (NOT IMPLEMENTED)\n") );
  print_pid("pid:       ", pid);
  print_conn_handle("handle:  ", handle);
  
  delete_pending(*ref); // Ignore returned data

  free((void*)handle);
  free((void*)action);
  return (Megaco_SessionUser_handleTransRequest__rs*)NULL;
}


Megaco_SessionUser_handleTransReply__rs* 
Megaco_SessionUser_handleTransReply__cb(Megaco_SessionUser oe_obj, 
					CORBA_long *ref, 
					erlang_pid *replyTo, 
					Megaco_ConnHandle *handle, 
					CORBA_unsigned_short *XXX, 
					Megaco_Status *status, 
					Megaco_ActionReplies *reply, 
					CORBA_Environment *oe_env) {
    
  V( ("(session) received handleTransReply\n") );
  P( print_pid("replyTo: ", replyTo) );
  P( print_conn_handle("handle:  ", handle) );

  ASSERT_OK(status);

  delete_pending(*ref); // Ignore returned data

  if (handle_transaction_replies(reply)) {
    I( ("received service change reply => we are operational...\n") );
    state = MgsOperational;

    /* 
     * The next part is simply to show (and test) 
     * some other functions of the api.
     * This will start a sequence of calls to systemInfo,
     * userInfo and connInfo (in that order).
     */
    {
      Megaco_SystemInfoItem item = Megaco_SystemInfo_users;

      prepare_session(&dummy, &session_pid);
  
      V( ("send (users) systemInfo request\n") );
      Megaco_Session_systemInfo(NULL, *ref, &session_user_pid, item, send_env);
      
      ASSERT_SEND();
    }
  } else {
    W( ("service change invalid\n") );
  }

  free ((void*)handle);
  free ((void*)status);
  free ((void*)reply);
  return (Megaco_SessionUser_handleTransReply__rs*)NULL;
}


Megaco_SessionUser_handleTransAck__rs* 
Megaco_SessionUser_handleTransAck__cb(Megaco_SessionUser oe_obj, 
				      CORBA_long *ref, 
				      erlang_pid *pid, 
				      Megaco_ConnHandle *handle, 
				      CORBA_unsigned_short *XXX, 
				      Megaco_Status *status, 
				      CORBA_Environment *oe_env) {

  W( ("(session) received handleTransAck (NOT IMPLEMENTED)\n") );

  delete_pending(*ref); // Ignore returned data

  free ((void*)handle);
  free ((void*)status);
  return (Megaco_SessionUser_handleTransAck__rs*)NULL;
}


Megaco_SessionUser_handleUnexpectedTrans__rs* 
Megaco_SessionUser_handleUnexpectedTrans__cb(Megaco_SessionUser oe_obj, 
					     CORBA_long *ref, 
					     erlang_pid *pid, 
					     Megaco_ConnHandle *handle, 
					     CORBA_unsigned_short *XXX, 
					     MegacoMessage_TransactionUnion *transaction, 
					     CORBA_Environment *oe_env) {

  W( ("(session) received handleUnexpectedTrans (NOT IMPLEMENTED)\n") );

  delete_pending(*ref); // Ignore returned data

  free ((void*)handle);
  free ((void*)transaction);
  return (Megaco_SessionUser_handleUnexpectedTrans__rs*)NULL;
}


Megaco_SessionUser_systemInfoResponse__rs* 
Megaco_SessionUser_systemInfoResponse__cb(Megaco_SessionUser oe_obj, 
					  CORBA_long *ref, 
					  Megaco_Status *status, 
					  Megaco_SystemInfoValue *info, 
					  CORBA_Environment *oe_env) {

  V( ("(session) received systemInfoResponse\n") );

  ASSERT_OK(status);
  print_system_info(info);

  delete_pending(*ref); // Ignore returned data

  if (info->_d != Megaco_SystemInfo_connections) {
    /*
     * one more thing... 
     */
    Megaco_SystemInfoItem item = Megaco_SystemInfo_connections;
    
    prepare_session(&dummy, &session_pid);
    
    V( ("send (connections) systemInfo request\n") );
    Megaco_Session_systemInfo(NULL, *ref, &session_user_pid, item, send_env);
    
  } else {
    /*
     * OK, now it's time to test user info 
     */
    Megaco_UserInfoItem item = Megaco_UserInfo_connections;
    
    prepare_session(&dummy, &session_pid);
    
    V( ("send (connections) userInfo request\n") );
    Megaco_Session_userInfo(NULL, *ref, &session_user_pid, &mid, item, 
			    send_env);
  }

  ASSERT_SEND();

  free ((void*)status);
  free ((void*)info);
  return (Megaco_SessionUser_systemInfoResponse__rs*)NULL;
}


Megaco_SessionUser_startUserResponse__rs* 
Megaco_SessionUser_startUserResponse__cb(Megaco_SessionUser oe_obj, 
					 CORBA_long *ref, 
					 Megaco_Status *status, 
					 CORBA_Environment *oe_env) {
    
  V( ("(session) received startUserResponse\n") );

  ASSERT_OK(status);

  delete_pending(*ref); // Ignore returned data

  state = MgsUserStarted;

  setup_transport();
  
  free ((void*)status);
  return (Megaco_SessionUser_startUserResponse__rs*)NULL;
} 


Megaco_SessionUser_stopUserResponse__rs* 
Megaco_SessionUser_stopUserResponse__cb(Megaco_SessionUser oe_obj, 
					CORBA_long *ref, 
					Megaco_Status *status, 
					CORBA_Environment *oe_env) {

  V( ("(session) received stopUserResponse\n") );

  ASSERT_OK(status);

  delete_pending(*ref); // Ignore returned data

  state = MgsStopSession; 
  prepare_factory(&dummy);

  V( ("send stopSession\n") );
  Megaco_SessionFactory_stopSession(NULL, 
				    ref_counter, 
				    &session_user_pid,
				    &session_pid, 
				    send_env);
  ASSERT_SEND();
  
  free ((void*)status);
  return (Megaco_SessionUser_stopUserResponse__rs*)NULL;
}


Megaco_SessionUser_userInfoResponse__rs* 
Megaco_SessionUser_userInfoResponse__cb(Megaco_SessionUser oe_obj, 
					CORBA_long *ref, 
					Megaco_Status *status, 
					Megaco_UserInfoValue *info, 
					CORBA_Environment *oe_env) {

  V( ("(session) received userInfoResponse\n") );

  ASSERT_OK(status);
  print_user_info(info);

  delete_pending(*ref); // Ignore returned data

  if (info->_d != Megaco_UserInfo_connections) {
    /*
     * one more thing... 
     */
    Megaco_UserInfoItem item = Megaco_UserInfo_replyTimer;

    prepare_session(&dummy, &session_pid);
    
    V( ("send (replyTimer) userInfo request\n") );
    Megaco_Session_userInfo(NULL, *ref, &session_user_pid, &mid, item, 
			    send_env);
  } else {
    /*
     * OK, now it's time to test conn info 
     */
    Megaco_ConnInfoItem item = Megaco_ConnInfo_sendHandle;

    prepare_session(&dummy, &session_pid);
    
    V( ("send (sendHandle) connInfo request\n") );
    Megaco_Session_connInfo(NULL, *ref, &session_user_pid, &conn_handle, item, 
			    send_env);
  }

  ASSERT_SEND();

  free ((void*)status);
  free ((void*)info);
  return (Megaco_SessionUser_userInfoResponse__rs*)NULL;
}

Megaco_SessionUser_updateUserInfoResponse__rs* 
Megaco_SessionUser_updateUserInfoResponse__cb(Megaco_SessionUser oe_obj, 
					      CORBA_long *ref, 
					      Megaco_Status *status, 
					      CORBA_Environment *oe_env) {
    
  W( ("(session) received updateUserInfoResponse (NOT IMPLEMENTED)\n") );

  delete_pending(*ref); // Ignore returned data

  free ((void*)status);
  return (Megaco_SessionUser_updateUserInfoResponse__rs*)NULL;
}


Megaco_SessionUser_connInfoResponse__rs* 
Megaco_SessionUser_connInfoResponse__cb(Megaco_SessionUser oe_obj, 
					CORBA_long *ref, 
					Megaco_Status *status, 
					Megaco_ConnInfoValue *info, 
					CORBA_Environment *oe_env) {

  V( ("(session) received connInfoResponse\n") );

  ASSERT_OK(status);
  print_conn_info(info);  

  delete_pending(*ref); // Ignore returned data

  if (info->_d == Megaco_ConnInfo_sendHandle) {
    /*
     * one more thing... 
     */
    Megaco_ConnInfoItem item = Megaco_ConnInfo_pendingTimer;
    
    prepare_session(&dummy, &session_pid);
    
    V( ("send (pendingTimer) connInfo request: %d\n", item) );
    Megaco_Session_connInfo(NULL, *ref, &session_user_pid, &conn_handle, item, 
			    send_env);
    
    ASSERT_SEND();
    
  } else if (info->_d == Megaco_ConnInfo_pendingTimer) {
    /*
     * one more thing... 
     */
    Megaco_ConnInfoItem item = Megaco_ConnInfo_protocolVersion;
    
    prepare_session(&dummy, &session_pid);
    
    V( ("send (protocolVersion) connInfo request: %d\n", item) );
    Megaco_Session_connInfo(NULL, *ref, &session_user_pid, &conn_handle, item, 
			    send_env);
    
    ASSERT_SEND();
    
  } else if (stop) {
    
    /*
     * OK, this is it, now it is time to close shop...
     */

    // state = MgsClosing;

    // stop_transport();

    state = MgsDisconnecting;
    prepare_session(&dummy, &session_pid);
    
    V( ("send megaco disconnect\n") );
    Megaco_Session_disconnect(NULL, ref_counter, 
			      &session_user_pid, &conn_handle, 
			      "time to disco...", send_env);
    
    ASSERT_SEND();

  }

  free ((void*)status);
  free ((void*)info);
  return (Megaco_SessionUser_connInfoResponse__rs*)NULL;
}


Megaco_SessionUser_updateConnInfoResponse__rs* 
Megaco_SessionUser_updateConnInfoResponse__cb(Megaco_SessionUser oe_obj, 
					      CORBA_long *ref, 
					      Megaco_Status *status, 
					      CORBA_Environment *oe_env) {
    
  W( ("(session) received updateConnInfoResponse (NOT IMPLEMENTED)\n") );

  delete_pending(*ref); // Ignore returned data

  free ((void*)status);
  return (Megaco_SessionUser_updateConnInfoResponse__rs*)NULL;
}


Megaco_SessionUser_connectResponse__rs* 
Megaco_SessionUser_connectResponse__cb(Megaco_SessionUser oe_obj, 
				       CORBA_long *ref, 
				       Megaco_Status *status, 
				       Megaco_ConnHandle *handle, 
				       CORBA_Environment *oe_env) {
  Megaco_ActionRequests              actReqs;
  MegacoMessage_ActionRequest        actReq;
  MegacoMessage_CommandRequest       cmdReq;
  MegacoMessage_ServiceChangeRequest scReq;
  MegacoMessage_TerminationIdUnion   tid;
  Megaco_ConnInfoValues              connInfos;

  V( ("(session) received connectResponse\n") );
  P( print_conn_handle("handle:  ", handle) );

  ASSERT_OK(status);

  delete_pending(*ref); // Ignore returned data

  state = MgsConnected;

  /* Initiate the service change */
  if (strcmp(encoding, ENCODING_TEXT) == 0) {
    tid._d                        = MegacoMessage_Encoding_text;
    tid._u.text.containsWildcards = FALSE;
    tid._u.text.id._maximum       = 1;
    tid._u.text.id._length        = 1;
    tid._u.text.id._buffer        = &text_root;
  } else {
    tid._d                          = MegacoMessage_Encoding_binary;
    tid._u.binary.wildcard._maximum = 0;
    tid._u.binary.wildcard._length  = 0;
    tid._u.binary.wildcard._buffer  = NULL;
    tid._u.binary.id._maximum       = sizeof(bin_root);
    tid._u.binary.id._length        = sizeof(bin_root);
    tid._u.binary.id._buffer        = bin_root;
  }

  scReq.termIdList._maximum           = 1;
  scReq.termIdList._length            = 1;
  scReq.termIdList._buffer            = &tid;
  scReq.serviceChangeParms.method     = MegacoMessage_ServiceChangeMethod_restart;
  scReq.serviceChangeParms.address._d = FALSE; // Optional
  scReq.serviceChangeParms.version._d = FALSE; // Optional
  scReq.serviceChangeParms.profile._d = FALSE; // Optional
  scReq.serviceChangeParms.reason._maximum = 1;
  scReq.serviceChangeParms.reason._length  = 1;
  scReq.serviceChangeParms.reason._buffer  = &reason_cold_boot;
  scReq.serviceChangeParms.delay._d     = FALSE; // Optional
  scReq.serviceChangeParms.mgcId._d     = FALSE; // Optional
  scReq.serviceChangeParms.timeStamp._d = FALSE; // Optional
  
  cmdReq.command._d               = MegacoMessage_CommandChoice_serviceChangeReq;
  cmdReq.command._u.serviceChange = scReq;
  cmdReq.optional                 = FALSE;
  cmdReq.wildcardReturn           = FALSE;
  
  actReq.id                       = MegacoMessage_nullContextID;
  actReq.contextRequest._d        = FALSE;
  actReq.contextAttrAuditReq._d   = FALSE;
  actReq.commandRequests._maximum = 1;
  actReq.commandRequests._length  = 1;
  actReq.commandRequests._buffer  = &cmdReq;

  actReqs._maximum = 1;
  actReqs._length  = 1;
  actReqs._buffer  = &actReq;
  
  connInfos._maximum = 0;
  connInfos._length = 0;
  connInfos._buffer = NULL;
  
  prepare_session(&dummy, &session_pid);

  V( ("send sendTransRequest\n") );
  Megaco_Session_sendTransRequest(NULL, *ref, &session_user_pid, handle, &actReqs, 
				  &connInfos, send_env);
  ASSERT_SEND();
  
  free ((void*)status);
  free ((void*)handle);
  return (Megaco_SessionUser_connectResponse__rs*)NULL;
}


Megaco_SessionUser_disconnectResponse__rs* 
Megaco_SessionUser_disconnectResponse__cb(Megaco_SessionUser oe_obj, 
					  CORBA_long *ref, 
					  Megaco_Status *status, 
					  CORBA_Environment *oe_env) {
    
  V( ("(session) received disconnectResponse\n") );