minisiptextui.cxx

MiniSip Client with DomainKeys Authentication, Sip, Audio communications, Echo Cancel

			p2tGroupId=grpList->getGroupIdentity();   
			
			displayMessage(inviting_user + " invited you to a P2T Session:", blue);
			showGroupList();
			displayMessage("type 'accept' or 'deny'", blue);
			state="P2T ACCEPT?";
			setPrompt("P2T ACCEPT?");
		}
	
	}
	
	/****
	* p2tSessionCreated
	* DestinationID: 
	* Param1:        GroupId (SipDialogP2T)
	* Param2:
	* Param3:
	* Description:   the P2T Session is set up
	****/
	else if (cmd.getOp()=="p2tSessionCreated"){
		p2tGroupId=cmd.getParam();
		displayMessage("P2T Session "+ p2tGroupId + " created", green);
		grpList->setGroupIdentity(p2tGroupId);
		state="P2T CONNECTED";
		setPrompt(state);
	}    
	
	else if (cmd.getOp().substr(0,3)=="p2t"){
		displayMessage("Received: "+cmd.getOp(), blue);
	}
#endif
}

bool MinisipTextUI::configDialog( MRef<SipSoftPhoneConfiguration *> /*conf*/ ){
	cout << "ERROR: MinisipTextUI::configDialog is not implemented"<< endl;
	return false;
}

void MinisipTextUI::showCalls(){
	//list<MRef<SipDialog*> > *calls = config->sip->getDialogContainer()->getDispatcher()->getDialogs();
	list<MRef<SipDialog*> > calls = config->sip->getSipStack()->getDispatcher()->getDialogs();
	displayMessage(string("Calls:"));
	if (calls.size()==0)
		displayMessage("    (no calls)");
	else{
		int ii=0;	   
		for (list<MRef<SipDialog*> >::iterator i=calls.begin(); i!=calls.end(); i++,ii++){
			displayMessage(string("    (")+itoa(ii)+") "
					+ (*i)->getName() 
					+ "   State: "
					+ (*i)->getCurrentStateName());
			//                    + "  ObjectId: " + itoa(   (int) (*(((*calls)[i])))    )  );
		}
	}
}

void MinisipTextUI::showTransactions(string command){
	list<MRef<SipDialog*> > calls = config->sip->getSipStack()->getDispatcher()->getDialogs();

	string tno = trim(command).substr(17);
	int itno=0;
	if (trim(tno).size()==0){
		displayMessage("show transaction <transaction_nr>");
	}else{
		itno = atoi(tno.c_str());

		if (((int)calls.size())-1>=itno){
			list<MRef<SipDialog*> >::iterator call = calls.begin();
			for (int j=0; j < itno; j++)
				call++;
			//            MRef<SipDialog*> call = (*calls)[itno];

			displayMessage(string("Transactions for call ")+(*call)->getName());
			list<MRef<SipTransaction*> > transactions = (*call)->getTransactions();
			if (transactions.size()==0)
				displayMessage("(no transactions)");
			else{
				int n=0;
				for (list<MRef<SipTransaction*> >::iterator i = transactions.begin();
						i!=transactions.end(); i++){
					displayMessage(string("    (")+itoa(n)+") "+
							(*i)->getName() 
							+ "   State: "
							+ (*i)->getCurrentStateName()
#ifdef _MSC_VER
							);
#else
							+ "  ObjecdId: " + itoa((int)*(*i)));
#endif
					n++;
				}
			}
		}else{
			displayMessage("Call not found", red);
		}
	}

}

void MinisipTextUI::showTimeouts(){
	string to = config->sip->getSipStack()->getTimeoutProvider()->getTimeouts();
	displayMessage(string("Timeouts: \n")+to);
}


void MinisipTextUI::showDialogInfo(MRef<SipDialog*> d, bool usesStateMachine, string header){
	list <TPRequest<string,MRef<StateMachine<SipSMCommand,string>*> > > torequests = 
				config->sip->getSipStack()->getTimeoutProvider()->getTimeoutRequests();
		
	if (usesStateMachine){
		displayMessage(header + d->getName() + "   State: " + d->getCurrentStateName());
	}else{
		displayMessage(header + d->getName());
	}
		
	displayMessage("        SipDialogState:",bold);
	cerr << BOLD << "        SipDialogState: "<< PLAIN;
	displayMessage(
			string("            secure=") + (d->dialogState.secure?string("true"):string("false"))
				+"; localTag=" + d->dialogState.localTag
				+"; remoteTag=" + d->dialogState.remoteTag
				+"; seqNo=" + itoa(d->dialogState.seqNo)
				+"; remoteSeqNo=" + itoa(d->dialogState.remoteSeqNo)
				+"; remoteUri=" + d->dialogState.remoteUri
				+"; remoteTarget=" + d->dialogState.remoteTarget
				+"; isEarly=" + (d->dialogState.isEarly?string("true"):string("false"))
			);
		string routeset;
		list<string>::iterator i;
		for (i=d->dialogState.routeSet.begin(); i!= d->dialogState.routeSet.end(); i++){
			if (i!=d->dialogState.routeSet.begin())
				routeset+= ",";
			routeset+= *i;
		}
		displayMessage( string("            route_set: ")+routeset);
		
	//	displayMessage("        Timeouts:", bold);
		int ntimeouts=0;
		std::list<TPRequest<string,MRef<StateMachine<SipSMCommand,string>*> > >::iterator jj=torequests.begin();
		for (uint32_t j=0; j< torequests.size(); j++,jj++){
			if ( *d == *((*jj).get_subscriber()) ){
				int ms= (*jj).get_ms_to_timeout();
				string theader = ntimeouts==0?"        Timeouts: ": "                  ";
				displayMessage(theader+ (*jj).get_command() + "  Time: " + itoa(ms/1000) + "." + itoa(ms%1000));
				ntimeouts++;
			}
		}
		if (ntimeouts==0){
			displayMessage("        (no timeouts)");
		}

	//	displayMessage( "        Transactions:", bold);
		list<MRef<SipTransaction*> > transactions = d->getTransactions();
		if (transactions.size()==0)
			displayMessage("        (no transactions)");
		else{
			int n=0;
			for (list<MRef<SipTransaction*> >::iterator i = transactions.begin();
					i!=transactions.end(); i++){
				
				string header =  n==0 ? "        Transactions: " : "                      " ;
				displayMessage(header +  string("(")+itoa(n)+") "+ (*i)->getName() + "   State: " + (*i)->getCurrentStateName());
				n++;
	
	//			displayMessage("                Timeouts:", bold);
	
				int ntimeouts=0;
				std::list<TPRequest<string,   MRef<StateMachine<SipSMCommand,string>*>  > >::iterator jj=torequests.begin();
				for (uint32_t j=0; j< torequests.size(); j++, jj++){
					if ( *((*i)) == *((*jj).get_subscriber()) ){
						int ms= (*jj).get_ms_to_timeout();
						string header = ntimeouts==0?"            Timeouts: " : "                      ";
						displayMessage(header + string("      timeout: ")
							+ (*jj).get_command()
							+ "  Time: " + itoa(ms/1000) + "." + itoa(ms%1000));
						ntimeouts++;
					}
				}
				if (ntimeouts==0)
					displayMessage("                        (no timeouts)");
			}
		}
	
}

void MinisipTextUI::showStat(){
	list<MRef<SipDialog*> > calls = config->sip->getSipStack()->getDispatcher()->getDialogs();

	list <TPRequest<string, MRef<StateMachine<SipSMCommand,string>*> > > torequests = config->sip->getSipStack()->getTimeoutProvider()->getTimeoutRequests();

//	displayMessage(" Default dialog handler:", bold);
//	showDialogInfo(config->sip->getSipStack()->getDefaultHandler(), false, "  Default dialog handler: ");

	displayMessage(" Calls:", bold);
	if (calls.size()==0)
		displayMessage("    (no calls)");
	else{
		int ii=0;
		for (list<MRef<SipDialog*> >::iterator i=calls.begin(); i!= calls.end(); i++, ii++){
			showDialogInfo(*i,true, string("    (")+itoa(ii)+") ");
		}
	}

}


void MinisipTextUI::showMem(){
	string all;
	minilist<string> names = getMemObjectNames();
	for (int i=0; i<names.size();i++){
		all = all+names[i]+"\n";
	}
	displayMessage(all+itoa(getMemObjectCount())+" objects");
}

#ifdef P2T_SUPPORT

void MinisipTextUI::showGroupList(){
	if (grpList->getDescription().substr(0,5)=="ERROR"){
		displayMessage(grpList->getDescription(), red);
		return;
	}
	displayMessage("Session Parameters:", bold);
	
	if(grpList->getDescription()!="")
		displayMessage("Description:      " + grpList->getDescription());
	
	if(grpList->getGroupIdentity()!="")
		displayMessage("Group Id:         " + grpList->getGroupIdentity());
	
	if(grpList->getGroupOwner()!="")    
		displayMessage("Group Owner:      " + grpList->getGroupOwner());
		
	displayMessage("Session Type:     " + P2T::getSessionType(grpList->getSessionType()));
	displayMessage("Membership:       " + P2T::getMembership(grpList->getMembership()));   
	
	if(grpList->getMaxFloorTime()>0)
		displayMessage("Max Floor Time:   " + itoa(grpList->getMaxFloorTime()));
	
	if(grpList->getMaxParticipants()>0)
		displayMessage("Max Participants: " + itoa(grpList->getMaxParticipants()));
	
	if(grpList->getAllMember().size()>0){
		displayMessage("Members:", bold);
		for(uint32_t k=0;k<grpList->getAllMember().size();k++) {
			displayMessage(grpList->getAllMember().at(k));
		}
	}
	
	if(grpList->getAllUser().size()>0){
		displayMessage("Participants:", bold);
		for(uint32_t k=0;k<grpList->getAllUser().size();k++)
			displayMessage(grpList->getAllUser().at(k)->getUri() + " (" + 
				itoa(grpList->getAllUser().at(k)->getPriority()) + ") " +
				P2T::getStatus(grpList->getAllUser().at(k)->getStatus()));
	}
}

void MinisipTextUI::showP2TInfo(){
	displayMessage("*********************************************", blue);
	displayMessage("*          You are now in P2T-Mode          *",blue);
	displayMessage("*********************************************",blue);				
	displayMessage("The following commands are possible:", blue);
	displayMessage("add <uri>      add a user to the session",blue);
	//displayMessage("edit           set the parameters",blue);
	displayMessage("download <url> load group member list from",blue);
	displayMessage("               http server, e.g.",blue);
	displayMessage("               http://1.2.3.4:3365/grouplist.xml",blue);
	//displayMessage("load <file>    load group member list form file",blue);
	//displayMessage("save <file>    save group member list to file",blue);
	displayMessage("show           shows the group member list",blue);
	displayMessage("connect        start p2t session",blue);
	displayMessage("talk           get the floor",blue);
	displayMessage("stop           release the floor",blue);
	displayMessage("exit           leave P2T Mode",blue);
}
#endif

void MinisipTextUI::keyPressed(int key){
	switch(key){
	case '*':
		showMem();
		break;
	case '+':
		showStat();
		break;
	}
}

void MinisipTextUI::guiExecute(string cmd){
	string command = trim(cmd);
	string regproxy;
	bool handled = false;

/*	if (cmd=="quit"){
		exit(0);
	}
*/
	
	if (command.substr(0,8) == "register"){
		displayMessage("Registering to proxy", blue);
		regproxy = trim(command.substr(8));
		mdbg << "Regproxy=<"<<regproxy<<">"<< end;
		CommandString command("",SipCommandString::proxy_register/*, regproxy*/);

//		if (regproxy=="pstn")
//			command.setDestinationId("pstn");

		command["proxy_domain"] = regproxy;
		//callback->guicb_handleCommand(command);
		sendCommand("sip",command);
		handled=true;
	}
	
	if (command == "quit"){
		running=false;
		displayMessage("Minisip is exiting...");
		handled=true;
	}

	if (command == "show calls"){
		showCalls();
		handled=true;
	}

	if (command == "enable autoanswer"){
		autoanswer=true;
		displayMessage("Autoanswer is now enabled.");
		handled=true;
	}
	if (command == "disable autoanswer"){
		autoanswer=false;
		displayMessage("Autoanswer is now disabled.");
		handled=true;
	}
	if (command == "enable debugmsgs"){
		mdbg.setEnabled(true);
		displayMessage("Debug messages is now enabled.");
		handled=true;
	}
	if (command == "disable debugmsgs"){
		mdbg.setEnabled(false);
		displayMessage("Debug messages is now disabled.");
		handled=true;
	}

	if (command == "show timeouts"){
		showTimeouts();
		handled=true;
	}

#ifdef DEBUG_OUTPUT
	if (command == "show packets"){
		set_debug_print_packets(true);
		//sipdebug_print_packets=true;
		displayMessage("SIP messages will be displayed on the screen", blue);
		handled=true;
	}

	if (command == "hide packets"){
		set_debug_print_packets(false);
		//sipdebug_print_packets=false;
		displayMessage("SIP messages will NOT be displayed on the screen", blue);
		handled=true;
	}
#endif

	if (command.substr(0,17) == "show transactions"){
		showTransactions(command);
		handled=true;
	}

	if (command == "answer"){
		CommandString command(callId, SipCommandString::accept_invite);
		//callback->guicb_handleCommand(command);
		sendCommand("sip", command);
		displayMessage("A call with the most recent callId will be accepted");
		handled=true;
                inCall = true;
		displayMessage("Unmuting sending of sound.", blue);
		CommandString cmdstr( callId,
				MediaCommandString::set_session_sound_settings,
				"senders", "ON");
		//callback->guicb_handleMediaCommand(cmdstr);
		sendCommand("media",cmdstr);
		

	}
	if (command == "join"){
		CommandString command(callId, SipCommandString::accept_invite, currentcaller);
		command.setParam3(currentconfname);
				//currentconf->setCallback(callback);
				//state="CONF";
				//displayMessage("	Conf. Name: "+currentconfname);
		//callback->guicb_handleConfCommand(cmd);
		confCallback->setConferenceController(currentconf);
		addCommand("addc");
		addCommand("hangupc");
		confCallback->guicb_handleConfCommand(command);
		displayMessage("A call with the most recent callId will be accepted");
		handled=true;
                inCall = true;
	}

	
	
	if (command == "accept" && state == "TRANSFER?"){
		CommandString command(callId, SipCommandString::user_transfer_accept);
		//callback->guicb_handleCommand(command);
		sendCommand("sip", command);
		handled=true;
	}
	
        if (command == "reject" && state == "TRANSFER?"){
		CommandString command(callId, SipCommandString::user_transfer_refuse);
		//callback->guicb_handleCommand(command);
		sendCommand("sip", command);
		handled=true;
	}

	if (command == "show all"){
		showCalls();

		list<MRef<SipDialog*> > calls = config->sip->getSipStack()->getDispatcher()->getDialogs();
		for (uint32_t i=0; i<calls.size(); i++){
			showTransactions("show transactions "+itoa(i));
		}
		showTimeouts();
		handled=true;
	}

	if (trim(command) == "hangup"){
		CommandString hup(callId, SipCommandString::hang_up);
		//callback->guicb_handleCommand(hup);
		sendCommand("sip", hup);
		
		state="IDLE";
		setPrompt(state);
		displayMessage("hangup");
		handled=true;
		inCall=false;
	}
	if (trim(command) == "hangupc"){
		CommandString hup("", SipCommandString::hang_up);
		hup.setParam3(currentconfname);
		confCallback->guicb_handleConfCommand(hup);