<?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>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 contains information on previous releases running up to the
latest.</p>

<h2>Contents</h2>
<ul>
  <li><a href="#1.0.0">Version 1.0.0 - 06th May 2007</a></li>
  <li><a href="#0.96">Version 0.96 - 22nd December 2006</a></li>
  <li><a href="#0.95">Version 0.95 - 26th October 2006</a></li>
  <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 id="1.0.0"></a>
<h3>06th May 2007 - Apache Axis2/C Version 1.0.0 Released</h3>
    <a href='http://ws.apache.org/axis2/c/download.cgi'>Download 1.0.0</a>
    <h4>Key Features</h4>
    <ol>
      <li>Support for one-way messaging (In-Only) and request response messaging
    (In-Out)</li>
      <li>Client APIs: Easy to use service client API and a more advanced
    operation client API</li>
      <li>Transports supported : HTTP
        <ul>
          <li>Inbuilt HTTP server called simple axis server</li>
          <li>Apache2 HTTPD module called mod_axis2 for the server side</li>
          <li>IIS module for the server side</li>
          <li>Client transport with the ability to enable SSL support</li>
          <li>libcurl based client transport</li>
        </ul>
      </li>
      <li>Module architecture, with a mechanism to extend the SOAP processing
    model</li>
      <li>WS-Addressing support, for both the submission (2004/08) and final
    (2005/08) versions, implemented as a module</li>
      <li>MTOM/XOP support</li>
      <li>AXIOM, which is an XML object model optimized for SOAP 1.1/1.2
    messages. This has complete XML infoset support.</li>
      <li>XML parser abstraction
        <ul>
          <li>Libxml2 wrapper</li>
          <li>Guththila pull parser support</li>
        </ul>
      </li>
      <li>Both directory based and archive based deployment models for deploying
    services and modules</li>
      <li>Description hierarchy providing access to static data of Axis2/C
    runtime (configuration, service groups, services, operations, and
    messages)</li>
      <li>Context hierarchy providing access to dynamic Axis2/C runtime
    information (corresponding contexts mapped to each level of the
    description hierarchy)</li>
      <li>Message receiver abstraction
        <ul>
          <li>Inbuilt raw XML message receiver</li>
        </ul>
      </li>
      <li>Code generation tool for stub and skeleton generation for a given WSDL
    (based on the Java tool)
        <ul>
          <li>Axis Data Binding (ADB) support</li>
        </ul>
      </li>
      <li>Transport proxy support</li>
      <li>REST support (more POX like) using both HTTP POST and GET</li>
      <li>Comprehensive documentation
        <ul>
          <li>Axis2/C Manual</li>
        </ul>
      </li>
    </ol>
    <h4>Major Changes Since Last Release</h4>
    <ol>
      <li>Many Bug Fixes</li>
      <li>IIS module for the server side</li>
      <li>libcurl based client transport</li>
      <li>Improvements to overall API to make it more user friendly, stable, and
    binary compatible</li>
      <li>Transport proxy support</li>
      <li>Memory leak fixes</li>
    </ol>

<a id="0.96"></a>

<h3>22nd December 2006 Axis2/C Version 0.96 Released</h3>
<a href="download.cgi">Download 0.96</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 mapped to each level of the
    description hierarchy)</li>
  <li>Raw XML message receiver</li>
  <li>Module architecture, with a 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 the server
      side</li>
      <li>Client transport with the 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 the 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</li>
  <li>WSDL2C code generation tool- with schema code generation
  (experimental)</li>
  <li>TCP Monitor - C implementation (experimental)</li>
  <li>Axis2/C Manual</li>
</ol>

<h4>Major Changes Since Last Release</h4>
<ol>
  <li>Major Memory leak fixes</li>
  <li>Many Bug Fixes</li>
  <li>Improvement to REST processing</li>
  <li>Improvement to SOAP-Fault processing</li>
  <li>Improvement to mod_axis2 library (plugged with apr pools)</li>
  <li>Visual Studio 7.0 project</li>
</ol>

<h4>Items pending for 1.0</h4>
<ol>
  <li>Complete API documentation and API improvements</li>
  <li>Fix further memory leaks</li>
  <li>Create a comprehensive functional test framework</li>
</ol>
<a id="0.95"></a>

<h3>26th October 2006 Axis2/C Version 0.95 Released</h3>
<a href="download.cgi">Download 0.95</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 mapped to each level of the
    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, for 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 the 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</li>
  <li>WSDL2C code generation tool- with schema code generation
  (experimental)</li>
  <li>TCP Monitor - C implementation (experimental)</li>
  <li>Axis2/C Manual - <strong>New</strong></li>
</ol>

<h4>Major Changes Since Last Release</h4>
<ol>
  <li>Major Memory leak fixes</li>
  <li>Many Bug Fixes</li>
  <li>Improvement to Documentation</li>
</ol>

<h4>Items pending for 1.0</h4>
<ol>
  <li>Complete API documentation and API improvements</li>
  <li>Fix further memory leaks</li>
  <li>Create a comprehensive functional test framework</li>
</ol>
<a id="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 mapped to each level of the
    description hierarchy)</li>
  <li>Raw XML message receiver</li>
  <li>Module architecture, with a mechanism to extend the SOAP processing
    model</li>
  <li>Module version support</li>
  <li>Transports support: HTTP
    <ul>
      <li>Both simple axis server and Apache2 HTTPD module for the server
      side</li>
      <li>Client transport with the 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 the 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 the 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>Items pending for 1.0</h4>
<ol>
  <li>Complete API documentation and API improvements</li>
  <li>Fix further memory leaks</li>
  <li>Create a comprehensive functional test framework</li>
</ol>
<a id="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 mapped to each level of the
    description hierarchy)</li>
  <li>Raw XML message receiver</li>
  <li>Module architecture, with a 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 the server
      side</li>
      <li>Client transport with the 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 the 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 the 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, it consumes the 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 the Sandesha2/C implementation</li>
</ol>

<h4>Items pending 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 id="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, with a 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, for 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>Session 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, it consumes 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 id="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, with a 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, for 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 id="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, with a 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, for 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 was 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>Session 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 the 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 id="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, with a 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>Still to be Done</h4>

<p>See a list of what we think needs to be done, and consider helping out if
you're interested.</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 id="M0.4"></a>

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

<p>We have done a 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 id="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 the 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
hierarchies 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 id="M0.2"></a>

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

<p>We have been able to improve the OM module since the last release, and PHP
binding for the 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 the OM module</p>

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

<p>5. Many memory leak fixes</p>
<a id="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
the 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>
