--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// //
+// PBX4Linux //
+// //
+//---------------------------------------------------------------------------//
+// Copyright: Andreas Eversberg //
+// //
+// h323_con connection class //
+// //
+///////////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "main.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+//
+// constructor
+//
+H323_con::H323_con(H323_ep &endpoint, unsigned callReference) : H323Connection(endpoint, callReference)
+{
+ PDEBUG(DEBUG_H323, "H323 connection constuctor\n");
+
+ SetAudioJitterDelay(0, 0);
+}
+
+
+//
+// destructor
+//
+H323_con::~H323_con()
+{
+ class H323Port *port;
+ const unsigned char *token_string = callToken;
+ struct message *message;
+
+ mutex_h323.Wait();
+
+ // get ioport
+ port = (class H323Port *)find_port_with_token((char *)token_string);
+ if (!port)
+ {
+ PERROR("no port with token '%s'\n", token_string);
+ } else
+ {
+ /* sending release (if not already) */
+ message = message_create(port->p_serial, ACTIVE_EPOINT(port->p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
+ message->param.disconnectinfo.cause = 16;
+ message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
+ message_put(message);
+ }
+
+ mutex_h323.Signal();
+
+ PDEBUG(DEBUG_H323, "H323 connection destuctor\n");
+}
+
+
+//
+// AnswerCallResponse (incoming call)
+//
+H323Connection::AnswerCallResponse H323_con::OnAnswerCall(const PString &, const H323SignalPDU &setupPDU, H323SignalPDU &connectPDU)
+{
+ class H323Port *port;
+ const char *calleraddress;
+ char callerip[32], *extension;
+ const char *dialing = NULL;
+ const H225_Setup_UUIE &setup = setupPDU.m_h323_uu_pdu.m_h323_message_body;
+ const H225_ArrayOf_AliasAddress &adr = setup.m_destinationAddress;
+ PINDEX i;
+ const unsigned char *token_string = callToken;
+ struct message *message;
+ class Endpoint *epoint;
+
+ const Q931 setup_q931 = setupPDU.GetQ931();
+ PString calling_number;
+ PString redir_number;
+ unsigned type, plan, present, screen, reason;
+
+ struct caller_info *callerinfo;
+ struct dialing_info *dialinginfo;
+ struct capa_info *capainfo;
+ struct redir_info *redirinfo;
+ char option[64] = "";
+
+ PDEBUG(DEBUG_H323, "H323 connection incoming call\n");
+
+ mutex_h323.Wait();
+
+ // alloc new h323 port structure
+ if (!(port = new H323Port(PORT_TYPE_H323_IN, (char *)token_string, NULL)))
+ {
+ mutex_h323.Signal();
+ return AnswerCallDenied;
+ }
+ callerinfo = &port->p_callerinfo;
+ redirinfo = &port->p_redirinfo;
+ capainfo = &port->p_capainfo;
+ dialinginfo = &port->p_dialinginfo;
+
+ memset(callerinfo, 0, sizeof(struct caller_info));
+ memset(redirinfo, 0, sizeof(struct redir_info));
+ memset(capainfo, 0, sizeof(struct capa_info));
+ memset(dialinginfo, 0, sizeof(struct dialing_info));
+
+ callerinfo->itype = INFO_ITYPE_H323;
+
+ // get calling party information
+ if (setup_q931.GetCallingPartyNumber(calling_number, &plan, &type, &present, &screen))
+ {
+ SCPY(callerinfo->id, calling_number.GetPointer());
+ switch (present)
+ {
+ case 1:
+ callerinfo->present = INFO_PRESENT_RESTRICTED;
+ break;
+ case 2:
+ callerinfo->present = INFO_PRESENT_NOTAVAIL;
+ break;
+ default:
+ callerinfo->present = INFO_PRESENT_ALLOWED;
+ break;
+ }
+ switch (type)
+ {
+ case Q931::InternationalType:
+ callerinfo->ntype = INFO_NTYPE_INTERNATIONAL;
+ break;
+ case Q931::NationalType:
+ callerinfo->ntype = INFO_NTYPE_NATIONAL;
+ break;
+ case Q931::SubscriberType:
+ callerinfo->ntype = INFO_NTYPE_SUBSCRIBER;
+ break;
+ default:
+ callerinfo->ntype = INFO_NTYPE_UNKNOWN;
+ break;
+ }
+ switch (screen)
+ {
+ case 0:
+ callerinfo->screen = INFO_SCREEN_USER;
+ break;
+ default:
+ callerinfo->screen = INFO_SCREEN_NETWORK;
+ break;
+ }
+ }
+ redirinfo->itype = INFO_ITYPE_H323;
+ // get redirecting number information
+ if (setup_q931.GetRedirectingNumber(redir_number, &plan, &type, &present, &screen, &reason))
+ {
+ SCPY(redirinfo->id, redir_number.GetPointer());
+ switch (present)
+ {
+ case 1:
+ redirinfo->present = INFO_PRESENT_RESTRICTED;
+ break;
+ case 2:
+ redirinfo->present = INFO_PRESENT_NOTAVAIL;
+ break;
+ default:
+ redirinfo->present = INFO_PRESENT_ALLOWED;
+ break;
+ }
+ switch (type)
+ {
+ case Q931::InternationalType:
+ redirinfo->ntype = INFO_NTYPE_INTERNATIONAL;
+ break;
+ case Q931::NationalType:
+ redirinfo->ntype = INFO_NTYPE_NATIONAL;
+ break;
+ case Q931::SubscriberType:
+ redirinfo->ntype = INFO_NTYPE_SUBSCRIBER;
+ break;
+ default:
+ redirinfo->ntype = INFO_NTYPE_UNKNOWN;
+ break;
+ }
+ switch (screen)
+ {
+ case 0:
+ redirinfo->screen = INFO_SCREEN_USER;
+ break;
+ default:
+ redirinfo->screen = INFO_SCREEN_NETWORK;
+ break;
+ }
+ switch (reason)
+ {
+ case 1:
+ redirinfo->reason = INFO_REDIR_BUSY;
+ break;
+ case 2:
+ redirinfo->reason = INFO_REDIR_NORESPONSE;
+ break;
+ case 15:
+ redirinfo->reason = INFO_REDIR_UNCONDITIONAL;
+ break;
+ case 10:
+ redirinfo->reason = INFO_REDIR_CALLDEFLECT;
+ break;
+ case 9:
+ redirinfo->reason = INFO_REDIR_OUTOFORDER;
+ break;
+ default:
+ redirinfo->reason = INFO_REDIR_UNKNOWN;
+ break;
+ }
+ }
+
+ // get remote party h323-address information
+ calleraddress = GetRemotePartyAddress();
+ callerip[0] = '\0';
+ if (calleraddress)
+ {
+ if (strstr(calleraddress, "ip$"))
+ {
+ SCPY(callerip, strstr(calleraddress, "ip$")+3);
+ if (strchr(callerip, ':'))
+ *strchr(callerip, ':') = '\0';
+ memmove(strstr(calleraddress, "ip$"), strstr(calleraddress, "ip$")+3, strlen(strstr(calleraddress, "ip$")+3)+1);
+ }
+ if (strchr(calleraddress, ':'))
+ *strchr(calleraddress, ':') = '\0';
+ }
+
+ // get dialing information
+ for(i=0; i<adr.GetSize(); i++)
+ if (adr[i].GetTag() == H225_AliasAddress::e_dialedDigits)
+ dialing = H323GetAliasAddressString(adr[i]);
+ if (!dialing)
+ dialing = "";
+
+ // fill port's information
+ if (calleraddress)
+ SCPY(callerinfo->voip, (char *)calleraddress);
+ capainfo->bearer_mode = INFO_BMODE_CIRCUIT;
+ capainfo->bearer_info1 = (options.law=='u')?INFO_INFO1_ULAW:INFO_INFO1_ALAW;
+ capainfo->bearer_capa = INFO_BC_SPEECH;
+
+ // change to incoming setup state
+ port->new_state(PORT_STATE_IN_OVERLAP);
+
+ // allocate new endpoint
+ if (!(epoint = new Endpoint(port->p_serial, 0)))
+ {
+ // error allocating endpoint
+ PDEBUG(DEBUG_H323, "h323-connection(%s) rejecting call because cannot create epoint for '%s'\n", port->p_name, callerinfo->id);
+ delete port;
+ port = NULL;
+ mutex_h323.Signal();
+ return AnswerCallDenied;
+ }
+ if (!(epoint->ep_app = new DEFAULT_ENDPOINT_APP(epoint)))
+ {
+ PERROR("no memory for application\n");
+ exit(-1);
+ }
+ if (!(port->epointlist_new(epoint->ep_serial)))
+ {
+ PERROR("no memory for epointlist\n");
+ exit(-1);
+ }
+ port->set_tone(NULL, "");
+
+ // send setup message to endpoint
+ message = message_create(port->p_serial, ACTIVE_EPOINT(port->p_epointlist), PORT_TO_EPOINT, MESSAGE_SETUP);
+ message->param.setup.port_type = port->p_type;
+
+ // before we start, we may check for h323_gateway entry
+ if (callerip[0])
+ {
+ extension = parse_h323gateway(callerip, option, sizeof(option));
+ if (extension)
+ {
+ PDEBUG(DEBUG_H323, "h323-connection(%s) gateway '%s' is mapped to extension '%s' (option= '%s')\n", port->p_name, callerip, extension, option);
+ SCPY(callerinfo->id, extension);
+ SCPY(callerinfo->intern, extension);
+ callerinfo->itype = INFO_ITYPE_INTERN;
+ callerinfo->screen = INFO_SCREEN_NETWORK;
+ } else
+ {
+ PDEBUG(DEBUG_H323, "h323-connection(%s) gateway '%s' is not mapped to any extension. (port_type=0x%x)\n", port->p_name, callerip, port->p_type);
+ // get the default dialing external dialing string
+ }
+ }
+
+ // default dialing for extenal calls
+ if (!callerinfo->intern[0] && !dialing[0])
+ dialing = options.h323_icall_prefix;
+
+ // dialing information
+ if (callerip[0] || dialing[0])
+ {
+ SCPY(dialinginfo->number, (char *)dialing);
+ dialinginfo->ntype = INFO_NTYPE_UNKNOWN;
+ }
+
+ memcpy(&message->param.setup.callerinfo, callerinfo, sizeof(struct caller_info));
+ memcpy(&message->param.setup.dialinginfo, dialinginfo, sizeof(struct dialing_info));
+ memcpy(&message->param.setup.redirinfo, redirinfo, sizeof(struct redir_info));
+ memcpy(&message->param.setup.capainfo, capainfo, sizeof(struct capa_info));
+ message->param.setup.dtmf = 1;
+ message_put(message);
+
+ port->p_h323_connect = &(connectPDU.GetQ931());
+
+ mutex_h323.Signal();
+
+ if (!strcasecmp(option, "connect") || !strcasecmp(option, "dtmf"))
+ {
+ port->new_state(PORT_STATE_CONNECT);
+ return AnswerCallNow;
+ } else
+ {
+ return AnswerCallDeferred;
+ }
+}
+
+
+//
+// OnOutgoingCall (outgoing call)
+//
+BOOL H323_con::OnOutgoingCall(const H323SignalPDU &connectPDU)
+{
+ class H323Port *port;
+ const char *calleraddress;
+ char callerip[32];
+ const unsigned char *token_string = callToken;
+ struct message *message;
+// H225_Connect_UUIE &connect_uuie = connectPDU.m_h323_uu_pdu.m_h323_message_body;
+
+ const Q931 connect_q931 = connectPDU.GetQ931();
+ PString connect_number;
+ unsigned type = 0, plan = 0, present = 0, screen = 0;
+ struct connect_info *connectinfo;
+
+ PDEBUG(DEBUG_H323, "H323 connection outgoing call is connected.\n");
+
+ mutex_h323.Wait();
+
+ if (!(port = (class H323Port *)find_port_with_token((char *)token_string)))
+ {
+ PERROR(" cannot find port with token '%s'\n", token_string);
+ mutex_h323.Signal();
+ return FALSE;
+ }
+ connectinfo = &port->p_connectinfo;
+
+ if (port->p_type == PORT_TYPE_H323_IN)
+ {
+ PDEBUG(DEBUG_H323, "H323 endpoint OnConnectionEstablished() incoming port\n");
+ }
+ if (port->p_type == PORT_TYPE_H323_OUT)
+ {
+ PDEBUG(DEBUG_H323, "H323 endpoint OnConnectionEstablished() outgoing port\n");
+ if (port->p_state==PORT_STATE_OUT_SETUP
+ || port->p_state==PORT_STATE_OUT_OVERLAP
+ || port->p_state==PORT_STATE_OUT_PROCEEDING
+ || port->p_state==PORT_STATE_OUT_ALERTING)
+ {
+ // get remote party h323-address information
+ calleraddress = GetRemotePartyAddress();
+ callerip[0] = '\0';
+ if (calleraddress)
+ {
+ if (strchr(calleraddress, '$'))
+ {
+ SCPY(callerip, strchr(calleraddress, '$'));
+ callerip[sizeof(callerip)-1] = '\0';
+ if (strchr(callerip, ':'))
+ *strchr(callerip, ':') = '\0';
+ }
+ SCPY(connectinfo->voip, (char *)calleraddress);
+ }
+
+ // get COLP
+ memset(connectinfo, 0, sizeof(struct connect_info));
+ connectinfo->itype = INFO_ITYPE_H323;
+ if (connect_q931.GetConnectedNumber(connect_number, &plan, &type, &present, &screen))
+ {
+ SCPY(connectinfo->id, connect_number.GetPointer());
+ switch (present)
+ {
+ case 1:
+ connectinfo->present = INFO_PRESENT_RESTRICTED;
+ break;
+ case 2:
+ connectinfo->present = INFO_PRESENT_NOTAVAIL;
+ break;
+ default:
+ connectinfo->present = INFO_PRESENT_ALLOWED;
+ }
+ switch (type)
+ {
+ case Q931::InternationalType:
+ connectinfo->ntype = INFO_NTYPE_INTERNATIONAL;
+ break;
+ case Q931::NationalType:
+ connectinfo->ntype = INFO_NTYPE_NATIONAL;
+ break;
+ case Q931::SubscriberType:
+ connectinfo->ntype = INFO_NTYPE_SUBSCRIBER;
+ break;
+ default:
+ connectinfo->ntype = INFO_NTYPE_UNKNOWN;
+ }
+ switch (screen)
+ {
+ case 0:
+ connectinfo->screen = INFO_SCREEN_USER;
+ break;
+ default:
+ connectinfo->screen = INFO_SCREEN_NETWORK;
+ }
+ }
+ port->new_state(PORT_STATE_CONNECT);
+ message = message_create(port->p_serial, ACTIVE_EPOINT(port->p_epointlist), PORT_TO_EPOINT, MESSAGE_CONNECT);
+ memcpy(&message->param.connectinfo, connectinfo, sizeof(struct connect_info));
+ message_put(message);
+ }
+ }
+
+ mutex_h323.Signal();
+
+ return H323Connection::OnOutgoingCall(connectPDU);
+}
+
+
+//
+// send setup information to the called h323 user
+//
+BOOL H323_con::OnSendSignalSetup(H323SignalPDU &setupPDU)
+{
+ H225_Setup_UUIE &setup = setupPDU.m_h323_uu_pdu.m_h323_message_body;
+ H225_ArrayOf_AliasAddress &adr = setup.m_sourceAddress;
+ H225_AliasAddress new_alias;
+ PString calling_number;
+ PString calling_alias;
+ PString dialing_number;
+ PString redir_number;
+ int type, present, screen, reason;
+ class H323Port *port;
+ const unsigned char *token_string = callToken;
+
+ struct caller_info *callerinfo;
+ struct dialing_info *dialinginfo;
+ struct capa_info *capainfo;
+ struct redir_info *redirinfo;
+
+ mutex_h323.Wait();
+
+ if (!(port = (class H323Port *)find_port_with_token((char *)token_string)))
+ {
+ PERROR(" no port with token '%s'\n", token_string);
+ mutex_h323.Signal();
+ return FALSE;
+ }
+ callerinfo = &port->p_callerinfo;
+ redirinfo = &port->p_redirinfo;
+ capainfo = &port->p_capainfo;
+ dialinginfo = &port->p_dialinginfo;
+
+ PDEBUG(DEBUG_H323, "H323-connection sending modified setup signal '%s'->'%s'\n", callerinfo->id, dialinginfo->number);
+
+
+ if (callerinfo->present!=INFO_PRESENT_NULL)
+ {
+ calling_alias = numberrize_callerinfo(callerinfo->id, callerinfo->ntype);
+ H323SetAliasAddress(calling_alias, new_alias);
+ adr.SetSize(adr.GetSize()+1);
+ adr[adr.GetSize()-1] = new_alias;
+
+ calling_number = callerinfo->id;
+ switch(callerinfo->ntype)
+ {
+ case INFO_NTYPE_SUBSCRIBER:
+ type = Q931::SubscriberType;
+ break;
+ case INFO_NTYPE_NATIONAL:
+ type = Q931::NationalType;
+ break;
+ case INFO_NTYPE_INTERNATIONAL:
+ type = Q931::InternationalType;
+ break;
+ default: /* INFO_NTYPE_UNKNOWN */
+ type = Q931::UnknownType;
+ }
+
+ switch(callerinfo->present)
+ {
+ case INFO_PRESENT_RESTRICTED:
+ present = 1;
+ break;
+ case INFO_PRESENT_NOTAVAIL:
+ present = 2;
+ break;
+ default: /* INFO_PRESENT_ALLOWED */
+ present = 0;
+ }
+ switch(callerinfo->screen)
+ {
+ case INFO_SCREEN_USER:
+ screen = 0;
+ break;
+ default: /* INFO_SCREEN_NETWORK */
+ screen = 3;
+ }
+
+ Q931 &new_q931 = setupPDU.GetQ931();
+ new_q931.SetCallingPartyNumber(calling_number, Q931::ISDNPlan, type, present, screen);
+ }
+
+ if (redirinfo->present!=INFO_PRESENT_NULL)
+ {
+ if (redirinfo->present==INFO_PRESENT_ALLOWED)
+ {
+ redir_number = callerinfo->id;
+ } else
+ redir_number = "";
+
+ switch(redirinfo->ntype)
+ {
+ case INFO_NTYPE_SUBSCRIBER:
+ type = Q931::SubscriberType;
+ break;
+ case INFO_NTYPE_NATIONAL:
+ type = Q931::NationalType;
+ break;
+ case INFO_NTYPE_INTERNATIONAL:
+ type = Q931::InternationalType;
+ break;
+ default: /* INFO_TYPE_UNKNOWN */
+ type = Q931::UnknownType;
+ }
+
+ switch(redirinfo->present)
+ {
+ case INFO_PRESENT_RESTRICTED:
+ present = 1;
+ break;
+ case INFO_PRESENT_NOTAVAIL:
+ present = 2;
+ break;
+ default: /* INFO_PRESENT_ALLOWED */
+ present = 0;
+ }
+
+ switch(redirinfo->reason)
+ {
+ case INFO_REDIR_BUSY:
+ reason = 1;
+ break;
+ case INFO_REDIR_NORESPONSE:
+ reason = 2;
+ break;
+ case INFO_REDIR_UNCONDITIONAL:
+ reason = 15;
+ break;
+ case INFO_REDIR_OUTOFORDER:
+ reason = 9;
+ break;
+ case INFO_REDIR_CALLDEFLECT:
+ reason = 10;
+ break;
+ default: /* INFO_REDIR_UNKNOWN */
+ reason = 0;
+ }
+
+ Q931 &new_q931 = setupPDU.GetQ931();
+ new_q931.SetRedirectingNumber(redir_number, Q931::ISDNPlan, type, present, screen, reason);
+ }
+
+ if (dialinginfo->number[0])
+ {
+ dialing_number = dialinginfo->number;
+
+ Q931 &new_q931 = setupPDU.GetQ931();
+ new_q931.SetCalledPartyNumber(dialing_number);
+ }
+
+ mutex_h323.Signal();
+
+ return H323Connection::OnSendSignalSetup(setupPDU);
+}
+
+
+//
+// callback for start of channel
+//
+BOOL H323_con::OnStartLogicalChannel(H323Channel &channel)
+{
+ if (!H323Connection::OnStartLogicalChannel(channel))
+ {
+ PERROR("starting logical channel failed!\n");
+ return FALSE;
+ }
+
+ PDEBUG(DEBUG_H323, "H323 connection starting logical channel using \"%s\" codec %s :%s\n",
+ channel.GetCapability().GetFormatName().GetPointer(),
+ (channel.GetDirection()==H323Channel::IsTransmitter)?"transmit":"receive",
+ callToken.GetPointer());
+
+ return H323Connection::OnStartLogicalChannel(channel);
+}
+
+
+//
+// user input received
+//
+void H323_con::OnUserInputString (const PString &value)
+{
+ class H323Port *port;
+ const unsigned char *token_string = callToken;
+ const unsigned char *value_string = value;
+ struct message *message;
+
+ PDEBUG(DEBUG_H323, "H323-connection received user input'%s'\n", value_string);
+
+ mutex_h323.Wait();
+
+ if (!(port = (class H323Port *)find_port_with_token((char *)token_string)))
+ {
+ PERROR("no port with token '%s'\n", token_string);
+ } else
+ {
+ while(*value_string)
+ {
+ message = message_create(port->p_serial, ACTIVE_EPOINT(port->p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
+ message->param.dtmf = *value_string++;
+ message_put(message);
+ }
+#if 0
+ message = message_create(port->p_serial, ACTIVE_EPOINT(port->p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION);
+ SCPY(message->param.information.number, (char *)value_string);
+ message_put(message);
+#endif
+ }
+
+ mutex_h323.Signal();
+}
+
projects / lcr.git / blobdiff