private ContactHeader getRegistrationContactHeader() throws IOException {
    if (contactHeader != null) {
      return contactHeader;
    }

    try {
      SipURI contactURI =
          (SipURI)
              addressFactory.createURI(
                  "sip:" + proxyCredentials.getUserName() + "@" + proxyCredentials.getHost());

      contactURI.setTransportParam(sipProvider.getListeningPoint().getTransport());
      contactURI.setPort(sipProvider.getListeningPoint().getPort());
      Address contactAddress = addressFactory.createAddress(contactURI);
      contactAddress.setDisplayName(proxyCredentials.getUserDisplay());
      contactHeader = headerFactory.createContactHeader(contactAddress);
      return contactHeader;
    } catch (ParseException e) {
      throw new IOException(
          "A ParseException occurred while creating From Header! " + " " + e.getMessage());
    }
  }
示例#2
0
 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();
   }
 }
示例#3
0
  public void init() {
    SipFactory sipFactory = null;
    sipStack = null;
    sipFactory = SipFactory.getInstance();
    sipFactory.setPathName("gov.nist");
    Properties properties = new Properties();
    // If you want to try TCP transport change the following to
    String transport = "udp";
    String peerHostPort = "127.0.0.1:5070";
    properties.setProperty("javax.sip.IP_ADDRESS", "127.0.0.1");
    properties.setProperty("javax.sip.OUTBOUND_PROXY", peerHostPort + "/" + transport);
    properties.setProperty("javax.sip.STACK_NAME", "shootist");
    properties.setProperty("javax.sip.RETRANSMISSION_FILTER", "on");

    // The following properties are specific to nist-sip
    // and are not necessarily part of any other jain-sip
    // implementation.
    // You can set a max message size for tcp transport to
    // guard against denial of service attack.
    properties.setProperty("gov.nist.javax.sip.MAX_MESSAGE_SIZE", "1048576");
    properties.setProperty("gov.nist.javax.sip.DEBUG_LOG", "shootistdebug.txt");
    properties.setProperty("gov.nist.javax.sip.SERVER_LOG", "shootistlog.txt");

    // Drop the client connection after we are done with the transaction.
    properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS", "false");
    // Set to 0 in your production code for max speed.
    // You need 16 for logging traces. 32 for debug + traces.
    // Your code will limp at 32 but it is best for debugging.
    properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", "0");

    try {
      // Create SipStack object
      sipStack = sipFactory.createSipStack(properties);
      System.out.println("createSipStack " + sipStack);
    } catch (PeerUnavailableException e) {
      // could not find
      // gov.nist.jain.protocol.ip.sip.SipStackImpl
      // in the classpath
      e.printStackTrace();
      System.err.println(e.getMessage());
      System.exit(0);
    }

    try {
      headerFactory = sipFactory.createHeaderFactory();
      addressFactory = sipFactory.createAddressFactory();
      messageFactory = sipFactory.createMessageFactory();
      udpListeningPoint = sipStack.createListeningPoint(sipStack.getIPAddress(), 5060, "udp");
      udpProvider = sipStack.createSipProvider(udpListeningPoint);
      Shootist listener = this;
      udpProvider.addSipListener(listener);

      tcpListeningPoint = sipStack.createListeningPoint(sipStack.getIPAddress(), 5060, "tcp");
      tcpProvider = sipStack.createSipProvider(tcpListeningPoint);
      tcpProvider.addSipListener(listener);

      SipProvider sipProvider = transport.equalsIgnoreCase("udp") ? udpProvider : tcpProvider;

      String fromName = "BigGuy";
      String fromSipAddress = "here.com";
      String fromDisplayName = "The Master Blaster";

      String toSipAddress = "there.com";
      String toUser = "******";
      String toDisplayName = "The Little Blister";

      // send the request out.
      for (int i = 0; i < 100; i++) {
        // create >From Header
        SipURI fromAddress = addressFactory.createSipURI(fromName, fromSipAddress);

        Address fromNameAddress = addressFactory.createAddress(fromAddress);
        fromNameAddress.setDisplayName(fromDisplayName);
        FromHeader fromHeader = headerFactory.createFromHeader(fromNameAddress, "12345" + i);

        // create To Header
        SipURI toAddress = addressFactory.createSipURI(toUser, toSipAddress);
        Address toNameAddress = addressFactory.createAddress(toAddress);
        toNameAddress.setDisplayName(toDisplayName);
        ToHeader toHeader = headerFactory.createToHeader(toNameAddress, null);

        // create Request URI
        SipURI requestURI = addressFactory.createSipURI(toUser, peerHostPort);

        // Create ViaHeaders

        ArrayList viaHeaders = new ArrayList();
        int port = sipProvider.getListeningPoint(transport).getPort();
        ViaHeader viaHeader =
            headerFactory.createViaHeader(sipStack.getIPAddress(), port, transport, null);

        // add via headers
        viaHeaders.add(viaHeader);

        // Create ContentTypeHeader
        ContentTypeHeader contentTypeHeader =
            headerFactory.createContentTypeHeader("application", "sdp");

        // Create a new CallId header
        CallIdHeader callIdHeader = sipProvider.getNewCallId();

        // Create a new Cseq header
        CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1L, Request.INVITE);

        // Create a new MaxForwardsHeader
        MaxForwardsHeader maxForwards = headerFactory.createMaxForwardsHeader(70);

        // Create the request.
        Request request =
            messageFactory.createRequest(
                requestURI,
                Request.INVITE,
                callIdHeader,
                cSeqHeader,
                fromHeader,
                toHeader,
                viaHeaders,
                maxForwards);
        // Create contact headers
        String host = sipStack.getIPAddress();

        SipURI contactUrl = addressFactory.createSipURI(fromName, host);
        contactUrl.setPort(tcpListeningPoint.getPort());

        // Create the contact name address.
        SipURI contactURI = addressFactory.createSipURI(fromName, host);
        contactURI.setPort(sipProvider.getListeningPoint(transport).getPort());

        Address contactAddress = addressFactory.createAddress(contactURI);

        // Add the contact address.
        contactAddress.setDisplayName(fromName);

        contactHeader = headerFactory.createContactHeader(contactAddress);
        request.addHeader(contactHeader);

        // Add the extension header.
        Header extensionHeader = headerFactory.createHeader("My-Header", "my header value");
        request.addHeader(extensionHeader);

        String sdpData =
            "v=0\r\n"
                + "o=4855 13760799956958020 13760799956958020"
                + " IN IP4  129.6.55.78\r\n"
                + "s=mysession session\r\n"
                + "p=+46 8 52018010\r\n"
                + "c=IN IP4  129.6.55.78\r\n"
                + "t=0 0\r\n"
                + "m=audio 6022 RTP/AVP 0 4 18\r\n"
                + "a=rtpmap:0 PCMU/8000\r\n"
                + "a=rtpmap:4 G723/8000\r\n"
                + "a=rtpmap:18 G729A/8000\r\n"
                + "a=ptime:20\r\n";
        byte[] contents = sdpData.getBytes();

        request.setContent(contents, contentTypeHeader);

        extensionHeader = headerFactory.createHeader("My-Other-Header", "my new header value ");
        request.addHeader(extensionHeader);

        Header callInfoHeader =
            headerFactory.createHeader("Call-Info", "<http://www.antd.nist.gov>");
        request.addHeader(callInfoHeader);

        // Create the client transaction.
        ClientTransaction inviteTid = sipProvider.getNewClientTransaction(request);
        inviteTid.sendRequest();
      }

    } catch (Exception ex) {
      System.out.println(ex.getMessage());
      ex.printStackTrace();
      usage();
    }
  }
  public void sendSubscribe(String localURL, String buddyURI, boolean EXPIRED) {
    try {
      logger.debug("Sending SUBSCRIBE in progress to the buddy: " + buddyURI);
      int proxyPort = imUA.getProxyPort();
      String proxyAddress = imUA.getProxyAddress();
      String imProtocol = imUA.getIMProtocol();
      SipStack sipStack = imUA.getSipStack();
      SipProvider sipProvider = imUA.getSipProvider();
      MessageFactory messageFactory = imUA.getMessageFactory();
      HeaderFactory headerFactory = imUA.getHeaderFactory();
      AddressFactory addressFactory = imUA.getAddressFactory();

      // Request-URI:
      // URI requestURI=addressFactory.createURI(buddyURI);
      SipURI requestURI = addressFactory.createSipURI(null, proxyAddress);
      requestURI.setPort(proxyPort);
      requestURI.setTransportParam(imProtocol);

      // Call-Id:
      CallIdHeader callIdHeader = null;

      // CSeq:
      CSeqHeader cseqHeader = null;

      // To header:
      ToHeader toHeader = null;

      // From Header:
      FromHeader fromHeader = null;

      // Via header
      String branchId = Utils.generateBranchId();
      ViaHeader viaHeader =
          headerFactory.createViaHeader(
              imUA.getIMAddress(), imUA.getIMPort(), imProtocol, branchId);
      Vector viaList = new Vector();
      viaList.addElement(viaHeader);

      PresenceManager presenceManager = imUA.getPresenceManager();
      Presentity presentity = presenceManager.getPresentity(buddyURI);
      Dialog dialog = null;
      if (presentity != null) dialog = presentity.getDialog();

      if (dialog != null) {

        // We have to remove the subscriber and the Presentity related
        // with this Buddy...
        presenceManager.removePresentity(buddyURI);
        Subscriber subscriber = presenceManager.getSubscriber(buddyURI);
        if (subscriber == null) {
          // It means that the guy does not have us in his buddy list
          // nothing to do!!!
        } else {
          presenceManager.removeSubscriber(buddyURI);
        }

        Address localAddress = dialog.getLocalParty();
        Address remoteAddress = dialog.getRemoteParty();

        fromHeader = headerFactory.createFromHeader(localAddress, dialog.getLocalTag());
        toHeader = headerFactory.createToHeader(remoteAddress, dialog.getRemoteTag());

        long cseq = dialog.getLocalSeqNumber();
        cseqHeader = headerFactory.createCSeqHeader(cseq, "MESSAGE");

        callIdHeader = dialog.getCallId();
      } else {
        String localTag = Utils.generateTag();

        Address toAddress = addressFactory.createAddress(buddyURI);
        Address fromAddress = addressFactory.createAddress(localURL);

        fromHeader = headerFactory.createFromHeader(fromAddress, localTag);
        toHeader = headerFactory.createToHeader(toAddress, null);

        // CSeq:
        cseqHeader = headerFactory.createCSeqHeader(1L, "SUBSCRIBE");

        callIdCounter++;
        // Call-ID:
        callIdHeader =
            (CallIdHeader)
                headerFactory.createCallIdHeader("nist-sip-im-subscribe-callId" + callIdCounter);
      }

      // MaxForwards header:
      MaxForwardsHeader maxForwardsHeader = headerFactory.createMaxForwardsHeader(70);

      Request request =
          messageFactory.createRequest(
              requestURI,
              "SUBSCRIBE",
              callIdHeader,
              cseqHeader,
              fromHeader,
              toHeader,
              viaList,
              maxForwardsHeader);

      RouteHeader rh = this.imUA.getRouteToProxy();
      request.setHeader(rh);

      // Contact header:
      SipURI sipURI = addressFactory.createSipURI(null, imUA.getIMAddress());
      sipURI.setPort(imUA.getIMPort());
      sipURI.setTransportParam(imUA.getIMProtocol());
      Address contactAddress = addressFactory.createAddress(sipURI);
      ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress);
      request.setHeader(contactHeader);

      ExpiresHeader expiresHeader = null;
      if (EXPIRED) {
        expiresHeader = headerFactory.createExpiresHeader(0);
      } else {
        expiresHeader = headerFactory.createExpiresHeader(presenceManager.getExpiresTime());
      }
      request.setHeader(expiresHeader);

      // WE have to add a new Header: "Event"
      Header eventHeader = headerFactory.createHeader("Event", "presence");
      request.setHeader(eventHeader);

      // Add Acceptw Header
      Header acceptHeader = headerFactory.createHeader("Accept", "application/pidf+xml");
      request.setHeader(acceptHeader);

      // ProxyAuthorization header if not null:
      ProxyAuthorizationHeader proxyAuthHeader = imUA.getProxyAuthorizationHeader();
      if (proxyAuthHeader != null) request.setHeader(proxyAuthHeader);

      ClientTransaction clientTransaction = sipProvider.getNewClientTransaction(request);

      if (dialog != null) {
        dialog.sendRequest(clientTransaction);
      } else {
        clientTransaction.sendRequest();
      }

      logger.debug("IMSubscribeProcessing, sendSubscribe(), SUBSCRIBE sent:\n" + request);
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
示例#5
0
  public ClientTransaction call(SipURI destination) {
    try {

      String fromName = "B2BUA";
      String fromSipAddress = "here.com";
      String fromDisplayName = "B2BUA";

      String toSipAddress = "there.com";
      String toUser = "******";
      String toDisplayName = "Target";

      // create >From Header
      SipURI fromAddress = addressFactory.createSipURI(fromName, fromSipAddress);

      Address fromNameAddress = addressFactory.createAddress(fromAddress);
      fromNameAddress.setDisplayName(fromDisplayName);
      FromHeader fromHeader =
          headerFactory.createFromHeader(
              fromNameAddress, new Long(counter.getAndIncrement()).toString());

      // create To Header
      SipURI toAddress = addressFactory.createSipURI(toUser, toSipAddress);
      Address toNameAddress = addressFactory.createAddress(toAddress);
      toNameAddress.setDisplayName(toDisplayName);
      ToHeader toHeader = headerFactory.createToHeader(toNameAddress, null);

      // create Request URI
      SipURI requestURI = destination;

      // Create ViaHeaders

      ArrayList viaHeaders = new ArrayList();
      String ipAddress = listeningPoint.getIPAddress();
      ViaHeader viaHeader =
          headerFactory.createViaHeader(
              ipAddress, sipProvider.getListeningPoint(transport).getPort(), transport, null);

      // add via headers
      viaHeaders.add(viaHeader);

      // Create ContentTypeHeader
      ContentTypeHeader contentTypeHeader =
          headerFactory.createContentTypeHeader("application", "sdp");

      // Create a new CallId header
      CallIdHeader callIdHeader = sipProvider.getNewCallId();

      // Create a new Cseq header
      CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1L, Request.INVITE);

      // Create a new MaxForwardsHeader
      MaxForwardsHeader maxForwards = headerFactory.createMaxForwardsHeader(70);

      // Create the request.
      Request request =
          messageFactory.createRequest(
              requestURI,
              Request.INVITE,
              callIdHeader,
              cSeqHeader,
              fromHeader,
              toHeader,
              viaHeaders,
              maxForwards);
      // Create contact headers
      String host = "127.0.0.1";

      SipURI contactUrl = addressFactory.createSipURI(fromName, host);
      contactUrl.setPort(listeningPoint.getPort());
      contactUrl.setLrParam();

      // Create the contact name address.
      SipURI contactURI = addressFactory.createSipURI(fromName, host);
      contactURI.setPort(sipProvider.getListeningPoint(transport).getPort());

      Address contactAddress = addressFactory.createAddress(contactURI);

      // Add the contact address.
      contactAddress.setDisplayName(fromName);

      ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress);
      request.addHeader(contactHeader);

      // You can add extension headers of your own making
      // to the outgoing SIP request.
      // Add the extension header.
      Header extensionHeader = headerFactory.createHeader("My-Header", "my header value");
      request.addHeader(extensionHeader);

      String sdpData =
          "v=0\r\n"
              + "o=4855 13760799956958020 13760799956958020"
              + " IN IP4  129.6.55.78\r\n"
              + "s=mysession session\r\n"
              + "p=+46 8 52018010\r\n"
              + "c=IN IP4  129.6.55.78\r\n"
              + "t=0 0\r\n"
              + "m=audio 6022 RTP/AVP 0 4 18\r\n"
              + "a=rtpmap:0 PCMU/8000\r\n"
              + "a=rtpmap:4 G723/8000\r\n"
              + "a=rtpmap:18 G729A/8000\r\n"
              + "a=ptime:20\r\n";
      byte[] contents = sdpData.getBytes();

      request.setContent(contents, contentTypeHeader);
      // You can add as many extension headers as you
      // want.

      extensionHeader = headerFactory.createHeader("My-Other-Header", "my new header value ");
      request.addHeader(extensionHeader);

      Header callInfoHeader = headerFactory.createHeader("Call-Info", "<http://www.antd.nist.gov>");
      request.addHeader(callInfoHeader);

      // Create the client transaction.
      ClientTransaction inviteTid = sipProvider.getNewClientTransaction(request);

      System.out.println("inviteTid = " + inviteTid);

      // send the request out.

      inviteTid.sendRequest();

      return inviteTid;

    } catch (Exception ex) {
      System.out.println(ex.getMessage());
      ex.printStackTrace();
    }
    return null;
  }