/**
* Get the content length, including both soap and any attachments.
*
* @return the total length of this message in bytes
* @throws org.apache.axis.AxisFault if there was a problem that prevented the length being
* calculated
*/
public long getContentLength() throws org.apache.axis.AxisFault {
long ret = mSOAPPart.getContentLength();
if (mAttachments != null && 0 < mAttachments.getAttachmentCount()) {
ret = mAttachments.getContentLength();
}
return ret;
}
/**
* Get the content type of the attachments.
*
* @param sc provides the default content type
* @return a <code>String</code> giving the content type of the attachment
* @throws AxisFault if there was an error deducing the content type from this message
*/
public String getContentType(SOAPConstants sc) throws AxisFault {
boolean soap12 = false;
if (sc != null) {
if (sc == SOAPConstants.SOAP12_CONSTANTS) {
soap12 = true;
}
} else {
// Support of SOAP 1.2 HTTP binding
SOAPEnvelope envelope = getSOAPEnvelope();
if (envelope != null) {
if (envelope.getSOAPConstants() == SOAPConstants.SOAP12_CONSTANTS) {
soap12 = true;
}
}
}
String encoding = XMLUtils.getEncoding(this, msgContext);
;
String ret = sc.getContentType() + "; charset=" + encoding.toLowerCase();
// Support of SOAP 1.2 HTTP binding
if (soap12) {
ret = HTTPConstants.HEADER_ACCEPT_APPL_SOAP + "; charset=" + encoding;
}
if (getSendType() != Attachments.SEND_TYPE_NONE
&& mAttachments != null
&& 0 != mAttachments.getAttachmentCount()) {
ret = mAttachments.getContentType();
}
return ret;
}
/**
* Retrieves all the <CODE>AttachmentPart</CODE> objects that are part of this <CODE>SOAPMessage
* </CODE> object.
*
* @return an iterator over all the attachments in this message
*/
public Iterator getAttachments() {
try {
if (mAttachments != null && 0 != mAttachments.getAttachmentCount()) {
return mAttachments.getAttachments().iterator();
}
} catch (AxisFault af) {
log.error(Messages.getMessage("exception00"), af);
}
return Collections.EMPTY_LIST.iterator();
}
/**
* Adds the given <CODE>AttachmentPart</CODE> object to this <CODE>SOAPMessage</CODE> object. An
* <CODE>
* AttachmentPart</CODE> object must be created before it can be added to a message.
*
* @param attachmentpart an <CODE>
* AttachmentPart</CODE> object that is to become part of this <CODE>SOAPMessage</CODE> object
* @throws java.lang.IllegalArgumentException
*/
public void addAttachmentPart(AttachmentPart attachmentpart) {
try {
mAttachments.addAttachmentPart((org.apache.axis.Part) attachmentpart);
} catch (AxisFault af) {
log.error(Messages.getMessage("exception00"), af);
}
}
/**
* Updates this <CODE>SOAPMessage</CODE> object with all the changes that have been made to it.
* This method is called automatically when a message is sent or written to by the methods <CODE>
* ProviderConnection.send</CODE>, <CODE>
* SOAPConnection.call</CODE>, or <CODE>
* SOAPMessage.writeTo</CODE>. However, if changes are made to a message that was received or to
* one that has already been sent, the method <CODE>saveChanges</CODE> needs to be called
* explicitly in order to save the changes. The method <CODE>saveChanges</CODE> also generates any
* changes that can be read back (for example, a MessageId in profiles that support a message id).
* All MIME headers in a message that is created for sending purposes are guaranteed to have valid
* values only after <CODE>saveChanges</CODE> has been called.
*
* <p>In addition, this method marks the point at which the data from all constituent <CODE>
* AttachmentPart</CODE> objects are pulled into the message.
*
* @throws SOAPException if there was a problem saving changes to this message.
*/
public void saveChanges() throws SOAPException {
headers.removeHeader("Content-Length");
if (mAttachments != null && 0 < mAttachments.getAttachmentCount()) {
try {
headers.setHeader("Content-Type", mAttachments.getContentType());
} catch (AxisFault af) {
log.error(Messages.getMessage("exception00"), af);
}
}
saveRequired = false;
try {
/* Fix for Bug 16418 - Start from scratch */
mSOAPPart.saveChanges();
} catch (AxisFault axisFault) {
log.error(Messages.getMessage("exception00"), axisFault);
}
}
/**
* Creates a new empty <CODE>AttachmentPart</CODE> object. Note that the method <CODE>
* addAttachmentPart</CODE> must be called with this new <CODE>AttachmentPart</CODE> object as the
* parameter in order for it to become an attachment to this <CODE>SOAPMessage</CODE> object.
*
* @return a new <CODE>AttachmentPart</CODE> object that can be populated and added to this <CODE>
* SOAPMessage</CODE> object
*/
public AttachmentPart createAttachmentPart() {
if (!isAttachmentSupportEnabled(getMessageContext())) {
throw new RuntimeException(Messages.getMessage("noAttachments"));
}
try {
return (AttachmentPart) mAttachments.createAttachmentPart();
} catch (AxisFault af) {
log.error(Messages.getMessage("exception00"), af);
}
return null;
}
/**
* Writes this <CODE>SOAPMessage</CODE> object to the given output stream. The externalization
* format is as defined by the SOAP 1.1 with Attachments specification.
*
* <p>If there are no attachments, just an XML stream is written out. For those messages that have
* attachments, <CODE>writeTo</CODE> writes a MIME-encoded byte stream.
*
* @param os the <CODE>OutputStream</CODE> object to which this <CODE>SOAPMessage</CODE> object
* will be written
* @throws SOAPException if there was a problem in externalizing this SOAP message
* @throws IOException if an I/O error occurs
*/
public void writeTo(java.io.OutputStream os) throws SOAPException, IOException {
// Do it the old fashion way.
if (getSendType() == Attachments.SEND_TYPE_NONE
|| mAttachments == null
|| 0 == mAttachments.getAttachmentCount()) {
try {
String charEncoding = XMLUtils.getEncoding(this, msgContext);
;
mSOAPPart.setEncoding(charEncoding);
mSOAPPart.writeTo(os);
} catch (java.io.IOException e) {
log.error(Messages.getMessage("javaIOException00"), e);
}
} else {
try {
mAttachments.writeContentToStream(os);
} catch (java.lang.Exception e) {
log.error(Messages.getMessage("exception00"), e);
}
}
}
/** Dispose of attachments. */
public void dispose() {
if (mAttachments != null) {
mAttachments.dispose();
}
}
/**
* Retrieves all the <CODE>AttachmentPart</CODE> objects that have header entries that match the
* specified headers. Note that a returned attachment could have headers in addition to those
* specified.
*
* @param headers a <CODE>MimeHeaders</CODE> object containing the MIME headers for which to
* search
* @return an iterator over all attachments that have a header that matches one of the given
* headers
*/
public Iterator getAttachments(javax.xml.soap.MimeHeaders headers) {
return mAttachments.getAttachments(headers);
}
/**
* Gets a count of the number of attachments in this message. This count does not include the SOAP
* part.
*
* @return the number of <CODE>AttachmentPart</CODE> objects that are part of this <CODE>
* SOAPMessage</CODE> object
*/
public int countAttachments() {
return mAttachments == null ? 0 : mAttachments.getAttachmentCount();
}
/**
* Removes all <CODE>AttachmentPart</CODE> objects that have been added to this <CODE>SOAPMessage
* </CODE> object.
*
* <p>This method does not touch the SOAP part.
*/
public void removeAllAttachments() {
mAttachments.removeAllAttachments();
}
/**
* Do the work of construction.
*
* @param initialContents may be String, byte[], InputStream, SOAPEnvelope, or AxisFault
* @param bodyInStream is true if initialContents is an InputStream containing just the SOAP body
* (no SOAP-ENV)
* @param contentType this if the contentType has been already determined (as in the case of
* servlets)
* @param contentLocation the location of the content
* @param mimeHeaders mime headers for attachments
*/
private void setup(
Object initialContents,
boolean bodyInStream,
String contentType,
String contentLocation,
javax.xml.soap.MimeHeaders mimeHeaders) {
if (contentType == null && mimeHeaders != null) {
String contentTypes[] = mimeHeaders.getHeader("Content-Type");
contentType = (contentTypes != null) ? contentTypes[0] : null;
}
if (contentLocation == null && mimeHeaders != null) {
String contentLocations[] = mimeHeaders.getHeader("Content-Location");
contentLocation = (contentLocations != null) ? contentLocations[0] : null;
}
if (contentType != null) {
int delimiterIndex = contentType.lastIndexOf("charset");
if (delimiterIndex > 0) {
String charsetPart = contentType.substring(delimiterIndex);
int delimiterIndex2 = charsetPart.indexOf(';');
if (delimiterIndex2 != -1) {
charsetPart = charsetPart.substring(0, delimiterIndex2);
}
int charsetIndex = charsetPart.indexOf('=');
String charset = charsetPart.substring(charsetIndex + 1).trim();
if ((charset.startsWith("\"") || charset.startsWith("\'"))) {
charset = charset.substring(1, charset.length());
}
if ((charset.endsWith("\"") || charset.endsWith("\'"))) {
charset = charset.substring(0, charset.length() - 1);
}
try {
setProperty(SOAPMessage.CHARACTER_SET_ENCODING, charset);
} catch (SOAPException e) {
}
}
}
// Try to construct an AttachmentsImpl object for attachment
// functionality.
// If there is no org.apache.axis.attachments.AttachmentsImpl class,
// it must mean activation.jar is not present and attachments are not
// supported.
if (isAttachmentSupportEnabled(getMessageContext())) {
// Construct one, and cast to Attachments.
// There must be exactly one constructor of AttachmentsImpl, which
// must take an org.apache.axis.Message!
Constructor attachImplConstr = attachImpl.getConstructors()[0];
try {
mAttachments =
(Attachments)
attachImplConstr.newInstance(
new Object[] {initialContents, contentType, contentLocation});
// If it can't support it, it wont have a root part.
mSOAPPart = (SOAPPart) mAttachments.getRootPart();
} catch (InvocationTargetException ex) {
log.fatal(Messages.getMessage("invocationTargetException00"), ex);
throw new RuntimeException(ex.getMessage());
} catch (InstantiationException ex) {
log.fatal(Messages.getMessage("instantiationException00"), ex);
throw new RuntimeException(ex.getMessage());
} catch (IllegalAccessException ex) {
log.fatal(Messages.getMessage("illegalAccessException00"), ex);
throw new RuntimeException(ex.getMessage());
}
} else if (contentType != null && contentType.startsWith("multipart")) {
throw new RuntimeException(Messages.getMessage("noAttachments"));
}
// text/xml
if (null == mSOAPPart) {
mSOAPPart = new SOAPPart(this, initialContents, bodyInStream);
} else mSOAPPart.setMessage(this);
// The stream was not determined by a more complex type so default to
if (mAttachments != null) mAttachments.setRootPart(mSOAPPart);
headers = (mimeHeaders == null) ? new MimeHeaders() : new MimeHeaders(mimeHeaders);
}
