<!--
  ~ 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.
  -->

<html>
<head>
  <meta http-equiv="content-type" content="">
  <title>Apache Axis2 1.5.2 Release Notes</title>
</head>

<body lang="en">
<h1>Apache Axis2 1.5.2 Release Notes</h1>

<h2>About this version</h2>

<p>1.5.2 is a maintenance release to fix the security issue described in
<a href="http://svn.apache.org/repos/asf/axis/axis2/java/core/security/CVE-2010-1632.pdf">CVE-2010-1632</a>
as well as an XSS vulnerability in the admin console and some other minor issues. It also
upgrades Axiom to version 1.2.9.</p>

<h2>Changes since 1.5.1</h2>

<ul>
  	<li>[AXIS2-3290] surefire is still run even if maven.test.skip is true</li>
    <li>[AXIS2-4113] Unable to sign axis2 jar 1.4/1.4.1: ZipException</li>
    <li>[AXIS2-4371] Unable to compile class for JSP: axis2-web/viewphases.jsp</li>
    <li>[AXIS2-4450] CVE-2010-1632: Message builders for SOAP and XML should not attempt to load DTDs</li>
    <li>[AXIS2-4751] Cookie value is always kept whatever SESSION_MAINTAIN_PROPERTY value is configured</li>
    <li>[AXIS2-4752] Timeout due to connection pool is starved in latest 1.5.2-SNAPSHOT code.</li>
    <li>[AXIS2-4768] Mtom optimization doesn't work when using simple bean</li>
    <li>[AXIS2-4787] Hardcoded Bundle-Versions in adb, jaxws, kernel, metadata and saaj modules</li>
    <li>[AXIS2-4788] axis2-jibx has conflicting bcel dependencies</li>
</ul>

<h2>About Axis2</h2>

<p>Apache Axis2 is a complete re-design and re-write of the widely used
Apache Axis engine and is a more efficient, more scalable, more modular
and more XML-oriented Web services framework. It is carefully designed to
support the easy addition of plug-in "modules" that extend its
functionality for features such as security and reliability.</p>

<p>Modules supporting WS-Security/Secure-Conversation (Apache Rampart),
WS-Trust (Apache Rahas), WS-Reliable Messaging (Apache Sandesha) and
WS-Eventing (Apache Savan) are available via the Apache Web Services
project. Please see the individual subproject sites for further information.</p>

<h2>Feedback</h2>

<p>We are striving for a simple and happy first time user experience as well as a
satisfying experienced user experience with this release. We welcome any
and all feedback at:</p>
<ul>
  <li><a href="mailto:java-user@axis.apache.org">java-user@axis.apache.org</a> (please include "[axis2]" in the subject)</li>
  <li><a href="mailto:java-dev@axis.apache.org">java-dev@axis.apache.org</a> (please include "[axis2]" in the subject)</li>
  <li><a href="http://issues.apache.org/jira/browse/AXIS2">http://issues.apache.org/jira/browse/AXIS2</a></li>
</ul>

<p>Thank you for your interest in Apache Axis2!</p>

<p><i>The Axis2 Development Team<br>
<a href="http://axis.apache.org/">http://axis.apache.org/</a></i></p>
</body>
</html>
