/** * Utility method to create a hop from a SIP URI * * @param sipUri * @return */ private final Hop createHop(SipURI sipUri, Request request) { // always use TLS when secure String transport = sipUri.isSecure() ? SIPConstants.TLS : sipUri.getTransportParam(); if (transport == null) { // @see issue 131 ViaHeader via = (ViaHeader) request.getHeader(ViaHeader.NAME); transport = via.getTransport(); } // sipUri.removeParameter("transport"); int port; if (sipUri.getPort() != -1) { port = sipUri.getPort(); } else { if (transport.equalsIgnoreCase(SIPConstants.TLS)) port = 5061; else port = 5060; // TCP or UDP } String host = sipUri.getMAddrParam() != null ? sipUri.getMAddrParam() : sipUri.getHost(); AddressResolver addressResolver = this.sipStack.getAddressResolver(); return addressResolver.resolveAddress(new HopImpl(host, port, transport)); }
/** 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(); } } }