mg_user.c

一个Megaco实现源代码

// ``The contents of this file are subject to the Erlang Public License,
// Version 1.1, (the "License"); you may not use this file except in
// compliance with the License. You should have received a copy of the
// Erlang Public License along with this software. If not, it can be
// retrieved via the world wide web at http://www.erlang.org/.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Initial Developer of the Original Code is Ericsson Utvecklings AB.
// Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
// AB. All Rights Reserved.''
//
//     $Id$

#include <stdlib.h>
#include <string.h>
#include "megaco_session.h"
#include "mg_user.h"
#include "mg.h"
#include "verbose.h"


#define FALSE 0
#define TRUE  1

#define HOSTNAMESZ  256
#define NAMESZ      128

#define MEGACO_SESSION_FACTORY "megaco_session_factory"
#define MEGACO_SESSION_UDP     "megaco_session_udp"
#define MEGACO_SESSION_TCP     "megaco_session_tcp"

#define MAXPENDING  512

#define R901 "901 - optional explanatory string"


#define ASSERT_OK(status) assert_ok(status, __FILE__, __LINE__)
#define ASSERT_SEND()     assert_send(__FILE__, __LINE__)

#define P( proto ) if (verbose) proto
#define V( proto ) if (verbose) VERBOSE( "" ,          proto )
#define I( proto )              VERBOSE( "<INFO>" ,    proto )
#define W( proto )              VERBOSE( "<WARNING>" , proto )


/** 
 * This is a _very_ simplified MG state "handling".
 * A real life MG, is probably implemented as a 
 * state machine and only handling events expected 
 * in each state. In our small example we do it the
 * other way around (actually we more or less ignore
 * state).
 * Call handling is of course an entirely different 
 * matter. */
typedef enum {MgsUndefined = 0,
	      MgsInitiated,
	      MgsSessionStarted,
	      MgsUserStarted,
	      MgsTransportInit,
	      MgsConnectInit, 
	      MgsConnected, 
	      MgsOperational,
	      MgsClosing,
	      MgsDisconnecting,
	      MgsStopUser,
	      MgsStopSession} MgState;


/* Root termination constants */
static char  bin_root[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
static char* text_root = "root";

static CORBA_Environment* send_env  	   = NULL;
static CORBA_Environment* receive_env  	   = NULL;
static erlang_pid         session_pid;
static erlang_pid         session_user_pid;
static char               dname[NAMESZ];
static Megaco_UserMid     mid;
static CORBA_long         ref_counter 	   = 0;
static void*              pending_messages[MAXPENDING];
static char               dummy[] = "dummy";
static int                verbose = FALSE;
static int                stop    = FALSE;
static char mgc_host[HOSTNAMESZ];
static char transport[NAMESZ];
static char encoding[NAMESZ];
static Megaco_ReceiveHandle recv_handle;
static Megaco_ConnHandle    conn_handle;
static erlang_binary        send_handle;
static erlang_pid           control_pid;
static MegacoMessage_OctetString reason_cold_boot;

static int state = MgsUndefined;


static void bincpy(erlang_binary* to, erlang_binary* from);
static void pidcpy(erlang_pid*    to, erlang_pid*    from);
static void mchcpy(Megaco_ConnHandle* to, Megaco_ConnHandle* from);
static void midcpy(MegacoMessage_MIdUnion* to, MegacoMessage_MIdUnion* from);
static void ip4cpy(MegacoMessage_IP4Address* to, MegacoMessage_IP4Address* from);
static void ip6cpy(MegacoMessage_IP6Address* to, MegacoMessage_IP6Address* from);
static void domcpy(MegacoMessage_DomainName* to, MegacoMessage_DomainName* from);
static void devcpy(CORBA_char** to, CORBA_char* from);
static void mtpcpy(MegacoMessage_OctetString* to, MegacoMessage_OctetString* from);


static int handle_transaction_replies(Megaco_ActionReplies* actRepliesP);
static int handle_transaction_reply(MegacoMessage_ActionReply* actReplyP);
static int handle_command_reply(int                              cid,
				MegacoMessage_CommandReplyUnion* repP);
static int handle_service_change_rep(int                               cid,
				     MegacoMessage_ServiceChangeReply* repP);


/************************************************************
 * Helpers
 ************************************************************/

static void assert_ok(Megaco_Status* status, char* file, int line) {
    switch(status->_d) { 
    case Megaco_ok:
      break;
      
    case Megaco_errorString:
      fprintf(stderr, "%s(%i): errorString -> %s\n", file, line, 
	      status->_u.result);
      mg_exit(send_env, receive_env);
      break;
      
    case Megaco_errorDesc:
      if (status->_u.desc.text._d) {
	fprintf(stderr, "%s(%i): errorDesc(%i) -> %s\n", file, line, 
		  status->_u.desc.code, status->_u.desc.text._u.val); 
	mg_exit(send_env, receive_env);
      } else {
	fprintf(stderr, "%s(%i): errorDesc(%i)\n", file, line, 
		(status->_u.desc).code);
	mg_exit(send_env, receive_env);
      }
    }
}


static void assert_send(char* file, int line) {
  switch(send_env->_major) {
  case CORBA_NO_EXCEPTION: /* Success */
    break;
  case CORBA_SYSTEM_EXCEPTION: /* System exception */
    fprintf(stderr, "%s(%i): <ERROR> send failure - %s\n", file, line,
	    (char *) CORBA_exception_value(send_env));
    CORBA_exception_free(send_env);
    mg_exit(send_env, receive_env);
  default: /* Should not come here */
    fprintf(stderr, "%s(%i): <ERROR> unknown major value - %d\n", file, line, 
	    send_env->_major);
    mg_exit(send_env, receive_env);
  }
}


static void print_error_desc(char* prefix, MegacoMessage_ErrorDescriptor* errorP) {
  fprintf(stdout, "%s: {%d,", prefix, errorP->code);
  if (errorP->text._d)
    fprintf(stdout, "%s}\n", errorP->text._u.val);
  else
    fprintf(stdout, "-}\n");
}


static void print_pid(char* prefix, erlang_pid* pidP) {
  fprintf(stdout, "%s{<%d.%d.%d>, %s}\n", 
	  prefix, pidP->creation, pidP->num, pidP->serial, pidP->node);
}


static void print_binary(char* prefix, erlang_binary* binP) {
  int i;

  fprintf(stdout, "%s<<", prefix);
  for (i = 0 ; i < binP->_length ; i++) {
    if (i == 0)
      fprintf(stdout, "%d", binP->_buffer[i]);
    else
      fprintf(stdout, ",%d", binP->_buffer[i]);
  }
  fprintf(stdout, ">>");
}


static void print_mid_ip4(MegacoMessage_IP4Address ip4) {
  int i;
  fprintf(stdout, "ip4, [");
  for (i = 0 ; i < ip4.address._length ; i++) {
    fprintf(stdout, "%2d", ip4.address._buffer[i]);
    if (i < (ip4.address._length - 1))
      fprintf(stdout, ".");
  }
  fprintf(stdout, "]");
  if (ip4.portNumber._d)
    fprintf(stdout, ":%d", ip4.portNumber._u.val);
}


static void print_mid_ip6(MegacoMessage_IP6Address ip6) {
  int i;
  fprintf(stdout, "ip6, [");
  for (i = 0 ; i < ip6.address._length ; i++) {
    fprintf(stdout, "%2d", ip6.address._buffer[i]);
    if (i < (ip6.address._length - 1))
      fprintf(stdout, ".");
  }
  fprintf(stdout, "]");
  if (ip6.portNumber._d)
    fprintf(stdout, ":%d", ip6.portNumber._u.val);
}


static void print_mid_domain(MegacoMessage_DomainName domain) {
  fprintf(stdout, "domain, %s", domain.name);
  if (domain.portNumber._d)
    fprintf(stdout, ":%d", domain.portNumber._u.val);
}


static void print_mid_device(char* device) {
  fprintf(stdout, "device, %s", device);
}


static void print_mid_mtp(MegacoMessage_OctetString mtp) {
  int i;
  fprintf(stdout, "mtp, ");
  for (i = 0 ; i < mtp._length ; i++) {
    fprintf(stdout, "%d", mtp._buffer[i]);
    if (i < (mtp._length - 1))
      fprintf(stdout, ".");
  }
}


static void print_mid(char* prefix, MegacoMessage_MIdUnion* midP) {
  fprintf(stdout, "%s{", prefix);

  switch (midP->_d) {

  case MegacoMessage_MIdChoice_ip4Address:
    print_mid_ip4(midP->_u.ip4);
    break;

  case MegacoMessage_MIdChoice_ip6Address:
    print_mid_ip6(midP->_u.ip6);
    break;

  case MegacoMessage_MIdChoice_domainName:
    print_mid_domain(midP->_u.domain);
    break;

  case MegacoMessage_MIdChoice_deviceName:    
    print_mid_device(midP->_u.device);
    break;
    
  case MegacoMessage_MIdChoice_mtpAddress:
    print_mid_mtp(midP->_u.mtp);
    break;
    
  case MegacoMessage_MIdChoice_preliminary:
    fprintf(stdout, "preliminary");
    break;
    
  default:
    fprintf(stdout, "UNDEFINED(%d)", midP->_d);
    break;
  }
  fprintf(stdout, "}");
}


static void print_conn_handle(char* prefix, Megaco_ConnHandle* connP) {
  fprintf(stdout, "%s", prefix);
  print_mid("{",  &connP->localMid);
  print_mid(", ", &connP->remoteMid);
  fprintf(stdout, "}\n");
  fflush(stdout);
}


static void print_recv_handle(Megaco_ReceiveHandle* rhP) {
  print_mid("{",  &rhP->localMid);
  fprintf(stdout, ", %s, %s, %s}", 
	  rhP->encodingMod, rhP->encodingConfig, rhP->sendMod);
}


static void print_incr_timer(Megaco_IncrTimer* tmrP) {
  fprintf(stdout, "{%d, %d, %d, %d}", 
	  (int) tmrP->waitFor, (int) tmrP->factor, 
	  (int) tmrP->incr, (int) tmrP->maxRetries);
}


static void print_timer(Megaco_Timer* tmrP) {
  if (tmrP->_d == Megaco_TimerType_once) {
    fprintf(stdout, "{once, %d}", (int) tmrP->_u.once);
  } else {
    fprintf(stdout, "{incremental, ");
    print_incr_timer(&tmrP->_u.incr);
    fprintf(stdout, "}");
  }
}


static void print_info_recv_handle(Megaco_ReceiveHandle* rhP) {
  fprintf(stdout, "receive handle: ");
  print_recv_handle(rhP);
}


static void print_info_send_handle(erlang_binary* binP) {
  print_binary("send handle: ", binP);
}


static void print_info_long(const char* prefix, CORBA_long val) {
  fprintf(stdout, "%s: %d", prefix, (int) val);
}


static void print_info_ushort(const char* prefix, 
				   CORBA_unsigned_short val) {
  fprintf(stdout, "%s: %d", prefix, val);
}


static void print_info_timer(const char* prefix, Megaco_Timer* tmrP) {
  fprintf(stdout, "%s: ", prefix);
  print_timer(tmrP);
}


static void print_info_str(const char* prefix, char* str) {
  fprintf(stdout, "%s: %s", prefix, str);
}


static void print_info_bool(const char* prefix, CORBA_boolean val) {
  fprintf(stdout, "%s: ", prefix);
  if (val) 
    fprintf(stdout, "TRUE");
  else 
    fprintf(stdout, "FALSE");
}


static void print_system_info_conns(Megaco_SystemInfoValue_connections* connsP) {
  int i;

  fprintf(stdout, "connections: ");
  if (connsP->_length > 0) {
    fprintf(stdout, "[");
    for (i = 0 ; i < connsP->_length ; i++) {
      print_conn_handle("", &connsP->_buffer[i]);
    }
    fprintf(stdout, "]");
  } else {
    fprintf(stdout, "[]");
  }
}

static void print_system_info_users(Megaco_SystemInfoValue_users* usersP) {
  int i;

  fprintf(stdout, "users: ");
  if (usersP->_length > 0) {
    fprintf(stdout, "[");
    for (i = 0 ; i < usersP->_length ; i++) {
      if (i == 0)
	print_mid("", &usersP->_buffer[i]);
      else
	print_mid(", ", &usersP->_buffer[i]);
    }
    fprintf(stdout, "]");
  } else {
    fprintf(stdout, "[]");
  }
}


static void print_system_info_nactreq(CORBA_long nActReqs) {
  fprintf(stdout, "number of active requests: %d", (int) nActReqs);
}

static void print_system_info_nactrep(CORBA_long nActReps) {
  fprintf(stdout, "number of active replies: %d", (int) nActReps);
}

static void print_system_info_nactconn(CORBA_long nActConns) {
  fprintf(stdout, "number of active connections: %d", (int) nActConns);
}


static void print_system_info(Megaco_SystemInfoValue* infoP) {
  fprintf(stdout, "system info - ");

  switch (infoP->_d) {
  case Megaco_SystemInfo_connections:
    print_system_info_conns(&infoP->_u.connections);
    break;

  case Megaco_SystemInfo_users:
    print_system_info_users(&infoP->_u.users);
    break;
    
  case Megaco_SystemInfo_NActiveRequests:
    print_system_info_nactreq(infoP->_u.nActiveRequests);
    break;
    
  case Megaco_SystemInfo_NActiveReplies:
    print_system_info_nactrep(infoP->_u.nActiveReplies);
    break;
    
  case Megaco_SystemInfo_NActiveConnections:
    print_system_info_nactconn(infoP->_u.nActiveConnections);
    break;

  default:
    fprintf(stdout, "UNDEFINED(%d)", infoP->_d);
    break;
  }
  fprintf(stdout, "\n");
  fflush(stdout);
}


static void print_user_info_conns(Megaco_UserInfoValue_connections* connsP) {
  int i;

  fprintf(stdout, "connections: ");
  if (connsP->_length > 0) {
    fprintf(stdout, "[");
    for (i = 0 ; i < connsP->_length ; i++) {
      print_conn_handle("", &connsP->_buffer[i]);
    }
    fprintf(stdout, "]");
  } else {
    fprintf(stdout, "[]");
  }
}


static void print_user_info(Megaco_UserInfoValue* infoP) {
  fprintf(stdout, "user info - ");

  switch (infoP->_d) {
  case Megaco_UserInfo_connections:
    print_user_info_conns(&infoP->_u.connections);
    break;

  case Megaco_UserInfo_receiveHandle:
    print_info_recv_handle(&infoP->_u.rh);
    break;
    
  case Megaco_UserInfo_minTransId:
    print_info_long("min transaction id", infoP->_u.minTransId);
    break;
    
  case Megaco_UserInfo_maxTransId:
    print_info_long("max transaction id", infoP->_u.maxTransId);
    break;
    
  case Megaco_UserInfo_autoAck:
    print_info_bool("auto ack", infoP->_u.autoAck);
    break;
    
  case Megaco_UserInfo_requestTimer:
    print_info_timer("request timer", &infoP->_u.requestTimer);
    break;

  case Megaco_UserInfo_longRequestTimer:
    print_info_timer("long request timer", &infoP->_u.longRequestTimer);
    break;

  case Megaco_UserInfo_replyTimer:
    print_info_timer("reply timer", &infoP->_u.replyTimer);
    break;

  case Megaco_UserInfo_pendingTimer:
    print_info_timer("pending timer", &infoP->_u.pendingTimer);
    break;

  case Megaco_UserInfo_sendMod:
    print_info_str("send module", infoP->_u.sendMod);
    break;

  case Megaco_UserInfo_encodingMod:
    print_info_str("encoding module", infoP->_u.encodingMod);
    break;

  case Megaco_UserInfo_encodingConfig:
    print_info_str("encoding config", infoP->_u.encodingConfig);
    break;

  case Megaco_UserInfo_replyData:
    print_info_str("reply data", infoP->_u.replyData);
    break;

  case Megaco_UserInfo_userMod:
    print_info_str("user module", infoP->_u.userMod);
    break;

  case Megaco_UserInfo_userArgs:
    print_info_str("user arguments", infoP->_u.userArgs);
    break;

  case Megaco_UserInfo_protocolVersion: