Ejemplo n.º 1
0
  private FromHeader getFromHeader() throws IOException {

    if (fromHeader != null) {
      return fromHeader;
    }

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

      fromURI.setTransportParam(sipProvider.getListeningPoint().getTransport());

      fromURI.setPort(sipProvider.getListeningPoint().getPort());

      Address fromAddress = addressFactory.createAddress(fromURI);

      fromAddress.setDisplayName(proxyCredentials.getUserDisplay());

      fromHeader = headerFactory.createFromHeader(fromAddress, Integer.toString(hashCode()));

    } catch (ParseException e) {
      throw new IOException(
          "A ParseException occurred while creating From Header! " + e.getMessage());
    }

    return fromHeader;
  }
Ejemplo n.º 2
0
  private ArrayList getLocalViaHeaders() throws IOException {
    /*
     * We can't keep a cached copy because the callers
     * of this method change the viaHeaders.  In particular
     * a branch may be added which causes INVITES to fail.
     */
    if (viaHeaders != null) {
      return viaHeaders;
    }

    ListeningPoint lp = sipProvider.getListeningPoint();
    viaHeaders = new ArrayList();

    try {
      String addr = lp.getIPAddress();

      ViaHeader viaHeader =
          headerFactory.createViaHeader(addr, lp.getPort(), lp.getTransport(), null);

      viaHeader.setRPort();

      viaHeaders.add(viaHeader);
      return viaHeaders;
    } catch (ParseException e) {
      throw new IOException(
          "A ParseException occurred while creating Via Headers! " + e.getMessage());
    } catch (InvalidArgumentException e) {
      throw new IOException(
          "Unable to create a via header for port " + lp.getPort() + " " + e.getMessage());
    }
  }
Ejemplo n.º 3
0
  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();
    }
  }
Ejemplo n.º 4
0
  /** 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);
    }
  }
Ejemplo n.º 5
0
  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());
    }
  }
Ejemplo n.º 6
0
  private void register() throws IOException {
    Log.info("Registering with " + registrar);
    FromHeader fromHeader = getFromHeader();
    Address fromAddress = fromHeader.getAddress();

    // Request URI
    SipURI requestURI = null;
    try {
      requestURI = addressFactory.createSipURI(null, registrar);

    } catch (ParseException e) {
      throw new IOException("Bad registrar address:" + registrar + " " + e.getMessage());
    }
    // requestURI.setPort(registrarPort);

    try {
      requestURI.setTransportParam(sipProvider.getListeningPoint().getTransport());

    } catch (ParseException e) {
      throw new IOException(
          sipProvider.getListeningPoint().getTransport()
              + " is not a valid transport! "
              + e.getMessage());
    }

    CallIdHeader callIdHeader = sipProvider.getNewCallId();
    CSeqHeader cSeqHeader = null;

    try {
      cSeqHeader = headerFactory.createCSeqHeader(1, Request.REGISTER);
    } catch (ParseException e) {
      // Should never happen
      throw new IOException("Corrupt Sip Stack " + e.getMessage());
    } catch (InvalidArgumentException e) {
      // Should never happen
      throw new IOException("The application is corrupt ");
    }

    ToHeader toHeader = null;
    try {
      String proxyWorkAround = System.getProperty("com.sun.mc.softphone.REGISTRAR_WORKAROUND");

      if (proxyWorkAround != null && proxyWorkAround.toUpperCase().equals("TRUE")) {

        SipURI toURI = (SipURI) (requestURI.clone());
        toURI.setUser(System.getProperty("user.name"));

        toHeader = headerFactory.createToHeader(addressFactory.createAddress(toURI), null);
      } else {
        toHeader = headerFactory.createToHeader(fromAddress, null);
      }
    } catch (ParseException e) {
      throw new IOException(
          "Could not create a To header for address:"
              + fromHeader.getAddress()
              + " "
              + e.getMessage());
    }

    ArrayList viaHeaders = getLocalViaHeaders();
    MaxForwardsHeader maxForwardsHeader = getMaxForwardsHeader();
    Request request = null;

    try {
      request =
          messageFactory.createRequest(
              requestURI,
              Request.REGISTER,
              callIdHeader,
              cSeqHeader,
              fromHeader,
              toHeader,
              viaHeaders,
              maxForwardsHeader);
    } catch (ParseException e) {
      throw new IOException("Could not create the register request! " + e.getMessage());
    }

    ExpiresHeader expHeader = null;

    for (int retry = 0; retry < 2; retry++) {
      try {
        expHeader = headerFactory.createExpiresHeader(expires);
      } catch (InvalidArgumentException e) {
        if (retry == 0) {
          continue;
        }
        throw new IOException(
            "Invalid registrations expiration parameter - " + expires + " " + e.getMessage());
      }
    }

    request.addHeader(expHeader);
    ContactHeader contactHeader = getRegistrationContactHeader();
    request.addHeader(contactHeader);

    try {
      SipURI routeURI =
          (SipURI) addressFactory.createURI("sip:" + proxyCredentials.getProxy() + ";lr");
      RouteHeader routeHeader =
          headerFactory.createRouteHeader(addressFactory.createAddress(routeURI));
      request.addHeader(routeHeader);

    } catch (Exception e) {

      Log.error("Creating registration route error ", e);
    }

    ClientTransaction regTrans = null;
    try {
      regTrans = sipProvider.getNewClientTransaction(request);
    } catch (TransactionUnavailableException e) {
      throw new IOException(
          "Could not create a register transaction!\n"
              + "Check that the Registrar address is correct! "
              + e.getMessage());
    }

    try {
      sipCallId = callIdHeader.getCallId();
      sipServerCallback.addSipListener(sipCallId, this);
      registerRequest = request;
      regTrans.sendRequest();

      Log.debug("Sent register request " + registerRequest);

      if (expires > 0) {
        scheduleReRegistration();
      }
    } catch (Exception e) {
      throw new IOException("Could not send out the register request! " + e.getMessage());
    }

    this.registerRequest = request;
  }
Ejemplo n.º 7
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();
    }
  }
Ejemplo n.º 8
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;
  }