| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.camel.component.sip; |
| |
| import java.net.URI; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| |
| import javax.sip.ClientTransaction; |
| import javax.sip.Dialog; |
| import javax.sip.InvalidArgumentException; |
| import javax.sip.ListeningPoint; |
| import javax.sip.SipFactory; |
| import javax.sip.SipStack; |
| import javax.sip.address.Address; |
| import javax.sip.address.AddressFactory; |
| import javax.sip.address.SipURI; |
| import javax.sip.header.CSeqHeader; |
| import javax.sip.header.CallIdHeader; |
| import javax.sip.header.ContactHeader; |
| import javax.sip.header.ContentTypeHeader; |
| import javax.sip.header.EventHeader; |
| import javax.sip.header.ExpiresHeader; |
| import javax.sip.header.ExtensionHeader; |
| import javax.sip.header.FromHeader; |
| import javax.sip.header.HeaderFactory; |
| import javax.sip.header.MaxForwardsHeader; |
| import javax.sip.header.ToHeader; |
| import javax.sip.header.ViaHeader; |
| import javax.sip.message.MessageFactory; |
| import javax.sip.message.Request; |
| |
| import org.apache.camel.util.ObjectHelper; |
| import org.apache.camel.util.URISupport; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| public class SipConfiguration { |
| private static final Logger LOG = LoggerFactory.getLogger(SipConfiguration.class); |
| private static final String IMPLEMENTATION = "gov.nist"; |
| private URI uri; |
| private Map<String, Object> parameters; |
| private SipComponent component; |
| private AddressFactory addressFactory; |
| private MessageFactory messageFactory; |
| private HeaderFactory headerFactory; |
| private SipStack sipStack; |
| private ListeningPoint listeningPoint; |
| private String protocol; |
| private SipURI sipUri; |
| private String stackName; |
| private String transport; |
| private int maxForwards; |
| private boolean consumer; |
| private String eventHeaderName; |
| private String eventId; |
| private int msgExpiration; |
| private String useRouterForAllUris; |
| private long receiveTimeoutMillis; |
| private String maxMessageSize; |
| private String cacheConnections; |
| private String contentType; |
| private String contentSubType; |
| private String automaticDialogSupport; |
| private String nistServerLog; |
| private String nistDebugLog; |
| private String nistTraceLevel; |
| private SipFactory sipFactory; |
| private String fromUser; |
| private String fromHost; |
| private int fromPort; |
| private String toUser; |
| private String toHost; |
| private int toPort; |
| private boolean presenceAgent; |
| |
| private FromHeader fromHeader; |
| private ToHeader toHeader; |
| private List<ViaHeader> viaHeaders; |
| private ContentTypeHeader contentTypeHeader; |
| private CallIdHeader callIdHeader; |
| private MaxForwardsHeader maxForwardsHeader; |
| private ContactHeader contactHeader; |
| private EventHeader eventHeader; |
| private ExtensionHeader extensionHeader; |
| private ExpiresHeader expiresHeader; |
| private ClientTransaction clientTransactionId; |
| private Dialog dialog; |
| |
| public SipConfiguration() { |
| sipFactory = SipFactory.getInstance(); |
| sipFactory.setPathName(IMPLEMENTATION); |
| |
| setStackName("NAME_NOT_SET"); |
| setTransport("tcp"); |
| setMaxMessageSize("1048576"); |
| setCacheConnections("false"); |
| setAutomaticDialogSupport("off"); |
| setContentType("text"); |
| setContentSubType("plain"); |
| setReceiveTimeoutMillis(10000); |
| setConsumer(false); |
| setUseRouterForAllUris("false"); |
| setMsgExpiration(3600); |
| setPresenceAgent(false); |
| } |
| |
| public void initialize(URI uri, Map<String, Object> parameters, |
| SipComponent component) { |
| this.setParameters(parameters); |
| this.setComponent(component); |
| this.setUri(uri); |
| } |
| |
| public void parseURI() throws Exception { |
| protocol = uri.getScheme(); |
| |
| if ((!protocol.equalsIgnoreCase("sip")) && (!protocol.equalsIgnoreCase("sips"))) { |
| throw new IllegalArgumentException("Unrecognized SIP protocol: " + protocol + " for uri: " + uri); |
| } |
| |
| Map<String, Object> settings = URISupport.parseParameters(uri); |
| |
| if (settings.containsKey("stackName")) { |
| setStackName((String) settings.get("stackName")); |
| } |
| if (settings.containsKey("transport")) { |
| setTransport((String) settings.get("transport")); |
| } |
| if (settings.containsKey("maxMessageSize")) { |
| setMaxMessageSize((String) settings.get("maxMessageSize")); |
| } |
| if (settings.containsKey("cacheConnections")) { |
| setCacheConnections((String) settings.get("cacheConnections")); |
| } |
| if (settings.containsKey("contentType")) { |
| setContentType((String) settings.get("contentType")); |
| } |
| if (settings.containsKey("contentSubType")) { |
| setContentSubType((String) settings.get("contentSubType")); |
| } |
| if (settings.containsKey("maxForwards")) { |
| setMaxForwards(Integer.valueOf((String) settings.get("maxForwards"))); |
| } |
| if (settings.containsKey("receiveTimeoutMillis")) { |
| setReceiveTimeoutMillis(Long.valueOf((String) settings.get("receiveTimeoutMillis"))); |
| } |
| if (settings.containsKey("eventHeaderName")) { |
| setEventHeaderName((String) settings.get("eventHeaderName")); |
| } |
| if (settings.containsKey("eventId")) { |
| setEventId((String) settings.get("eventId")); |
| } |
| if (settings.containsKey("useRouterForAllUris")) { |
| setUseRouterForAllUris((String) settings.get("useRouterForAllUris")); |
| } |
| if (settings.containsKey("msgExpiration")) { |
| setMsgExpiration(Integer.valueOf((String) settings.get("msgExpiration"))); |
| } |
| if (settings.containsKey("presenceAgent")) { |
| setPresenceAgent(Boolean.valueOf((String) settings.get("presenceAgent"))); |
| } |
| |
| if (!consumer) { |
| if (settings.containsKey("fromUser")) { |
| setFromUser((String) settings.get("fromUser")); |
| } |
| if (settings.containsKey("fromHost")) { |
| setFromHost((String) settings.get("fromHost")); |
| } |
| if (settings.containsKey("fromPort")) { |
| setFromPort(Integer.valueOf((String) settings.get("fromPort"))); |
| } |
| setToUser(uri.getUserInfo()); |
| setToHost(uri.getHost()); |
| setToPort(uri.getPort()); |
| } else { |
| setFromUser(uri.getUserInfo()); |
| setFromHost(uri.getHost()); |
| setFromPort(uri.getPort()); |
| if (!presenceAgent) { |
| if (settings.containsKey("toUser")) { |
| setToUser((String) settings.get("toUser")); |
| } |
| if (settings.containsKey("toHost")) { |
| setToHost((String) settings.get("toHost")); |
| } |
| if (settings.containsKey("toPort")) { |
| setToPort(Integer.valueOf((String) settings.get("toPort"))); |
| } |
| } |
| } |
| nistDebugLog = component.getAndRemoveParameter(parameters, "implementationDebugLogFile", String.class, null); |
| nistServerLog = component.getAndRemoveParameter(parameters, "implementationServerLogFile", String.class, null); |
| nistTraceLevel = component.getAndRemoveParameter(parameters, "implementationTraceLevel", String.class, "0"); |
| |
| LOG.trace("Consumer:" + consumer + " StackName:" + stackName); |
| LOG.trace("From User: " + getFromUser() + " From host: " + getFromHost() + " From Port: " + getFromPort()); |
| |
| createFactoriesAndHeaders(parameters, component); |
| |
| sipUri = component.resolveAndRemoveReferenceParameter(parameters, "sipUri", SipURI.class, null); |
| if (sipUri == null) { |
| sipUri = addressFactory.createSipURI(getToUser(), getToHost() + ":" + getToPort()); |
| } |
| |
| ObjectHelper.notNull(fromUser, "From User"); |
| ObjectHelper.notNull(fromHost, "From Host"); |
| ObjectHelper.notNull(fromPort, "From Port"); |
| ObjectHelper.notNull(eventHeader, "Event Header"); |
| ObjectHelper.notNull(eventHeaderName, "Event Header Name"); |
| ObjectHelper.notNull(eventId, "Event Id"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private void createFactoriesAndHeaders(Map<String, Object> parameters, SipComponent component) throws Exception { |
| headerFactory = sipFactory.createHeaderFactory(); |
| addressFactory = sipFactory.createAddressFactory(); |
| setMessageFactory(sipFactory.createMessageFactory()); |
| |
| fromHeader = component.resolveAndRemoveReferenceParameter(parameters, "fromHeader", FromHeader.class, null); |
| if (fromHeader == null) { |
| createFromHeader(); |
| } |
| if (!presenceAgent) { |
| toHeader = component.resolveAndRemoveReferenceParameter(parameters, "toHeader", ToHeader.class, null); |
| if (toHeader == null) { |
| createToHeader(); |
| } |
| } |
| viaHeaders = component.resolveAndRemoveReferenceParameter(parameters, "viaHeaders", List.class, null); |
| if (viaHeaders == null) { |
| createViaHeaders(); |
| } |
| contentTypeHeader = component.resolveAndRemoveReferenceParameter(parameters, "contentTypeHeader", ContentTypeHeader.class, null); |
| if (contentTypeHeader == null) { |
| createContentTypeHeader(); |
| } |
| |
| callIdHeader = component.resolveAndRemoveReferenceParameter(parameters, "callIdHeader", CallIdHeader.class, null); |
| |
| maxForwardsHeader = component.resolveAndRemoveReferenceParameter(parameters, "maxForwardsHeader", MaxForwardsHeader.class, null); |
| if (maxForwardsHeader == null) { |
| createMaxForwardsHeader(); |
| } |
| |
| // Optional Headers |
| eventHeader = component.resolveAndRemoveReferenceParameter(parameters, "eventHeader", EventHeader.class, null); |
| if (eventHeader == null) { |
| createEventHeader(); |
| } |
| contactHeader = component.resolveAndRemoveReferenceParameter(parameters, "contactHeader", ContactHeader.class, null); |
| if (contactHeader == null) { |
| createContactHeader(); |
| } |
| expiresHeader = component.resolveAndRemoveReferenceParameter(parameters, "expiresHeader", ExpiresHeader.class, null); |
| if (expiresHeader == null) { |
| createExpiresHeader(); |
| } |
| extensionHeader = component.resolveAndRemoveReferenceParameter(parameters, "extensionHeader", ExtensionHeader.class, null); |
| } |
| |
| public Request createSipRequest(long sequenceNumber, String requestMethod, Object body) throws ParseException, InvalidArgumentException { |
| //SipConfiguration configuration = sipPublisher.getConfiguration(); |
| CSeqHeader cSeqHeader = getHeaderFactory().createCSeqHeader(sequenceNumber, requestMethod); |
| |
| // Create the request. |
| Request request = getMessageFactory().createRequest( |
| getSipUri(), |
| requestMethod, |
| getCallIdHeader(), |
| cSeqHeader, |
| getFromHeader(), |
| getToHeader(), |
| getViaHeaders(), |
| getMaxForwardsHeader()); |
| |
| if (getEventHeader() != null) { |
| request.addHeader(getEventHeader()); |
| } |
| if (getExpiresHeader() != null) { |
| request.addHeader(getExpiresHeader()); |
| } |
| if (getContactHeader() != null) { |
| request.addHeader(getContactHeader()); |
| } |
| if (getExtensionHeader() != null) { |
| request.addHeader(getExtensionHeader()); |
| } |
| request.setContent(body, getContentTypeHeader()); |
| |
| return request; |
| } |
| |
| private void createFromHeader() throws ParseException { |
| SipURI fromAddress = getAddressFactory().createSipURI(getFromUser(), getFromHost()); |
| fromAddress.setPort(Integer.valueOf(getFromPort()).intValue()); |
| Address fromNameAddress = addressFactory.createAddress(fromAddress); |
| fromNameAddress.setDisplayName(getFromUser()); |
| |
| setFromHeader(headerFactory.createFromHeader(fromNameAddress, getFromUser() + "_Header")); |
| } |
| |
| private void createToHeader() throws ParseException { |
| SipURI toAddress = getAddressFactory().createSipURI(getToUser(), getToHost()); |
| toAddress.setPort(getToPort()); |
| Address toNameAddress = addressFactory.createAddress(toAddress); |
| toNameAddress.setDisplayName(getToUser()); |
| |
| setToHeader(headerFactory.createToHeader(toNameAddress, getToUser() + "_Header")); |
| } |
| |
| private void createViaHeaders() throws ParseException, InvalidArgumentException { |
| viaHeaders = new ArrayList<ViaHeader>(); |
| ViaHeader viaHeader = headerFactory.createViaHeader(getFromHost(), getFromPort(), |
| getTransport(), null); |
| |
| viaHeaders.add(viaHeader); |
| } |
| |
| private void createContentTypeHeader() throws ParseException { |
| setContentTypeHeader(headerFactory.createContentTypeHeader(getContentType(), getContentSubType())); |
| } |
| |
| private void createMaxForwardsHeader() throws ParseException, InvalidArgumentException { |
| setMaxForwardsHeader(headerFactory.createMaxForwardsHeader(getMaxForwards())); |
| } |
| |
| private void createEventHeader() throws ParseException { |
| eventHeader = getHeaderFactory().createEventHeader(getEventHeaderName()); |
| eventHeader.setEventId(getEventId()); |
| } |
| |
| private void createContactHeader() throws ParseException { |
| SipURI contactURI = addressFactory.createSipURI(getFromUser(), getFromHost()); |
| contactURI.setTransportParam(getTransport()); |
| contactURI.setPort(Integer.valueOf(getFromPort()).intValue()); |
| Address contactAddress = addressFactory.createAddress(contactURI); |
| |
| // Add the contact address. |
| contactAddress.setDisplayName(getFromUser()); |
| |
| contactHeader = headerFactory.createContactHeader(contactAddress); |
| } |
| |
| private void createExpiresHeader() throws ParseException, InvalidArgumentException { |
| expiresHeader = getHeaderFactory().createExpiresHeader(getMsgExpiration()); |
| } |
| |
| Properties createInitialProperties() { |
| Properties properties = new Properties(); |
| properties.setProperty("javax.sip.STACK_NAME", getStackName()); |
| properties.setProperty("gov.nist.javax.sip.MAX_MESSAGE_SIZE", getMaxMessageSize()); |
| properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS", getCacheConnections()); |
| properties.setProperty("javax.sip.USE_ROUTER_FOR_ALL_URIS", getUseRouterForAllUris()); |
| if ((nistDebugLog != null) && (nistServerLog != null)) { |
| properties.setProperty("gov.nist.javax.sip.DEBUG_LOG", nistDebugLog); |
| properties.setProperty("gov.nist.javax.sip.SERVER_LOG", nistServerLog); |
| properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", nistTraceLevel); |
| } |
| |
| return properties; |
| } |
| |
| public AddressFactory getAddressFactory() { |
| return addressFactory; |
| } |
| |
| public void setAddressFactory(AddressFactory addressFactory) { |
| this.addressFactory = addressFactory; |
| } |
| |
| public MessageFactory getMessageFactory() { |
| return messageFactory; |
| } |
| |
| public void setMessageFactory(MessageFactory messageFactory) { |
| this.messageFactory = messageFactory; |
| } |
| |
| public HeaderFactory getHeaderFactory() { |
| return headerFactory; |
| } |
| |
| public void setHeaderFactory(HeaderFactory headerFactory) { |
| this.headerFactory = headerFactory; |
| } |
| |
| public SipStack getSipStack() { |
| return sipStack; |
| } |
| |
| public void setSipStack(SipStack sipStack) { |
| this.sipStack = sipStack; |
| } |
| |
| public String getProtocol() { |
| return protocol; |
| } |
| |
| public void setProtocol(String protocol) { |
| this.protocol = protocol; |
| } |
| |
| public SipURI getSipUri() { |
| return sipUri; |
| } |
| |
| public void setSipUri(SipURI sipUri) { |
| this.sipUri = sipUri; |
| } |
| |
| public String getStackName() { |
| return stackName; |
| } |
| |
| public void setStackName(String stackName) { |
| this.stackName = stackName; |
| } |
| |
| public String getTransport() { |
| return transport; |
| } |
| |
| public void setTransport(String transport) { |
| this.transport = transport; |
| } |
| |
| public String getMaxMessageSize() { |
| return maxMessageSize; |
| } |
| |
| public void setMaxMessageSize(String maxMessageSize) { |
| this.maxMessageSize = maxMessageSize; |
| } |
| |
| public String getAutomaticDialogSupport() { |
| return automaticDialogSupport; |
| } |
| |
| public void setAutomaticDialogSupport(String automaticDialogSupport) { |
| this.automaticDialogSupport = automaticDialogSupport; |
| } |
| |
| public String getCacheConnections() { |
| return cacheConnections; |
| } |
| |
| public void setCacheConnections(String cacheConnections) { |
| this.cacheConnections = cacheConnections; |
| } |
| |
| public ListeningPoint getListeningPoint() { |
| return listeningPoint; |
| } |
| |
| public void setListeningPoint(ListeningPoint listeningPoint) { |
| this.listeningPoint = listeningPoint; |
| } |
| |
| public void setContentType(String contentType) { |
| this.contentType = contentType; |
| } |
| |
| public String getContentType() { |
| return contentType; |
| } |
| |
| public void setContentSubType(String contentSubType) { |
| this.contentSubType = contentSubType; |
| } |
| |
| public String getContentSubType() { |
| return contentSubType; |
| } |
| |
| public void setMaxForwards(int maxForwards) { |
| this.maxForwards = maxForwards; |
| } |
| |
| public int getMaxForwards() { |
| return maxForwards; |
| } |
| |
| public void setReceiveTimeoutMillis(long receiveTimeoutMillis) { |
| this.receiveTimeoutMillis = receiveTimeoutMillis; |
| } |
| |
| public long getReceiveTimeoutMillis() { |
| return receiveTimeoutMillis; |
| } |
| |
| public void setParameters(Map<String, Object> parameters) { |
| this.parameters = parameters; |
| } |
| |
| public Map<String, Object> getParameters() { |
| return parameters; |
| } |
| |
| public void setComponent(SipComponent component) { |
| this.component = component; |
| } |
| |
| public SipComponent getComponent() { |
| return component; |
| } |
| |
| public String getNistServerLog() { |
| return nistServerLog; |
| } |
| |
| public void setNistServerLog(String nistServerLog) { |
| this.nistServerLog = nistServerLog; |
| } |
| |
| public String getNistDebugLog() { |
| return nistDebugLog; |
| } |
| |
| public void setNistDebugLog(String nistDebugLog) { |
| this.nistDebugLog = nistDebugLog; |
| } |
| |
| public String getNistTraceLevel() { |
| return nistTraceLevel; |
| } |
| |
| public void setNistTraceLevel(String nistTraceLevel) { |
| this.nistTraceLevel = nistTraceLevel; |
| } |
| |
| public SipFactory getSipFactory() { |
| return sipFactory; |
| } |
| |
| public void setSipFactory(SipFactory sipFactory) { |
| this.sipFactory = sipFactory; |
| } |
| |
| public String getFromUser() { |
| return fromUser; |
| } |
| |
| public void setFromUser(String fromUser) { |
| this.fromUser = fromUser; |
| } |
| |
| public String getFromHost() { |
| return fromHost; |
| } |
| |
| public void setFromHost(String fromHost) { |
| this.fromHost = fromHost; |
| } |
| |
| public int getFromPort() { |
| return fromPort; |
| } |
| |
| public void setFromPort(int fromPort) { |
| this.fromPort = fromPort; |
| } |
| |
| public String getToUser() { |
| return toUser; |
| } |
| |
| public void setToUser(String toUser) { |
| this.toUser = toUser; |
| } |
| |
| public String getToHost() { |
| return toHost; |
| } |
| |
| public void setToHost(String toHost) { |
| this.toHost = toHost; |
| } |
| |
| public int getToPort() { |
| return toPort; |
| } |
| |
| public void setToPort(int toPort) { |
| this.toPort = toPort; |
| } |
| |
| public FromHeader getFromHeader() { |
| return fromHeader; |
| } |
| |
| public void setFromHeader(FromHeader fromHeader) { |
| this.fromHeader = fromHeader; |
| } |
| |
| public ToHeader getToHeader() { |
| return toHeader; |
| } |
| |
| public void setToHeader(ToHeader toHeader) { |
| this.toHeader = toHeader; |
| } |
| |
| public List<ViaHeader> getViaHeaders() { |
| return viaHeaders; |
| } |
| |
| public void setViaHeaders(List<ViaHeader> viaHeaders) { |
| this.viaHeaders = viaHeaders; |
| } |
| |
| public ContentTypeHeader getContentTypeHeader() { |
| return contentTypeHeader; |
| } |
| |
| public void setContentTypeHeader(ContentTypeHeader contentTypeHeader) { |
| this.contentTypeHeader = contentTypeHeader; |
| } |
| |
| public CallIdHeader getCallIdHeader() { |
| return callIdHeader; |
| } |
| |
| public void setCallIdHeader(CallIdHeader callIdHeader) { |
| this.callIdHeader = callIdHeader; |
| } |
| |
| public MaxForwardsHeader getMaxForwardsHeader() { |
| return maxForwardsHeader; |
| } |
| |
| public void setMaxForwardsHeader(MaxForwardsHeader maxForwardsHeader) { |
| this.maxForwardsHeader = maxForwardsHeader; |
| } |
| |
| public ContactHeader getContactHeader() { |
| return contactHeader; |
| } |
| |
| public void setContactHeader(ContactHeader contactHeader) { |
| this.contactHeader = contactHeader; |
| } |
| |
| public ExtensionHeader getExtensionHeader() { |
| return extensionHeader; |
| } |
| |
| public void setExtensionHeader(ExtensionHeader extensionHeader) { |
| this.extensionHeader = extensionHeader; |
| } |
| |
| public void setUri(URI uri) { |
| this.uri = uri; |
| } |
| |
| public URI getUri() { |
| return uri; |
| } |
| |
| public void setConsumer(boolean consumer) { |
| this.consumer = consumer; |
| } |
| |
| public boolean isConsumer() { |
| return consumer; |
| } |
| |
| public void setClientTransactionId(ClientTransaction clientTransactionId) { |
| this.clientTransactionId = clientTransactionId; |
| } |
| |
| public ClientTransaction getClientTransactionId() { |
| return clientTransactionId; |
| } |
| |
| public void setDialog(Dialog dialog) { |
| this.dialog = dialog; |
| } |
| |
| public Dialog getDialog() { |
| return dialog; |
| } |
| |
| public void setEventHeader(EventHeader eventHeader) { |
| this.eventHeader = eventHeader; |
| } |
| |
| public EventHeader getEventHeader() { |
| return eventHeader; |
| } |
| |
| public void setEventHeaderName(String eventHeaderName) { |
| this.eventHeaderName = eventHeaderName; |
| } |
| |
| public String getEventHeaderName() { |
| return eventHeaderName; |
| } |
| |
| public void setEventId(String eventId) { |
| this.eventId = eventId; |
| } |
| |
| public String getEventId() { |
| return eventId; |
| } |
| |
| public void setUseRouterForAllUris(String useRouterForAllUris) { |
| this.useRouterForAllUris = useRouterForAllUris; |
| } |
| |
| public String getUseRouterForAllUris() { |
| return useRouterForAllUris; |
| } |
| |
| public int getMsgExpiration() { |
| return msgExpiration; |
| } |
| |
| public void setMsgExpiration(int msgExpiration) { |
| this.msgExpiration = msgExpiration; |
| } |
| |
| public ExpiresHeader getExpiresHeader() { |
| return expiresHeader; |
| } |
| |
| public void setExpiresHeader(ExpiresHeader expiresHeader) { |
| this.expiresHeader = expiresHeader; |
| } |
| |
| public boolean isPresenceAgent() { |
| return presenceAgent; |
| } |
| |
| public void setPresenceAgent(boolean presenceAgent) { |
| this.presenceAgent = presenceAgent; |
| } |
| |
| } |