<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
       "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
<head>
  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
  <title>Apache Axis2/C Archived News</title>
  <meta name="generator" content="amaya 9.2.1, see http://www.w3.org/Amaya/"
  />
</head>

<body xml:lang="en">
<h1>Apache Axis2/C Archived News</h1>

<p>This page will contain information on previous releases running up to the
latest.</p>

<h2>Content</h2>
<ul>
  <li><a href="#0.94">Version 0.94 -3rd October 2006</a></li>
  <li><a href="#0.93">Version 0.93-31st August 2006</a></li>
  <li><a href="#0.92">Version 0.92- 16th June 2006</a></li>
  <li><a href="#0.91">Version 0.91- 15th May 2006</a></li>
  <li><a href="#0.90">Version 0.90- 31st March 2006</a></li>
  <li><a href="#M0.5">Milestone version 0.5- 10th March 2006</a></li>
  <li><a href="#M0.4">Milestone version 0.4- 17th February 2006</a></li>
  <li><a href="#M0.3">Milestone version 0.3- 02nd February 2006</a></li>
  <li><a href="#M0.2">Milestone version 0.2- 08th December 2005</a></li>
  <li><a href="#M0.1">Milestone version 0.1- 25th November 2005</a></li>
</ul>
<a name="0.94"></a>

<h3>3rd October 2006 Axis2/C Version 0.94 Released</h3>
<a href="download.cgi">Download 0.94</a>

<h4>Key Features</h4>
<ol>
  <li>AXIOM, an XML object model optimized for SOAP 1.1/1.2 Messages. This
    has complete XML infoset support</li>
  <li>Support for one-way messaging (In-Only) and request response messaging
    (In-Out)</li>
  <li>Description hierarchy (configuration, service groups, services,
    operations and messages)</li>
  <li>Directory based deployment model</li>
  <li>Archive based deployment model</li>
  <li>Context hierarchy (corresponding contexts to map to each level of
    description hierarchy)</li>
  <li>Raw XML message receiver</li>
  <li>Module architecture, mechanism to extend the SOAP processing model</li>
  <li>Module version support</li>
  <li>Transports supports: HTTP
    <ul>
      <li>Both simple axis server and Apache2 httpd module for server
      side</li>
      <li>Client transport with ability to enable SSL support</li>
    </ul>
  </li>
  <li>Service client and operation client APIs</li>
  <li>REST support (HTTP POST case)</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>MTOM/XOP support</li>
  <li>Code generation tool for stub and skeleton generation for a given WSDL
    (based on Java tool)
    <ul>
      <li>Axis Data Binding (ADB) support</li>
    </ul>
  </li>
  <li>Security module with UsernameToken support</li>
  <li>REST support (HTTP GET case)</li>
  <li>Dynamic invocation support (based on XML schema and WSDL
    implementations)</li>
  <li>Guththila pull parser support - <strong>New</strong></li>
  <li>WSDL2C code generation tool- with schema code generation (experimental)
    - <strong>New</strong></li>
  <li>TCP Monitor - C implementation (experimental) -
  <strong>New</strong></li>
</ol>

<h4>Major Changes Since Last Release</h4>
<ol>
  <li>Guththila pull parser support</li>
  <li>WSDL2C code generation tool</li>
  <li>TCP Monitor - C implementation</li>
  <li>Major Memory leak fixes</li>
  <li>Fixes to code generation with Java Tool</li>
  <li>Many Bug Fixes</li>
</ol>

<h4>TODOs Remaining for 1.0</h4>
<ol>
  <li>Complete API documentation and API improvements</li>
  <li>Fix further memory leaks</li>
  <li>Put in place a comprehensive functional test framework</li>
</ol>
<a name="0.93"></a>

<h3>31st August 2006 Axis2/C Version 0.93 Released</h3>
<a href="download.cgi">Download 0.93</a>

<h4>Key Features</h4>
<ol>
  <li>AXIOM, an XML object model optimized for SOAP 1.1/1.2 Messages. This
    has complete XML infoset support</li>
  <li>Support for one-way messaging (In-Only) and request response messaging
    (In-Out)</li>
  <li>Description hierarchy (configuration, service groups, services,
    operations and messages)</li>
  <li>Directory based deployment model</li>
  <li>Archive based deployment model</li>
  <li>Context hierarchy (corresponding contexts to map to each level of
    description hierarchy)</li>
  <li>Raw XML message receiver</li>
  <li>Module architecture, mechanism to extend the SOAP processing model</li>
  <li>Module version support</li>
  <li>Transports supports: HTTP
    <ul>
      <li>Both simple axis server and Apache2 httpd module for server
      side</li>
      <li>Client transport with ability to enable SSL support</li>
    </ul>
  </li>
  <li>Service client and operation client APIs</li>
  <li>REST support (HTTP POST case)</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>MTOM/XOP support</li>
  <li>Code generation tool for stub and skeleton generation for a given WSDL
    (based on Java tool)
    <ul>
      <li>Axis Data Binding (ADB) support</li>
    </ul>
  </li>
  <li>Security module with UsernameToken support</li>
  <li>REST support (HTTP GET case)</li>
  <li>Dynamic invocation support (based on XML schema and WSDL
    implementations)</li>
</ol>

<h4>Major Changes Since Last Release</h4>
<ol>
  <li>REST support for HTTP GET case</li>
  <li>XML Schema implementation</li>
  <li>Woden/C implementation that supports both WSDL 1.1 and WSDL 2.0</li>
  <li>Dynamic client invocation (given a WSDL, consume services
  dynamically)</li>
  <li>Numerous improvements to API and API documentation</li>
  <li>Many bug fixes, especially, many paths of execution previously
    untouched were tested along with Sandesha2/C implementation</li>
</ol>

<h4>TODOs Remaining for 1.0</h4>
<ol>
  <li>Complete API documentation and API improvements</li>
  <li>Fix major memory leaks</li>
  <li>Test codegen for both ADB and none cases</li>
  <li>Put in place a comprehensive functional test framework</li>
  <li>WSDL2C tool</li>
</ol>
<a  name="0.92"></a>

<h3>16th June 2006 Axis2/C Version 0.92 Released</h3>
<a href="download.cgi">Download 0.92</a>

<h4>Key Features</h4>
<ol>
  <li>AXIOM, an XML object model optimized for SOAP 1.1/1.2 Messages. This
    has complete XML infoset support.</li>
  <li>Support for One-Way Messaging (In-Only) and Request Response Messaging
    (In-Out)</li>
  <li>Module Architecture, mechanism to extend the SOAP processing model</li>
  <li>Context hierarchy</li>
  <li>Directory based deployment model</li>
  <li>Raw XML providers</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>Transports supports: HTTP
    <ul>
      <li>Both simple axis server and Apache2 httpd module</li>
      <li>SSL client transport</li>
    </ul>
  </li>
  <li>Service Groups</li>
  <li>Service client and operation client APIs</li>
  <li>REST support (POST case)</li>
  <li>Module version support</li>
  <li>Archive based deployment Model</li>
  <li>MTOM support</li>
  <li>WSDL Code Generation Tool for Stub and skeletons (based on Java tool)
    <strong>New</strong>
    <ul>
      <li>Axis Data Binding - ADB <strong>New</strong></li>
    </ul>
  </li>
  <li>Security module, usernameToken support <strong>New</strong></li>
</ol>

<h4>Major Changes Since Last Release</h4>
<ol>
  <li>Completed MTOM implementation with multiple attachment support and
    non-optimized case</li>
  <li>Completed service client API with send robust and fire and forget</li>
  <li>Added "message" to description hierarchy</li>
  <li>Archive based deployment Model (for services and modules)</li>
  <li>Code generation for WSDL using Java WSDL2Code tool</li>
  <li>ADB support (with Java WSDL2Code tool)</li>
  <li>WS-Security usernameToken support</li>
  <li>Initial implementation of the XML Schema parser (To be used in WSDL
    parser and REST support)</li>
  <li>Initial implementation of WSDL parser (To be used in dynamic
  invocation)</li>
  <li>Changed double pointer environment parameters into pointer parameters
    to improve efficiency</li>
</ol>

<h4>Un-Implemented Architecture Features (TBD in 1.0)</h4>
<ol>
  <li>Sessions scoping for Application, SOAP, Transport and Request
  levels</li>
  <li>Different character encoding support</li>
  <li>REST (REpresentational State Transfer) Support (GET case)</li>
  <li>Dynamic client invocation (given a WSDL, consume services
  dynamically)</li>
</ol>

<h4>Un-Implemented Architecture Features (TBD post 1.0)</h4>
<ol>
  <li>Security module with encryption and signing</li>
  <li>Server side Web Service Policy support</li>
  <li>C2WSDL</li>
  <li>WSDL2C</li>
</ol>
<a name="0.91"></a>

<h3>15th May 2006 Axis2/C Version 0.91 Released</h3>

<p><a href="download.cgi">Download 0.91</a></p>

<h4>Key Features</h4>
<ol>
  <li>AXIOM, an XML object model optimized for SOAP 1.1/1.2 messages. This
    has complete XML infoset support.</li>
  <li>Support for One-Way Messaging (In-Only) and Request Response Messaging
    (In-Out)</li>
  <li>Module architecture, mechanism to extend the SOAP processing model</li>
  <li>Context hierarchy</li>
  <li>Directory based deployment model</li>
  <li>Raw XML providers</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>Transports: HTTP
    <ul>
      <li>Both simple axis server and Apache2 httpd module</li>
      <li>SSL client transport <strong>New</strong></li>
    </ul>
  </li>
  <li>Service Groups <strong>New</strong></li>
  <li>Service client and operation client APIs <strong>New</strong></li>
  <li>REST support (POST case) <strong>New</strong></li>
  <li>Module version support <strong>New</strong></li>
  <li>MTOM support <strong>New</strong></li>
</ol>

<h4>Other notes</h4>
<ol>
  <li>Interoperability tested with Axis2/Java for XML in/out client and
    services</li>
  <li>Addressing 1.0 interoperability</li>
</ol>

<h4>Major changes since last release</h4>
<ol>
  <li>Full Addressing 1.0 support</li>
  <li>Improved fault handling model</li>
  <li>SSL client transport</li>
  <li>MTOM implementation</li>
  <li>Implementation of easy to use service client and operation client APIs
    for client side programming</li>
  <li>REST support (POST case)</li>
  <li>Module version support</li>
  <li>Service groups</li>
  <li>Numerous bug fixes since last release</li>
</ol>

<h4>Un-Implemented Architecture Features (TBD in 1.0)</h4>
<ol>
  <li>Sessions scoping for application, SOAP, transport and request
  levels</li>
  <li>Different character encoding support</li>
  <li>Dynamic invocation</li>
  <li>Archive based deployment Model</li>
</ol>

<h4>Un-Implemented Architecture Features (TBD post 1.0)</h4>
<ol>
  <li>WSDL code generation tool for stub and skeletons (based on Java
  tool)</li>
  <li>Security module</li>
  <li>REST (REpresentational State Transfer) support (GET case)</li>
  <li>Web Services policy support</li>
</ol>
<a name="0.90"></a>

<h3>31st March 2006 Axis2/C Version 0.90 Released</h3>
<a href="download.cgi">Download 0.90</a>

<h4>Key Features</h4>
<ol>
  <li>AXIOM, an XML object model optimized for SOAP 1.1/1.2 messages. This
    has complete XML infoset support.</li>
  <li>Support for One-Way Messaging (In-Only) and Request Response Messaging
    (In-Out)</li>
  <li>Module architecture, mechanism to extend the SOAP processing model</li>
  <li>Context hierarchy</li>
  <li>Directory based deployment model</li>
  <li>Raw XML providers</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>Transports: HTTP
    <ul>
      <li>Both simple axis server and Apache2 httpd module</li>
    </ul>
  </li>
</ol>

<h4>Experimental Features</h4>
<ol>
  <li>WSDL object model support <strong>New</strong>
    <ul>
      <li>Dynamic invocation</li>
    </ul>
  </li>
</ol>

<h4>Other notes</h4>
<ol>
  <li>Interoperability tested with Axis2/Java for XML in/out client and
    services</li>
  <li>Addressing interoperability on client side</li>
</ol>

<h4>Major changes since last release</h4>
<ol>
  <li>Minimal memory leaks</li>
  <li>Apache2 module working in Windows</li>
  <li>More samples and tests</li>
  <li>WSDL object model built based on the proposed WSDL 2.0 Component
  model.</li>
  <li>Dynamic invocation</li>
  <li>Numerous bug fixes since last release</li>
</ol>

<h4>Un-Implemented Architecture Features (TBD in 1.0)</h4>
<ol>
  <li>Module version support</li>
  <li>Archive based deployment model</li>
  <li>Improved and user friendly client API</li>
  <li>Support for MTOM</li>
  <li>Sessions scoping for application, SOAP, transport and request
  levels</li>
  <li>Service groups</li>
  <li>Different character encoding support</li>
</ol>

<h4>Un-Implemented Architecture Features (TBD post 1.0)</h4>
<ol>
  <li>WSDL code generation tool for stub and skeletons (based on Java
  tool)</li>
  <li>Security module</li>
  <li>REST (REpresentational State Transfer) support</li>
  <li>Web Services policy support</li>
  <li>Axis2 Web application (Web App)</li>
</ol>
<a name="M0.5"></a>

<h3>10th March 2006 Axis2/C Milestone 0.5 Released</h3>
<a href="download.cgi">Download M-0.5</a>

<h4>Key Features</h4>
<ol type="1">
  <li>AXIOM, an XML object model optimized for SOAP 1.1/1.2 Messages.</li>
  <li>Support for Request Response Messaging (In-Out)</li>
  <li>Module Architecture, mechanism to extend the SOAP Processing Model</li>
  <li>Directory based deployment model</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>Improved and user friendly Client API</li>
  <li>Transports supports: HTTP
    <ul>
      <li>Axis2/C server</li>
      <li>Apache integration module</li>
    </ul>
  </li>
  <li>Raw XML providers</li>
  <li>Numerous bug fixes since last release</li>
</ol>

<h4>Major Changes Since the Last Release</h4>
<ol type="1">
  <li>Improving code quality by fixing memory leaks and reviewing the
  code.</li>
  <li>Apache2 integration.</li>
  <li>More samples and tests</li>
  <li>Initial documentations(User Guide, Developer Guide, Installation
  Guide)</li>
</ol>

<h4>What's Still To Do?</h4>

<p>See list of what we think needs to be done, and consider helping out if
you're interested &amp; able!</p>
<ol type="1">
  <li>Management Interface for Axis2/C</li>
  <li>Implementation of other Transports.</li>
  <li>Code generation and Dynamic Invocation</li>
  <li>Hot Deployment of Services</li>
  <li>Completion of interop tests</li>
  <li>Support for MTOM</li>
  <li>Axis Data Binding - ADB (Framework and Schema Compiler)</li>
  <li>REST (REpresentational State Transfer) Support</li>
</ol>
<a name="M0.4"></a>

<h3>17th February 2006 Axis2/C Milestone 0.4 Released</h3>

<p>We have done considerable amount of improvements in the past two weeks
since the M0.3 release.</p>

<p>We have the following features added on top of the M0.3 release</p>

<h4>Key Features</h4>

<p>1. Threading support and threaded simple axis server</p>

<p>2. Module loading support</p>

<p>3. Addressing module and addressing based dispatching</p>

<p>4. HTTP chunking support</p>

<p>5. Improved logging mechanism</p>

<p>6. Ability to build and run on Windows platform</p>
<a name="M0.3"></a>

<h3>02nd February 2006 Axis2/C Milestone 0.3 Released</h3>

<p>This is the first milestone release with a working soap engine; we have
the simple axis server and client stubs working.</p>

<p>In addition to M0.2 feature set, the following features are included</p>

<h4>Key Features</h4>

<p>1. Core engine in place with deployment, description and context
hiarachies and http transport support.</p>

<p>2. Soap processing support</p>

<p>3. Simple http server</p>

<p>4. Client API implementation</p>

<p>5. Couple of working service and client samples</p>
<a name="M0.2"></a>

<h3>08th December 2005 Axis2/C Milestone 0.2 Released</h3>

<p>We have been able to improve OM module since the last release and PHP
binding for OM module is in place.</p>

<h4>Key Features</h4>

<p>1. Improved OM module</p>

<p>2. libxml2 parser support</p>

<p>3. PHP binding for OM module</p>

<p>4. Some test cases for PHP binding</p>

<p>5. Many memory leaks fixes</p>
<a name="M0.1"></a>

<h3>25th November 2005 Axis2/C Milestone 0.1 Released</h3>

<p>This release includes the C implementation of AXIOM, an important part of
Axis2C web service stack.</p>

<h4>Key Features</h4>

<p>1. OM module</p>

<p>2. Guththila pull parser support</p>

<p>3. libxml2 parser support(only reader is supported as of now)</p>

<p>4. doxygen documentation support</p>

<p>5. A sample demonstrating how to use OM</p>
</body>
</html>
