<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html><head><title>Apache Axis2/C - Archived News</title>
    <h2>Apache Axis2/C Archived News</h2>
    <p>This page contains information on previous releases running up to the
      latest.</p>
    <div class="subsection"><a name="Contents"></a>
      <h3>Contents</h3>
      <ul>
        <li><a href="#1_2_0">Version 1.2.0 - 17th January 2008</a></li>
        <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>
    </div>
<!--############################################################################-->
<div class="subsection"><a name="1_2_0"></a><h3>17th January 2008 - Apache Axis2/C Version 1.2.0 Released</h3><p><a href="http://ws.apache.org/axis2/c/download.cgi" class="externalLink" title="External Link">Download 1.2.0</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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 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 server side</li>
          <li>IIS module for server side</li>
          <li>Client transport with ability to enable SSL support</li>
          <li>Basic HTTP Authentication</li>
          <li>libcurl based client transport</li>
        </ul>
      </li>
      <li>Module architecture, mechanism to extend the SOAP processing model</li>
      <li>WS-Addressing support, both the submission (2004/08) and final (2005/08) versions, implemented as a module</li>
      <li>MTOM/XOP support</li>
      <li>AXIOM, 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 to map to each level of 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 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>
      <li>WS-Policy implementation called Neethi/C, with WS-SecurityPolicy extension</li>
      <li>TCP Transport, for both client and server side </li>
    </ol></div>
<div class="subsection">
  <a name="Major_Changes_Since_Last_Release"></a>
  <h3>Major Changes Since Last Release</h3>
  <ol> 
      <li>WS-Policy implementation</li>
      <li>TCP Transport</li>
      <li>Improvements to Guththila parser to improve performance</li>
      <li>Improvements to Java tool, WSDL2C, that generates C code</li>
      <li>Basic HTTP Authentication</li>
      <li>Memory leak fixes</li>
      <li>Many <a
      href="https://issues.apache.org/jira/browse/AXIS2C/fixforversion/12312520">
      bug fixes</a></li>
    </ol>
</div>
<!--########################################################################-->
<a id="1.0.0"></a>
    <div class="subsection">
      <a name="06th_May_2007_-_Apache_Axis2_C_Version_1_0_0_Released"></a>
      <h3>06th May 2007 - Apache Axis2/C Version 1.0.0 Released</h3>
      <p><a href="http://ws.apache.org/axis2/c/download.cgi" class="externalLink" title="External Link">Download 1.0.0</a></p>
    </div>
    <div class="subsection"><a name="Key_Features"></a>
      <h3>Key Features</h3>
      <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></div><div class="subsection"><a name="Major_Changes_Since_Last_Release"></a><h3>Major Changes Since Last Release</h3><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><p><a id="0.96"></a></p></div><div class="subsection"><a name="22nd_December_2006_Axis2_C_Version_0_96_Released"></a><h3>22nd December 2006 Axis2/C Version 0.96 Released</h3><p><a href="download.cgi">Download 0.96</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Major_Changes_Since_Last_Release"></a><h3>Major Changes Since Last Release</h3><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></div><div class="subsection"><a name="Items_pending_for_1_0"></a><h3>Items pending for 1.0</h3><ol>
        <li>Complete API documentation and API improvements</li>
        <li>Fix further memory leaks</li>
        <li>Create a comprehensive functional test framework</li>
      </ol><p><a id="0.95"></a></p></div><div class="subsection"><a name="26th_October_2006_Axis2_C_Version_0_95_Released"></a><h3>26th October 2006 Axis2/C Version 0.95 Released</h3><p><a href="download.cgi">Download 0.95</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Major_Changes_Since_Last_Release"></a><h3>Major Changes Since Last Release</h3><ol>
        <li>Major Memory leak fixes</li>
        <li>Many Bug Fixes</li>
        <li>Improvement to Documentation</li>
    </ol></div><div class="subsection"><a name="Items_pending_for_1_0"></a><h3>Items pending for 1.0</h3><ol>
        <li>Complete API documentation and API improvements</li>
        <li>Fix further memory leaks</li>
        <li>Create a comprehensive functional test framework</li>
      </ol><p><a id="0.94"></a></p></div><div class="subsection"><a name="3rd_October_2006_Axis2_C_Version_0_94_Released"></a><h3>3rd October 2006 Axis2/C Version 0.94 Released</h3><p><a href="download.cgi">Download 0.94</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Major_Changes_Since_Last_Release"></a><h3>Major Changes Since Last Release</h3><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></div><div class="subsection"><a name="Items_pending_for_1_0"></a><h3>Items pending for 1.0</h3><ol>
        <li>Complete API documentation and API improvements</li>
        <li>Fix further memory leaks</li>
        <li>Create a comprehensive functional test framework</li>
      </ol><p><a id="0.93"></a></p></div><div class="subsection"><a name="31st_August_2006_Axis2_C_Version_0_93_Released"></a><h3>31st August 2006 Axis2/C Version 0.93 Released</h3><p><a href="download.cgi">Download 0.93</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Major_Changes_Since_Last_Release"></a><h3>Major Changes Since Last Release</h3><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></div><div class="subsection"><a name="Items_pending_for_1_0"></a><h3>Items pending for 1.0</h3><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><p><a id="0.92"></a></p></div><div class="subsection"><a name="16th_June_2006_Axis2_C_Version_0_92_Released"></a><h3>16th June 2006 Axis2/C Version 0.92 Released</h3><p><a href="download.cgi">Download 0.92</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Major_Changes_Since_Last_Release"></a><h3>Major Changes Since Last Release</h3><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></div><div class="subsection"><a name="Un-Implemented_Architecture_Features__TBD_in_1_0_"></a><h3>Un-Implemented Architecture Features (TBD in 1.0)</h3><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></div><div class="subsection"><a name="Un-Implemented_Architecture_Features__TBD_post_1_0_"></a><h3>Un-Implemented Architecture Features (TBD post 1.0)</h3><ol>
        <li>Security module with encryption and signing</li>
        <li>Server side Web Service Policy support</li>
        <li>C2WSDL</li>
        <li>WSDL2C</li>
      </ol><p><a id="0.91"></a></p></div><div class="subsection"><a name="15th_May_2006_Axis2_C_Version_0_91_Released"></a><h3>15th May 2006 Axis2/C Version 0.91 Released</h3><p><a href="download.cgi">Download 0.91</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Other_notes"></a><h3>Other notes</h3><ol>
        <li>Interoperability tested with Axis2/Java for XML in/out client and
          services</li>
        <li>Addressing 1.0 interoperability</li>
    </ol></div><div class="subsection"><a name="Major_changes_since_last_release"></a><h3>Major changes since last release</h3><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></div><div class="subsection"><a name="Un-Implemented_Architecture_Features__TBD_in_1_0_"></a><h3>Un-Implemented Architecture Features (TBD in 1.0)</h3><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></div><div class="subsection"><a name="Un-Implemented_Architecture_Features__TBD_post_1_0_"></a><h3>Un-Implemented Architecture Features (TBD post 1.0)</h3><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><p><a id="0.90"></a></p></div><div class="subsection"><a name="31st_March_2006_Axis2_C_Version_0_90_Released"></a><h3>31st March 2006 Axis2/C Version 0.90 Released</h3><p><a href="download.cgi">Download 0.90</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Experimental_Features"></a><h3>Experimental Features</h3><ol>
        <li>WSDL object model support <strong>New</strong>
          <ul>
            <li>Dynamic invocation</li>
          </ul>
        </li>
    </ol></div><div class="subsection"><a name="Other_notes"></a><h3>Other notes</h3><ol>
        <li>Interoperability tested with Axis2/Java for XML in/out client and
          services</li>
        <li>Addressing interoperability on client side</li>
    </ol></div><div class="subsection"><a name="Major_changes_since_last_release"></a><h3>Major changes since last release</h3><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></div><div class="subsection"><a name="Un-Implemented_Architecture_Features__TBD_in_1_0_"></a><h3>Un-Implemented Architecture Features (TBD in 1.0)</h3><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></div><div class="subsection"><a name="Un-Implemented_Architecture_Features__TBD_post_1_0_"></a><h3>Un-Implemented Architecture Features (TBD post 1.0)</h3><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><p><a id="M0.5"></a></p></div><div class="subsection"><a name="10th_March_2006_Axis2_C_Milestone_0_5_Released"></a><h3>10th March 2006 Axis2/C Milestone 0.5 Released</h3><p><a href="download.cgi">Download M-0.5</a></p></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div><div class="subsection"><a name="Major_Changes_Since_the_Last_Release"></a><h3>Major Changes Since the Last Release</h3><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></div><div class="subsection"><a name="Still_to_be_Done"></a><h3>Still to be Done</h3><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><p><a id="M0.4"></a></p></div><div class="subsection"><a name="17th_February_2006_Axis2_C_Milestone_0_4_Released"></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></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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><p><a id="M0.3"></a></p></div><div class="subsection"><a name="02nd_February_2006_Axis2_C_Milestone_0_3_Released"></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></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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><p><a id="M0.2"></a></p></div><div class="subsection"><a name="08th_December_2005_Axis2_C_Milestone_0_2_Released"></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></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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><p><a id="M0.1"></a></p></div><div class="subsection"><a name="25th_November_2005_Axis2_C_Milestone_0_1_Released"></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></div><div class="subsection"><a name="Key_Features"></a><h3>Key Features</h3><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></div></div></div></div><div class="clear"><hr></hr></div></body></html>
