001: /*
002: * Portions Copyright 2006 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: package com.sun.xml.internal.ws.encoding.soap.client;
027:
028: import com.sun.xml.internal.ws.pept.ept.MessageInfo;
029: import com.sun.xml.internal.ws.pept.presentation.MessageStruct;
030: import com.sun.xml.internal.ws.client.BindingProviderProperties;
031: import com.sun.xml.internal.ws.client.RequestContext;
032: import com.sun.xml.internal.ws.client.dispatch.DispatchContext;
033: import com.sun.xml.internal.ws.client.dispatch.impl.encoding.DispatchSerializer;
034: import com.sun.xml.internal.ws.client.dispatch.impl.encoding.DispatchUtil;
035: import com.sun.xml.internal.ws.encoding.internal.InternalEncoder;
036: import com.sun.xml.internal.ws.encoding.jaxb.JAXBBeanInfo;
037: import com.sun.xml.internal.ws.encoding.jaxb.JAXBBridgeInfo;
038: import com.sun.xml.internal.ws.encoding.simpletype.EncoderUtils;
039: import com.sun.xml.internal.ws.encoding.soap.DeserializationException;
040: import com.sun.xml.internal.ws.encoding.soap.SOAPConstants;
041: import com.sun.xml.internal.ws.encoding.soap.SOAPDecoder;
042: import com.sun.xml.internal.ws.encoding.soap.SOAPEPTFactory;
043: import com.sun.xml.internal.ws.encoding.soap.SOAP12Constants;
044: import com.sun.xml.internal.ws.encoding.soap.streaming.SOAPNamespaceConstants;
045: import com.sun.xml.internal.ws.encoding.soap.internal.BodyBlock;
046: import com.sun.xml.internal.ws.encoding.soap.internal.HeaderBlock;
047: import com.sun.xml.internal.ws.encoding.soap.internal.InternalMessage;
048: import com.sun.xml.internal.ws.encoding.soap.message.SOAPFaultInfo;
049: import com.sun.xml.internal.ws.server.RuntimeContext;
050: import com.sun.xml.internal.ws.spi.runtime.WSConnection;
051: import com.sun.xml.internal.ws.streaming.SourceReaderFactory;
052: import com.sun.xml.internal.ws.streaming.XMLStreamReaderUtil;
053: import com.sun.xml.internal.ws.streaming.Attributes;
054: import com.sun.xml.internal.ws.streaming.XMLStreamWriterFactory;
055: import com.sun.xml.internal.ws.util.MessageInfoUtil;
056: import com.sun.xml.internal.ws.util.SOAPConnectionUtil;
057: import com.sun.xml.internal.ws.util.SOAPUtil;
058: import com.sun.xml.internal.ws.util.ByteArrayBuffer;
059: import com.sun.xml.internal.ws.util.xml.StAXSource;
060: import com.sun.xml.internal.ws.util.xml.XmlUtil;
061: import com.sun.xml.internal.bind.api.BridgeContext;
062:
063: import javax.xml.bind.JAXBContext;
064: import javax.xml.bind.Marshaller;
065: import javax.xml.bind.Unmarshaller;
066: import javax.xml.namespace.QName;
067: import javax.xml.soap.Detail;
068: import javax.xml.soap.MessageFactory;
069: import javax.xml.soap.SOAPException;
070: import javax.xml.soap.SOAPMessage;
071: import static javax.xml.stream.XMLStreamConstants.*;
072: import javax.xml.stream.XMLStreamReader;
073: import javax.xml.stream.XMLStreamWriter;
074: import javax.xml.stream.XMLStreamException;
075: import javax.xml.transform.Source;
076: import javax.xml.transform.Transformer;
077: import javax.xml.transform.TransformerException;
078: import javax.xml.transform.TransformerFactory;
079: import javax.xml.transform.TransformerFactoryConfigurationError;
080: import javax.xml.transform.dom.DOMResult;
081: import javax.xml.ws.WebServiceException;
082: import javax.xml.ws.Service;
083: import javax.xml.ws.soap.SOAPBinding;
084: import javax.xml.ws.soap.SOAPFaultException;
085: import java.lang.reflect.Method;
086: import java.util.Iterator;
087: import java.util.Map;
088: import java.util.HashMap;
089:
090: /**
091: * @author WS Development Team
092: */
093:
094: public class SOAPXMLDecoder extends SOAPDecoder {
095: public SOAPXMLDecoder() {
096: }
097:
098: protected DispatchSerializer getSerializerInstance() {
099: return DispatchSerializer.SOAP_1_0;
100: }
101:
102: @Override
103: public SOAPMessage toSOAPMessage(MessageInfo messageInfo) {
104: WSConnection connection = (WSConnection) messageInfo
105: .getConnection();
106: return SOAPConnectionUtil.getSOAPMessage(connection,
107: messageInfo, getBindingId());
108: }
109:
110: /*protected void decodeBody(XMLStreamReader reader, InternalMessage response,
111: MessageInfo messageInfo) {
112: XMLStreamReaderUtil.verifyReaderState(reader, START_ELEMENT);
113: XMLStreamReaderUtil.verifyTag(reader, getBodyTag());
114: int state = XMLStreamReaderUtil.nextElementContent(reader);
115: decodeBodyContent(reader, response, messageInfo);
116: XMLStreamReaderUtil.verifyReaderState(reader, END_ELEMENT);
117: XMLStreamReaderUtil.verifyTag(reader, getBodyTag());
118: XMLStreamReaderUtil.nextElementContent(reader);
119: }
120: */
121:
122: /*
123: * skipBody is true, the body is skipped during parsing.
124: */
125: protected void decodeEnvelope(XMLStreamReader reader,
126: InternalMessage request, boolean skipBody,
127: MessageInfo messageInfo) {
128:
129: XMLStreamReaderUtil.verifyReaderState(reader, START_ELEMENT);
130: //XMLStreamReaderUtil.verifyTag(reader, getEnvelopeTag());
131: if (isDispatch(messageInfo))
132: dispatchUtil.collectPrefixes(reader);
133:
134: XMLStreamReaderUtil.nextElementContent(reader);
135:
136: if (skipHeader(messageInfo)) {
137: //System.out.println("Skipping header");
138: skipHeader(reader, messageInfo);
139: } else {
140: //System.out.println("Decoding header");
141: decodeHeader(reader, messageInfo, request);
142: }
143:
144: if (skipBody) {
145: //System.out.println("Skipping body");
146: skipBody(reader);
147: } else {
148: //System.out.println("Decodong body");
149: decodeBody(reader, request, messageInfo);
150: }
151:
152: XMLStreamReaderUtil.verifyReaderState(reader, END_ELEMENT);
153: XMLStreamReaderUtil.verifyTag(reader, getEnvelopeTag());
154: XMLStreamReaderUtil.nextElementContent(reader);
155: XMLStreamReaderUtil.verifyReaderState(reader, END_DOCUMENT);
156: }
157:
158: private static String convertNull(String s) {
159: return (s != null) ? s : "";
160: }
161:
162: //@Override
163: protected void decodeBody(XMLStreamReader reader,
164: InternalMessage response, MessageInfo messageInfo) {
165: DispatchContext context = (DispatchContext) messageInfo
166: .getMetaData(BindingProviderProperties.DISPATCH_CONTEXT);
167: if (context != null) {
168: //System.out.println("Dispatch context not null");
169: XMLStreamReaderUtil
170: .verifyReaderState(reader, START_ELEMENT);
171: XMLStreamReaderUtil.verifyTag(reader, getBodyTag());
172: int state = XMLStreamReaderUtil.nextElementContent(reader);
173: // if Body is not empty, then deserialize the Body
174: if (state != END_ELEMENT) {
175: BodyBlock responseBody;
176: QName responseBodyName = reader.getName(); // Operation name
177:
178: if (responseBodyName.equals(getFaultTag())) {
179: SOAPFaultInfo soapFaultInfo = decodeFault(reader,
180: response, messageInfo);
181: responseBody = new BodyBlock(soapFaultInfo);
182: } else {
183: // System.out.println("Deserializing body");
184: JAXBContext jaxbContext = getJAXBContext(messageInfo);
185: if (jaxbContext == null) {
186: //System.out.println("JAXBContext == null");
187: responseBody = new BodyBlock(
188: getSerializerInstance()
189: .deserializeSource(reader,
190: dispatchUtil));
191: } else {
192: //jaxb will leave reader on ending </body> element
193: //System.out.println("Doing a jaxb bean");
194: JAXBBeanInfo jaxBean = null;
195: Unmarshaller um = (Unmarshaller) messageInfo
196: .getMetaData(BindingProviderProperties.DISPATCH_UNMARSHALLER);
197: if (um != null)
198: jaxBean = JAXBBeanInfo.fromStAX(reader,
199: jaxbContext, um);
200: else
201: jaxBean = JAXBBeanInfo.fromStAX(reader,
202: jaxbContext);
203:
204: responseBody = new BodyBlock(jaxBean);
205: }
206: }
207: response.setBody(responseBody);
208: }
209:
210: XMLStreamReaderUtil.verifyReaderState(reader, END_ELEMENT);
211: XMLStreamReaderUtil.verifyTag(reader, getBodyTag());
212: XMLStreamReaderUtil.nextElementContent(reader);
213: } //else
214: else
215: super .decodeBody(reader, response, messageInfo);
216: }
217:
218: @Override
219: //Todo:kw 102505
220: public void toMessageInfo(InternalMessage internalMessage,
221: MessageInfo messageInfo) {
222:
223: RuntimeContext rtContext = (RuntimeContext) messageInfo
224: .getMetaData(BindingProviderProperties.JAXWS_RUNTIME_CONTEXT);
225: if (rtContext != null) {
226: SOAPEPTFactory eptf = (SOAPEPTFactory) messageInfo
227: .getEPTFactory();
228: InternalEncoder encoder = eptf.getInternalEncoder();
229: encoder.toMessageInfo(internalMessage, messageInfo);
230:
231: } else { //here we need to set attachments in response context
232: if (internalMessage != null
233: && internalMessage.getBody() != null) {
234: if (internalMessage.getBody().getValue() instanceof SOAPFaultInfo) {
235: messageInfo
236: .setResponseType(MessageStruct.CHECKED_EXCEPTION_RESPONSE);
237: messageInfo.setResponse(internalMessage.getBody()
238: .getValue());
239: } else if (internalMessage.getBody().getValue() instanceof Exception) {
240: messageInfo
241: .setResponseType(MessageStruct.UNCHECKED_EXCEPTION_RESPONSE);
242: messageInfo.setResponse(internalMessage.getBody()
243: .getValue());
244: } else {
245: messageInfo
246: .setResponseType(MessageStruct.NORMAL_RESPONSE);
247: setAttachments(internalMessage, messageInfo);
248: //unfortunately we must do this
249: if (internalMessage.getBody().getValue() instanceof JAXBBeanInfo)
250: messageInfo
251: .setResponse(((JAXBBeanInfo) internalMessage
252: .getBody().getValue())
253: .getBean());
254: else
255: messageInfo.setResponse(internalMessage
256: .getBody().getValue());
257: }
258: } else
259: messageInfo
260: .setResponseType(MessageStruct.NORMAL_RESPONSE);
261: }
262: }
263:
264: private void setAttachments(InternalMessage internalMessage,
265: MessageInfo messageInfo) {
266:
267: }
268:
269: protected void decodeEnvelope(XMLStreamReader reader,
270: MessageInfo messageInfo) {
271: InternalMessage im = decodeInternalMessage(reader, messageInfo);
272: toMessageInfo(im, messageInfo);
273: }
274:
275: protected InternalMessage decodeInternalMessage(
276: XMLStreamReader reader, MessageInfo messageInfo) {
277: InternalMessage response = new InternalMessage();
278:
279: XMLStreamReaderUtil.verifyReaderState(reader, START_ELEMENT);
280: XMLStreamReaderUtil.verifyTag(reader, getEnvelopeTag());
281: XMLStreamReaderUtil.nextElementContent(reader);
282: decodeHeader(reader, messageInfo, response);
283: decodeBody(reader, response, messageInfo);
284: XMLStreamReaderUtil.verifyReaderState(reader, END_ELEMENT);
285: XMLStreamReaderUtil.verifyTag(reader, getEnvelopeTag());
286: XMLStreamReaderUtil.nextElementContent(reader);
287: XMLStreamReaderUtil.verifyReaderState(reader, END_DOCUMENT);
288:
289: return response;
290: }
291:
292: @Override
293: public InternalMessage toInternalMessage(SOAPMessage soapMessage,
294: MessageInfo messageInfo) {
295: // TODO handle exceptions, attachments
296: XMLStreamReader reader = null;
297: try {
298: InternalMessage response = new InternalMessage();
299: processAttachments(messageInfo, response, soapMessage);
300: Source source = soapMessage.getSOAPPart().getContent();
301: reader = SourceReaderFactory.createSourceReader(source,
302: true, getSOAPMessageCharsetEncoding(soapMessage));
303: XMLStreamReaderUtil.nextElementContent(reader);
304: decodeEnvelope(reader, response, false, messageInfo);
305: return response;
306: } catch (DeserializationException e) {
307: //e.printStackTrace();
308: throw new WebServiceException(e.getCause());
309: } catch (Exception e) {
310: //e.printStackTrace();
311: throw new WebServiceException(e);
312: } finally {
313: if (reader != null) {
314: XMLStreamReaderUtil.close(reader);
315: }
316: }
317: }
318:
319: @Override
320: public InternalMessage toInternalMessage(SOAPMessage soapMessage,
321: InternalMessage response, MessageInfo messageInfo) {
322: // TODO handle exceptions, attachments
323: XMLStreamReader reader = null;
324: try {
325: processAttachments(messageInfo, response, soapMessage);
326: Source source = soapMessage.getSOAPPart().getContent();
327: reader = SourceReaderFactory.createSourceReader(source,
328: true, getSOAPMessageCharsetEncoding(soapMessage));
329: XMLStreamReaderUtil.nextElementContent(reader);
330: decodeEnvelope(reader, response, !isDispatch(messageInfo),
331: messageInfo);
332:
333: if (!isDispatch(messageInfo))
334: convertBodyBlock(response, messageInfo);
335:
336: } catch (DeserializationException e) {
337: //e.printStackTrace();
338: throw new WebServiceException(e.getCause());
339: } catch (Exception e) {
340: //e.printStackTrace();
341: throw new WebServiceException(e);
342: } finally {
343: if (reader != null) {
344: XMLStreamReaderUtil.close(reader);
345: }
346: }
347: return response;
348:
349: }
350:
351: /**
352: * @return Returns the soap binding - SOAP 1.1 namespace.
353: */
354: public String getSOAPBindingId() {
355: return SOAPConstants.NS_WSDL_SOAP;
356: }
357:
358: @Override
359: protected SOAPFaultInfo decodeFault(XMLStreamReader reader,
360: InternalMessage internalMessage, MessageInfo messageInfo) {
361: RuntimeContext rtCtxt = MessageInfoUtil
362: .getRuntimeContext(messageInfo);
363:
364: XMLStreamReaderUtil.verifyReaderState(reader, START_ELEMENT);
365: XMLStreamReaderUtil.verifyTag(reader,
366: SOAPConstants.QNAME_SOAP_FAULT);
367: Method methodName = messageInfo.getMethod();
368:
369: // faultcode
370: XMLStreamReaderUtil.nextElementContent(reader);
371: XMLStreamReaderUtil.verifyReaderState(reader, START_ELEMENT);
372: XMLStreamReaderUtil.verifyTag(reader,
373: SOAPConstants.QNAME_SOAP_FAULT_CODE);
374: XMLStreamReaderUtil.nextContent(reader);
375: QName faultcode;
376: String tokens = reader.getText();
377: String uri = "";
378: tokens = EncoderUtils.collapseWhitespace(tokens);
379: String prefix = XmlUtil.getPrefix(tokens);
380: if (prefix != null) {
381: uri = reader.getNamespaceURI(prefix);
382: if (uri == null) {
383: throw new DeserializationException("xsd.unknownPrefix",
384: prefix);
385: }
386: }
387: String localPart = XmlUtil.getLocalPart(tokens);
388: faultcode = new QName(uri, localPart);
389: XMLStreamReaderUtil.next(reader);
390: XMLStreamReaderUtil.verifyReaderState(reader, END_ELEMENT);
391: XMLStreamReaderUtil.verifyTag(reader,
392: SOAPConstants.QNAME_SOAP_FAULT_CODE);
393:
394: // faultstring
395: XMLStreamReaderUtil.nextElementContent(reader);
396: XMLStreamReaderUtil.verifyReaderState(reader, START_ELEMENT);
397: XMLStreamReaderUtil.verifyTag(reader,
398: SOAPConstants.QNAME_SOAP_FAULT_STRING);
399: XMLStreamReaderUtil.nextContent(reader);
400: String faultstring = "";
401: //reader may give more than one char events so coalesc them all.
402: if (reader.getEventType() == CHARACTERS) {
403: do {
404: faultstring += reader.getText();
405: XMLStreamReaderUtil.next(reader);
406: } while (reader.getEventType() == CHARACTERS);
407: }
408: XMLStreamReaderUtil.verifyReaderState(reader, END_ELEMENT);
409: XMLStreamReaderUtil.verifyTag(reader,
410: SOAPConstants.QNAME_SOAP_FAULT_STRING);
411:
412: String faultactor = null;
413: Object faultdetail = null;
414: QName faultName;
415: if (XMLStreamReaderUtil.nextElementContent(reader) == START_ELEMENT) {
416: QName elementName = reader.getName();
417: // faultactor
418: if (elementName
419: .equals(SOAPConstants.QNAME_SOAP_FAULT_ACTOR)) {
420: XMLStreamReaderUtil.nextContent(reader);
421: // faultactor may be empty
422: if (reader.getEventType() == CHARACTERS) {
423: faultactor = reader.getText();
424: XMLStreamReaderUtil.next(reader);
425: }
426: XMLStreamReaderUtil.verifyReaderState(reader,
427: END_ELEMENT);
428: XMLStreamReaderUtil.verifyTag(reader,
429: SOAPConstants.QNAME_SOAP_FAULT_ACTOR);
430: XMLStreamReaderUtil.nextElementContent(reader);
431: elementName = reader.getName();
432: }
433:
434: // faultdetail
435: if (elementName
436: .equals(SOAPConstants.QNAME_SOAP_FAULT_DETAIL)) {
437: //skip <detail/>
438: if (XMLStreamReaderUtil.nextContent(reader) == START_ELEMENT) {
439: if (messageInfo
440: .getMetaData(BindingProviderProperties.DISPATCH_CONTEXT) == null)
441: faultdetail = readFaultDetail(reader,
442: messageInfo);
443: else {
444: XMLStreamReaderUtil.skipElement(reader);
445: XMLStreamReaderUtil.next(reader);
446: }
447: }
448: // move from </detail> to </Fault>.
449: XMLStreamReaderUtil.nextContent(reader);
450: } else {
451: if (internalMessage.getHeaders() != null) {
452: boolean isHeaderFault = false;
453: // could be a header fault or a protocol exception with no detail
454: for (HeaderBlock headerBlock : internalMessage
455: .getHeaders()) {
456: if (rtCtxt.getModel().isKnownFault(
457: headerBlock.getName(), methodName)) {
458: isHeaderFault = true;
459: faultdetail = headerBlock.getValue();
460: }
461: }
462:
463: // if not a header fault, then it is a protocol exception with no detail
464: if (!isHeaderFault) {
465: faultdetail = null;
466: }
467: XMLStreamReaderUtil.next(reader);
468: }
469: }
470: } else {
471: // a header fault (with no faultactor)
472: if (internalMessage.getHeaders() != null) {
473: for (HeaderBlock headerBlock : internalMessage
474: .getHeaders()) {
475: if (rtCtxt.getModel().isKnownFault(
476: headerBlock.getName(), methodName)) {
477: faultdetail = headerBlock.getValue();
478: }
479: }
480: }
481: }
482:
483: SOAPFaultInfo soapFaultInfo = new SOAPFaultInfo(faultstring,
484: faultcode, faultactor, faultdetail, getBindingId());
485:
486: // reader could be left on CHARS token rather than </fault>
487: if (reader.getEventType() == CHARACTERS
488: && reader.isWhiteSpace()) {
489: XMLStreamReaderUtil.nextContent(reader);
490: }
491:
492: XMLStreamReaderUtil.verifyReaderState(reader, END_ELEMENT);
493: XMLStreamReaderUtil.verifyTag(reader,
494: SOAPConstants.QNAME_SOAP_FAULT);
495: XMLStreamReaderUtil.nextElementContent(reader);
496:
497: return soapFaultInfo;
498: }
499:
500: /**
501: * Decodes the fault <detail> into a {@link Detail} object or a JAXB object.
502: * <p/>
503: * Upon entry the cursor must be at the start tag of the first child element of <detail>.
504: * Upon a successful completion, the cursor is left at </detail>.
505: */
506: protected final Object readFaultDetail(XMLStreamReader reader,
507: MessageInfo mi) {
508: RuntimeContext rtCtxt = MessageInfoUtil.getRuntimeContext(mi);
509: if (rtCtxt == null) {
510: XMLStreamReaderUtil.skipElement(reader);
511: XMLStreamReaderUtil.nextElementContent(reader);
512: return null;
513: }
514: QName faultName = reader.getName();
515: if (rtCtxt.getModel().isKnownFault(faultName, mi.getMethod())) {
516: Object decoderInfo = rtCtxt.getDecoderInfo(faultName);
517: if (decoderInfo != null
518: && decoderInfo instanceof JAXBBridgeInfo) {
519: JAXBBridgeInfo bridgeInfo = (JAXBBridgeInfo) decoderInfo;
520: // JAXB leaves on </env:Header> or <nextHeaderElement>
521: bridgeInfo.deserialize(reader, rtCtxt
522: .getBridgeContext());
523:
524: // skip other detail entries
525: int event = reader.getEventType();
526: if (!(event == START_ELEMENT || event == END_ELEMENT)) {
527: XMLStreamReaderUtil.nextElementContent(reader);
528: }
529: while (reader.getEventType() == START_ELEMENT) {
530: XMLStreamReaderUtil.skipElement(reader);
531: XMLStreamReaderUtil.nextElementContent(reader);
532: }
533:
534: XMLStreamReaderUtil.verifyReaderState(reader,
535: END_ELEMENT);
536: XMLStreamReaderUtil.verifyTag(reader,
537: getFaultDetailTag());
538: return bridgeInfo;
539: }
540: }
541:
542: return decodeFaultDetail(reader);
543: }
544:
545: /**
546: * Decodes the fault <detail> into a {@link Detail} object.
547: * <p/>
548: * Upon entry the cursor must be at the start tag of the first child element of <detail>.
549: * Upon a successful completion, the cursor is left at </detail>.
550: */
551: protected Detail decodeFaultDetail(XMLStreamReader reader) {
552: try {
553: // parse the current element that the reader is pointing to
554: Transformer trans = XmlUtil.newTransformer();
555:
556: MessageFactory messageFactory = MessageFactory
557: .newInstance();
558: SOAPMessage soapMessage = messageFactory.createMessage();
559: Detail detail = soapMessage.getSOAPBody().addFault()
560: .addDetail();
561:
562: // repeatedly copy all the child elements of <detail>.
563: do {
564: trans.transform(new StAXSource(reader, true),
565: new DOMResult(detail));
566: } while (XMLStreamReaderUtil.nextContent(reader) == START_ELEMENT);
567:
568: // now we should be at </detail>.
569: return detail;
570: } catch (SOAPException e) {
571: throw new WebServiceException(
572: "sender.response.cannotDecodeFaultDetail", e);
573: } catch (TransformerException e) {
574: throw new WebServiceException(
575: "sender.response.cannotDecodeFaultDetail", e);
576: } catch (TransformerFactoryConfigurationError e) {
577: throw new WebServiceException(
578: "sender.response.cannotDecodeFaultDetail", e);
579: }
580: }
581:
582: /* protected static String getCurrentPrefix(XMLStreamReader reader, String tokens, String namespaceURI) {
583: tokens = reader.getText();
584: String uri = "";
585: tokens = EncoderUtils.collapseWhitespace(tokens);
586: String prefix = XmlUtil.getPrefix(tokens);
587: if (prefix != null) {
588: uri = reader.getNamespaceURI(prefix);
589: if (uri == null) {
590: throw new DeserializationException("xsd.unknownPrefix", prefix);
591: }
592: }
593: String localPart = XmlUtil.getLocalPart(tokens);
594: return prefix;
595: }
596: */
597:
598: protected JAXBContext getJAXBContext(MessageInfo messageInfo) {
599: JAXBContext jc = null;
600:
601: RequestContext requestContext = (RequestContext) messageInfo
602: .getMetaData(BindingProviderProperties.JAXWS_CONTEXT_PROPERTY);
603: if (requestContext != null)
604: // TODO: does this really need to be copied?
605: jc = (JAXBContext) requestContext.copy().get(
606: BindingProviderProperties.JAXB_CONTEXT_PROPERTY);
607: return jc;
608: }
609:
610: protected String getBindingId(MessageInfo messageInfo) {
611: RequestContext requestContext = (RequestContext) messageInfo
612: .getMetaData(BindingProviderProperties.JAXWS_CONTEXT_PROPERTY);
613: if (requestContext != null) {
614: String bindingId = (String) requestContext
615: .get(BindingProviderProperties.BINDING_ID_PROPERTY);
616: if (bindingId != null)
617: return bindingId;
618: }
619: return getBindingId();
620: }
621:
622: @Override
623: public String getBindingId() {
624: return SOAPBinding.SOAP11HTTP_BINDING;
625: }
626:
627: @Override
628: protected QName getSenderFaultCode() {
629: return SOAPConstants.FAULT_CODE_SERVER;
630: }
631:
632: @Override
633: protected QName getReceiverFaultCode() {
634: return SOAPConstants.FAULT_CODE_CLIENT;
635: }
636:
637: @Override
638: protected QName getVersionMismatchFaultCode() {
639: return SOAPConstants.FAULT_CODE_VERSION_MISMATCH;
640: }
641:
642: }
|