| /* |
| * Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Sun designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Sun in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| */ |
| package com.sun.xml.internal.ws.api.message; |
| |
| import com.sun.istack.internal.NotNull; |
| import com.sun.istack.internal.Nullable; |
| import com.sun.xml.internal.ws.addressing.WsaTubeHelper; |
| import com.sun.xml.internal.ws.api.SOAPVersion; |
| import com.sun.xml.internal.ws.api.WSBinding; |
| import com.sun.xml.internal.ws.api.addressing.AddressingVersion; |
| import com.sun.xml.internal.ws.api.addressing.OneWayFeature; |
| import com.sun.xml.internal.ws.api.addressing.WSEndpointReference; |
| import com.sun.xml.internal.ws.api.model.wsdl.WSDLBoundOperation; |
| import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort; |
| import com.sun.xml.internal.ws.api.pipe.Pipe; |
| import com.sun.xml.internal.ws.api.pipe.Codec; |
| import com.sun.xml.internal.ws.message.RelatesToHeader; |
| import com.sun.xml.internal.ws.message.StringHeader; |
| import com.sun.xml.internal.ws.protocol.soap.ClientMUTube; |
| import com.sun.xml.internal.ws.protocol.soap.ServerMUTube; |
| import com.sun.xml.internal.ws.resources.AddressingMessages; |
| import com.sun.xml.internal.ws.resources.ClientMessages; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.ws.WebServiceException; |
| import java.util.ArrayList; |
| import java.util.BitSet; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.NoSuchElementException; |
| import java.util.Set; |
| |
| /** |
| * A list of {@link Header}s on a {@link Message}. |
| * |
| * <p> |
| * This list can be modified to add headers |
| * from outside a {@link Message}, this is necessary |
| * since intermediate processing layers often need to |
| * put additional headers. |
| * |
| * <p> |
| * Following the SOAP convention, the order among headers |
| * are not significant. However, {@link Codec}s are |
| * expected to preserve the order of headers in the input |
| * message as much as possible. |
| * |
| * |
| * <a name="MU"></a> |
| * <h3>MustUnderstand Processing</h3> |
| * <p> |
| * To perform SOAP mustUnderstang processing correctly, we need to keep |
| * track of headers that are understood and headers that are not. |
| * This is a collaborative process among {@link Pipe}s, thus it's something |
| * a {@link Pipe} author needs to keep in mind. |
| * |
| * <p> |
| * Specifically, when a {@link Pipe} sees a header and processes it |
| * (that is, if it did enough computing with the header to claim that |
| * the header is understood), then it should mark the corresponding |
| * header as "understood". For example, when a pipe that handles JAX-WSA |
| * examins the <wsa:To> header, it can claim that it understood the header. |
| * But for example, if a pipe that does the signature verification checks |
| * <wsa:To> for a signature, that would not be considered as "understood". |
| * |
| * <p> |
| * There are two ways to mark a header as understood: |
| * |
| * <ol> |
| * <li>Use one of the <tt>getXXX</tt> methods that take a |
| * boolean <tt>markAsUnderstood</tt> parameter. |
| * Most often, a {@link Pipe} knows it's going to understand a header |
| * as long as it's present, so this is the easiest and thus the preferred way. |
| * |
| * For example, if JAX-WSA looks for <wsa:To>, then it can set |
| * <tt>markAsUnderstand</tt> to true, to do the obtaining of a header |
| * and marking at the same time. |
| * |
| * <li>Call {@link #understood(int)}. |
| * If under a rare circumstance, a pipe cannot determine whether |
| * it can understand it or not when you are fetching a header, then |
| * you can use this method afterward to mark it as understood. |
| * </ol> |
| * |
| * <p> |
| * Intuitively speaking, at the end of the day, if a header is not |
| * understood but {@link Header#isIgnorable(SOAPVersion, Set)} is false, a bad thing |
| * will happen. The actual implementation of the checking is more complicated, |
| * for that see {@link ClientMUTube}/{@link ServerMUTube}. |
| * |
| * @see Message#getHeaders() |
| */ |
| public final class HeaderList extends ArrayList<Header> { |
| |
| /** |
| * Bit set to keep track of which headers are understood. |
| * <p> |
| * The first 32 headers use this field, and the rest will use |
| * {@link #moreUnderstoodBits}. The expectation is that |
| * most of the time a SOAP message will only have up to 32 headers, |
| * so we can avoid allocating separate objects for {@link BitSet}. |
| */ |
| private int understoodBits; |
| /** |
| * If there are more than 32 headers, we use this {@link BitSet} |
| * to keep track of whether those headers are understood. |
| * Lazily allocated. |
| */ |
| private BitSet moreUnderstoodBits = null; |
| |
| private String to = null; |
| private String action = null; |
| private WSEndpointReference replyTo = null; |
| private WSEndpointReference faultTo = null; |
| private String messageId; |
| |
| |
| /** |
| * Creates an empty {@link HeaderList}. |
| */ |
| public HeaderList() { |
| } |
| |
| /** |
| * Copy constructor. |
| */ |
| public HeaderList(HeaderList that) { |
| super(that); |
| this.understoodBits = that.understoodBits; |
| if(that.moreUnderstoodBits!=null) |
| this.moreUnderstoodBits = (BitSet)that.moreUnderstoodBits.clone(); |
| this.to = that.to; |
| this.action = that.action; |
| this.replyTo = that.replyTo; |
| this.faultTo = that.faultTo; |
| this.messageId = that.messageId; |
| } |
| |
| /** |
| * The number of total headers. |
| */ |
| public int size() { |
| return super.size(); |
| } |
| |
| /** |
| * Adds all the headers. |
| */ |
| public void addAll(Header... headers) { |
| for (Header header : headers) |
| add(header); |
| } |
| |
| /** |
| * Gets the {@link Header} at the specified index. |
| * |
| * <p> |
| * This method does not mark the returned {@link Header} as understood. |
| * |
| * @see #understood(int) |
| */ |
| public Header get(int index) { |
| return super.get(index); |
| } |
| |
| /** |
| * Marks the {@link Header} at the specified index as |
| * <a href="#MU">"understood"</a>. |
| */ |
| public void understood(int index) { |
| assert index<size(); // check that index is in range |
| if(index<32) |
| understoodBits |= 1<<index; |
| else { |
| if(moreUnderstoodBits==null) |
| moreUnderstoodBits = new BitSet(); |
| moreUnderstoodBits.set(index-32); |
| } |
| } |
| |
| /** |
| * Returns true if a {@link Header} at the given index |
| * was <a href="#MU">"understood"</a>. |
| */ |
| public boolean isUnderstood(int index) { |
| assert index<size(); // check that index is in range |
| if(index<32) |
| return understoodBits == (understoodBits|(1<<index)); |
| else { |
| if(moreUnderstoodBits==null) |
| return false; |
| return moreUnderstoodBits.get(index-32); |
| } |
| } |
| |
| /** |
| * Marks the specified {@link Header} as <a href="#MU">"understood"</a>. |
| * |
| * @deprecated |
| * By the deifnition of {@link ArrayList}, this operation requires |
| * O(n) search of the array, and thus inherently inefficient. |
| * |
| * Because of this, if you are developing a {@link Pipe} for |
| * a performance sensitive environment, do not use this method. |
| * |
| * @throws IllegalArgumentException |
| * if the given header is not {@link #contains(Object) contained} |
| * in this header. |
| */ |
| public void understood(@NotNull Header header) { |
| int sz = size(); |
| for( int i=0; i<sz; i++ ) { |
| if(get(i)==header) { |
| understood(i); |
| return; |
| } |
| } |
| throw new IllegalArgumentException(); |
| } |
| |
| /** |
| * Gets the first {@link Header} of the specified name. |
| * |
| * @param markAsUnderstood |
| * If this parameter is true, the returned header will |
| * be marked as <a href="#MU">"understood"</a>. |
| * @return null if not found. |
| */ |
| public @Nullable Header get(@NotNull String nsUri, @NotNull String localName, boolean markAsUnderstood) { |
| int len = size(); |
| for( int i=0; i<len; i++ ) { |
| Header h = get(i); |
| if(h.getLocalPart().equals(localName) && h.getNamespaceURI().equals(nsUri)) { |
| if(markAsUnderstood) |
| understood(i); |
| return h; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * @deprecated |
| * Use {@link #get(String, String, boolean)} |
| */ |
| public Header get(String nsUri, String localName) { |
| return get(nsUri,localName,true); |
| } |
| |
| /** |
| * Gets the first {@link Header} of the specified name. |
| * |
| * @param markAsUnderstood |
| * If this parameter is true, the returned header will |
| * be marked as <a href="#MU">"understood"</a>. |
| * @return null |
| * if not found. |
| */ |
| public @Nullable Header get(@NotNull QName name, boolean markAsUnderstood) { |
| return get(name.getNamespaceURI(),name.getLocalPart(),markAsUnderstood); |
| } |
| |
| /** |
| * @deprecated |
| * Use {@link #get(QName)} |
| */ |
| public @Nullable Header get(@NotNull QName name) { |
| return get(name,true); |
| } |
| |
| /** |
| * @deprecated |
| * Use {@link #getHeaders(String, String, boolean)} |
| */ |
| public Iterator<Header> getHeaders(final String nsUri, final String localName) { |
| return getHeaders(nsUri,localName,true); |
| } |
| |
| /** |
| * Gets all the {@link Header}s of the specified name, |
| * including duplicates (if any.) |
| * |
| * @param markAsUnderstood |
| * If this parameter is true, the returned headers will |
| * be marked as <a href="#MU">"understood"</a> when they are returned |
| * from {@link Iterator#next()}. |
| * @return empty iterator if not found. |
| */ |
| public @NotNull Iterator<Header> getHeaders(@NotNull final String nsUri, @NotNull final String localName, final boolean markAsUnderstood) { |
| return new Iterator<Header>() { |
| int idx = 0; |
| Header next; |
| public boolean hasNext() { |
| if(next==null) |
| fetch(); |
| return next!=null; |
| } |
| |
| public Header next() { |
| if(next==null) { |
| fetch(); |
| if(next==null) |
| throw new NoSuchElementException(); |
| } |
| |
| if(markAsUnderstood) { |
| assert get(idx-1)==next; |
| understood(idx-1); |
| } |
| |
| Header r = next; |
| next = null; |
| return r; |
| } |
| |
| private void fetch() { |
| while(idx<size()) { |
| Header h = get(idx++); |
| if(h.getLocalPart().equals(localName) && h.getNamespaceURI().equals(nsUri)) { |
| next = h; |
| break; |
| } |
| } |
| } |
| |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| }; |
| } |
| |
| /** |
| * @see #getHeaders(String, String, boolean) |
| */ |
| public @NotNull Iterator<Header> getHeaders(@NotNull QName headerName, final boolean markAsUnderstood) { |
| return getHeaders(headerName.getNamespaceURI(),headerName.getLocalPart(),markAsUnderstood); |
| } |
| |
| /** |
| * @deprecated |
| * use {@link #getHeaders(String, boolean)}. |
| */ |
| public @NotNull Iterator<Header> getHeaders(@NotNull final String nsUri) { |
| return getHeaders(nsUri,true); |
| } |
| |
| /** |
| * Gets an iteration of headers {@link Header} in the specified namespace, |
| * including duplicates (if any.) |
| * |
| * @param markAsUnderstood |
| * If this parameter is true, the returned headers will |
| * be marked as <a href="#MU">"understood"</a> when they are returned |
| * from {@link Iterator#next()}. |
| * @return |
| * empty iterator if not found. |
| */ |
| public @NotNull Iterator<Header> getHeaders(@NotNull final String nsUri, final boolean markAsUnderstood) { |
| return new Iterator<Header>() { |
| int idx = 0; |
| Header next; |
| public boolean hasNext() { |
| if(next==null) |
| fetch(); |
| return next!=null; |
| } |
| |
| public Header next() { |
| if(next==null) { |
| fetch(); |
| if(next==null) |
| throw new NoSuchElementException(); |
| } |
| |
| if(markAsUnderstood) { |
| assert get(idx-1)==next; |
| understood(idx-1); |
| } |
| |
| Header r = next; |
| next = null; |
| return r; |
| } |
| |
| private void fetch() { |
| while(idx<size()) { |
| Header h = get(idx++); |
| if(h.getNamespaceURI().equals(nsUri)) { |
| next = h; |
| break; |
| } |
| } |
| } |
| |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| }; |
| } |
| |
| /** |
| * Gets the first {@link Header} of the specified name targeted at the |
| * current implicit role. |
| * |
| * @param name name of the header |
| * @param markUnderstood |
| * If this parameter is true, the returned headers will |
| * be marked as <a href="#MU">"understood"</a> when they are returned |
| * from {@link Iterator#next()}. |
| * @return null if header not found |
| */ |
| private Header getFirstHeader(QName name, boolean markUnderstood, SOAPVersion sv) { |
| if (sv == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_SOAP_VERSION()); |
| |
| Iterator<Header> iter = getHeaders(name.getNamespaceURI(), name.getLocalPart(), markUnderstood); |
| while (iter.hasNext()) { |
| Header h = iter.next(); |
| if (h.getRole(sv).equals(sv.implicitRole)) |
| return h; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the value of WS-Addressing <code>To</code> header. The <code>version</code> |
| * identifies the WS-Addressing version and the header returned is targeted at |
| * the current implicit role. Caches the value for subsequent invocation. |
| * Duplicate <code>To</code> headers are detected earlier. |
| * |
| * @param av WS-Addressing version |
| * @param sv SOAP version |
| * @throws IllegalArgumentException if either <code>av</code> or <code>sv</code> is null. |
| * @return Value of WS-Addressing To header, anonymous URI if no header is present |
| */ |
| public String getTo(AddressingVersion av, SOAPVersion sv) { |
| if (to != null) |
| return to; |
| if (av == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_ADDRESSING_VERSION()); |
| |
| Header h = getFirstHeader(av.toTag, true, sv); |
| if (h != null) { |
| to = h.getStringContent(); |
| } else { |
| to = av.anonymousUri; |
| } |
| |
| return to; |
| } |
| |
| /** |
| * Returns the value of WS-Addressing <code>Action</code> header. The <code>version</code> |
| * identifies the WS-Addressing version and the header returned is targeted at |
| * the current implicit role. Caches the value for subsequent invocation. |
| * Duplicate <code>Action</code> headers are detected earlier. |
| * |
| * @param av WS-Addressing version |
| * @param sv SOAP version |
| * @throws IllegalArgumentException if either <code>av</code> or <code>sv</code> is null. |
| * @return Value of WS-Addressing Action header, null if no header is present |
| */ |
| public String getAction(@NotNull AddressingVersion av, @NotNull SOAPVersion sv) { |
| if (action!= null) |
| return action; |
| if (av == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_ADDRESSING_VERSION()); |
| |
| Header h = getFirstHeader(av.actionTag, true, sv); |
| if (h != null) { |
| action = h.getStringContent(); |
| } |
| |
| return action; |
| } |
| |
| /** |
| * Returns the value of WS-Addressing <code>ReplyTo</code> header. The <code>version</code> |
| * identifies the WS-Addressing version and the header returned is targeted at |
| * the current implicit role. Caches the value for subsequent invocation. |
| * Duplicate <code>ReplyTo</code> headers are detected earlier. |
| * |
| * @param av WS-Addressing version |
| * @param sv SOAP version |
| * @throws IllegalArgumentException if either <code>av</code> or <code>sv</code> is null. |
| * @return Value of WS-Addressing ReplyTo header, null if no header is present |
| */ |
| public WSEndpointReference getReplyTo(@NotNull AddressingVersion av, @NotNull SOAPVersion sv) { |
| if (replyTo!=null) |
| return replyTo; |
| if (av == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_ADDRESSING_VERSION()); |
| |
| Header h = getFirstHeader(av.replyToTag, true, sv); |
| if (h != null) { |
| try { |
| replyTo = h.readAsEPR(av); |
| } catch (XMLStreamException e) { |
| throw new WebServiceException(AddressingMessages.REPLY_TO_CANNOT_PARSE(), e); |
| } |
| } else { |
| replyTo = av.anonymousEpr; |
| } |
| |
| return replyTo; |
| } |
| |
| /** |
| * Returns the value of WS-Addressing <code>FaultTo</code> header. The <code>version</code> |
| * identifies the WS-Addressing version and the header returned is targeted at |
| * the current implicit role. Caches the value for subsequent invocation. |
| * Duplicate <code>FaultTo</code> headers are detected earlier. |
| * |
| * @param av WS-Addressing version |
| * @param sv SOAP version |
| * @throws IllegalArgumentException if either <code>av</code> or <code>sv</code> is null. |
| * @return Value of WS-Addressing FaultTo header, null if no header is present |
| */ |
| public WSEndpointReference getFaultTo(@NotNull AddressingVersion av, @NotNull SOAPVersion sv) { |
| if (faultTo != null) |
| return faultTo; |
| |
| if (av == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_ADDRESSING_VERSION()); |
| |
| Header h = getFirstHeader(av.faultToTag, true, sv); |
| if (h != null) { |
| try { |
| faultTo = h.readAsEPR(av); |
| } catch (XMLStreamException e) { |
| throw new WebServiceException(AddressingMessages.FAULT_TO_CANNOT_PARSE(), e); |
| } |
| } |
| |
| return faultTo; |
| } |
| |
| /** |
| * Returns the value of WS-Addressing <code>MessageID</code> header. The <code>version</code> |
| * identifies the WS-Addressing version and the header returned is targeted at |
| * the current implicit role. Caches the value for subsequent invocation. |
| * Duplicate <code>MessageID</code> headers are detected earlier. |
| * |
| * @param av WS-Addressing version |
| * @param sv SOAP version |
| * @throws WebServiceException if either <code>av</code> or <code>sv</code> is null. |
| * @return Value of WS-Addressing MessageID header, null if no header is present |
| */ |
| public String getMessageID(@NotNull AddressingVersion av, @NotNull SOAPVersion sv) { |
| if (messageId != null) |
| return messageId; |
| |
| if (av == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_ADDRESSING_VERSION()); |
| |
| Header h = getFirstHeader(av.messageIDTag, true, sv); |
| if (h != null) { |
| messageId = h.getStringContent(); |
| } |
| |
| return messageId; |
| } |
| |
| /** |
| * Creates a set of outbound WS-Addressing headers on the client with the |
| * specified Action Message Addressing Property value. |
| * <p><p> |
| * This method needs to be invoked right after such a Message is |
| * created which is error prone but so far only MEX, RM and JAX-WS |
| * creates a request so this ugliness is acceptable. This method is also used |
| * to create protocol messages that are not associated with any {@link WSBinding} |
| * and {@link WSDLPort}. |
| * |
| * @param packet request packet |
| * @param av WS-Addressing version |
| * @param sv SOAP version |
| * @param oneway Indicates if the message exchange pattern is oneway |
| * @param action Action Message Addressing Property value |
| */ |
| public void fillRequestAddressingHeaders(Packet packet, AddressingVersion av, SOAPVersion sv, boolean oneway, String action) { |
| fillCommonAddressingHeaders(packet, av, sv, action); |
| |
| // wsa:ReplyTo |
| // null or "true" is equivalent to request/response MEP |
| if (!oneway) { |
| WSEndpointReference epr = av.anonymousEpr; |
| add(epr.createHeader(av.replyToTag)); |
| |
| // wsa:MessageID |
| Header h = new StringHeader(av.messageIDTag, packet.getMessage().getID(av, sv)); |
| add(h); |
| } |
| } |
| |
| /** |
| * Creates a set of outbound WS-Addressing headers on the client with the |
| * default Action Message Addressing Property value. |
| * <p><p> |
| * This method needs to be invoked right after such a Message is |
| * created which is error prone but so far only MEX, RM and JAX-WS |
| * creates a request so this ugliness is acceptable. If more components |
| * are identified using this, then we may revisit this. |
| * <p><p> |
| * This method is used if default Action Message Addressing Property is to |
| * be used. See |
| * {@link #fillRequestAddressingHeaders(Packet, com.sun.xml.internal.ws.api.addressing.AddressingVersion, com.sun.xml.internal.ws.api.SOAPVersion, boolean, String)} |
| * if non-default Action is to be used, for example when creating a protocol message not |
| * associated with {@link WSBinding} and {@link WSDLPort}. |
| * This method uses SOAPAction as the Action unless set expplicitly in the wsdl. |
| * @param wsdlPort request WSDL port |
| * @param binding request WSBinding |
| * @param packet request packet |
| */ |
| public void fillRequestAddressingHeaders(WSDLPort wsdlPort, @NotNull WSBinding binding, Packet packet) { |
| if (binding == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_BINDING()); |
| |
| AddressingVersion addressingVersion = binding.getAddressingVersion(); |
| //seiModel is passed as null as it is not needed. |
| WsaTubeHelper wsaHelper = addressingVersion.getWsaHelper(wsdlPort, null, binding); |
| |
| // wsa:Action |
| String action = wsaHelper.getEffectiveInputAction(packet); |
| if (action == null || action.equals("")) { |
| throw new WebServiceException(ClientMessages.INVALID_SOAP_ACTION()); |
| } |
| boolean oneway = !packet.expectReply; |
| if (wsdlPort != null) { |
| // if WSDL has <wsaw:Anonymous>prohibited</wsaw:Anonymous>, then throw an error |
| // as anonymous ReplyTo MUST NOT be added in that case. BindingProvider need to |
| // disable AddressingFeature and MemberSubmissionAddressingFeature and hand-craft |
| // the SOAP message with non-anonymous ReplyTo/FaultTo. |
| if (!oneway && packet.getMessage() != null && packet.getMessage().getOperation(wsdlPort) != null && packet.getMessage().getOperation(wsdlPort).getAnonymous() == WSDLBoundOperation.ANONYMOUS.prohibited) |
| { |
| throw new WebServiceException(AddressingMessages.WSAW_ANONYMOUS_PROHIBITED()); |
| } |
| } |
| if (!binding.isFeatureEnabled(OneWayFeature.class)) { |
| // standard oneway |
| fillRequestAddressingHeaders(packet, addressingVersion, binding.getSOAPVersion(), oneway, action); |
| } else { |
| // custom oneway |
| fillRequestAddressingHeaders(packet, addressingVersion, binding.getSOAPVersion(), binding.getFeature(OneWayFeature.class), action); |
| } |
| } |
| |
| private void fillRequestAddressingHeaders(@NotNull Packet packet, @NotNull AddressingVersion av, @NotNull SOAPVersion sv, @NotNull OneWayFeature of, @NotNull String action) { |
| fillCommonAddressingHeaders(packet, av, sv, action); |
| |
| // wsa:ReplyTo |
| if (of.getReplyTo() != null) { |
| add(of.getReplyTo().createHeader(av.replyToTag)); |
| |
| // add wsa:MessageID only for non-null ReplyTo |
| Header h = new StringHeader(av.messageIDTag, packet.getMessage().getID(av, sv)); |
| add(h); |
| } |
| |
| // wsa:From |
| if (of.getFrom() != null) { |
| add(of.getFrom().createHeader(av.fromTag)); |
| } |
| |
| // wsa:RelatesTo |
| if (of.getRelatesToID() != null) { |
| add(new RelatesToHeader(av.relatesToTag, of.getRelatesToID())); |
| } |
| } |
| |
| /** |
| * Creates wsa:To, wsa:Action and wsa:MessageID header on the client |
| * |
| * @param packet request packet |
| * @param av WS-Addressing version |
| * @param sv SOAP version |
| * @param action Action Message Addressing Property value |
| * @throws IllegalArgumentException if any of the parameters is null. |
| */ |
| private void fillCommonAddressingHeaders(Packet packet, @NotNull AddressingVersion av, @NotNull SOAPVersion sv, @NotNull String action) { |
| if (packet == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_PACKET()); |
| |
| if (av == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_ADDRESSING_VERSION()); |
| |
| if (sv == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_SOAP_VERSION()); |
| |
| if (action == null) |
| throw new IllegalArgumentException(AddressingMessages.NULL_ACTION()); |
| |
| // wsa:To |
| StringHeader h = new StringHeader(av.toTag, packet.endpointAddress.toString()); |
| add(h); |
| |
| // wsa:Action |
| packet.soapAction = action; |
| h = new StringHeader(av.actionTag, action); |
| add(h); |
| } |
| |
| /** |
| * Adds a new {@link Header}. |
| * |
| * <p> |
| * Order doesn't matter in headers, so this method |
| * does not make any guarantee as to where the new header |
| * is inserted. |
| * |
| * @return |
| * always true. Don't use the return value. |
| */ |
| public boolean add(Header header) { |
| return super.add(header); |
| } |
| |
| /** |
| * @deprecated |
| * {@link HeaderList} is monotonic and you can't remove anything. |
| */ |
| // to allow this, we need to implement the resizing of understoodBits |
| public Header remove(int index) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @deprecated |
| * {@link HeaderList} is monotonic and you can't remove anything. |
| */ |
| public boolean remove(Object o) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @deprecated |
| * {@link HeaderList} is monotonic and you can't remove anything. |
| */ |
| public boolean removeAll(Collection<?> c) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @deprecated |
| * {@link HeaderList} is monotonic and you can't remove anything. |
| */ |
| public boolean retainAll(Collection<?> c) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * Creates a copy. |
| * |
| * This handles null {@link HeaderList} correctly. |
| * |
| * @param original |
| * Can be null, in which case null will be returned. |
| */ |
| public static HeaderList copy(HeaderList original) { |
| if(original==null) |
| return null; |
| else |
| return new HeaderList(original); |
| } |
| |
| public void readResponseAddressingHeaders(WSDLPort wsdlPort, WSBinding binding) { |
| // read Action |
| String action = getAction(binding.getAddressingVersion(), binding.getSOAPVersion()); |
| // TODO: validate client-inbound Action |
| } |
| } |
