private void sendInviteOK(RequestEvent requestEvent, ServerTransaction inviteTid) {
try {
logger.info("sendInviteOK: " + inviteTid);
if (inviteTid.getState() != TransactionState.COMPLETED) {
logger.info("shootme: Dialog state before OK: " + inviteTid.getDialog().getState());
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
Response okResponse = protocolObjects.messageFactory.createResponse(Response.OK, request);
ListeningPoint lp = sipProvider.getListeningPoint(protocolObjects.transport);
int myPort = lp.getPort();
Address address =
protocolObjects.addressFactory.createAddress(
"Shootme <sip:" + myAddress + ":" + myPort + ">");
ContactHeader contactHeader = protocolObjects.headerFactory.createContactHeader(address);
okResponse.addHeader(contactHeader);
inviteTid.sendResponse(okResponse);
logger.info("shootme: Dialog state after OK: " + inviteTid.getDialog().getState());
TestHarness.assertEquals(DialogState.CONFIRMED, inviteTid.getDialog().getState());
} else {
logger.info("semdInviteOK: inviteTid = " + inviteTid + " state = " + inviteTid.getState());
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
System.out.println("shootme: got an Invite sending Trying");
// System.out.println("shootme: " + request);
Response response = messageFactory.createResponse(Response.RINGING, request);
ServerTransaction st = requestEvent.getServerTransaction();
if (st == null) {
st = sipProvider.getNewServerTransaction(request);
}
dialog = st.getDialog();
st.sendResponse(response);
this.okResponse = messageFactory.createResponse(Response.OK, request);
Address address =
addressFactory.createAddress("Shootme <sip:" + myAddress + ":" + myPort + ">");
ContactHeader contactHeader = headerFactory.createContactHeader(address);
response.addHeader(contactHeader);
ToHeader toHeader = (ToHeader) okResponse.getHeader(ToHeader.NAME);
toHeader.setTag("4321"); // Application is supposed to set.
okResponse.addHeader(contactHeader);
this.inviteTid = st;
// Defer sending the OK to simulate the phone ringing.
// Answered in 1 second ( this guy is fast at taking calls)
this.inviteRequest = request;
new Timer().schedule(new MyTimerTask(this), 1000);
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
System.out.println("cutme: got an Invite sending Trying");
// System.out.println("cutme: " + request);
Response response = messageFactory.createResponse(Response.RINGING, request);
String toTag = Integer.toString((int) (Math.random() * 10000000));
ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
toHeader.setTag(toTag); // Application is supposed to set.
ServerTransaction st = requestEvent.getServerTransaction();
if (st == null) {
st = sipProvider.getNewServerTransaction(request);
}
inviteTid = st;
inviteRequest = request;
dialog = st.getDialog();
// inviteRequest = request;
if (timeToWaitBeforeAnswer > 0) {
Thread.sleep(timeToWaitBeforeAnswer);
}
st.sendResponse(response);
// If we dont send final response this will receive cancel.
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void processCancel(RequestEvent requestEvent, ServerTransaction serverTransactionId) {
Request request = requestEvent.getRequest();
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
try {
logger.info("shootme: got a cancel. ");
// Because this is not an In-dialog request, you will get a null server Tx id here.
if (serverTransactionId == null) {
serverTransactionId = sipProvider.getNewServerTransaction(request);
}
Response response = protocolObjects.messageFactory.createResponse(200, request);
serverTransactionId.sendResponse(response);
String serverTxId = ((ViaHeader) response.getHeader(ViaHeader.NAME)).getBranch();
ServerTransaction serverTx = (ServerTransaction) this.serverTxTable.get(serverTxId);
if (serverTx != null
&& (serverTx.getState().equals(TransactionState.TRYING)
|| serverTx.getState().equals(TransactionState.PROCEEDING))) {
Request originalRequest = serverTx.getRequest();
Response resp =
protocolObjects.messageFactory.createResponse(
Response.REQUEST_TERMINATED, originalRequest);
serverTx.sendResponse(resp);
}
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void run() {
Request request = requestEvent.getRequest();
try {
// System.out.println("shootme: got an Invite sending OK");
Response response = messageFactory.createResponse(180, request);
ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
Address address =
addressFactory.createAddress("Shootme <sip:" + myAddress + ":" + myPort + ">");
ContactHeader contactHeader = headerFactory.createContactHeader(address);
response.addHeader(contactHeader);
// System.out.println("got a server tranasaction " + st);
Dialog dialog = st.getDialog();
/*
* if (dialog != null) { System.out.println("Dialog " + dialog);
* System.out.println("Dialog state " + dialog.getState()); }
*/
st.sendResponse(response); // send 180(RING)
response = messageFactory.createResponse(200, request);
toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
String toTag = new Integer((int) (Math.random() * 1000)).toString();
toHeader.setTag(toTag); // Application is supposed to set.
response.addHeader(contactHeader);
st.sendResponse(response); // send 200(OK)
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void processResponse(ResponseEvent responseReceivedEvent) {
// Log.info("Registering response...." + sipCallId);
Response response = (Response) responseReceivedEvent.getResponse();
int statusCode = response.getStatusCode();
String method = ((CSeqHeader) response.getHeader(CSeqHeader.NAME)).getMethod();
Log.debug("Got response " + response);
if (statusCode == Response.OK) {
isRegistered = true;
Log.info(
"Voice bridge successfully registered with "
+ registrar
+ " for "
+ proxyCredentials.getXmppUserName());
PluginImpl.sipRegisterStatus = "Registered ok with " + proxyCredentials.getHost();
sipServerCallback.removeSipListener(sipCallId);
} else if (statusCode == Response.UNAUTHORIZED
|| statusCode == Response.PROXY_AUTHENTICATION_REQUIRED) {
if (method.equals(Request.REGISTER)) {
CSeqHeader cseq = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
if (cseq.getSequenceNumber() < 2) {
ClientTransaction regTrans =
SipService.handleChallenge(
response, responseReceivedEvent.getClientTransaction(), proxyCredentials);
if (regTrans != null) {
try {
regTrans.sendRequest();
} catch (Exception e) {
Log.info("Registration failed, cannot send transaction " + e);
PluginImpl.sipRegisterStatus = "Registration error " + e.toString();
}
} else {
Log.info("Registration failed, cannot create transaction");
PluginImpl.sipRegisterStatus = "Registration cannot create transaction";
}
} else {
Log.info("Registration failed " + responseReceivedEvent);
PluginImpl.sipRegisterStatus = "Registration failed";
}
}
} else {
Log.info("Unrecognized response: " + response);
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
logger.info("shootme: got an Invite sending Trying");
// logger.info("shootme: " + request);
ServerTransaction st = requestEvent.getServerTransaction();
if (st == null) {
logger.info("null server tx -- getting a new one");
st = sipProvider.getNewServerTransaction(request);
}
logger.info("getNewServerTransaction : " + st);
String txId = ((ViaHeader) request.getHeader(ViaHeader.NAME)).getBranch();
this.serverTxTable.put(txId, st);
// Create the 100 Trying response.
Response response = protocolObjects.messageFactory.createResponse(Response.TRYING, request);
ListeningPoint lp = sipProvider.getListeningPoint(protocolObjects.transport);
int myPort = lp.getPort();
Address address =
protocolObjects.addressFactory.createAddress(
"Shootme <sip:" + myAddress + ":" + myPort + ">");
// Add a random sleep to stagger the two OK's for the benifit of implementations
// that may not be too good about handling re-entrancy.
int timeToSleep = (int) (Math.random() * 1000);
Thread.sleep(timeToSleep);
st.sendResponse(response);
Response ringingResponse =
protocolObjects.messageFactory.createResponse(Response.RINGING, request);
ContactHeader contactHeader = protocolObjects.headerFactory.createContactHeader(address);
response.addHeader(contactHeader);
ToHeader toHeader = (ToHeader) ringingResponse.getHeader(ToHeader.NAME);
String toTag =
actAsNonRFC3261UAS ? null : new Integer((int) (Math.random() * 10000)).toString();
if (!actAsNonRFC3261UAS) toHeader.setTag(toTag); // Application is supposed to set.
ringingResponse.addHeader(contactHeader);
st.sendResponse(ringingResponse);
Dialog dialog = st.getDialog();
dialog.setApplicationData(st);
this.inviteSeen = true;
new Timer().schedule(new MyTimerTask(requestEvent, st /*,toTag*/), 1000);
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void processResponse(ResponseEvent responseReceivedEvent) {
System.out.println("Got a response");
Response response = (Response) responseReceivedEvent.getResponse();
Transaction tid = responseReceivedEvent.getClientTransaction();
System.out.println(
"Response received with client transaction id " + tid + ":\n" + response.getStatusCode());
if (tid == null) {
System.out.println("Stray response -- dropping ");
return;
}
System.out.println("transaction state is " + tid.getState());
System.out.println("Dialog = " + tid.getDialog());
System.out.println("Dialog State is " + tid.getDialog().getState());
try {
if (response.getStatusCode() == Response.OK
&& ((CSeqHeader) response.getHeader(CSeqHeader.NAME))
.getMethod()
.equals(Request.INVITE)) {
// Request cancel = inviteTid.createCancel();
// ClientTransaction ct =
// sipProvider.getNewClientTransaction(cancel);
// ct.sendRequest();
Dialog dialog = tid.getDialog();
CSeqHeader cseq = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
Request ackRequest = dialog.createAck(cseq.getSeqNumber());
System.out.println("Sending ACK");
dialog.sendAck(ackRequest);
// Send a Re INVITE but this time force it
// to use UDP as the transport. Else, it will
// Use whatever transport was used to create
// the dialog.
if (reInviteCount == 0) {
Request inviteRequest = dialog.createRequest(Request.INVITE);
((SipURI) inviteRequest.getRequestURI()).removeParameter("transport");
((ViaHeader) inviteRequest.getHeader(ViaHeader.NAME)).setTransport("udp");
inviteRequest.addHeader(contactHeader);
try {
Thread.sleep(100);
} catch (Exception ex) {
}
ClientTransaction ct = udpProvider.getNewClientTransaction(inviteRequest);
dialog.sendRequest(ct);
reInviteCount++;
}
}
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void processResponse(ResponseEvent responseEvent) {
try {
Response response = responseEvent.getResponse();
SipProvider sender = null;
// Topmost via header is me. As it is reposne to external reqeust
response.removeFirst(ViaHeader.NAME);
sender = this.sipProvider;
sender.sendResponse(response);
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Receives options requests and replies with an OK response containing methods that we support.
*
* @param requestEvent the incoming options request.
* @return <tt>true</tt> if request has been successfully processed, <tt>false</tt> otherwise
*/
@Override
public boolean processRequest(RequestEvent requestEvent) {
Response optionsOK = null;
try {
optionsOK =
provider.getMessageFactory().createResponse(Response.OK, requestEvent.getRequest());
// add to the allows header all methods that we support
for (String method : provider.getSupportedMethods()) {
// don't support REGISTERs
if (!method.equals(Request.REGISTER))
optionsOK.addHeader(provider.getHeaderFactory().createAllowHeader(method));
}
Iterable<String> knownEventsList = provider.getKnownEventsList();
synchronized (knownEventsList) {
for (String event : knownEventsList)
optionsOK.addHeader(provider.getHeaderFactory().createAllowEventsHeader(event));
}
} catch (ParseException ex) {
// What else could we do apart from logging?
logger.warn("Failed to create an incoming OPTIONS request", ex);
return false;
}
try {
SipStackSharing.getOrCreateServerTransaction(requestEvent).sendResponse(optionsOK);
} catch (TransactionUnavailableException ex) {
// this means that we received an OPTIONS request outside the scope
// of a transaction which could mean that someone is simply sending
// us b****hit to keep a NAT connection alive, so let's not get too
// excited.
if (logger.isInfoEnabled())
logger.info("Failed to respond to an incoming " + "transactionless OPTIONS request");
if (logger.isTraceEnabled()) logger.trace("Exception was:", ex);
return false;
} catch (InvalidArgumentException ex) {
// What else could we do apart from logging?
logger.warn("Failed to send an incoming OPTIONS request", ex);
return false;
} catch (SipException ex) {
// What else could we do apart from logging?
logger.warn("Failed to send an incoming OPTIONS request", ex);
return false;
}
return true;
}
public void processResponse(ResponseEvent responseReceivedEvent) {
LOG.debug("Response received at Subscriber");
Response response = responseReceivedEvent.getResponse();
Transaction clientTransactionId = responseReceivedEvent.getClientTransaction();
LOG.debug(
"Response received with client transaction id {}:{}",
clientTransactionId,
response.getStatusCode());
if (clientTransactionId == null) {
if (LOG.isWarnEnabled()) {
LOG.warn("Stray response -- dropping");
}
return;
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
System.out.println("shootme: got an Invite sending Trying");
// System.out.println("shootme: " + request);
Response response = messageFactory.createResponse(Response.TRYING, request);
ServerTransaction st = requestEvent.getServerTransaction();
if (st == null) {
st = sipProvider.getNewServerTransaction(request);
}
dialog = st.getDialog();
st.sendResponse(response);
this.okResponse = messageFactory.createResponse(Response.BUSY_HERE, request);
ToHeader toHeader = (ToHeader) okResponse.getHeader(ToHeader.NAME);
toHeader.setTag("4321"); // Application is supposed to set.
this.inviteTid = st;
// Defer sending the OK to simulate the phone ringing.
this.inviteRequest = request;
new Timer().schedule(new MyTimerTask(this), 100);
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
private void sendOkResponse(ServerTransaction st, Request request, int expiryTime, String eTag) {
// return an OK message back to the publisher
try {
Response response = getSipMessageFactory().createResponse(Response.OK, request);
// set contacts
ArrayList newContacts = new ArrayList(4);
for (Iterator it = request.getHeaders(ContactHeader.NAME); it.hasNext(); ) {
ContactHeader contact = (ContactHeader) it.next();
newContacts.add(contact);
}
Iterator it = newContacts.iterator();
while (it.hasNext()) {
ContactHeader contact = (ContactHeader) it.next();
response.addHeader(contact);
}
// add an Expires header
ExpiresHeader expiresHeader = getSipHeaderFactory().createExpiresHeader(expiryTime);
response.addHeader(expiresHeader);
// add a SIP-ETag header
SIPETagHeader sipETagHeader = getSipHeaderFactory().createSIPETagHeader(eTag);
response.addHeader(sipETagHeader);
st.sendResponse(response);
if (isTraceable(TraceLevel.FINEST)) {
finest("sending OK response:\n" + response);
}
} catch (Exception e) {
// some error occured. Try to send an error response instead
sendErrorResponse(
Response.SERVER_INTERNAL_ERROR,
"An error occurred while attempting to send 200 OK response",
st,
request);
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
Response okResponse = messageFactory.createResponse(Response.OK, request);
FromHeader from = (FromHeader) okResponse.getHeader(FromHeader.NAME);
from.removeParameter("tag");
Address address =
addressFactory.createAddress("Shootme <sip:" + myAddress + ":" + myPort + ">");
ContactHeader contactHeader = headerFactory.createContactHeader(address);
ToHeader toHeader = (ToHeader) okResponse.getHeader(ToHeader.NAME);
toHeader.setTag("4321"); // Application is supposed to set.
okResponse.addHeader(contactHeader);
sipProvider.sendResponse(okResponse); // Send it through the Provider.
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void processResponse(ResponseEvent responseReceivedEvent) {
// System.out.println("Got a response");
Response response = (Response) responseReceivedEvent.getResponse();
Transaction tid = responseReceivedEvent.getClientTransaction();
// System.out.println("Response received with client transaction id "
// + tid + ":\n" + response);
try {
if (response.getStatusCode() == Response.OK
&& ((CSeqHeader) response.getHeader(CSeqHeader.NAME))
.getMethod()
.equals(Request.INVITE)) {
Dialog dialog = tid.getDialog();
Request request = tid.getRequest();
dialog.sendAck(request);
}
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public synchronized void processNotify(
RequestEvent requestEvent, ServerTransaction serverTransactionId) {
LOG.debug("Notification received at Subscriber");
SipProvider provider = (SipProvider) requestEvent.getSource();
Request notify = requestEvent.getRequest();
try {
if (serverTransactionId == null) {
LOG.info("ServerTransaction is null. Creating new Server transaction");
serverTransactionId = provider.getNewServerTransaction(notify);
}
Dialog dialog = serverTransactionId.getDialog();
if (dialog != subscriberDialog) {
forkedDialog = dialog;
}
// Dispatch the response along the route
dispatchExchange(notify.getContent());
// Send back an success response
Response response =
sipSubscriber.getConfiguration().getMessageFactory().createResponse(200, notify);
response.addHeader(sipSubscriber.getConfiguration().getContactHeader());
serverTransactionId.sendResponse(response);
SubscriptionStateHeader subscriptionState =
(SubscriptionStateHeader) notify.getHeader(SubscriptionStateHeader.NAME);
// Subscription is terminated?
if (subscriptionState.getState().equalsIgnoreCase(SubscriptionStateHeader.TERMINATED)) {
LOG.info("Subscription state is terminated. Deleting the current dialog");
dialog.delete();
}
} catch (Exception e) {
LOG.error("Exception thrown during Notify processing in the SipSubscriptionListener.", e);
}
}
public void processOK(Response responseCloned, ClientTransaction clientTransaction) {
try {
logger.debug("Processing OK for SUBSCRIBE in progress...");
ExpiresHeader expiresHeader = (ExpiresHeader) responseCloned.getHeader(ExpiresHeader.NAME);
if (expiresHeader != null && expiresHeader.getExpires() == 0) {
logger.debug(
"DEBUG, IMSubscribeProcessing, processOK(), we got" + " the OK for the unsubscribe...");
} else {
// We have to create or update the presentity!
PresenceManager presenceManager = imUA.getPresenceManager();
String presentityURL = IMUtilities.getKey(responseCloned, "To");
Dialog dialog = clientTransaction.getDialog();
if (dialog != null) presenceManager.addPresentity(presentityURL, responseCloned, dialog);
else {
logger.debug(
"ERROR, IMSubscribeProcessing, processOK(), the"
+ " dialog for the SUBSCRIBE we sent is null!!!"
+ " No presentity added....");
}
// WE have to create a new Buddy in the GUI!!!
InstantMessagingGUI imGUI = imUA.getInstantMessagingGUI();
BuddyList buddyList = imGUI.getBuddyList();
if (!buddyList.hasBuddy(presentityURL)) {
buddyList.addBuddy(presentityURL, "offline");
} else {
logger.debug("The buddy is already in the Buddy list...");
}
}
logger.debug("Processing OK for SUBSCRIBE completed...");
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void processResponse(ResponseEvent responseEvent) {
ClientTransaction ct = responseEvent.getClientTransaction();
Response response = responseEvent.getResponse();
ServerTransaction st = (ServerTransaction) ct.getApplicationData();
try {
Response otherResponse =
messageFactory.createResponse(response.getStatusCode(), st.getRequest());
if (response.getStatusCode() == 200 && ct.getRequest().getMethod().equals("INVITE")) {
Address address =
addressFactory.createAddress("B2BUA <sip:" + myAddress + ":" + myPort + ">");
ContactHeader contactHeader = headerFactory.createContactHeader(address);
response.addHeader(contactHeader);
ToHeader toHeader = (ToHeader) otherResponse.getHeader(ToHeader.NAME);
if (toHeader.getTag() == null)
toHeader.setTag(new Long(counter.getAndIncrement()).toString());
otherResponse.addHeader(contactHeader);
}
st.sendResponse(otherResponse);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** This is a listener method. */
public void processResponse(ResponseEvent responseEvent) {
try {
Response response = responseEvent.getResponse();
SipProvider sipProvider = (SipProvider) responseEvent.getSource();
ClientTransaction clientTransaction = responseEvent.getClientTransaction();
ProxyDebug.println(
"\n***************************************************************"
+ "\n***************************************************************"
+ "\nResponse "
+ response.getStatusCode()
+ " "
+ response.getReasonPhrase()
+ " received:\n"
+ response.toString());
ProxyDebug.println("Processing Response in progress");
if (ProxyDebug.debug) ProxyUtilities.printTransaction(clientTransaction);
// Henrik - added handling of responses addressed to server
// If we use a presenceserver, and if statuscode was OK...
CSeqHeader cseqHeader = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
if (cseqHeader.getMethod().equals("SUBSCRIBE")) {
presenceServer.processSubscribeResponse((Response) response.clone(), clientTransaction);
} else if (cseqHeader.getMethod().equals("NOTIFY")) {
// presenceServer.processNotifyResponse((Response)response.clone(),
// clientTransaction);
}
responseForwarding.forwardResponse(sipProvider, response, clientTransaction);
} catch (Exception ex) {
if (ProxyDebug.debug) {
ProxyDebug.println("Proxy, processResponse(), internal error, " + "exception raised:");
ProxyDebug.logException(ex);
}
}
}
public void processResponse(ResponseEvent responseEvent) {
Response response = responseEvent.getResponse();
ClientTransaction clientTransaction = responseEvent.getClientTransaction();
CSeqHeader cseqHeader = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
logger.debug("***** Response: " + response.getStatusCode() + " received by UA *****");
logger.debug(response);
logger.debug("***** Response dispatched *****");
if (response.getStatusCode() == Response.PROXY_AUTHENTICATION_REQUIRED
|| response.getStatusCode() == Response.UNAUTHORIZED) {
if (clientTransaction == null) {
logger.info("Bad username ?");
} else {
try {
logger.debug("IMUserAgent, processResponse(), Credentials to provide!");
// WE start the authentication process!!!
// Let's get the Request related to this response:
Request clonedRequest = (Request) clientTransaction.getRequest().clone();
if (clonedRequest == null) {
logger.debug(
"IMUserAgent, processResponse(), the request "
+ " that caused the 407 has not been retrieved!!! Return cancelled!");
} else {
// Let's increase the Cseq:
cseqHeader = (CSeqHeader) clonedRequest.getHeader(CSeqHeader.NAME);
cseqHeader.setSequenceNumber(cseqHeader.getSequenceNumber() + 1);
// Let's add a Proxy-Authorization header:
// We send the informations stored:
FromHeader fromHeader = (FromHeader) clonedRequest.getHeader(FromHeader.NAME);
String fromURI = fromHeader.getAddress().getURI().toString();
Header header;
if (fromURI.equals(getLocalURI())) {
header = authenticationProcess.getHeader(response);
} else {
String fromAddress = IMUtilities.getUsernameFromURI(fromURI);
logger.info("Fetching credentials dor user: "******"ERROR, user not found");
header = null;
}
}
if (header == null) {
logger.debug(
"IMUserAgent, processResponse(), Proxy-Authorization "
+ " header is null, the request is not resent");
} else {
clonedRequest.setHeader(header);
ClientTransaction newClientTransaction =
getSipProvider().getNewClientTransaction(clonedRequest);
newClientTransaction.sendRequest();
logger.debug(
"IMUserAgent, processResponse(), REGISTER "
+ "with credentials sent:\n"
+ clonedRequest);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
} else {
if (cseqHeader.getMethod().equals("REGISTER")) {
// logger.info("REGISTER Response received");
sipRC.processResponse(responseEvent);
} else if (cseqHeader.getMethod().equals("ACK")) {
} else if (cseqHeader.getMethod().equals("MESSAGE")) {
sipMC.processResponse(responseEvent);
}
}
}
public void processResponse(ResponseEvent responseReceivedEvent) {
/// System.out.println("=> BUNDLE: br.ufes.inf.ngn.televoto.client.logic | CLASS: LogicListener
// | METOD: processResponse ");//By Ju
try {
Response myResponse = responseReceivedEvent.getResponse();
logger.info("<<< " + myResponse.toString());
ClientTransaction thisClientTransaction = responseReceivedEvent.getClientTransaction();
int myStatusCode = myResponse.getStatusCode();
switch (status) {
case WAIT_PROV:
if (!thisClientTransaction.equals(myClientTransaction))
myClientTransaction = thisClientTransaction;
if (myStatusCode < 200) {
status = WAIT_FINAL;
myDialog = thisClientTransaction.getDialog();
} else if (myStatusCode < 300) {
myDialog = thisClientTransaction.getDialog();
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
Request myAck = myDialog.createAck(numseq);
myAck.addHeader(myContactHeader);
myDialog.sendAck(myAck);
// logger.info(">>> "+myAck.toString());
status = ESTABLISHED;
byte[] cont = (byte[]) myResponse.getContent();
answerInfo = mySdpManager.getSdp(cont);
} else {
if (myStatusCode == 401) {
} else {
status = IDLE;
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
Request myAck = myDialog.createAck(numseq);
myAck.addHeader(myContactHeader);
myDialog.sendAck(myAck);
// logger.info(">>> "+myAck.toString());
}
}
break;
case WAIT_FINAL:
if (!thisClientTransaction.equals(myClientTransaction))
myClientTransaction = thisClientTransaction;
if (myStatusCode < 200) {
status = WAIT_FINAL;
myDialog = thisClientTransaction.getDialog();
} else if (myStatusCode < 300) {
if (useQueue.equals("yes")) {
status = IDLE;
} else {
status = ESTABLISHED;
}
myDialog = thisClientTransaction.getDialog();
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
Request myAck = myDialog.createAck(numseq); // Aquiiii
myAck.addHeader(myContactHeader);
myDialog.sendAck(myAck);
// logger.info(">>> "+myAck.toString());
byte[] cont = (byte[]) myResponse.getContent();
answerInfo = mySdpManager.getSdp(cont);
} else {
// Cancelando requisição ao cliente
Request myCancelRequest = myClientTransaction.createCancel();
ClientTransaction myCancelClientTransaction =
mySipProvider.getNewClientTransaction(myCancelRequest);
myCancelClientTransaction.sendRequest();
// logger.info(">>> " + myCancelRequest.toString());
status = IDLE;
}
break;
case REGISTERING:
if (!thisClientTransaction.equals(myClientTransaction))
myClientTransaction = thisClientTransaction;
if (myStatusCode == 200) {
status = IDLE;
if (!Unregistring) {
System.out.println(myName + ": Registrado");
// inserir captura de timestamp
// logger.info(myName + ";INVITE;" + getTime());
// Random gerador = new Random();
// int temp = gerador.nextInt(10);
// System.out.println(myName + ": Esperando " + temp + "segundos");
// Thread.sleep(temp);
System.out.println(myName + ": chamando " + destination);
SdpInfo offerInfo = new SdpInfo();
offerInfo.IpAddress = myIP;
offerInfo.aport = myAudioPort;
offerInfo.aformat = 0;
byte[] content = mySdpManager.createSdp(offerInfo);
// Via
// ViaHeader comentei
myViaHeader = myHeaderFactory.createViaHeader(myIP, myPort, "udp", null);
myViaHeader.setRPort();
ArrayList viaHeaders = new ArrayList();
viaHeaders.add(myViaHeader);
// From
Address addressOfRecord = myAddressFactory.createAddress("<sip:" + myUserID + ">");
FromHeader myFromHeader = myHeaderFactory.createFromHeader(addressOfRecord, "456249");
// To
String dstURI[] = destination.split("@");
String dstSipAlias = dstURI[0];
Address destinationAddress =
myAddressFactory.createAddress("<sip:" + destination + ">");
javax.sip.address.URI myRequestURI = destinationAddress.getURI();
ToHeader myToHeader = myHeaderFactory.createToHeader(destinationAddress, null);
// MaxForwards
MaxForwardsHeader myMaxForwardsHeader = myHeaderFactory.createMaxForwardsHeader(70);
// Call-ID
CallIdHeader myCallIdHeader = mySipProvider.getNewCallId();
// CSeq
Random random = new Random();
CSeqHeader myCSeqHeader =
myHeaderFactory.createCSeqHeader(random.nextInt(1000) * 1L, "INVITE");
// Create SIP request
Request myRequest =
myMessageFactory.createRequest(
myRequestURI,
"INVITE",
myCallIdHeader,
myCSeqHeader,
myFromHeader,
myToHeader,
viaHeaders,
myMaxForwardsHeader);
// Contact
Address contactAddress =
myAddressFactory.createAddress(
"<sip:" + mySipAlias + "@" + myIP + ":" + myPort + ";transport=udp>");
myContactHeader = myHeaderFactory.createContactHeader(contactAddress);
myRequest.addHeader(myContactHeader);
// Allow
Allow myAllow = new Allow();
myAllow.setMethod(
"INVITE, ACK, CANCEL, BYE, MESSAGE, OPTIONS, NOTIFY, PRACK, UPDATE, REFER");
myRequest.addHeader(myAllow);
// Privacy
Privacy myPrivacy = new Privacy("none");
myRequest.addHeader(myPrivacy);
// PPreferredIdentity
HeaderFactoryImpl myHeaderFactoryImpl = new HeaderFactoryImpl();
PPreferredIdentityHeader myPPreferredIdentityHeader =
myHeaderFactoryImpl.createPPreferredIdentityHeader(
myAddressFactory.createAddress("sip:" + myName + '@' + myServer));
myRequest.addHeader(myPPreferredIdentityHeader);
// Route
Address routeAddress =
myAddressFactory.createAddress("sip:orig@scscf." + myServer + ":6060;lr");
// RouteHeader comentei
myRouteHeader = myHeaderFactory.createRouteHeader(routeAddress);
myRequest.addHeader(myRouteHeader);
// Para proxy funcionar
SipURI outboundProxyURI = myAddressFactory.createSipURI("proxy", myProxyIP);
outboundProxyURI.setLrParam();
outboundProxyURI.setPort(myProxyPort);
myRouteHeader =
myHeaderFactory.createRouteHeader(
myAddressFactory.createAddress(outboundProxyURI));
myRequest.addFirst(myRouteHeader);
// Content Type
ContentTypeHeader contentTypeHeader =
myHeaderFactory.createContentTypeHeader("application", "sdp");
myRequest.setContent(content, contentTypeHeader);
// ClientTransaction comentei aqui
myClientTransaction = mySipProvider.getNewClientTransaction(myRequest);
myClientTransaction.setRetransmitTimer(700);
myClientTransaction.sendRequest();
status = WAIT_PROV;
logger.info(">>> " + myRequest.toString());
} else {
this.setOff(mySipStack);
}
} else {
if (myStatusCode == 403) {
System.out.println("Problemas com credenciais!!!!\n");
} else if (myStatusCode == 401) {
myName = (String) this.getLocalName();
myUserID = (String) this.getLocalName() + "@" + myServer;
Address contactAddress =
myAddressFactory.createAddress("sip:" + myName + '@' + myIP + ":" + myPort);
myContactHeader = myHeaderFactory.createContactHeader(contactAddress);
myViaHeader = myHeaderFactory.createViaHeader(myIP, myPort, "udp", null);
fromAddress = myAddressFactory.createAddress(myName + " <sip:" + myUserID + ">");
Address registrarAddress = myAddressFactory.createAddress("sip:" + myServer);
Address registerToAddress = fromAddress;
Address registerFromAddress = fromAddress;
ToHeader myToHeader = myHeaderFactory.createToHeader(registerToAddress, null);
FromHeader myFromHeader =
myHeaderFactory.createFromHeader(registerFromAddress, "647554");
ArrayList myViaHeaders = new ArrayList();
myViaHeaders.add(myViaHeader);
// System.out.println("myClientTransaction.getRequest():"+
// myClientTransaction.getRequest());
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
MaxForwardsHeader myMaxForwardsHeader = myHeaderFactory.createMaxForwardsHeader(70);
CSeqHeader myCSeqHeader = myHeaderFactory.createCSeqHeader(numseq + 1L, "REGISTER");
CallIdHeader myCallID =
(CallIdHeader) myClientTransaction.getRequest().getHeader(CallIdHeader.NAME);
CallIdHeader myCallIDHeader = myCallID;
SipURI myRequestURI = (SipURI) registrarAddress.getURI();
Request myRegisterRequest =
myMessageFactory.createRequest(
myRequestURI,
"REGISTER",
myCallIDHeader,
myCSeqHeader,
myFromHeader,
myToHeader,
myViaHeaders,
myMaxForwardsHeader);
myRegisterRequest.addHeader(myContactHeader);
// Expires
ExpiresHeader myExpiresHeader;
if (Unregistring) {
myExpiresHeader = myHeaderFactory.createExpiresHeader(0);
myContactHeader.setExpires(0);
} else {
myExpiresHeader = myHeaderFactory.createExpiresHeader(60000);
}
myRegisterRequest.addHeader(myExpiresHeader);
// Allow
Allow myAllow = new Allow();
myAllow.setMethod(
"INVITE, ACK, CANCEL, BYE, MESSAGE, OPTIONS, NOTIFY, PRACK, UPDATE, REFER");
myRegisterRequest.addHeader(myAllow);
// Privacy
Privacy myPrivacy = new Privacy("none");
myRegisterRequest.addHeader(myPrivacy);
// PPreferredIdentity
HeaderFactoryImpl myHeaderFactoryImpl = new HeaderFactoryImpl();
PPreferredIdentityHeader myPPreferredIdentityHeader =
myHeaderFactoryImpl.createPPreferredIdentityHeader(
myAddressFactory.createAddress("sip:" + myName + '@' + myServer));
myRegisterRequest.addHeader(myPPreferredIdentityHeader);
// Supported
Supported mySupported = new Supported("path");
myRegisterRequest.addHeader(mySupported);
myWWWAuthenticateHeader =
Utils.makeAuthHeader(
myHeaderFactory, myResponse, myRegisterRequest, myUserID, myPassword);
myRegisterRequest.addHeader(myWWWAuthenticateHeader);
myClientTransaction = mySipProvider.getNewClientTransaction(myRegisterRequest);
myClientTransaction.sendRequest();
// logger.info(">>> "+myRegisterRequest.toString());
// System.out.println(">>> " + myRegisterRequest.toString());
status = REGISTERING;
}
}
break;
}
} catch (Exception excep) {
excep.printStackTrace();
}
}
public void processRequest(RequestEvent requestReceivedEvent) {
/// System.out.println("=> BUNDLE: br.ufes.inf.ngn.televoto.client.logic | CLASS: LogicListener
// | METOD: processRequest ");//By Ju
String method;
Response myResponse;
ToHeader myToHeader;
Request myRequest = requestReceivedEvent.getRequest();
method = myRequest.getMethod();
// logger.info(myRequest.toString());
if (!method.equals("CANCEL")) {
myServerTransaction = requestReceivedEvent.getServerTransaction();
}
try {
switch (status) {
case WAIT_PROV:
status = WAIT_ACK;
System.out.println("Chamando....");
break;
case IDLE:
if (method.equals("INVITE")) {
if (myServerTransaction == null) {
myServerTransaction = mySipProvider.getNewServerTransaction(myRequest);
}
byte[] cont = (byte[]) myRequest.getContent();
offerInfo = mySdpManager.getSdp(cont);
answerInfo.IpAddress = myIP;
answerInfo.aport = myAudioPort;
answerInfo.aformat = offerInfo.aformat;
if (useQueue.equals("yes")) {
status = ESTABLISHED;
} else {
// envio do PROVISIONAL 180
myResponse = myMessageFactory.createResponse(180, myRequest);
myResponse.addHeader(myContactHeader);
myToHeader = (ToHeader) myResponse.getHeader("To");
myToHeader.setTag("454326");
myServerTransaction.sendResponse(myResponse);
myDialog = myServerTransaction.getDialog();
// logger.info(">>> "+myResponse.toString());
status = WAIT_ACK;
}
// inicio do envio do ACK ao cliente em confirmacao ao PROV_180 e envio do SDP
Request originalRequest = myServerTransaction.getRequest();
myResponse = myMessageFactory.createResponse(200, originalRequest);
// System.out.println(originalRequest.toString());
myToHeader = (ToHeader) myResponse.getHeader("To");
myResponse.addHeader(myContactHeader);
// SEND ANSWER SDP
ContentTypeHeader contentTypeHeader =
myHeaderFactory.createContentTypeHeader("application", "sdp");
byte[] content = mySdpManager.createSdp(answerInfo);
myResponse.setContent(content, contentTypeHeader);
// aguardando ACK do cliente
myServerTransaction.sendResponse(myResponse);
myDialog = myServerTransaction.getDialog();
new Timer().schedule(new MyTimerTask(this), 500000); // Aqui!!!
// logger.info(">>> " + myResponse.toString());
}
if (method.equals("OPTIONS")) {
if (myServerTransaction == null) {
myServerTransaction = mySipProvider.getNewServerTransaction(myRequest);
}
Request originalRequest = myServerTransaction.getRequest();
myResponse = myMessageFactory.createResponse(200, originalRequest);
myResponse.addHeader(myContactHeader);
myServerTransaction.sendResponse(myResponse);
}
break;
case ESTABLISHED:
if (method.equals("BYE")) {
// capturar o timestamp
// logger.info(myName + ";BYE;" + getTime());
System.out.println(myName + ": BYE");
myResponse = myMessageFactory.createResponse(200, myRequest);
myResponse.addHeader(myContactHeader);
myServerTransaction.sendResponse(myResponse);
// logger.info(">>> "+myResponse.toString());
if (ack == 1) {
ack = 0;
redial++;
if (redial <= dialTimes) {
// inserir captura timestamp
logger.info(myName + ";BYE;" + getTime());
System.out.println(myName + ": rediscagem " + redial + " para: " + destination);
String dstURI[] = destination.split("@");
String dstSipAlias = dstURI[0];
Address destinationAddress =
myAddressFactory.createAddress(dstSipAlias + " <sip:" + destination + ">");
javax.sip.address.URI myRequestURI = destinationAddress.getURI();
Address addressOfRecord =
myAddressFactory.createAddress(
mySipAlias + " <sip:" + mySipAlias + "@" + myIP + ":" + myPort + ">");
// HeaderFactory comentei
myHeaderFactory = mySipFactory.createHeaderFactory();
// ViaHeader comentei
myViaHeader = myHeaderFactory.createViaHeader(myIP, myPort, "udp", null);
ArrayList viaHeaders = new ArrayList();
viaHeaders.add(myViaHeader);
MaxForwardsHeader myMaxForwardsHeader = myHeaderFactory.createMaxForwardsHeader(70);
CallIdHeader myCallIdHeader = mySipProvider.getNewCallId();
CSeqHeader myCSeqHeader = myHeaderFactory.createCSeqHeader(1L, "INVITE");
FromHeader myFromHeader =
myHeaderFactory.createFromHeader(addressOfRecord, "456249");
myToHeader = myHeaderFactory.createToHeader(destinationAddress, null);
myRequest =
myMessageFactory.createRequest(
myRequestURI,
"INVITE",
myCallIdHeader,
myCSeqHeader,
myFromHeader,
myToHeader,
viaHeaders,
myMaxForwardsHeader);
Address contactAddress =
myAddressFactory.createAddress(
"<sip:" + mySipAlias + "@" + myIP + ":" + myPort + ">");
myContactHeader = myHeaderFactory.createContactHeader(contactAddress);
myRequest.addHeader(myContactHeader);
SdpInfo offerInfo = new SdpInfo();
offerInfo.IpAddress = myIP;
offerInfo.aport = myAudioPort;
offerInfo.aformat = 0;
ContentTypeHeader contentTypeHeader =
myHeaderFactory.createContentTypeHeader("application", "sdp");
byte[] content = mySdpManager.createSdp(offerInfo);
myRequest.setContent(content, contentTypeHeader);
// ClientTransaction Comentei aqui
myClientTransaction = mySipProvider.getNewClientTransaction(myRequest);
myClientTransaction.sendRequest();
logger.info(myName + ";INVITE;" + getTime());
// System.out.println(myRequest);
status = WAIT_PROV;
} else {
status = IDLE;
System.out.println(myName + ": pronto.");
}
} else ack++;
}
break;
case RINGING:
if (method.equals("CANCEL")) {
ServerTransaction myCancelServerTransaction =
requestReceivedEvent.getServerTransaction();
Request originalRequest = myServerTransaction.getRequest();
myResponse = myMessageFactory.createResponse(487, originalRequest);
myServerTransaction.sendResponse(myResponse);
Response myCancelResponse = myMessageFactory.createResponse(200, myRequest);
myCancelServerTransaction.sendResponse(myCancelResponse);
// logger.info(">>> "+myResponse.toString());
// logger.info(">>> "+myCancelResponse.toString());
status = IDLE;
}
break;
case WAIT_ACK:
if (method.equals("ACK")) {
status = ESTABLISHED;
System.out.println("Conectado ...");
// SendMedia(offerInfo.IpAddress, offerInfo.aport);
}
break;
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* @param originalRequestEvent
* @param response
* @param serviceUnit
*/
@Override
public void sendResponse(
RequestEvent originalRequestEvent, Response response, ServiceUnit serviceUnit, String toTag) {
/** Here we need to do some specific handling specific to the type of responses being sent. */
/**
* If it is a 180 RINGING response, then we need to set the To tag to the same to tag generated
* when creating the associated B2BSession and B2BDialog.
*/
if (isDialogCreating(response.getStatusCode())) {
logger.fine("Sending a ringing response...");
/** Copy the Local Tag from the B2BDialog to the SipResponse */
logger.info("Setting the To Dialog of the response to be sent to : " + toTag);
SIPResponse sipResponse = (SIPResponse) response;
sipResponse.setToTag(toTag);
}
logger.info(
"Sending Response for the request associated with ServiceUnit: " + serviceUnit.getName());
/** Conveying the response sending to the UserAgent */
logger.info("Sending Response: " + response.getReasonPhrase());
Dialog sipDialog = userAgent.sendResponse(originalRequestEvent, response, serviceUnit);
if (sipDialog == null) {
logger.info(
"The sent response " + response.getReasonPhrase() + " did not resulted in any dialog...");
} else {
logger.info(
"The sent response "
+ response.getReasonPhrase()
+ " has created a new Dialog with ID: "
+ sipDialog.getDialogId());
}
/**
* Set the underlying SIP Dialog of the B2BDialog for Dialog creating responses as well as the
* local seq number and the current state of the dialog.
*/
if (isDialogCreating(response.getStatusCode())) {
B2BSession b2BSessions[] =
RuntimeComponentContext.getInstance().getB2BSessions(serviceUnit.getName());
for (B2BSession b2BSession : b2BSessions) {
B2BDialogImpl b2BDialogImpl = null;
if (sipDialog != null) {
b2BDialogImpl =
(B2BDialogImpl) b2BSession.getB2BDialog(sipDialog.getDialogId(), true, null);
}
if (b2BDialogImpl != null) {
logger.info(
"Setting the underlying SIP Dialog property of the B2BDialog: "
+ b2BDialogImpl.getDialogId());
b2BDialogImpl.setUnderlyingSipDialog(sipDialog);
b2BDialogImpl.setLocalSeqNumber(sipDialog.getLocalSeqNumber());
b2BDialogImpl.setState(sipDialog.getState().toString());
logger.info(
"Setting the Dialog status with ID: "
+ b2BDialogImpl.getDialogId()
+ " to "
+ sipDialog.getState().toString());
break;
} else {
logger.info("Unable to locate a B2BDialog with ID " + sipDialog.getDialogId());
}
}
}
}
/**
* Tries to steer a TI client transaction through the following scenario Calling-->Terminated.
* Apart from state transitions, we also test, retransmissions and proper hiding/passing of
* messages to the TU.
*/
public void testCallingTerminatedScenario() {
try {
Request invite = createTiInviteRequest(null, null, null);
ClientTransaction tran = null;
try {
eventCollector.collectRequestEvent(riSipProvider);
tran = tiSipProvider.getNewClientTransaction(invite);
tran.sendRequest();
} catch (SipException ex) {
throw new TiUnexpectedError("A SipExceptionOccurred while trying to send request!", ex);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
waitForMessage();
RequestEvent inviteReceivedEvent = eventCollector.extractCollectedRequestEvent();
if (inviteReceivedEvent == null || inviteReceivedEvent.getRequest() == null)
throw new TiUnexpectedError("The invite request was not received by the RI!");
// At this point the ClientTransaction should be CALLING!
assertEquals(TransactionState.CALLING, tran.getState());
// Check Request retransmission
try {
eventCollector.collectRequestEvent(riSipProvider);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
// Wait for the retransmission timer to fire if it had not already
// done so.
if (tran.getRetransmitTimer() > MESSAGES_ARRIVE_FOR)
sleep((long) tran.getRetransmitTimer() - MESSAGES_ARRIVE_FOR); // subtract
// the
// time
// we
// waited
// for
// the
// invite
// Wait for the retransmitted request to arrive
waitForMessage();
inviteReceivedEvent = eventCollector.extractCollectedRequestEvent();
assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent);
assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent.getRequest());
assertEquals(Request.INVITE, inviteReceivedEvent.getRequest().getMethod());
// At this point the ClientTransaction should STILL be CALLING!
assertEquals(TransactionState.CALLING, tran.getState());
// Send a 200 OK (final) response from the RI
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Failed to register a SipListener with TI", ex);
}
// The OK response shouldn't trigger any ACKs so let's register
// a listener with the RI to verify whether that is the case
SipEventCollector ackCollector = new SipEventCollector();
try {
ackCollector.collectRequestEvent(riSipProvider);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
Response ok = null;
try {
ok = riMessageFactory.createResponse(Response.OK, inviteReceivedEvent.getRequest());
addStatus(inviteReceivedEvent.getRequest(), ok);
// JvB: MUST add Contact too!
ContactHeader contact =
riHeaderFactory.createContactHeader(((ToHeader) ok.getHeader("To")).getAddress());
ok.addHeader(contact);
// end JvB
riSipProvider.sendResponse(ok);
} catch (Throwable ex) {
throw new TckInternalError("The TCK could not send an OK response back to the TI", ex);
}
waitForMessage();
// Analyze the OK response and Tran state back at the TI
ResponseEvent responseEvent = eventCollector.extractCollectedResponseEvent();
assertNotNull(
"The Tested Implementation did not pass a 200 OK response to the TU!", responseEvent);
assertNotNull(
"The Tested Implementation did not pass a 200 OK response to the TU!",
responseEvent.getResponse());
assertSame(
"The OK response was not associated with the right transaction",
tran,
responseEvent.getClientTransaction());
assertSame(
"A response different from OK was passed to the TU",
tran,
responseEvent.getClientTransaction());
assertEquals(
"The ClientTransaction did not pass in the TERMINATED state after "
+ "receiving 200 final response",
tran.getState(),
TransactionState.TERMINATED);
// check whether the ackCollector has caught any fish
RequestEvent ackReceivedEvent = ackCollector.extractCollectedRequestEvent();
assertNull("The TI sent an ACK to an OK (this is TU's job)!", ackReceivedEvent);
// Now let's retransmit the final response and see that it is
// passed to the TU (again no ACKs should be sent by the TI)
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Failed to register a SipListener with TI", ex);
}
// go fish the ack
try {
ackCollector.collectRequestEvent(riSipProvider);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
try {
riSipProvider.sendResponse((Response) ok.clone());
} catch (Throwable ex) {
throw new TckInternalError("The TCK could not send an OK response back to the TI", ex);
}
waitForMessage();
// Did we get the 2nd OK?
responseEvent = eventCollector.extractCollectedResponseEvent();
/*
* JvB: see previous comment
*
* assertNotNull( "The TI did not pass to the TU a retransmitted OK
* response!", responseEvent); assertNotNull( "The TI did not pass
* to the TU a retransmitted OK response!",
* responseEvent.getResponse()); assertTrue( "The TI passed to the
* TU a bad response!",
* responseEvent.getResponse().getStatusCode()==Response.OK);
*/
// JvB: TBD
// assertNull( "The TI should filter the retransmitted OK response",
// responseEvent );
// We must still be in the terminated state.
assertEquals(
"The ClientTransaction mysteriously left the TERMINATED state!",
tran.getState(),
TransactionState.TERMINATED);
// check whether the ackCollector has caught any fish
ackReceivedEvent = ackCollector.extractCollectedRequestEvent();
assertNull(
"The TI sent an ACK request to the second OK response "
+ "(OK acks are TU's responsibility)!",
ackReceivedEvent);
} catch (Throwable exc) {
exc.printStackTrace();
fail(exc.getClass().getName() + ": " + exc.getMessage());
}
assertTrue(new Exception().getStackTrace()[0].toString(), true);
}
/** This is a listener method. */
public void processRequest(RequestEvent requestEvent) {
Request request = requestEvent.getRequest();
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
ServerTransaction serverTransaction = requestEvent.getServerTransaction();
try {
if (ProxyDebug.debug)
ProxyDebug.println(
"\n****************************************************"
+ "\nRequest "
+ request.getMethod()
+ " received:\n"
+ request.toString());
if (ProxyDebug.debug) ProxyUtilities.printTransaction(serverTransaction);
/** **************************************************************************** */
/** ********************* PROXY BEHAVIOR *********************************** */
/** **************************************************************************** */
/*
* RFC 3261: 16.2: For all new requests, including any with unknown
* methods, an element intending to proxy the request MUST:
*
* 1. Validate the request (Section 16.3)
*
* 2. Preprocess routing information (Section 16.4)
*
* 3. Determine target(s) for the request (Section 16.5)
*
* 4. Forward the request to each target (Section 16.6)
*
* 5. Process all responses (Section 16.7)
*/
/** **************************************************************************** */
/** *************************** 1. Validate the request (Section 16.3) ********* */
/** **************************************************************************** */
/*
* Before an element can proxy a request, it MUST verify the
* message's validity
*/
RequestValidation requestValidation = new RequestValidation(this);
if (!requestValidation.validateRequest(sipProvider, request, serverTransaction)) {
// An appropriate response has been sent back by the request
// validation step, so we just return. The request has been
// processed!
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(), the request has not been"
+ " validated, so the request is discarded "
+ " (an error code has normally been"
+ " sent back)");
return;
}
// Let's check if the ACK is for the proxy: if there is no Route
// header: it is mandatory for the ACK to be forwarded
if (request.getMethod().equals(Request.ACK)) {
ListIterator routes = request.getHeaders(RouteHeader.NAME);
if (routes == null || !routes.hasNext()) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(), "
+ "the request is an ACK"
+ " targeted for the proxy, we ignore it");
return;
}
/* added code */
CallID call_id = (CallID) request.getHeader(CallID.CALL_ID);
String call_id_str = call_id.getCallId();
TimeThreadController.Start(call_id_str);
/* end of added code */
}
if (serverTransaction == null) {
String method = request.getMethod();
// Methods that creates dialogs, so that can
// generate transactions
if (method.equals(Request.INVITE) || method.equals(Request.SUBSCRIBE)) {
try {
serverTransaction = sipProvider.getNewServerTransaction(request);
TransactionsMapping transactionsMapping =
(TransactionsMapping) serverTransaction.getDialog().getApplicationData();
if (transactionsMapping == null) {
transactionsMapping = new TransactionsMapping(serverTransaction);
}
} catch (TransactionAlreadyExistsException e) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(), this request" + " is a retransmission, we drop it!");
}
}
}
/** ************************************************************************ */
/** **** 2. Preprocess routing information (Section 16.4) ****************** */
/** ************************************************************************ */
/*
* The proxy MUST inspect the Request-URI of the request. If the
* Request-URI of the request contains a value this proxy previously
* placed into a Record-Route header field (see Section 16.6 item
* 4), the proxy MUST replace the Request-URI in the request with
* the last value from the Route header field, and remove that value
* from the Route header field. The proxy MUST then proceed as if it
* received this modified request. ..... (idem to below:) 16.12. The
* proxy will inspect the URI in the topmost Route header field
* value. If it indicates this proxy, the proxy removes it from the
* Route header field (this route node has been reached).
*/
ListIterator routes = request.getHeaders(RouteHeader.NAME);
if (routes != null) {
if (routes.hasNext()) {
RouteHeader routeHeader = (RouteHeader) routes.next();
Address routeAddress = routeHeader.getAddress();
SipURI routeSipURI = (SipURI) routeAddress.getURI();
String host = routeSipURI.getHost();
int port = routeSipURI.getPort();
if (sipStack.getIPAddress().equals(host)) {
Iterator lps = sipStack.getListeningPoints();
while (lps != null && lps.hasNext()) {
ListeningPoint lp = (ListeningPoint) lps.next();
if (lp.getPort() == port) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(),"
+ " we remove the first route form "
+ " the RouteHeader;"
+ " it matches the proxy");
routes.remove();
break;
}
}
}
}
}
/*
* If the Request-URI contains a maddr parameter, the proxy MUST
* check to see if its value is in the set of addresses or domains
* the proxy is configured to be responsible for. If the Request-URI
* has a maddr parameter with a value the proxy is responsible for,
* and the request was received using the port and transport
* indicated (explicitly or by default) in the Request-URI, the
* proxy MUST strip the maddr and any non-default port or transport
* parameter and continue processing as if those values had not been
* present in the request.
*/
URI requestURI = request.getRequestURI();
if (requestURI.isSipURI()) {
SipURI requestSipURI = (SipURI) requestURI;
if (requestSipURI.getMAddrParam() != null) {
// The domain the proxy is configured to be responsible for
// is defined
// by stack_domain parameter in the configuration file:
if (configuration.hasDomain(requestSipURI.getMAddrParam())) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(),"
+ " The maddr contains a domain we are responsible for,"
+ " we remove the mAddr parameter from the original"
+ " request");
// We have to strip the madr parameter:
requestSipURI.removeParameter("maddr");
// We have to strip the port parameter:
if (requestSipURI.getPort() != 5060 && requestSipURI.getPort() != -1) {
requestSipURI.setPort(5060);
}
// We have to strip the transport parameter:
requestSipURI.removeParameter("transport");
} else {
// The Maddr parameter is not a domain we have to take
// care of, we pass this check...
}
} else {
// No Maddr parameter, we pass this check...
}
} else {
// No SipURI, so no Maddr parameter, we pass this check...
}
/** *************************************************************************** */
/** *********** 3. Determine target(s) for the request (Section 16.5) ********* */
/** ************************************************************************** */
/*
* The set of targets will either be predetermined by the contents
* of the request or will be obtained from an abstract location
* service. Each target in the set is represented as a URI.
*/
Vector targetURIList = new Vector();
URI targetURI;
/*
* If the Request-URI of the request contains an maddr parameter,
* the Request-URI MUST be placed into the target set as the only
* target URI, and the proxy MUST proceed to Section 16.6.
*/
if (requestURI.isSipURI()) {
SipURI requestSipURI = (SipURI) requestURI;
if (requestSipURI.getMAddrParam() != null) {
targetURI = requestURI;
targetURIList.addElement(targetURI);
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(),"
+ " the only target is the Request-URI (mAddr parameter)");
// 4. Forward the request statefully:
requestForwarding.forwardRequest(
targetURIList, sipProvider, request, serverTransaction, true);
return;
}
}
/*
* If the domain of the Request-URI indicates a domain this element
* is not responsible for, the Request-URI MUST be placed into the
* target set as the only target, and the element MUST proceed to
* the task of Request Forwarding (Section 16.6).
*/
if (requestURI.isSipURI()) {
SipURI requestSipURI = (SipURI) requestURI;
if (!configuration.hasDomain(requestSipURI.getHost())) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(),"
+ " we are not responsible for the domain: Let's check if we have"
+ " a registration for this domain from another proxy");
// We have to check if another proxy did not registered
// to us, in this case we have to use the contacts provided
// by the registered proxy to create the targets:
if (registrar.hasDomainRegistered(request)) {
targetURIList = registrar.getDomainContactsURI(request);
if (targetURIList != null && !targetURIList.isEmpty()) {
if (ProxyDebug.debug) {
ProxyDebug.println(
"Proxy, processRequest(), we have"
+ " a registration for this domain from another proxy");
}
// 4. Forward the request statefully:
requestForwarding.forwardRequest(
targetURIList, sipProvider, request, serverTransaction, true);
return;
} else {
targetURIList = new Vector();
ProxyDebug.println(
"Proxy, processRequest(),"
+ " we are not responsible for the domain: the only target"
+ " URI is given by the request-URI");
targetURI = requestURI;
targetURIList.addElement(targetURI);
}
} else {
ProxyDebug.println(
"Proxy, processRequest(),"
+ " we are not responsible for the domain: the only target"
+ " URI is given by the request-URI");
targetURI = requestURI;
targetURIList.addElement(targetURI);
}
// 4. Forward the request statelessly:
requestForwarding.forwardRequest(
targetURIList, sipProvider, request, serverTransaction, false);
return;
} else {
ProxyDebug.println(
"Proxy, processRequest(),"
+ " we are responsible for the domain... Let's find the contact...");
}
}
// we use a SIP registrar:
if (request.getMethod().equals(Request.REGISTER)) {
if (ProxyDebug.debug) ProxyDebug.println("Incoming request Register");
// we call the RegisterProcessing:
registrar.processRegister(request, sipProvider, serverTransaction);
// Henrik: let the presenceserver do some processing too
if (isPresenceServer()) {
presenceServer.processRegisterRequest(sipProvider, request, serverTransaction);
}
return;
}
/*
* If we receive a subscription targeted to a user that is
* publishing its state here, send to presence server
*/
if (isPresenceServer() && (request.getMethod().equals(Request.SUBSCRIBE))) {
ProxyDebug.println("Incoming request Subscribe");
if (presenceServer.isStateAgent(request)) {
Request clonedRequest = (Request) request.clone();
presenceServer.processSubscribeRequest(sipProvider, clonedRequest, serverTransaction);
} else {
// Do we know this guy?
targetURIList = registrar.getContactsURI(request);
if (targetURIList == null) {
// If not respond that we dont know him.
ProxyDebug.println(
"Proxy: received a Subscribe request to "
+ " a user in our domain that was not found, "
+ " responded 404");
Response response = messageFactory.createResponse(Response.NOT_FOUND, request);
if (serverTransaction != null) serverTransaction.sendResponse(response);
else sipProvider.sendResponse(response);
return;
} else {
ProxyDebug.println(
"Trying to forward subscribe to "
+ targetURIList.toString()
+ "\n"
+ request.toString());
requestForwarding.forwardRequest(
targetURIList, sipProvider, request, serverTransaction, false);
}
}
return;
}
/** Received a Notify. TOADD: Check if it match active VirtualSubscriptions and update it */
if (isPresenceServer() && (request.getMethod().equals(Request.NOTIFY))) {
System.out.println("Incoming request Notify");
Response response = messageFactory.createResponse(481, request);
response.setReasonPhrase("Subscription does not exist");
if (serverTransaction != null) serverTransaction.sendResponse(response);
else sipProvider.sendResponse(response);
ProxyDebug.println("Proxy: received a Notify request. Probably wrong, responded 481");
return;
}
if (isPresenceServer() && (request.getMethod().equalsIgnoreCase("PUBLISH"))) {
System.out.println("Incoming request Publish");
ProxyDebug.println("Proxy: received a Publish request.");
Request clonedRequest = (Request) request.clone();
if (presenceServer.isStateAgent(clonedRequest)) {
ProxyDebug.println("PresenceServer.isStateAgent");
} else {
ProxyDebug.println("PresenceServer is NOT StateAgent");
}
if (presenceServer.isStateAgent(clonedRequest)) {
presenceServer.processPublishRequest(sipProvider, clonedRequest, serverTransaction);
} else {
Response response = messageFactory.createResponse(Response.NOT_FOUND, request);
if (serverTransaction != null) serverTransaction.sendResponse(response);
else sipProvider.sendResponse(response);
}
return;
}
// Forward to next hop but dont reply OK right away for the
// BYE. Bye is end-to-end not hop by hop!
if (request.getMethod().equals(Request.BYE)) {
if (serverTransaction == null) {
if (ProxyDebug.debug) ProxyDebug.println("Proxy, null server transaction for BYE");
return;
}
/* added code */
CallID call_id = (CallID) request.getHeader(CallID.CALL_ID);
String call_id_str = call_id.getCallId();
long end_time = TimeThreadController.Stop(call_id_str);
To tou = (To) request.getHeader(ToHeader.NAME);
From fromu = (From) request.getHeader(FromHeader.NAME);
String FromUser = fromu.getUserAtHostPort();
String ToUser = tou.getUserAtHostPort();
StringBuffer sb = new StringBuffer(FromUser);
int endsAt = sb.indexOf("@");
String FromUsername = sb.substring(0, endsAt);
sb = new StringBuffer(ToUser);
endsAt = sb.indexOf("@");
String ToUsername = sb.substring(0, endsAt);
BillStrategyApply bill = new BillStrategyApply(new StandardBillPolicy());
long start_time = TimeThreadController.getStartTime();
java.sql.Timestamp s = new java.sql.Timestamp(start_time);
System.out.println("START TIME POU BIKE :" + s.toString());
BigDecimal cost = bill.executeStrategy(1, 2, start_time, end_time);
ProcessBill.updateCallDB(FromUsername, ToUsername, start_time, end_time, cost);
/* end of added code */
Dialog d = serverTransaction.getDialog();
TransactionsMapping transactionsMapping = (TransactionsMapping) d.getApplicationData();
Dialog peerDialog = (Dialog) transactionsMapping.getPeerDialog(serverTransaction);
Request clonedRequest = (Request) request.clone();
FromHeader from = (FromHeader) clonedRequest.getHeader(FromHeader.NAME);
from.removeParameter("tag");
ToHeader to = (ToHeader) clonedRequest.getHeader(ToHeader.NAME);
to.removeParameter("tag");
ViaHeader via = this.getStackViaHeader();
clonedRequest.addHeader(via);
if (peerDialog.getState() != null) {
ClientTransaction newct = sipProvider.getNewClientTransaction(clonedRequest);
transactionsMapping.addMapping(serverTransaction, newct);
peerDialog.sendRequest(newct);
return;
} else {
// the peer dialog is not yet established so bail out.
// this is a client error - client is sending BYE
// before dialog establishment.
if (ProxyDebug.debug) ProxyDebug.println("Proxy, bad dialog state - BYE dropped");
return;
}
}
/*
* If the target set for the request has not been predetermined as
* described above, this implies that the element is responsible for
* the domain in the Request-URI, and the element MAY use whatever
* mechanism it desires to determine where to send the request. ...
* When accessing the location service constructed by a registrar,
* the Request-URI MUST first be canonicalized as described in
* Section 10.3 before being used as an index.
*/
if (requestURI.isSipURI()) {
SipURI requestSipURI = (SipURI) requestURI;
Iterator iterator = requestSipURI.getParameterNames();
if (ProxyDebug.debug)
ProxyDebug.println("Proxy, processRequest(), we canonicalized" + " the request-URI");
while (iterator != null && iterator.hasNext()) {
String name = (String) iterator.next();
requestSipURI.removeParameter(name);
}
}
if (registrar.hasRegistration(request)) {
targetURIList = registrar.getContactsURI(request);
// We fork only INVITE
if (targetURIList != null
&& targetURIList.size() > 1
&& !request.getMethod().equals("INVITE")) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(), the request "
+ " to fork is not an INVITE, so we will process"
+ " it with the first target as the only target.");
targetURI = (URI) targetURIList.firstElement();
targetURIList = new Vector();
targetURIList.addElement(targetURI);
// 4. Forward the request statefully to the target:
requestForwarding.forwardRequest(
targetURIList, sipProvider, request, serverTransaction, true);
return;
}
if (targetURIList != null && !targetURIList.isEmpty()) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(), the target set"
+ " is the set of the contacts URI from the "
+ " location service");
To to = (To) request.getHeader(ToHeader.NAME);
From from = (From) request.getHeader(FromHeader.NAME);
String FromUser = from.getUserAtHostPort();
String ToUser = to.getUserAtHostPort();
StringBuffer sb = new StringBuffer(FromUser);
int endsAt = sb.indexOf("@");
String FromUsername = sb.substring(0, endsAt);
sb = new StringBuffer(ToUser);
endsAt = sb.indexOf("@");
String ToUsername = sb.substring(0, endsAt);
if (!block.CheckBlock(FromUsername, ToUsername)) {
Response response =
messageFactory.createResponse(Response.TEMPORARILY_UNAVAILABLE, request);
if (serverTransaction != null) serverTransaction.sendResponse(response);
else sipProvider.sendResponse(response);
return;
}
/*
* // ECE355 Changes - Aug. 2005. // Call registry service,
* get response (uri - wsdl). // if response is not null
* then // do our staff // send to caller decline message by
* building a decline msg // and attach wsdl uri in the
* message body // else .. continue the logic below ...
*
*
* // Lets assume that wsdl_string contains the message with
* all the // service names and uri's for each service in
* the required format
*
* // Query for web services for the receiver of INVITE //
* Use WebServices class to get services for org
*
* String messageBody = "" ; WebServicesQuery wsq = null ;
* wsq = WebServicesQuery.getInstance();
*
* // Get services info for receiver // A receiver is
* represented as an organization in the Service Registry
*
* To to = (To)request.getHeader(ToHeader.NAME); String
* toAddress = to.getUserAtHostPort();
*
* // Remove all characters after the @ sign from To address
* StringBuffer sb = new StringBuffer(toAddress); int endsAt
* = sb.indexOf("@"); String orgNamePattern =
* sb.substring(0, endsAt);
*
*
* Collection serviceInfoColl =
* wsq.findServicesForOrg(orgNamePattern);
*
* // If services are found for this receiver (Org), build
* DECLINE message and // send to client if (serviceInfoColl
* != null) { if (serviceInfoColl.size()!= 0 ){
* System.out.println("Found " + serviceInfoColl.size() +
* " services for o rg " + orgNamePattern) ; // Build
* message body for DECLINE message with Service Info
* messageBody = serviceInfoColl.size()+ " -- " ;
*
* Iterator servIter = serviceInfoColl.iterator(); while
* (servIter.hasNext()) { ServiceInfo servInfo =
* (ServiceInfo)servIter.next(); messageBody = messageBody +
* servInfo.getDescription()+ " " + servInfo.getWsdluri() +
* " " + servInfo.getEndPoint()+ " -- ";
*
*
* System.out.println("Name: " + servInfo.getName()) ;
* System.out.println("Providing Organization: " +
* servInfo.getProvidingOrganization()) ;
* System.out.println("Description: " +
* servInfo.getDescription()) ;
* System.out.println("Service End Point " +
* servInfo.getEndPoint()) ; System.out.println("wsdl wri "
* + servInfo.getWsdluri()) ;
* System.out.println("---------------------------------");
*
*
*
* }
*
* System.out.println("ServiceInfo - Message Body " +
* messageBody) ;
*
* // Build and send DECLINE message with web service info
*
* ContentTypeHeader contentTypeHeader = new ContentType(
* "text", "plain");
*
* Response response = messageFactory.createResponse(
* Response.DECLINE, request, contentTypeHeader,
* messageBody);
*
*
*
* if (serverTransaction != null)
* serverTransaction.sendResponse(response); else
* sipProvider.sendResponse(response); return; } else
* System.out.println("There are no services for org " +
* orgNamePattern) ;
*
* }
*
* // End of ECE355 change
*/
// 4. Forward the request statefully to each target Section
// 16.6.:
requestForwarding.forwardRequest(
targetURIList, sipProvider, request, serverTransaction, true);
return;
} else {
// Let's continue and try the default hop.
}
}
// The registrar cannot help to decide the targets, so let's use
// our router: the default hop!
ProxyDebug.println(
"Proxy, processRequest(), the registrar cannot help"
+ " to decide the targets, so let's use our router: the default hop");
Router router = sipStack.getRouter();
if (router != null) {
ProxyHop hop = (ProxyHop) router.getOutboundProxy();
if (hop != null) {
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(), the target set" + " is the defaut hop: outbound proxy");
// Bug fix contributed by Joe Provino
String user = null;
if (requestURI.isSipURI()) {
SipURI requestSipURI = (SipURI) requestURI;
user = requestSipURI.getUser();
}
SipURI hopURI = addressFactory.createSipURI(user, hop.getHost());
hopURI.setTransportParam(hop.getTransport());
hopURI.setPort(hop.getPort());
targetURI = hopURI;
targetURIList.addElement(targetURI);
// 4. Forward the request statelessly to each target Section
// 16.6.:
requestForwarding.forwardRequest(
targetURIList, sipProvider, request, serverTransaction, false);
return;
}
}
/*
* If the target set remains empty after applying all of the above,
* the proxy MUST return an error response, which SHOULD be the 480
* (Temporarily Unavailable) response.
*/
Response response = messageFactory.createResponse(Response.TEMPORARILY_UNAVAILABLE, request);
if (serverTransaction != null) serverTransaction.sendResponse(response);
else sipProvider.sendResponse(response);
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(), unable to set "
+ " the targets, 480 (Temporarily Unavailable) replied:\n"
+ response.toString());
} catch (Exception ex) {
try {
if (ProxyDebug.debug) {
ProxyDebug.println("Proxy, processRequest(), internal error, " + "exception raised:");
ProxyDebug.logException(ex);
ex.printStackTrace();
}
// This is an internal error:
// Let's return a 500 SERVER_INTERNAL_ERROR
Response response = messageFactory.createResponse(Response.SERVER_INTERNAL_ERROR, request);
if (serverTransaction != null) serverTransaction.sendResponse(response);
else sipProvider.sendResponse(response);
if (ProxyDebug.debug)
ProxyDebug.println(
"Proxy, processRequest(),"
+ " 500 SERVER_INTERNAL_ERROR replied:\n"
+ response.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}
public synchronized void processResponse(ResponseEvent responseReceivedEvent) {
try {
Response response = (Response) responseReceivedEvent.getResponse();
ClientTransaction clientTransaction = responseReceivedEvent.getClientTransaction();
int statusCode = response.getStatusCode();
FromHeader fromHeader = (FromHeader) response.getHeader(FromHeader.NAME);
String displayName = fromHeader.getAddress().getDisplayName();
if (Logger.logLevel >= Logger.LOG_SIP) {
Logger.println(
"Response: statusCode "
+ statusCode
+ " state "
+ getCallState()
+ " fromHeader "
+ displayName
+ " call participant "
+ cp.getName());
}
if (reasonCallTerminated != null) {
/*
* Ignore OK and Request Terminated.
* XXX what's the symbol for 487?
*/
if (statusCode != Response.OK && statusCode != 487) {
if (Logger.logLevel >= Logger.LOG_SIP) {
Logger.println("Call " + cp + ": request cancelled, ignoring response");
}
}
CallIdHeader callIdHeader = (CallIdHeader) response.getHeader("Call-Id");
String sipCallId = callIdHeader.getCallId();
sipServerCallback.removeSipListener(sipCallId);
return;
}
/*
* Some type of global failure that prevents the
* CallParticipant from being contacted, report failure.
*/
if (forceGatewayError) {
statusCode = 500;
forceGatewayError = false;
}
if (statusCode >= 500 && getState() == CallState.INVITED) {
Logger.error(
"Call " + cp + " gateway error: " + statusCode + " " + response.getReasonPhrase());
cancelRequest("gateway error: " + statusCode + " " + response.getReasonPhrase());
return;
} else if (statusCode == Response.PROXY_AUTHENTICATION_REQUIRED
|| statusCode == Response.UNAUTHORIZED) {
if (cp.getProxyCredentials() != null) {
try {
SipServer.handleChallenge(response, clientTransaction, cp.getProxyCredentials())
.sendRequest();
} catch (Exception e) {
Logger.println("Proxy authentification failed " + e);
}
}
return;
} else if (statusCode >= 400) {
// if we get a busy or an unknown error, play busy.
Logger.println("Call " + cp + " got status code :" + statusCode);
cp.setCallEndTreatment(null);
cp.setConferenceJoinTreatment(null);
cp.setConferenceLeaveTreatment(null);
/*
* play busy treatment, but deallocate any resources
* held up by ringBack first, if any.
*/
// stopCallAnsweredTreatment();
if (statusCode == Response.BUSY_HERE) {
try {
if (busyTreatment != null) {
addTreatment(busyTreatment);
// busyTreatment.waitForTreatment();
} else {
Logger.println("Unable to play busy treatment!!!");
}
} catch (Exception e) {
Logger.error("can't start busy treatment!" + sdpBody);
}
CallEvent callEvent = new CallEvent(CallEvent.BUSY_HERE);
callEvent.setInfo(response.getReasonPhrase());
sendCallEventNotification(callEvent);
}
// sipUtil.sendBye(clientTransaction);
cancelRequest(response.getReasonPhrase());
return;
}
/* state machine */
switch (getState()) {
/*
* CallParticipant picked up, send treatment if any,
* and wait for it to finish.
*/
case CallState.INVITED:
if (rejectCall) {
Logger.error(
"Call " + cp + " gateway error: " + statusCode + " " + response.getReasonPhrase());
cancelRequest("gateway error: " + statusCode + " " + response.getReasonPhrase());
return;
}
handleCallParticipantInvited(response, clientTransaction);
break;
/*
* Call established, the ACK needs to be resent.
* According to Ranga, this is done by the NIST SIP Stack.
*/
case CallState.ESTABLISHED:
if (statusCode == Response.OK) {
gotOk = true;
Logger.writeFile("Call " + cp + " Got OK, ESTABLISHED");
if (ackSent == false) {
sipUtil.sendAck(clientTransaction);
ackSent = true;
}
}
break;
case CallState.ENDED:
break; // ignore the response
default:
Logger.error("Process Response bad state " + getState() + "\n" + response);
}
} catch (SipException e) {
Logger.exception("Call " + cp + " SIP Stack error ", e);
cancelRequest("processResponse: SIP Stack error " + e.getMessage());
} catch (Exception e) {
Logger.exception("processResponse: " + cp, e);
cancelRequest("processResponse: SIP Stack error " + e.getMessage());
}
}
public void processSubscribe(Request request, ServerTransaction serverTransaction) {
logger.debug("Processing SUBSCRIBE in progress ");
try {
MessageFactory messageFactory = imUA.getMessageFactory();
HeaderFactory headerFactory = imUA.getHeaderFactory();
AddressFactory addressFactory = imUA.getAddressFactory();
Dialog dialog = serverTransaction.getDialog();
// ********** Terminating subscriptions **********
ExpiresHeader expiresHeader = (ExpiresHeader) request.getHeader(ExpiresHeader.NAME);
if (expiresHeader != null && expiresHeader.getExpires() == 0) {
if (dialog != null) {
// Terminating an existing subscription
Response response = messageFactory.createResponse(Response.OK, request);
serverTransaction.sendResponse(response);
IMNotifyProcessing imNotifyProcessing = imUA.getIMNotifyProcessing();
imNotifyProcessing.sendNotify(response, null, dialog);
return;
} else {
// Terminating an non existing subscription
Response response =
messageFactory.createResponse(Response.CALL_OR_TRANSACTION_DOES_NOT_EXIST, request);
serverTransaction.sendResponse(response);
return;
}
}
// ********** Non-terminating subscriptions ************
// send a 202 Accepted while waiting for authorization from user
Response response = messageFactory.createResponse(Response.ACCEPTED, request);
// Tag:
ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
if (toHeader.getTag() == null)
toHeader.setTag(new Integer((int) (Math.random() * 10000)).toString());
serverTransaction.sendResponse(response);
logger.debug(response.toString());
// We have to ask the user to authorize the guy to be in his buddy
// list
String presentityURL = IMUtilities.getKey(request, "From");
SipProvider sipProvider = imUA.getSipProvider();
InstantMessagingGUI imGUI = imUA.getInstantMessagingGUI();
boolean authorization = imGUI.getAuthorizationForBuddy(presentityURL);
if (authorization) {
logger.debug(
"DEBUG: SubscribeProcessing, processSubscribe(), " + " Response 202 Accepted sent.");
// We have to create or update the subscriber!
PresenceManager presenceManager = imUA.getPresenceManager();
String subscriberURL = IMUtilities.getKey(request, "From");
if (dialog != null) presenceManager.addSubscriber(subscriberURL, response, dialog);
else {
logger.debug(
"ERROR, IMSubscribeProcessing, processSubscribe(), the"
+ " dialog for the SUBSCRIBE we received is null!!! No subscriber added....");
return;
}
// Let's see if this buddy is in our buddy list
// if not let's ask to add him!
BuddyList buddyList = imGUI.getBuddyList();
ListenerInstantMessaging listenerIM = imGUI.getListenerInstantMessaging();
if (!buddyList.hasBuddy(subscriberURL)) {
// Let's ask:
listenerIM.addContact(subscriberURL);
}
/** ********************** send NOTIFY ************************* */
// We send a NOTIFY for any of our status but offline
String localStatus = listenerIM.getLocalStatus();
if (!localStatus.equals("offline")) {
IMNotifyProcessing imNotifyProcessing = imUA.getIMNotifyProcessing();
Subscriber subscriber = presenceManager.getSubscriber(subscriberURL);
// Response okSent=subscriber.getOkSent();
subscriberURL = subscriber.getSubscriberName();
String contactAddress = imUA.getIMAddress() + ":" + imUA.getIMPort();
String subStatus = listenerIM.getLocalStatus();
String status = null;
if (subStatus.equals("offline")) status = "closed";
else status = "open";
String xmlBody =
imNotifyProcessing.xmlPidfParser.createXMLBody(
status, subStatus, subscriberURL, contactAddress);
imNotifyProcessing.sendNotify(response, xmlBody, dialog);
}
} else {
// User did not authorize subscription. Terminate it!
logger.debug(
"DEBUG, IMSubsribeProcessing, processSubscribe(), " + " Subscription declined!");
logger.debug(
"DEBUG, IMSubsribeProcessing, processSubscribe(), "
+ " Sending a Notify with Subscribe-state=terminated");
IMNotifyProcessing imNotifyProcessing = imUA.getIMNotifyProcessing();
if (dialog != null) {
imNotifyProcessing.sendNotify(response, null, dialog);
logger.debug(
"DEBUG, IMSubsribeProcessing, processSubscribe(), "
+ " Sending a Notify with Subscribe-state=terminated");
} else {
logger.debug(
"ERROR, IMSubscribeProcessing, processSubscribe(), the"
+ " dialog for the SUBSCRIBE we received is null!!! \n"
+ " No terminating Notify sent");
}
imNotifyProcessing.sendNotify(response, null, dialog);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Tries to steer a TI client transaction through the following scenario
* Calling-->Completed-->Terminated. Apart from state transitions, we also test, retransmissions
* and proper hiding/passing of messages to the TU.
*/
public void testCallingCompletedTerminatedScenario() {
try {
Request invite = createTiInviteRequest(null, null, null);
// JvB: test
// ((MessageExt) invite).getFirstViaHeader().setParameter( "rport",
// null );
ClientTransaction tran = null;
try {
eventCollector.collectRequestEvent(riSipProvider);
tran = tiSipProvider.getNewClientTransaction(invite);
tran.sendRequest();
} catch (SipException ex) {
throw new TiUnexpectedError("A SipExceptionOccurred while trying to send request!", ex);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
waitForMessage();
RequestEvent inviteReceivedEvent = eventCollector.extractCollectedRequestEvent();
if (inviteReceivedEvent == null || inviteReceivedEvent.getRequest() == null)
throw new TiUnexpectedError("The invite request was not received by the RI!");
// At this point the ClientTransaction should be CALLING!
assertEquals(TransactionState.CALLING, tran.getState());
// Check Request retransmission
try {
eventCollector.collectRequestEvent(riSipProvider);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
// Wait for the retransmission timer to fire if it had not already
// done so.
if (tran.getRetransmitTimer() > MESSAGES_ARRIVE_FOR)
sleep((long) tran.getRetransmitTimer() - MESSAGES_ARRIVE_FOR); // subtract
// the
// time
// we
// waited
// for
// the
// invite
// Wait for the retransmitted request to arrive
waitForMessage();
inviteReceivedEvent = eventCollector.extractCollectedRequestEvent();
assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent);
assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent.getRequest());
assertEquals(Request.INVITE, inviteReceivedEvent.getRequest().getMethod());
// At this point the ClientTransaction should STILL be CALLING!
assertEquals(TransactionState.CALLING, tran.getState());
// Send a 486 BUSY HERE (final) response from the RI
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Failed to register a SipListener with TI", ex);
}
// The BUSY_HERE response should trigger some ACKs so let's register
// a listener with the RI
SipEventCollector ackCollector = new SipEventCollector();
try {
ackCollector.collectRequestEvent(riSipProvider);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
Response busyHere = null;
try {
busyHere =
riMessageFactory.createResponse(Response.BUSY_HERE, inviteReceivedEvent.getRequest());
addStatus(inviteReceivedEvent.getRequest(), busyHere);
// JvB: set to-tag, check it against the ACK generated
((ToHeader) busyHere.getHeader("to")).setTag("ack-to-test");
riSipProvider.sendResponse((Response) busyHere.clone());
} catch (Throwable ex) {
throw new TckInternalError(
"The TCK could not send a BUSY HERE response back to the TI", ex);
}
waitForMessage();
// Analyze the BUSY_HERE response and Tran state back at the TI
ResponseEvent responseEvent = eventCollector.extractCollectedResponseEvent();
assertNotNull(
"The Tested Implementation did not pass a 300-699 response to the TU!", responseEvent);
assertNotNull(
"The Tested Implementation did not pass a 300-699 response to the TU!",
responseEvent.getResponse());
assertSame(
"The BUSY_HERE response was not associated with the right transaction",
tran,
responseEvent.getClientTransaction());
assertSame(
"A response different from BUSY_HERE was passed to the TU",
tran,
responseEvent.getClientTransaction());
assertEquals(
"The ClientTransaction did not pass in the COMPLETED state after "
+ "receiving 300-699 final response",
tran.getState(),
TransactionState.COMPLETED);
// check whether the ackCollector has caught any fish
RequestEvent ackReceivedEvent = ackCollector.extractCollectedRequestEvent();
assertNotNull("The TI did not send an ACK request", ackReceivedEvent);
assertNotNull("The TI did not send an ACK request", ackReceivedEvent.getRequest());
assertEquals(Request.ACK, ackReceivedEvent.getRequest().getMethod());
// Try to kill remaining ACK retransmissions
// TODO this may not always work .. should give it a specific
// timeout value
waitForMessage();
// Now let's retransmit the final response. This time it shouldn't
// be
// passed to the TU but an ACK should still be sent
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Failed to register a SipListener with TI", ex);
}
// go fish the ack
try {
ackCollector.collectRequestEvent(riSipProvider);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
try {
riSipProvider.sendResponse((Response) busyHere.clone());
} catch (Throwable ex) {
throw new TckInternalError(
"The TCK could not send a BUSY HERE response back to the TI", ex);
}
waitForMessage();
// The TU shouldn't see the retransmitted BUSY_HERE response
responseEvent = eventCollector.extractCollectedResponseEvent();
assertNull(
"The Tested Implementation passed a retransmitted 300-699 response "
+ "to the TU instead of just silently acknowledging it!",
responseEvent);
// We must still be in the completed state.
assertEquals(
"The ClientTransaction did not stay long enough in the COMPLETED " + "state.",
tran.getState(),
TransactionState.COMPLETED);
// check whether the ackCollector has caught any fish
ackReceivedEvent = ackCollector.extractCollectedRequestEvent();
assertNotNull("The TI did not send an ACK request to the second response", ackReceivedEvent);
assertNotNull(
"The TI did not send an ACK request to the second response",
ackReceivedEvent.getRequest());
assertEquals(Request.ACK, ackReceivedEvent.getRequest().getMethod());
// JvB: verify to tag
assertEquals(
"The To header field in the ACK MUST equal the To header field "
+ " in the response being acknowledged",
"ack-to-test",
((ToHeader) ackReceivedEvent.getRequest().getHeader("to")).getTag());
} catch (Throwable exc) {
exc.printStackTrace();
fail(exc.getClass().getName() + ": " + exc.getMessage());
}
assertTrue(new Exception().getStackTrace()[0].toString(), true);
// Unfortunately we can't assert the TERMINATED state as timerD
// is not exported by JAIN SIP
}
/**
* handles the INVITED state.
*
* @param response the response
* @param clientTransaction the client transaction
* @throws SipException SIP stack related error
*/
private void handleCallParticipantInvited(Response response, ClientTransaction clientTransaction)
throws ParseException, SipException, InvalidArgumentException {
FromHeader fromHeader = (FromHeader) response.getHeader(FromHeader.NAME);
String displayName = fromHeader.getAddress().getDisplayName();
int statusCode = response.getStatusCode();
Logger.println(
"handleCallParticipantInvited "
+ cp
+ " status "
+ statusCode
+ " "
+ response.getReasonPhrase());
Logger.println("handleCallParticipantInvited , displayname " + displayName);
CallIdHeader callIdHeader = (CallIdHeader) response.getHeader(CallIdHeader.NAME);
if (sipCallId.equals(callIdHeader.getCallId())
&& displayName.equals(cp.getDisplayName())
&& (statusCode == Response.OK || statusCode == Response.SESSION_PROGRESS)
&& ((CSeqHeader) response.getHeader(CSeqHeader.NAME)).getMethod().equals(Request.INVITE)) {
if (statusCode == Response.SESSION_PROGRESS) {
/*
* For some calls, we never get an OK. Instead we just get
* SESSION_PROGRESS. In order to handle these calls, we treat
* SESSION_PROGRESS as OK. If an OK arrives later, we'll
* send an ACK. This flag allows us to enable or
* disable this workaround for each call.
*
* The problem with always treating SESSION_PROGRESS as OK
* is that in a conference everybody will hear the ringing sound
* which the remote call sends until the call is actually answered.
* This can be avoided if joinConfirmation is specified.
* The other problem is that if we treat SESSION_PROGRESS
* as though the call has been answered, then we'll start
* playing the treatment before a person really answers to
* hear the treatment.
*/
if (cp.getHandleSessionProgress() == false) {
Logger.writeFile("Call " + cp + " Ignoring SESSION_PROGRESS");
return;
}
Logger.writeFile("Call " + cp + " Treating SESSION_PROGRESS as OK");
}
if (response.getRawContent() == null) {
Logger.error("Call " + cp + " no SDP in OK Response!");
cancelRequest("SIP error! no SDP in OK Response!");
return;
}
this.clientTransaction = clientTransaction;
if (statusCode == Response.OK) {
gotOk = true;
Logger.writeFile("Call " + cp + " Got OK, call answered\n" + response);
}
ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
/*
* We got an OK response.
*
* send an ACK back to the CallParticipant
*/
if (statusCode == Response.OK) {
sipUtil.sendAck(clientTransaction);
ackSent = true;
}
if (callAnswered) {
Logger.writeFile("Call " + cp + " done processing OK");
return;
}
/*
* Remember the IP and port of where to send data to
* the CallParticipant.
*/
sdpBody = new String(response.getRawContent());
SdpInfo sdpInfo;
try {
sdpInfo = sipUtil.getSdpInfo(sdpBody, false);
} catch (ParseException e) {
Logger.error("Call " + cp + " Invalid SDP in OK Response! " + e.getMessage());
cancelRequest("SIP error! Invalid SDP in OK Response!");
return;
}
MediaInfo mediaInfo = sdpInfo.getMediaInfo();
InetSocketAddress isa =
new InetSocketAddress(sdpInfo.getRemoteHost(), sdpInfo.getRemotePort());
InetSocketAddress rtcpAddress = sdpInfo.getRtcpAddress();
setEndpointAddress(
isa,
mediaInfo.getPayload(),
sdpInfo.getTransmitMediaInfo().getPayload(),
sdpInfo.getTelephoneEventPayload(),
rtcpAddress);
/*
* The CallParticipant has answered.
* If join confirmation is required, we remain in the
* INVITED state. We set the callAnswered flag so that
* if the join confirmation times out we know to
* send a BYE rather than a CANCEL.
*/
callAnswered = true;
if (cp.getJoinConfirmationTimeout() == 0) {
setState(CallState.ANSWERED);
}
/*
* Start treatment if any and wait for it to finish.
* When the treatment finishes, notification will
* be delivered to our parent which will indicate
* we're ready for the conference.
*
* If there's no treatment to be played, we're ready now
* unless we're waiting for join confirmation..
*/
initializeCallAnsweredTreatment();
if (callAnsweredTreatment != null) {
startCallAnsweredTreatment();
} else {
if (cp.getJoinConfirmationTimeout() == 0) {
setState(CallState.ESTABLISHED);
}
}
} else {
Logger.writeFile("Call " + cp + " Ignoring response: " + response.getReasonPhrase());
if (Logger.logLevel >= Logger.LOG_SIP) {
Logger.println("Call " + cp + " Response: " + response);
}
}
}
public void processResponse(ResponseEvent responseReceivedEvent) {
System.out.println("Got a response");
Response response = (Response) responseReceivedEvent.getResponse();
ClientTransaction tid = responseReceivedEvent.getClientTransaction();
CSeqHeader cseq = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
System.out.println(
"Response received : Status Code = " + response.getStatusCode() + " " + cseq);
if (tid == null) {
// RFC3261: MUST respond to every 2xx
if (ackRequest != null && dialog != null) {
System.out.println("re-sending ACK");
try {
dialog.sendAck(ackRequest);
} catch (SipException se) {
se.printStackTrace();
fail("Unxpected exception ");
}
}
return;
}
// If the caller is supposed to send the bye
if (callerSendsBye && !byeTaskRunning) {
byeTaskRunning = true;
new Timer().schedule(new ByeTask(dialog), 4000);
}
System.out.println("transaction state is " + tid.getState());
System.out.println("Dialog = " + tid.getDialog());
System.out.println("Dialog State is " + tid.getDialog().getState());
assertSame("Checking dialog identity", tid.getDialog(), this.dialog);
try {
if (response.getStatusCode() == Response.OK) {
if (cseq.getMethod().equals(Request.INVITE)) {
System.out.println("Dialog after 200 OK " + dialog);
System.out.println("Dialog State after 200 OK " + dialog.getState());
Request ackRequest = dialog.createAck(cseq.getSeqNumber());
System.out.println("Sending ACK");
dialog.sendAck(ackRequest);
// JvB: test REFER, reported bug in tag handling
// Request referRequest = dialog.createRequest("REFER");
// //simulating a balancer that will forward the request to the
// recovery node
// SipURI referRequestURI = addressFactory.createSipURI(null,
// "127.0.0.1:5080");
// referRequest.setRequestURI(referRequestURI);
// dialog.sendRequest(
// sipProvider.getNewClientTransaction(referRequest));
//
} else if (cseq.getMethod().equals(Request.CANCEL)) {
if (dialog.getState() == DialogState.CONFIRMED) {
// oops cancel went in too late. Need to hang up the
// dialog.
System.out.println("Sending BYE -- cancel went in too late !!");
Request byeRequest = dialog.createRequest(Request.BYE);
ClientTransaction ct = sipProvider.getNewClientTransaction(byeRequest);
dialog.sendRequest(ct);
}
} else if (cseq.getMethod().equals(Request.BYE)) {
okToByeReceived = true;
}
}
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
