/** * 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; }
/** * Attach any custom headers pre configured for the account. Added only to message Requests. The * header account properties are of form: ConfigHeader.N.Name=HeaderName * ConfigHeader.N.Value=HeaderValue ConfigHeader.N.Method=SIP_MethodName (optional) Where N is the * index of the header, multiple custom headers can be added. Name is the header name to use and * Value is its value. The optional property is whether to use a specific request method to attach * headers to or if missing we will attach it to all requests. * * @param message the message that we'd like to attach custom headers to. * @param protocolProvider the protocol provider to check for configured custom headers. */ static void attachConfigHeaders( Message message, ProtocolProviderServiceSipImpl protocolProvider) { if (message instanceof Response) return; Request request = (Request) message; Map<String, String> props = protocolProvider.getAccountID().getAccountProperties(); Map<String, Map<String, String>> headers = new HashMap<String, Map<String, String>>(); // parse the properties into the map where the index is the key for (Map.Entry<String, String> entry : props.entrySet()) { String pName = entry.getKey(); String prefStr = entry.getValue(); String name; String ix; if (!pName.startsWith(ACC_PROPERTY_CONFIG_HEADER) || prefStr == null) continue; prefStr = prefStr.trim(); if (pName.contains(".")) { pName = pName.replaceAll(ACC_PROPERTY_CONFIG_HEADER + ".", ""); name = pName.substring(pName.lastIndexOf('.') + 1).trim(); if (!pName.contains(".")) continue; ix = pName.substring(0, pName.lastIndexOf('.')).trim(); } else continue; Map<String, String> headerValues = headers.get(ix); if (headerValues == null) { headerValues = new HashMap<String, String>(); headers.put(ix, headerValues); } headerValues.put(name, prefStr); } // process the found custom headers for (Map<String, String> headerValues : headers.values()) { String method = headerValues.get(ACC_PROPERTY_CONFIG_HEADER_METHOD); // if there is a method setting and is different from // current request method skip this header // if any of the required properties are missing skip (Name & Value) if ((method != null && !request.getMethod().equalsIgnoreCase(method)) || !headerValues.containsKey(ACC_PROPERTY_CONFIG_HEADER_NAME) || !headerValues.containsKey(ACC_PROPERTY_CONFIG_HEADER_VALUE)) continue; try { String name = headerValues.get(ACC_PROPERTY_CONFIG_HEADER_NAME); String value = processParams(headerValues.get(ACC_PROPERTY_CONFIG_HEADER_VALUE), request); Header h = request.getHeader(name); // makes possible overriding already created headers which // are not custom one // RouteHeader is used by ProxyRouter/DefaultRouter and we // cannot use it as custom header if we want to add it if ((h != null && !(h instanceof CustomHeader)) || name.equals(SIPHeaderNames.ROUTE)) { request.setHeader(protocolProvider.getHeaderFactory().createHeader(name, value)); } else request.addHeader(new CustomHeaderList(name, value)); } catch (Exception e) { logger.error("Cannot create custom header", e); } } }