/** Default constructor. */ protected SIPTransactionStack() { super(); this.transactionTableSize = -1; // a set of methods that result in dialog creation. this.dialogCreatingMethods = new HashSet<String>(); // Standard set of methods that create dialogs. this.dialogCreatingMethods.add(Request.REFER); this.dialogCreatingMethods.add(Request.INVITE); this.dialogCreatingMethods.add(Request.SUBSCRIBE); // Notify may or may not create a dialog. This is handled in // the code. // Create the transaction collections clientTransactions = Collections.synchronizedList(new ArrayList<SIPClientTransaction>()); serverTransactions = Collections.synchronizedList(new ArrayList<SIPServerTransaction>()); // Dialog dable. this.dialogTable = new Hashtable<String, SIPDialog>(); clientTransactionTable = new Hashtable<String, SIPTransaction>(); serverTransactionTable = new Hashtable<String, SIPTransaction>(); // Start the timer event thread. this.timer = new Timer(); this.pendingRecordScanner = new Thread(new PendingRecordScanner(this)); this.pendingRecordScanner.setDaemon(true); this.pendingTransactions = new HashSet<SIPServerTransaction>(); pendingRecords = Collections.synchronizedList(new ArrayList<PendingRecord>()); pendingRecordScanner.setName("PendingRecordScanner"); pendingRecordScanner.start(); // endif // }
public void run() { try { for (int i = 0; i < 1; i++) { Thread.sleep(1000); Request request = this.notifier.dialog.createRequest(Request.NOTIFY); SubscriptionStateHeader subscriptionState = headerFactory.createSubscriptionStateHeader(SubscriptionStateHeader.ACTIVE); request.addHeader(subscriptionState); request.addHeader(eventHeader); ClientTransaction ct = udpProvider.getNewClientTransaction(request); this.notifier.dialog.sendRequest(ct); } Request request = this.notifier.dialog.createRequest(Request.NOTIFY); SubscriptionStateHeader subscriptionState = headerFactory.createSubscriptionStateHeader(SubscriptionStateHeader.TERMINATED); request.addHeader(eventHeader); request.addHeader(subscriptionState); ClientTransaction ct = udpProvider.getNewClientTransaction(request); this.notifier.dialog.sendRequest(ct); } catch (Exception ex) { ex.printStackTrace(); System.exit(0); } }
/** Re Initialize the stack instance. */ protected void reInit() { super.reInit(); clientTransactions = Collections.synchronizedList(new ArrayList<SIPClientTransaction>()); serverTransactions = Collections.synchronizedList(new ArrayList<SIPServerTransaction>()); pendingTransactions = new HashSet<SIPServerTransaction>(); pendingRecords = Collections.synchronizedList(new ArrayList<PendingRecord>()); clientTransactionTable = new Hashtable<String, SIPTransaction>(); serverTransactionTable = new Hashtable<String, SIPTransaction>(); // Dialog dable. this.dialogTable = new Hashtable<String, SIPDialog>(); this.timer = new Timer(); pendingRecordScanner = new Thread(new PendingRecordScanner(this)); pendingRecordScanner.setDaemon(true); pendingRecordScanner.setName("PendingRecordScanner"); pendingRecordScanner.start(); }
/** 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); } }
private void shutDown() { try { try { Thread.sleep(2000); } catch (InterruptedException e) { } System.out.println("nulling reference"); sipStack.deleteListeningPoint(tcpListeningPoint); sipStack.deleteListeningPoint(udpListeningPoint); // This will close down the stack and exit all threads tcpProvider.removeSipListener(this); udpProvider.removeSipListener(this); while (true) { try { sipStack.deleteSipProvider(udpProvider); sipStack.deleteSipProvider(tcpProvider); break; } catch (ObjectInUseException ex) { try { Thread.sleep(2000); } catch (InterruptedException e) { continue; } } } sipStack = null; tcpProvider = null; udpProvider = null; this.contactHeader = null; addressFactory = null; headerFactory = null; messageFactory = null; this.udpListeningPoint = null; this.tcpListeningPoint = null; this.reInviteCount = 0; System.gc(); // Redo this from the start. if (counter < 10) this.init(); else counter++; } catch (Exception ex) { ex.printStackTrace(); } }
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); } }