axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r580207 [2/3] - in /webservices/axis2/trunk/c/util/src: ./ minizip/ platforms/unix/
Date Fri, 28 Sep 2007 03:28:09 GMT
Modified: webservices/axis2/trunk/c/util/src/minizip/ioapi.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/util/src/minizip/ioapi.c?rev=580207&r1=580206&r2=580207&view=diff
==============================================================================
--- webservices/axis2/trunk/c/util/src/minizip/ioapi.c (original)
+++ webservices/axis2/trunk/c/util/src/minizip/ioapi.c Thu Sep 27 20:28:06 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +16,6 @@
  * limitations under the License.
  */
 
-
 /* ioapi.c -- IO base function header for compress/uncompress .zip
    files using zlib + zip or unzip API
 
@@ -31,8 +31,6 @@
 #include "zlib.h"
 #include "axis2_ioapi.h"
 
-
-
 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
 
 #ifndef SEEK_CUR
@@ -47,143 +45,168 @@
 #define SEEK_SET    0
 #endif
 
-voidpf ZCALLBACK fopen_file_func OF((
-            voidpf opaque,
-            const char* filename,
-            int mode));
-
-uLong ZCALLBACK fread_file_func OF((
-            voidpf opaque,
-            voidpf stream,
-            void* buf,
-            uLong size));
-
-uLong ZCALLBACK fwrite_file_func OF((
-            voidpf opaque,
-            voidpf stream,
-            const void* buf,
-            uLong size));
-
-long ZCALLBACK ftell_file_func OF((
-            voidpf opaque,
-            voidpf stream));
-
-long ZCALLBACK fseek_file_func OF((
-            voidpf opaque,
-            voidpf stream,
-            uLong offset,
-            int origin));
-
-int ZCALLBACK fclose_file_func OF((
-            voidpf opaque,
-            voidpf stream));
-
-int ZCALLBACK ferror_file_func OF((
-            voidpf opaque,
-            voidpf stream));
-
-
-voidpf ZCALLBACK fopen_file_func(opaque, filename, mode)
-voidpf opaque;
-const char* filename;
-int mode;
+voidpf ZCALLBACK fopen_file_func OF(
+     (voidpf opaque,
+      const char *filename,
+      int mode));
+
+uLong ZCALLBACK fread_file_func OF(
+     (voidpf opaque,
+      voidpf stream,
+      void *buf,
+      uLong size));
+
+uLong ZCALLBACK fwrite_file_func OF(
+     (voidpf opaque,
+      voidpf stream,
+      const void *buf,
+      uLong size));
+
+long ZCALLBACK ftell_file_func OF(
+     (voidpf opaque,
+      voidpf stream));
+
+long ZCALLBACK fseek_file_func OF(
+     (voidpf opaque,
+      voidpf stream,
+      uLong offset,
+      int origin));
+
+int ZCALLBACK fclose_file_func OF(
+     (voidpf opaque,
+      voidpf stream));
+
+int ZCALLBACK ferror_file_func OF(
+     (voidpf opaque,
+      voidpf stream));
+
+voidpf ZCALLBACK
+fopen_file_func(
+    opaque,
+    filename,
+    mode)
+    voidpf opaque;
+    const char *filename;
+    int mode;
 {
-    FILE* file = NULL;
-    const char* mode_fopen = NULL;
+    FILE *file = NULL;
+    const char *mode_fopen = NULL;
     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
         mode_fopen = "rb";
-    else
-        if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
-            mode_fopen = "r+b";
-        else
-            if (mode & ZLIB_FILEFUNC_MODE_CREATE)
-                mode_fopen = "wb";
+    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
 
     if ((filename) && (mode_fopen != NULL))
         file = fopen(filename, mode_fopen);
     return file;
 }
 
-
-uLong ZCALLBACK fread_file_func(opaque, stream, buf, size)
-voidpf opaque;
-voidpf stream;
-void* buf;
-uLong size;
+uLong ZCALLBACK
+fread_file_func(
+    opaque,
+    stream,
+    buf,
+    size)
+    voidpf opaque;
+    voidpf stream;
+    void *buf;
+    uLong size;
 {
     uLong ret;
-    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    ret = (uLong) fread(buf, 1, (size_t) size, (FILE *) stream);
     return ret;
 }
 
-
-uLong ZCALLBACK fwrite_file_func(opaque, stream, buf, size)
-voidpf opaque;
-voidpf stream;
-const void* buf;
-uLong size;
+uLong ZCALLBACK
+fwrite_file_func(
+    opaque,
+    stream,
+    buf,
+    size)
+    voidpf opaque;
+    voidpf stream;
+    const void *buf;
+    uLong size;
 {
     uLong ret;
-    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    ret = (uLong) fwrite(buf, 1, (size_t) size, (FILE *) stream);
     return ret;
 }
 
-long ZCALLBACK ftell_file_func(opaque, stream)
-voidpf opaque;
-voidpf stream;
+long ZCALLBACK
+ftell_file_func(
+    opaque,
+    stream)
+    voidpf opaque;
+    voidpf stream;
 {
     long ret;
-    ret = ftell((FILE *)stream);
+    ret = ftell((FILE *) stream);
     return ret;
 }
 
-long ZCALLBACK fseek_file_func(opaque, stream, offset, origin)
-voidpf opaque;
-voidpf stream;
-uLong offset;
-int origin;
+long ZCALLBACK
+fseek_file_func(
+    opaque,
+    stream,
+    offset,
+    origin)
+    voidpf opaque;
+    voidpf stream;
+    uLong offset;
+    int origin;
 {
     int fseek_origin = 0;
     long ret;
     switch (origin)
     {
-        case ZLIB_FILEFUNC_SEEK_CUR :
-            fseek_origin = SEEK_CUR;
-            break;
-        case ZLIB_FILEFUNC_SEEK_END :
-            fseek_origin = SEEK_END;
-            break;
-        case ZLIB_FILEFUNC_SEEK_SET :
-            fseek_origin = SEEK_SET;
-            break;
-        default:
-            return -1;
+    case ZLIB_FILEFUNC_SEEK_CUR:
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END:
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET:
+        fseek_origin = SEEK_SET;
+        break;
+    default:
+        return -1;
     }
     ret = 0;
-    fseek((FILE *)stream, offset, fseek_origin);
+    fseek((FILE *) stream, offset, fseek_origin);
     return ret;
 }
 
-int ZCALLBACK fclose_file_func(opaque, stream)
-voidpf opaque;
-voidpf stream;
+int ZCALLBACK
+fclose_file_func(
+    opaque,
+    stream)
+    voidpf opaque;
+    voidpf stream;
 {
     int ret;
-    ret = fclose((FILE *)stream);
+    ret = fclose((FILE *) stream);
     return ret;
 }
 
-int ZCALLBACK ferror_file_func(opaque, stream)
-voidpf opaque;
-voidpf stream;
+int ZCALLBACK
+ferror_file_func(
+    opaque,
+    stream)
+    voidpf opaque;
+    voidpf stream;
 {
     int ret;
-    ret = ferror((FILE *)stream);
+    ret = ferror((FILE *) stream);
     return ret;
 }
 
-void fill_fopen_filefunc(pzlib_filefunc_def)
-zlib_filefunc_def* pzlib_filefunc_def;
+void
+fill_fopen_filefunc(
+    pzlib_filefunc_def)
+    zlib_filefunc_def *pzlib_filefunc_def;
 {
     pzlib_filefunc_def->zopen_file = fopen_file_func;
     pzlib_filefunc_def->zread_file = fread_file_func;

Modified: webservices/axis2/trunk/c/util/src/minizip/iowin32.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/util/src/minizip/iowin32.c?rev=580207&r1=580206&r2=580207&view=diff
==============================================================================
--- webservices/axis2/trunk/c/util/src/minizip/iowin32.c (original)
+++ webservices/axis2/trunk/c/util/src/minizip/iowin32.c Thu Sep 27 20:28:06 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -38,40 +39,40 @@
 #define INVALID_SET_FILE_POINTER ((DWORD)-1)
 #endif
 
-voidpf ZCALLBACK win32_open_file_func OF((
-            voidpf opaque,
-            const char* filename,
-            int mode));
-
-uLong ZCALLBACK win32_read_file_func OF((
-            voidpf opaque,
-            voidpf stream,
-            void* buf,
-            uLong size));
-
-uLong ZCALLBACK win32_write_file_func OF((
-            voidpf opaque,
-            voidpf stream,
-            const void* buf,
-            uLong size));
-
-long ZCALLBACK win32_tell_file_func OF((
-            voidpf opaque,
-            voidpf stream));
-
-long ZCALLBACK win32_seek_file_func OF((
-            voidpf opaque,
-            voidpf stream,
-            uLong offset,
-            int origin));
-
-int ZCALLBACK win32_close_file_func OF((
-            voidpf opaque,
-            voidpf stream));
-
-int ZCALLBACK win32_error_file_func OF((
-            voidpf opaque,
-            voidpf stream));
+voidpf ZCALLBACK win32_open_file_func OF(
+     (voidpf opaque,
+      const char *filename,
+      int mode));
+
+uLong ZCALLBACK win32_read_file_func OF(
+     (voidpf opaque,
+      voidpf stream,
+      void *buf,
+      uLong size));
+
+uLong ZCALLBACK win32_write_file_func OF(
+     (voidpf opaque,
+      voidpf stream,
+      const void *buf,
+      uLong size));
+
+long ZCALLBACK win32_tell_file_func OF(
+     (voidpf opaque,
+      voidpf stream));
+
+long ZCALLBACK win32_seek_file_func OF(
+     (voidpf opaque,
+      voidpf stream,
+      uLong offset,
+      int origin));
+
+int ZCALLBACK win32_close_file_func OF(
+     (voidpf opaque,
+      voidpf stream));
+
+int ZCALLBACK win32_error_file_func OF(
+     (voidpf opaque,
+      voidpf stream));
 
 typedef struct
 {
@@ -80,13 +81,20 @@
 }
 WIN32FILE_IOWIN;
 
-voidpf ZCALLBACK win32_open_file_func(opaque, filename, mode)
-voidpf opaque;
-const char* filename;
-int mode;
+voidpf ZCALLBACK
+win32_open_file_func(
+    opaque,
+    filename,
+    mode)
+    voidpf opaque;
+    const char *filename;
+    int mode;
 {
-    const char* mode_fopen = NULL;
-    DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes ;
+    const char *mode_fopen = NULL;
+    DWORD dwDesiredAccess,
+     dwCreationDisposition,
+     dwShareMode,
+     dwFlagsAndAttributes;
     HANDLE hFile = 0;
     voidpf ret = NULL;
 
@@ -98,22 +106,21 @@
         dwCreationDisposition = OPEN_EXISTING;
         dwShareMode = FILE_SHARE_READ;
     }
-    else
-        if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
-        {
-            dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
-            dwCreationDisposition = OPEN_EXISTING;
-        }
-        else
-            if (mode & ZLIB_FILEFUNC_MODE_CREATE)
-            {
-                dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
-                dwCreationDisposition = CREATE_ALWAYS;
-            }
+    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+    {
+        dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+        dwCreationDisposition = OPEN_EXISTING;
+    }
+    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+    {
+        dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+        dwCreationDisposition = CREATE_ALWAYS;
+    }
 
     if ((filename) && (dwDesiredAccess != 0))
-        hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
-                dwCreationDisposition, dwFlagsAndAttributes, NULL);
+        hFile =
+            CreateFile((LPCTSTR) filename, dwDesiredAccess, dwShareMode, NULL,
+                       dwCreationDisposition, dwFlagsAndAttributes, NULL);
 
     if (hFile == INVALID_HANDLE_VALUE)
         hFile = NULL;
@@ -126,45 +133,54 @@
         ret = malloc(sizeof(WIN32FILE_IOWIN));
         if (ret == NULL)
             CloseHandle(hFile);
-        else *((WIN32FILE_IOWIN*)ret) = w32fiow;
+        else
+            *((WIN32FILE_IOWIN *) ret) = w32fiow;
     }
     return ret;
 }
 
-
-uLong ZCALLBACK win32_read_file_func(opaque, stream, buf, size)
-voidpf opaque;
-voidpf stream;
-void* buf;
-uLong size;
+uLong ZCALLBACK
+win32_read_file_func(
+    opaque,
+    stream,
+    buf,
+    size)
+    voidpf opaque;
+    voidpf stream;
+    void *buf;
+    uLong size;
 {
     uLong ret = 0;
     HANDLE hFile = NULL;
     if (stream)
-        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+        hFile = ((WIN32FILE_IOWIN *) stream)->hf;
     if (hFile)
         if (!ReadFile(hFile, buf, size, &ret, NULL))
         {
             DWORD dwErr = GetLastError();
             if (dwErr == ERROR_HANDLE_EOF)
                 dwErr = 0;
-            ((WIN32FILE_IOWIN*)stream) -> error = (int)dwErr;
+            ((WIN32FILE_IOWIN *) stream)->error = (int) dwErr;
         }
 
     return ret;
 }
 
-
-uLong ZCALLBACK win32_write_file_func(opaque, stream, buf, size)
-voidpf opaque;
-voidpf stream;
-const void* buf;
-uLong size;
+uLong ZCALLBACK
+win32_write_file_func(
+    opaque,
+    stream,
+    buf,
+    size)
+    voidpf opaque;
+    voidpf stream;
+    const void *buf;
+    uLong size;
 {
     uLong ret = 0;
     HANDLE hFile = NULL;
     if (stream)
-        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+        hFile = ((WIN32FILE_IOWIN *) stream)->hf;
 
     if (hFile)
         if (!WriteFile(hFile, buf, size, &ret, NULL))
@@ -172,60 +188,68 @@
             DWORD dwErr = GetLastError();
             if (dwErr == ERROR_HANDLE_EOF)
                 dwErr = 0;
-            ((WIN32FILE_IOWIN*)stream) -> error = (int)dwErr;
+            ((WIN32FILE_IOWIN *) stream)->error = (int) dwErr;
         }
 
     return ret;
 }
 
-long ZCALLBACK win32_tell_file_func(opaque, stream)
-voidpf opaque;
-voidpf stream;
+long ZCALLBACK
+win32_tell_file_func(
+    opaque,
+    stream)
+    voidpf opaque;
+    voidpf stream;
 {
     long ret = -1;
     HANDLE hFile = NULL;
     if (stream)
-        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+        hFile = ((WIN32FILE_IOWIN *) stream)->hf;
     if (hFile)
     {
         DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
         if (dwSet == INVALID_SET_FILE_POINTER)
         {
             DWORD dwErr = GetLastError();
-            ((WIN32FILE_IOWIN*)stream) -> error = (int)dwErr;
+            ((WIN32FILE_IOWIN *) stream)->error = (int) dwErr;
             ret = -1;
         }
         else
-            ret = (long)dwSet;
+            ret = (long) dwSet;
     }
     return ret;
 }
 
-long ZCALLBACK win32_seek_file_func(opaque, stream, offset, origin)
-voidpf opaque;
-voidpf stream;
-uLong offset;
-int origin;
+long ZCALLBACK
+win32_seek_file_func(
+    opaque,
+    stream,
+    offset,
+    origin)
+    voidpf opaque;
+    voidpf stream;
+    uLong offset;
+    int origin;
 {
     DWORD dwMoveMethod = 0xFFFFFFFF;
     HANDLE hFile = NULL;
 
     long ret = -1;
     if (stream)
-        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+        hFile = ((WIN32FILE_IOWIN *) stream)->hf;
     switch (origin)
     {
-        case ZLIB_FILEFUNC_SEEK_CUR :
-            dwMoveMethod = FILE_CURRENT;
-            break;
-        case ZLIB_FILEFUNC_SEEK_END :
-            dwMoveMethod = FILE_END;
-            break;
-        case ZLIB_FILEFUNC_SEEK_SET :
-            dwMoveMethod = FILE_BEGIN;
-            break;
-        default:
-            return -1;
+    case ZLIB_FILEFUNC_SEEK_CUR:
+        dwMoveMethod = FILE_CURRENT;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END:
+        dwMoveMethod = FILE_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET:
+        dwMoveMethod = FILE_BEGIN;
+        break;
+    default:
+        return -1;
     }
 
     if (hFile)
@@ -234,7 +258,7 @@
         if (dwSet == INVALID_SET_FILE_POINTER)
         {
             DWORD dwErr = GetLastError();
-            ((WIN32FILE_IOWIN*)stream) -> error = (int)dwErr;
+            ((WIN32FILE_IOWIN *) stream)->error = (int) dwErr;
             ret = -1;
         }
         else
@@ -243,16 +267,19 @@
     return ret;
 }
 
-int ZCALLBACK win32_close_file_func(opaque, stream)
-voidpf opaque;
-voidpf stream;
+int ZCALLBACK
+win32_close_file_func(
+    opaque,
+    stream)
+    voidpf opaque;
+    voidpf stream;
 {
     int ret = -1;
 
     if (stream)
     {
         HANDLE hFile;
-        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+        hFile = ((WIN32FILE_IOWIN *) stream)->hf;
         if (hFile)
         {
             CloseHandle(hFile);
@@ -263,20 +290,25 @@
     return ret;
 }
 
-int ZCALLBACK win32_error_file_func(opaque, stream)
-voidpf opaque;
-voidpf stream;
+int ZCALLBACK
+win32_error_file_func(
+    opaque,
+    stream)
+    voidpf opaque;
+    voidpf stream;
 {
     int ret = -1;
     if (stream)
     {
-        ret = ((WIN32FILE_IOWIN*)stream) -> error;
+        ret = ((WIN32FILE_IOWIN *) stream)->error;
     }
     return ret;
 }
 
-void fill_win32_filefunc(pzlib_filefunc_def)
-zlib_filefunc_def* pzlib_filefunc_def;
+void
+fill_win32_filefunc(
+    pzlib_filefunc_def)
+    zlib_filefunc_def *pzlib_filefunc_def;
 {
     pzlib_filefunc_def->zopen_file = win32_open_file_func;
     pzlib_filefunc_def->zread_file = win32_read_file_func;

Modified: webservices/axis2/trunk/c/util/src/minizip/unzip.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/util/src/minizip/unzip.c?rev=580207&r1=580206&r2=580207&view=diff
==============================================================================
--- webservices/axis2/trunk/c/util/src/minizip/unzip.c (original)
+++ webservices/axis2/trunk/c/util/src/minizip/unzip.c Thu Sep 27 20:28:06 2007
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +16,6 @@
  * limitations under the License.
  */
 
-
 /* unzip.c -- IO for uncompress .zip files using zlib
    Version 1.01e, February 12th, 2005
 
@@ -28,6 +28,7 @@
 compatibility with older software. The following is from the original crypt.c. Code
 woven in by Terry Thorsen 1/2003.
 */
+
 /*
   Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
 
@@ -36,6 +37,7 @@
   If, for some reason, all these files are missing, the Info-ZIP license
   also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
 */
+
 /*
   crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
 
@@ -52,7 +54,6 @@
   version without encryption capabilities).
  */
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -70,12 +71,11 @@
 #   include <errno.h>
 #endif
 
-
 #ifndef local
 #  define local static
 #endif
-/* compile with -Dlocal if your debugger can't find static symbols */
 
+/* compile with -Dlocal if your debugger can't find static symbols */
 
 #ifndef CASESENSITIVITYDEFAULT_NO
 #  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
@@ -83,7 +83,6 @@
 #  endif
 #endif
 
-
 #ifndef UNZ_BUFSIZE
 #define UNZ_BUFSIZE (16384)
 #endif
@@ -102,77 +101,71 @@
 #define SIZECENTRALDIRITEM (0x2e)
 #define SIZEZIPLOCALHEADER (0x1e)
 
-
-
-
 const char unz_copyright[] =
     " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
 
 /* unz_file_info_interntal contain internal info about a file in zipfile*/
 typedef struct unz_file_info_internal_s
 {
-    uLong offset_curfile;/* relative offset of local header 4 bytes */
+    uLong offset_curfile;       /* relative offset of local header 4 bytes */
 }
 unz_file_info_internal;
 
-
 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
     when reading and decompress it */
 typedef struct
 {
-    char  *read_buffer;         /* internal buffer for compressed data */
+    char *read_buffer;          /* internal buffer for compressed data */
     z_stream stream;            /* zLib stream structure for inflate */
 
-    uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
-    uLong stream_initialised;   /* flag set if stream structure is initialised*/
+    uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek */
+    uLong stream_initialised;   /* flag set if stream structure is initialised */
 
-    uLong offset_local_extrafield;/* offset of the local extra field */
-    uInt  size_local_extrafield;/* size of the local extra field */
-    uLong pos_local_extrafield;   /* position in the local extra field in read*/
+    uLong offset_local_extrafield;  /* offset of the local extra field */
+    uInt size_local_extrafield; /* size of the local extra field */
+    uLong pos_local_extrafield; /* position in the local extra field in read */
 
     uLong crc32;                /* crc32 of all data uncompressed */
     uLong crc32_wait;           /* crc32 we must obtain after decompress all */
     uLong rest_read_compressed; /* number of byte to be decompressed */
-    uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
+    uLong rest_read_uncompressed;   /*number of byte to be obtained after decomp */
     zlib_filefunc_def z_filefunc;
-    voidpf filestream;        /* io structore of the zipfile */
+    voidpf filestream;          /* io structore of the zipfile */
     uLong compression_method;   /* compression method (0==store) */
-    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
-    int   raw;
+    uLong byte_before_the_zipfile;  /* byte before the zipfile, (>0 for sfx) */
+    int raw;
 }
 file_in_zip_read_info_s;
 
-
 /* unz_s contain internal information about the zipfile
 */
 typedef struct
 {
     zlib_filefunc_def z_filefunc;
-    voidpf filestream;        /* io structore of the zipfile */
-    unz_global_info gi;       /* public global information */
-    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
-    uLong num_file;             /* number of the current file in the zipfile*/
-    uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
-    uLong current_file_ok;      /* flag about the usability of the current file*/
-    uLong central_pos;          /* position of the beginning of the central dir*/
+    voidpf filestream;          /* io structore of the zipfile */
+    unz_global_info gi;         /* public global information */
+    uLong byte_before_the_zipfile;  /* byte before the zipfile, (>0 for sfx) */
+    uLong num_file;             /* number of the current file in the zipfile */
+    uLong pos_in_central_dir;   /* pos of the current file in the central dir */
+    uLong current_file_ok;      /* flag about the usability of the current file */
+    uLong central_pos;          /* position of the beginning of the central dir */
 
     uLong size_central_dir;     /* size of the central directory  */
     uLong offset_central_dir;   /* offset of start of central directory with
-                                                   respect to the starting disk number */
+                                   respect to the starting disk number */
 
-    unz_file_info cur_file_info; /* public info about the current file in zip*/
-    unz_file_info_internal cur_file_info_internal; /* private info about it*/
-    file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
-                                                        file if we are decompressing it */
+    unz_file_info cur_file_info;    /* public info about the current file in zip */
+    unz_file_info_internal cur_file_info_internal;  /* private info about it */
+    file_in_zip_read_info_s *pfile_in_zip_read; /* structure about the current
+                                                   file if we are decompressing it */
     int encrypted;
 #    ifndef NOUNCRYPT
-    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
-    const unsigned long* pcrc_32_tab;
+    unsigned long keys[3];      /* keys defining the pseudo-random sequence */
+    const unsigned long *pcrc_32_tab;
 #    endif
 }
 unz_s;
 
-
 #ifndef NOUNCRYPT
 #include <axis2_crypt.h>
 #endif
@@ -183,22 +176,25 @@
    IN assertion: the stream s has been sucessfully opened for reading.
 */
 
-
-local int unzlocal_getByte OF((
-            const zlib_filefunc_def* pzlib_filefunc_def,
-            voidpf filestream,
-            int *pi));
-
-local int unzlocal_getByte(pzlib_filefunc_def, filestream, pi)
-const zlib_filefunc_def* pzlib_filefunc_def;
-voidpf filestream;
-int *pi;
+local int unzlocal_getByte OF(
+     (const zlib_filefunc_def * pzlib_filefunc_def,
+      voidpf filestream,
+      int *pi));
+
+local int
+unzlocal_getByte(
+    pzlib_filefunc_def,
+    filestream,
+    pi)
+    const zlib_filefunc_def *pzlib_filefunc_def;
+    voidpf filestream;
+    int *pi;
 {
     unsigned char c;
-    int err = (int)ZREAD(*pzlib_filefunc_def, filestream, &c, 1);
+    int err = (int) ZREAD(*pzlib_filefunc_def, filestream, &c, 1);
     if (err == 1)
     {
-        *pi = (int)c;
+        *pi = (int) c;
         return UNZ_OK;
     }
     else
@@ -210,30 +206,33 @@
     }
 }
 
-
 /* ===========================================================================
    Reads a long in LSB order from the given gz_stream. Sets
 */
-local int unzlocal_getShort OF((
-            const zlib_filefunc_def* pzlib_filefunc_def,
-            voidpf filestream,
-            uLong *pX));
-
-local int unzlocal_getShort(pzlib_filefunc_def, filestream, pX)
-const zlib_filefunc_def* pzlib_filefunc_def;
-voidpf filestream;
-uLong *pX;
+local int unzlocal_getShort OF(
+     (const zlib_filefunc_def * pzlib_filefunc_def,
+      voidpf filestream,
+      uLong * pX));
+
+local int
+unzlocal_getShort(
+    pzlib_filefunc_def,
+    filestream,
+    pX)
+    const zlib_filefunc_def *pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
 {
-    uLong x ;
+    uLong x;
     int i = 0;
     int err = 0;
 
     err = unzlocal_getByte(pzlib_filefunc_def, filestream, &i);
-    x = (uLong)i;
+    x = (uLong) i;
 
     if (err == UNZ_OK)
         err = unzlocal_getByte(pzlib_filefunc_def, filestream, &i);
-    x += ((uLong)i) << 8;
+    x += ((uLong) i) << 8;
 
     if (err == UNZ_OK)
         *pX = x;
@@ -242,34 +241,38 @@
     return err;
 }
 
-local int unzlocal_getLong OF((
-            const zlib_filefunc_def* pzlib_filefunc_def,
-            voidpf filestream,
-            uLong *pX));
-
-local int unzlocal_getLong(pzlib_filefunc_def, filestream, pX)
-const zlib_filefunc_def* pzlib_filefunc_def;
-voidpf filestream;
-uLong *pX;
+local int unzlocal_getLong OF(
+     (const zlib_filefunc_def * pzlib_filefunc_def,
+      voidpf filestream,
+      uLong * pX));
+
+local int
+unzlocal_getLong(
+    pzlib_filefunc_def,
+    filestream,
+    pX)
+    const zlib_filefunc_def *pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
 {
-    uLong x ;
+    uLong x;
     int i = 0;
     int err = 0;
 
     err = unzlocal_getByte(pzlib_filefunc_def, filestream, &i);
-    x = (uLong)i;
+    x = (uLong) i;
 
     if (err == UNZ_OK)
         err = unzlocal_getByte(pzlib_filefunc_def, filestream, &i);
-    x += ((uLong)i) << 8;
+    x += ((uLong) i) << 8;
 
     if (err == UNZ_OK)
         err = unzlocal_getByte(pzlib_filefunc_def, filestream, &i);
-    x += ((uLong)i) << 16;
+    x += ((uLong) i) << 16;
 
     if (err == UNZ_OK)
         err = unzlocal_getByte(pzlib_filefunc_def, filestream, &i);
-    x += ((uLong)i) << 24;
+    x += ((uLong) i) << 24;
 
     if (err == UNZ_OK)
         *pX = x;
@@ -278,11 +281,13 @@
     return err;
 }
 
-
 /* My own strcmpi / strcasecmp */
-local int strcmpcasenosensitive_internal(fileName1, fileName2)
-const char* fileName1;
-const char* fileName2;
+local int
+strcmpcasenosensitive_internal(
+    fileName1,
+    fileName2)
+    const char *fileName1;
+    const char *fileName2;
 {
     for (;;)
     {
@@ -303,7 +308,6 @@
     }
 }
 
-
 #ifdef  CASESENSITIVITYDEFAULT_NO
 #define CASESENSITIVITYDEFAULTVALUE 2
 #else
@@ -323,10 +327,14 @@
         (like 1 on Unix, 2 on Windows)
 
 */
-extern int ZEXPORT unzStringFileNameCompare(fileName1, fileName2, iCaseSensitivity)
-    const char* fileName1;
-const char* fileName2;
-int iCaseSensitivity;
+extern int ZEXPORT
+unzStringFileNameCompare(
+    fileName1,
+    fileName2,
+    iCaseSensitivity)
+    const char *fileName1;
+    const char *fileName2;
+    int iCaseSensitivity;
 {
     if (iCaseSensitivity == 0)
         iCaseSensitivity = CASESENSITIVITYDEFAULTVALUE;
@@ -345,55 +353,60 @@
   Locate the Central directory of a zipfile (at the end, just before
     the global comment)
 */
-local uLong unzlocal_SearchCentralDir OF((
-            const zlib_filefunc_def* pzlib_filefunc_def,
-            voidpf filestream));
-
-local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def, filestream)
-const zlib_filefunc_def* pzlib_filefunc_def;
-voidpf filestream;
+local uLong unzlocal_SearchCentralDir OF(
+     (const zlib_filefunc_def * pzlib_filefunc_def,
+      voidpf filestream));
+
+local uLong
+unzlocal_SearchCentralDir(
+    pzlib_filefunc_def,
+    filestream)
+    const zlib_filefunc_def *pzlib_filefunc_def;
+    voidpf filestream;
 {
-    unsigned char* buf;
+    unsigned char *buf;
     uLong uSizeFile;
     uLong uBackRead;
-    uLong uMaxBack = 0xffff; /* maximum size of global comment */
+    uLong uMaxBack = 0xffff;    /* maximum size of global comment */
     uLong uPosFound = 0;
 
     if (ZSEEK(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0)
         return 0;
 
-
     uSizeFile = ZTELL(*pzlib_filefunc_def, filestream);
 
     if (uMaxBack > uSizeFile)
         uMaxBack = uSizeFile;
 
-    buf = (unsigned char*)ALLOC(BUFREADCOMMENT + 4);
+    buf = (unsigned char *) ALLOC(BUFREADCOMMENT + 4);
     if (buf == NULL)
         return 0;
 
     uBackRead = 4;
     while (uBackRead < uMaxBack)
     {
-        uLong uReadSize, uReadPos ;
+        uLong uReadSize,
+         uReadPos;
         int i = 0;
         if (uBackRead + BUFREADCOMMENT > uMaxBack)
             uBackRead = uMaxBack;
         else
             uBackRead += BUFREADCOMMENT;
-        uReadPos = uSizeFile - uBackRead ;
+        uReadPos = uSizeFile - uBackRead;
 
         uReadSize = ((BUFREADCOMMENT + 4) < (uSizeFile - uReadPos)) ?
-                (BUFREADCOMMENT + 4) : (uSizeFile - uReadPos);
-        if (ZSEEK(*pzlib_filefunc_def, filestream, uReadPos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+            (BUFREADCOMMENT + 4) : (uSizeFile - uReadPos);
+        if (ZSEEK
+            (*pzlib_filefunc_def, filestream, uReadPos,
+             ZLIB_FILEFUNC_SEEK_SET) != 0)
             break;
 
         if (ZREAD(*pzlib_filefunc_def, filestream, buf, uReadSize) != uReadSize)
             break;
 
-        for (i = (int)uReadSize - 3; (i--) > 0;)
+        for (i = (int) uReadSize - 3; (i--) > 0;)
             if (((*(buf + i)) == 0x50) && ((*(buf + i + 1)) == 0x4b) &&
-                    ((*(buf + i + 2)) == 0x05) && ((*(buf + i + 3)) == 0x06))
+                ((*(buf + i + 2)) == 0x05) && ((*(buf + i + 3)) == 0x06))
             {
                 uPosFound = uReadPos + i;
                 break;
@@ -415,21 +428,25 @@
      Else, the return value is a unzFile Handle, usable with other function
        of this unzip package.
 */
-extern unzFile ZEXPORT unzOpen2(path, pzlib_filefunc_def)
+extern unzFile ZEXPORT
+unzOpen2(
+    path,
+    pzlib_filefunc_def)
     const char *path;
-zlib_filefunc_def* pzlib_filefunc_def;
+    zlib_filefunc_def *pzlib_filefunc_def;
 {
     unz_s us;
     unz_s *s;
-    uLong central_pos, uL;
+    uLong central_pos,
+     uL;
 
     uLong number_disk;          /* number of the current dist, used for
-                                                   spaning ZIP, unsupported, always 0*/
+                                   spaning ZIP, unsupported, always 0 */
     uLong number_disk_with_CD;  /* number the the disk with central dir, used
-                                                   for spaning ZIP, unsupported, always 0*/
+                                   for spaning ZIP, unsupported, always 0 */
     uLong number_entry_CD;      /* total number of entries in
-                                                   the central dir
-                                                   (same than number_entry on nospan) */
+                                   the central dir
+                                   (same than number_entry on nospan) */
 
     int err = UNZ_OK;
 
@@ -441,10 +458,10 @@
     else
         us.z_filefunc = *pzlib_filefunc_def;
 
-    us.filestream = (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
-            path,
-            ZLIB_FILEFUNC_MODE_READ |
-            ZLIB_FILEFUNC_MODE_EXISTING);
+    us.filestream = (*(us.z_filefunc.zopen_file)) (us.z_filefunc.opaque,
+                                                   path,
+                                                   ZLIB_FILEFUNC_MODE_READ |
+                                                   ZLIB_FILEFUNC_MODE_EXISTING);
     if (us.filestream == NULL)
         return NULL;
 
@@ -453,7 +470,7 @@
         err = UNZ_ERRNO;
 
     if (ZSEEK(us.z_filefunc, us.filestream,
-            central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+              central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
         err = UNZ_ERRNO;
 
     /* the signature, already checked */
@@ -461,41 +478,47 @@
         err = UNZ_ERRNO;
 
     /* number of this disk */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &number_disk) != UNZ_OK)
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &number_disk) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
     /* number of the disk with the start of the central directory */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &number_disk_with_CD) != UNZ_OK)
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &number_disk_with_CD)
+        != UNZ_OK)
         err = UNZ_ERRNO;
 
     /* total number of entries in the central dir on this disk */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &us.gi.number_entry) != UNZ_OK)
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &us.gi.number_entry) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
     /* total number of entries in the central dir */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &number_entry_CD) != UNZ_OK)
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &number_entry_CD) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
     if ((number_entry_CD != us.gi.number_entry) ||
-            (number_disk_with_CD != 0) ||
-            (number_disk != 0))
+        (number_disk_with_CD != 0) || (number_disk != 0))
         err = UNZ_BADZIPFILE;
 
     /* size of the central directory */
-    if (unzlocal_getLong(&us.z_filefunc, us.filestream, &us.size_central_dir) != UNZ_OK)
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream, &us.size_central_dir) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
     /* offset of start of central directory with respect to the
-          starting disk number */
-    if (unzlocal_getLong(&us.z_filefunc, us.filestream, &us.offset_central_dir) != UNZ_OK)
+       starting disk number */
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream, &us.offset_central_dir)
+        != UNZ_OK)
         err = UNZ_ERRNO;
 
     /* zipfile comment length */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &us.gi.size_comment) != UNZ_OK)
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream, &us.gi.size_comment) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
     if ((central_pos < us.offset_central_dir + us.size_central_dir) &&
-            (err == UNZ_OK))
+        (err == UNZ_OK))
         err = UNZ_BADZIPFILE;
 
     if (err != UNZ_OK)
@@ -505,20 +528,20 @@
     }
 
     us.byte_before_the_zipfile = central_pos -
-            (us.offset_central_dir + us.size_central_dir);
+        (us.offset_central_dir + us.size_central_dir);
     us.central_pos = central_pos;
     us.pfile_in_zip_read = NULL;
     us.encrypted = 0;
 
-
-    s = (unz_s*)ALLOC(sizeof(unz_s));
+    s = (unz_s *) ALLOC(sizeof(unz_s));
     *s = us;
-    unzGoToFirstFile((unzFile)s);
-    return (unzFile)s;
+    unzGoToFirstFile((unzFile) s);
+    return (unzFile) s;
 }
 
-
-extern unzFile ZEXPORT unzOpen(path)
+extern unzFile ZEXPORT
+unzOpen(
+    path)
     const char *path;
 {
     return unzOpen2(path, NULL);
@@ -529,13 +552,15 @@
   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzClose(file)
+extern int ZEXPORT
+unzClose(
+    file)
     unzFile file;
 {
-    unz_s* s;
+    unz_s *s;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
 
     if (s->pfile_in_zip_read)
         unzCloseCurrentFile(file);
@@ -545,73 +570,82 @@
     return UNZ_OK;
 }
 
-
 /*
   Write info about the ZipFile in the *pglobal_info structure.
   No preparation of the structure is needed
   return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzGetGlobalInfo(file, pglobal_info)
+extern int ZEXPORT
+unzGetGlobalInfo(
+    file,
+    pglobal_info)
     unzFile file;
-unz_global_info *pglobal_info;
+    unz_global_info *pglobal_info;
 {
-    unz_s* s;
+    unz_s *s;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     *pglobal_info = s->gi;
     return UNZ_OK;
 }
 
-
 /*
    Translate date/time from Dos format to tm_unz (readable more easilty)
 */
-local void unzlocal_DosDateToTmuDate(ulDosDate, ptm)
-uLong ulDosDate;
-tm_unz* ptm;
+local void
+unzlocal_DosDateToTmuDate(
+    ulDosDate,
+    ptm)
+    uLong ulDosDate;
+    tm_unz *ptm;
 {
     uLong uDate;
-    uDate = (uLong)(ulDosDate >> 16);
-    ptm->tm_mday = (uInt)(uDate & 0x1f) ;
-    ptm->tm_mon = (uInt)((((uDate) & 0x1E0) / 0x20) - 1) ;
-    ptm->tm_year = (uInt)(((uDate & 0x0FE00) / 0x0200) + 1980) ;
-
-    ptm->tm_hour = (uInt)((ulDosDate & 0xF800) / 0x800);
-    ptm->tm_min = (uInt)((ulDosDate & 0x7E0) / 0x20) ;
-    ptm->tm_sec = (uInt)(2 * (ulDosDate & 0x1f)) ;
+    uDate = (uLong) (ulDosDate >> 16);
+    ptm->tm_mday = (uInt) (uDate & 0x1f);
+    ptm->tm_mon = (uInt) ((((uDate) & 0x1E0) / 0x20) - 1);
+    ptm->tm_year = (uInt) (((uDate & 0x0FE00) / 0x0200) + 1980);
+
+    ptm->tm_hour = (uInt) ((ulDosDate & 0xF800) / 0x800);
+    ptm->tm_min = (uInt) ((ulDosDate & 0x7E0) / 0x20);
+    ptm->tm_sec = (uInt) (2 * (ulDosDate & 0x1f));
 }
 
 /*
   Get Info about the current file in the zipfile, with internal only info
 */
-local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
-        unz_file_info *pfile_info,
-        unz_file_info_internal
-        *pfile_info_internal,
-        char *szFileName,
-        uLong fileNameBufferSize,
-        void *extraField,
-        uLong extraFieldBufferSize,
-        char *szComment,
-        uLong commentBufferSize));
-
-local int unzlocal_GetCurrentFileInfoInternal(file,
-        pfile_info,
-        pfile_info_internal,
-        szFileName, fileNameBufferSize,
-        extraField, extraFieldBufferSize,
-        szComment,  commentBufferSize)
-unzFile file;
-unz_file_info *pfile_info;
-unz_file_info_internal *pfile_info_internal;
-char *szFileName;
-uLong fileNameBufferSize;
-void *extraField;
-uLong extraFieldBufferSize;
-char *szComment;
-uLong commentBufferSize;
+local int unzlocal_GetCurrentFileInfoInternal OF(
+     (unzFile file,
+      unz_file_info * pfile_info,
+      unz_file_info_internal * pfile_info_internal,
+      char *szFileName,
+      uLong fileNameBufferSize,
+      void *extraField,
+      uLong extraFieldBufferSize,
+      char *szComment,
+      uLong commentBufferSize));
+
+local int
+unzlocal_GetCurrentFileInfoInternal(
+    file,
+    pfile_info,
+    pfile_info_internal,
+    szFileName,
+    fileNameBufferSize,
+    extraField,
+    extraFieldBufferSize,
+    szComment,
+    commentBufferSize)
+    unzFile file;
+    unz_file_info *pfile_info;
+    unz_file_info_internal *pfile_info_internal;
+    char *szFileName;
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
 {
-    unz_s* s;
+    unz_s *s;
     unz_file_info file_info;
     unz_file_info_internal file_info_internal;
     int err = UNZ_OK;
@@ -620,13 +654,12 @@
 
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     if (ZSEEK(s->z_filefunc, s->filestream,
-            s->pos_in_central_dir + s->byte_before_the_zipfile,
-            ZLIB_FILEFUNC_SEEK_SET) != 0)
+              s->pos_in_central_dir + s->byte_before_the_zipfile,
+              ZLIB_FILEFUNC_SEEK_SET) != 0)
         err = UNZ_ERRNO;
 
-
     /* we check the magic */
     if (err == UNZ_OK)
     {
@@ -638,57 +671,74 @@
         err = UNZ_BADZIPFILE;
     }
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.version) != UNZ_OK)
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.version) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.version_needed) != UNZ_OK)
+    if (unzlocal_getShort
+        (&s->z_filefunc, s->filestream, &file_info.version_needed) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.flag) != UNZ_OK)
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.flag) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.compression_method) != UNZ_OK)
+    if (unzlocal_getShort
+        (&s->z_filefunc, s->filestream,
+         &file_info.compression_method) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.dosDate) != UNZ_OK)
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.dosDate) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
     unzlocal_DosDateToTmuDate(file_info.dosDate, &file_info.tmu_date);
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.crc) != UNZ_OK)
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.crc) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.compressed_size) != UNZ_OK)
+    if (unzlocal_getLong
+        (&s->z_filefunc, s->filestream, &file_info.compressed_size) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.uncompressed_size) != UNZ_OK)
+    if (unzlocal_getLong
+        (&s->z_filefunc, s->filestream, &file_info.uncompressed_size) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.size_filename) != UNZ_OK)
+    if (unzlocal_getShort
+        (&s->z_filefunc, s->filestream, &file_info.size_filename) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.size_file_extra) != UNZ_OK)
+    if (unzlocal_getShort
+        (&s->z_filefunc, s->filestream, &file_info.size_file_extra) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.size_file_comment) != UNZ_OK)
+    if (unzlocal_getShort
+        (&s->z_filefunc, s->filestream, &file_info.size_file_comment) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.disk_num_start) != UNZ_OK)
+    if (unzlocal_getShort
+        (&s->z_filefunc, s->filestream, &file_info.disk_num_start) != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.internal_fa) != UNZ_OK)
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &file_info.internal_fa)
+        != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.external_fa) != UNZ_OK)
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info.external_fa)
+        != UNZ_OK)
         err = UNZ_ERRNO;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &file_info_internal.offset_curfile) != UNZ_OK)
+    if (unzlocal_getLong
+        (&s->z_filefunc, s->filestream,
+         &file_info_internal.offset_curfile) != UNZ_OK)
         err = UNZ_ERRNO;
 
     lSeek += file_info.size_filename;
     if ((err == UNZ_OK) && (szFileName))
     {
-        uLong uSizeRead ;
+        uLong uSizeRead;
         if (file_info.size_filename < fileNameBufferSize)
         {
             *(szFileName + file_info.size_filename) = '\0';
@@ -698,15 +748,15 @@
             uSizeRead = fileNameBufferSize;
 
         if ((file_info.size_filename > 0) && (fileNameBufferSize > 0))
-            if (ZREAD(s->z_filefunc, s->filestream, szFileName, uSizeRead) != uSizeRead)
+            if (ZREAD(s->z_filefunc, s->filestream, szFileName, uSizeRead) !=
+                uSizeRead)
                 err = UNZ_ERRNO;
         lSeek -= uSizeRead;
     }
 
-
     if ((err == UNZ_OK) && (extraField))
     {
-        uLong uSizeRead ;
+        uLong uSizeRead;
         if (file_info.size_file_extra < extraFieldBufferSize)
             uSizeRead = file_info.size_file_extra;
         else
@@ -714,23 +764,25 @@
 
         if (lSeek != 0)
         {
-            if (ZSEEK(s->z_filefunc, s->filestream, lSeek, ZLIB_FILEFUNC_SEEK_CUR) == 0)
+            if (ZSEEK
+                (s->z_filefunc, s->filestream, lSeek,
+                 ZLIB_FILEFUNC_SEEK_CUR) == 0)
                 lSeek = 0;
             else
                 err = UNZ_ERRNO;
         }
         if ((file_info.size_file_extra > 0) && (extraFieldBufferSize > 0))
-            if (ZREAD(s->z_filefunc, s->filestream, extraField, uSizeRead) != uSizeRead)
+            if (ZREAD(s->z_filefunc, s->filestream, extraField, uSizeRead) !=
+                uSizeRead)
                 err = UNZ_ERRNO;
         lSeek += file_info.size_file_extra - uSizeRead;
     }
     else
         lSeek += file_info.size_file_extra;
 
-
     if ((err == UNZ_OK) && (szComment))
     {
-        uLong uSizeRead ;
+        uLong uSizeRead;
         if (file_info.size_file_comment < commentBufferSize)
         {
             *(szComment + file_info.size_file_comment) = '\0';
@@ -741,13 +793,16 @@
 
         if (lSeek != 0)
         {
-            if (ZSEEK(s->z_filefunc, s->filestream, lSeek, ZLIB_FILEFUNC_SEEK_CUR) == 0)
+            if (ZSEEK
+                (s->z_filefunc, s->filestream, lSeek,
+                 ZLIB_FILEFUNC_SEEK_CUR) == 0)
                 lSeek = 0;
             else
                 err = UNZ_ERRNO;
         }
         if ((file_info.size_file_comment > 0) && (commentBufferSize > 0))
-            if (ZREAD(s->z_filefunc, s->filestream, szComment, uSizeRead) != uSizeRead)
+            if (ZREAD(s->z_filefunc, s->filestream, szComment, uSizeRead) !=
+                uSizeRead)
                 err = UNZ_ERRNO;
         lSeek += file_info.size_file_comment - uSizeRead;
     }
@@ -763,50 +818,55 @@
     return err;
 }
 
-
-
 /*
   Write info about the ZipFile in the *pglobal_info structure.
   No preparation of the structure is needed
   return UNZ_OK if there is no problem.
 */
-extern int ZEXPORT unzGetCurrentFileInfo(file,
-            pfile_info,
-            szFileName, fileNameBufferSize,
-            extraField, extraFieldBufferSize,
-            szComment,  commentBufferSize)
-    unzFile file;
-unz_file_info *pfile_info;
-char *szFileName;
-uLong fileNameBufferSize;
-void *extraField;
-uLong extraFieldBufferSize;
-char *szComment;
-uLong commentBufferSize;
+extern int ZEXPORT
+unzGetCurrentFileInfo(
+    file,
+    pfile_info,
+    szFileName,
+    fileNameBufferSize,
+    extraField,
+    extraFieldBufferSize,
+    szComment,
+    commentBufferSize)
+    unzFile file;
+    unz_file_info *pfile_info;
+    char *szFileName;
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
 {
     return unzlocal_GetCurrentFileInfoInternal(file, pfile_info, NULL,
-            szFileName, fileNameBufferSize,
-            extraField, extraFieldBufferSize,
-            szComment, commentBufferSize);
+                                               szFileName, fileNameBufferSize,
+                                               extraField, extraFieldBufferSize,
+                                               szComment, commentBufferSize);
 }
 
 /*
   Set the current file of the zipfile to the first file.
   return UNZ_OK if there is no problem
 */
-extern int ZEXPORT unzGoToFirstFile(file)
+extern int ZEXPORT
+unzGoToFirstFile(
+    file)
     unzFile file;
 {
     int err = UNZ_OK;
-    unz_s* s;
+    unz_s *s;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     s->pos_in_central_dir = s->offset_central_dir;
     s->num_file = 0;
     err = unzlocal_GetCurrentFileInfoInternal(file, &s->cur_file_info,
-            &s->cur_file_info_internal,
-            NULL, 0, NULL, 0, NULL, 0);
+                                              &s->cur_file_info_internal,
+                                              NULL, 0, NULL, 0, NULL, 0);
     s->current_file_ok = (err == UNZ_OK);
     return err;
 }
@@ -816,32 +876,34 @@
   return UNZ_OK if there is no problem
   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
 */
-extern int ZEXPORT unzGoToNextFile(file)
+extern int ZEXPORT
+unzGoToNextFile(
+    file)
     unzFile file;
 {
-    unz_s* s;
+    unz_s *s;
     int err;
 
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     if (!s->current_file_ok)
         return UNZ_END_OF_LIST_OF_FILE;
-    if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
+    if (s->gi.number_entry != 0xffff)   /* 2^16 files overflow hack */
         if (s->num_file + 1 == s->gi.number_entry)
             return UNZ_END_OF_LIST_OF_FILE;
 
-    s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
-            s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
+    s->pos_in_central_dir +=
+        SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+        s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment;
     s->num_file++;
     err = unzlocal_GetCurrentFileInfoInternal(file, &s->cur_file_info,
-            &s->cur_file_info_internal,
-            NULL, 0, NULL, 0, NULL, 0);
+                                              &s->cur_file_info_internal,
+                                              NULL, 0, NULL, 0, NULL, 0);
     s->current_file_ok = (err == UNZ_OK);
     return err;
 }
 
-
 /*
   Try locate the file szFileName in the zipfile.
   For the iCaseSensitivity signification, see unzipStringFileNameCompare
@@ -850,12 +912,16 @@
   UNZ_OK if the file is found. It becomes the current file.
   UNZ_END_OF_LIST_OF_FILE if the file is not found
 */
-extern int ZEXPORT unzLocateFile(file, szFileName, iCaseSensitivity)
+extern int ZEXPORT
+unzLocateFile(
+    file,
+    szFileName,
+    iCaseSensitivity)
     unzFile file;
-const char *szFileName;
-int iCaseSensitivity;
+    const char *szFileName;
+    int iCaseSensitivity;
 {
-    unz_s* s;
+    unz_s *s;
     int err = 0;
 
     /* We remember the 'current' position in the file so that we can jump
@@ -866,14 +932,13 @@
     uLong num_fileSaved;
     uLong pos_in_central_dirSaved;
 
-
     if (file == NULL)
         return UNZ_PARAMERROR;
 
     if (strlen(szFileName) >= UNZ_MAXFILENAMEINZIP)
         return UNZ_PARAMERROR;
 
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     if (!s->current_file_ok)
         return UNZ_END_OF_LIST_OF_FILE;
 
@@ -887,14 +952,15 @@
 
     while (err == UNZ_OK)
     {
-        char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
+        char szCurrentFileName[UNZ_MAXFILENAMEINZIP + 1];
         err = unzGetCurrentFileInfo(file, NULL,
-                szCurrentFileName, sizeof(szCurrentFileName) - 1,
-                NULL, 0, NULL, 0);
+                                    szCurrentFileName,
+                                    sizeof(szCurrentFileName) - 1, NULL, 0,
+                                    NULL, 0);
         if (err == UNZ_OK)
         {
             if (unzStringFileNameCompare(szCurrentFileName,
-                    szFileName, iCaseSensitivity) == 0)
+                                         szFileName, iCaseSensitivity) == 0)
                 return UNZ_OK;
             err = unzGoToNextFile(file);
         }
@@ -903,14 +969,13 @@
     /* We failed, so restore the state of the 'current file' to where we
      * were.
      */
-    s->num_file = num_fileSaved ;
-    s->pos_in_central_dir = pos_in_central_dirSaved ;
+    s->num_file = num_fileSaved;
+    s->pos_in_central_dir = pos_in_central_dirSaved;
     s->cur_file_info = cur_file_infoSaved;
     s->cur_file_info_internal = cur_file_info_internalSaved;
     return err;
 }
 
-
 /*
 ///////////////////////////////////////////
 // Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
@@ -929,43 +994,49 @@
 } unz_file_pos;
 */
 
-extern int ZEXPORT unzGetFilePos(file, file_pos)
+extern int ZEXPORT
+unzGetFilePos(
+    file,
+    file_pos)
     unzFile file;
-unz_file_pos* file_pos;
+    unz_file_pos *file_pos;
 {
-    unz_s* s;
+    unz_s *s;
 
     if (file == NULL || file_pos == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     if (!s->current_file_ok)
         return UNZ_END_OF_LIST_OF_FILE;
 
-    file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
-    file_pos->num_of_file           = s->num_file;
+    file_pos->pos_in_zip_directory = s->pos_in_central_dir;
+    file_pos->num_of_file = s->num_file;
 
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzGoToFilePos(file, file_pos)
+extern int ZEXPORT
+unzGoToFilePos(
+    file,
+    file_pos)
     unzFile file;
-unz_file_pos* file_pos;
+    unz_file_pos *file_pos;
 {
-    unz_s* s;
+    unz_s *s;
     int err = 0;
 
     if (file == NULL || file_pos == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
 
     /* jump to the right spot */
     s->pos_in_central_dir = file_pos->pos_in_zip_directory;
-    s->num_file           = file_pos->num_of_file;
+    s->num_file = file_pos->num_of_file;
 
     /* set the current file */
     err = unzlocal_GetCurrentFileInfoInternal(file, &s->cur_file_info,
-            &s->cur_file_info_internal,
-            NULL, 0, NULL, 0, NULL, 0);
+                                              &s->cur_file_info_internal,
+                                              NULL, 0, NULL, 0, NULL, 0);
     /* return results */
     s->current_file_ok = (err == UNZ_OK);
     return err;
@@ -983,15 +1054,20 @@
   store in *piSizeVar the size of extra info in local header
         (filename and size of extra field data)
 */
-local int unzlocal_CheckCurrentFileCoherencyHeader(s, piSizeVar,
-        poffset_local_extrafield,
-        psize_local_extrafield)
-unz_s* s;
-uInt* piSizeVar;
-uLong *poffset_local_extrafield;
-uInt  *psize_local_extrafield;
-{
-    uLong uMagic, uData, uFlags;
+local int
+unzlocal_CheckCurrentFileCoherencyHeader(
+    s,
+    piSizeVar,
+    poffset_local_extrafield,
+    psize_local_extrafield)
+    unz_s *s;
+    uInt *piSizeVar;
+    uLong *poffset_local_extrafield;
+    uInt *psize_local_extrafield;
+{
+    uLong uMagic,
+     uData,
+     uFlags;
     uLong size_filename;
     uLong size_extra_field;
     int err = UNZ_OK;
@@ -1000,11 +1076,12 @@
     *poffset_local_extrafield = 0;
     *psize_local_extrafield = 0;
 
-    if (ZSEEK(s->z_filefunc, s->filestream, s->cur_file_info_internal.offset_curfile +
-            s->byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
+    if (ZSEEK
+        (s->z_filefunc, s->filestream,
+         s->cur_file_info_internal.offset_curfile + s->byte_before_the_zipfile,
+         ZLIB_FILEFUNC_SEEK_SET) != 0)
         return UNZ_ERRNO;
 
-
     if (err == UNZ_OK)
     {
         if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uMagic) != UNZ_OK)
@@ -1016,9 +1093,9 @@
     if (unzlocal_getShort(&s->z_filefunc, s->filestream, &uData) != UNZ_OK)
         err = UNZ_ERRNO;
     /*
-        else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
-            err=UNZ_BADZIPFILE;
-    */
+       else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
+       err=UNZ_BADZIPFILE;
+     */
     if (unzlocal_getShort(&s->z_filefunc, s->filestream, &uFlags) != UNZ_OK)
         err = UNZ_ERRNO;
 
@@ -1028,45 +1105,47 @@
         err = UNZ_BADZIPFILE;
 
     if ((err == UNZ_OK) && (s->cur_file_info.compression_method != 0) &&
-            (s->cur_file_info.compression_method != Z_DEFLATED))
+        (s->cur_file_info.compression_method != Z_DEFLATED))
         err = UNZ_BADZIPFILE;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK) /* date/time */
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK)  /* date/time */
         err = UNZ_ERRNO;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK) /* crc */
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK)  /* crc */
         err = UNZ_ERRNO;
     else if ((err == UNZ_OK) && (uData != s->cur_file_info.crc) &&
-            ((uFlags & 8) == 0))
+             ((uFlags & 8) == 0))
         err = UNZ_BADZIPFILE;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK) /* size compr */
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK)  /* size compr */
         err = UNZ_ERRNO;
     else if ((err == UNZ_OK) && (uData != s->cur_file_info.compressed_size) &&
-            ((uFlags & 8) == 0))
+             ((uFlags & 8) == 0))
         err = UNZ_BADZIPFILE;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK) /* size uncompr */
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream, &uData) != UNZ_OK)  /* size uncompr */
         err = UNZ_ERRNO;
     else if ((err == UNZ_OK) && (uData != s->cur_file_info.uncompressed_size) &&
-            ((uFlags & 8) == 0))
+             ((uFlags & 8) == 0))
         err = UNZ_BADZIPFILE;
 
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &size_filename) != UNZ_OK)
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &size_filename) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
-    else if ((err == UNZ_OK) && (size_filename != s->cur_file_info.size_filename))
+    else if ((err == UNZ_OK) &&
+             (size_filename != s->cur_file_info.size_filename))
         err = UNZ_BADZIPFILE;
 
-    *piSizeVar += (uInt)size_filename;
+    *piSizeVar += (uInt) size_filename;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &size_extra_field) != UNZ_OK)
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream, &size_extra_field) !=
+        UNZ_OK)
         err = UNZ_ERRNO;
     *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile +
-            SIZEZIPLOCALHEADER + size_filename;
-    *psize_local_extrafield = (uInt)size_extra_field;
+        SIZEZIPLOCALHEADER + size_filename;
+    *psize_local_extrafield = (uInt) size_extra_field;
 
-    *piSizeVar += (uInt)size_extra_field;
+    *piSizeVar += (uInt) size_extra_field;
 
     return err;
 }
@@ -1075,19 +1154,25 @@
   Open for reading data the current file in the zipfile.
   If there is no error and the file is opened, the return value is UNZ_OK.
 */
-extern int ZEXPORT unzOpenCurrentFile3(file, method, level, raw, password)
+extern int ZEXPORT
+unzOpenCurrentFile3(
+    file,
+    method,
+    level,
+    raw,
+    password)
     unzFile file;
-int* method;
-int* level;
-int raw;
-const char* password;
+    int *method;
+    int *level;
+    int raw;
+    const char *password;
 {
     int err = UNZ_OK;
     uInt iSizeVar;
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    unz_s *s;
+    file_in_zip_read_info_s *pfile_in_zip_read_info;
     uLong offset_local_extrafield;  /* offset of the local extra field */
-    uInt  size_local_extrafield;    /* size of the local extra field */
+    uInt size_local_extrafield; /* size of the local extra field */
 #    ifndef NOUNCRYPT
     char source[12];
 #    else
@@ -1097,7 +1182,7 @@
 
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     if (!s->current_file_ok)
         return UNZ_PARAMERROR;
 
@@ -1105,15 +1190,17 @@
         unzCloseCurrentFile(file);
 
     if (unzlocal_CheckCurrentFileCoherencyHeader(s, &iSizeVar,
-            &offset_local_extrafield, &size_local_extrafield) != UNZ_OK)
+                                                 &offset_local_extrafield,
+                                                 &size_local_extrafield) !=
+        UNZ_OK)
         return UNZ_BADZIPFILE;
 
-    pfile_in_zip_read_info = (file_in_zip_read_info_s*)
-            ALLOC(sizeof(file_in_zip_read_info_s));
+    pfile_in_zip_read_info = (file_in_zip_read_info_s *)
+        ALLOC(sizeof(file_in_zip_read_info_s));
     if (pfile_in_zip_read_info == NULL)
         return UNZ_INTERNALERROR;
 
-    pfile_in_zip_read_info->read_buffer = (char*)ALLOC(UNZ_BUFSIZE);
+    pfile_in_zip_read_info->read_buffer = (char *) ALLOC(UNZ_BUFSIZE);
     pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
     pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
     pfile_in_zip_read_info->pos_local_extrafield = 0;
@@ -1128,27 +1215,27 @@
     pfile_in_zip_read_info->stream_initialised = 0;
 
     if (method)
-        *method = (int)s->cur_file_info.compression_method;
+        *method = (int) s->cur_file_info.compression_method;
 
     if (level)
     {
         *level = 6;
         switch (s->cur_file_info.flag & 0x06)
         {
-            case 6 :
-                *level = 1;
-                break;
-            case 4 :
-                *level = 2;
-                break;
-            case 2 :
-                *level = 9;
-                break;
+        case 6:
+            *level = 1;
+            break;
+        case 4:
+            *level = 2;
+            break;
+        case 2:
+            *level = 9;
+            break;
         }
     }
 
     if ((s->cur_file_info.compression_method != 0) &&
-            (s->cur_file_info.compression_method != Z_DEFLATED))
+        (s->cur_file_info.compression_method != Z_DEFLATED))
         err = UNZ_BADZIPFILE;
 
     pfile_in_zip_read_info->crc32_wait = s->cur_file_info.crc;
@@ -1157,17 +1244,17 @@
         s->cur_file_info.compression_method;
     pfile_in_zip_read_info->filestream = s->filestream;
     pfile_in_zip_read_info->z_filefunc = s->z_filefunc;
-    pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile;
+    pfile_in_zip_read_info->byte_before_the_zipfile =
+        s->byte_before_the_zipfile;
 
     pfile_in_zip_read_info->stream.total_out = 0;
 
-    if ((s->cur_file_info.compression_method == Z_DEFLATED) &&
-            (!raw))
+    if ((s->cur_file_info.compression_method == Z_DEFLATED) && (!raw))
     {
-        pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
-        pfile_in_zip_read_info->stream.zfree = (free_func)0;
-        pfile_in_zip_read_info->stream.opaque = (voidpf)0;
-        pfile_in_zip_read_info->stream.next_in = (voidpf)0;
+        pfile_in_zip_read_info->stream.zalloc = (alloc_func) 0;
+        pfile_in_zip_read_info->stream.zfree = (free_func) 0;
+        pfile_in_zip_read_info->stream.opaque = (voidpf) 0;
+        pfile_in_zip_read_info->stream.next_in = (voidpf) 0;
         pfile_in_zip_read_info->stream.avail_in = 0;
 
         err = inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
@@ -1187,16 +1274,15 @@
          */
     }
     pfile_in_zip_read_info->rest_read_compressed =
-        s->cur_file_info.compressed_size ;
+        s->cur_file_info.compressed_size;
     pfile_in_zip_read_info->rest_read_uncompressed =
-        s->cur_file_info.uncompressed_size ;
-
+        s->cur_file_info.uncompressed_size;
 
     pfile_in_zip_read_info->pos_in_zipfile =
         s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
         iSizeVar;
 
-    pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+    pfile_in_zip_read_info->stream.avail_in = (uInt) 0;
 
     s->pfile_in_zip_read = pfile_in_zip_read_info;
 
@@ -1207,9 +1293,8 @@
         s->pcrc_32_tab = get_crc_table();
         init_keys(password, s->keys, s->pcrc_32_tab);
         if (ZSEEK(s->z_filefunc, s->filestream,
-                s->pfile_in_zip_read->pos_in_zipfile +
-                s->pfile_in_zip_read->byte_before_the_zipfile,
-                SEEK_SET) != 0)
+                  s->pfile_in_zip_read->pos_in_zipfile +
+                  s->pfile_in_zip_read->byte_before_the_zipfile, SEEK_SET) != 0)
             return UNZ_INTERNALERROR;
         if (ZREAD(s->z_filefunc, s->filestream, source, 12) < 12)
             return UNZ_INTERNALERROR;
@@ -1222,28 +1307,37 @@
     }
 #    endif
 
-
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzOpenCurrentFile(file)
+extern int ZEXPORT
+unzOpenCurrentFile(
+    file)
     unzFile file;
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
 }
 
-extern int ZEXPORT unzOpenCurrentFilePassword(file, password)
+extern int ZEXPORT
+unzOpenCurrentFilePassword(
+    file,
+    password)
     unzFile file;
-const char* password;
+    const char *password;
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
 }
 
-extern int ZEXPORT unzOpenCurrentFile2(file, method, level, raw)
+extern int ZEXPORT
+unzOpenCurrentFile2(
+    file,
+    method,
+    level,
+    raw)
     unzFile file;
-int* method;
-int* level;
-int raw;
+    int *method;
+    int *level;
+    int raw;
 {
     return unzOpenCurrentFile3(file, method, level, raw, NULL);
 }
@@ -1258,110 +1352,113 @@
   return <0 with error code if there is an error
     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
 */
-extern int ZEXPORT unzReadCurrentFile(file, buf, len)
+extern int ZEXPORT
+unzReadCurrentFile(
+    file,
+    buf,
+    len)
     unzFile file;
-voidp buf;
-unsigned len;
+    voidp buf;
+    unsigned len;
 {
     int err = UNZ_OK;
     uInt iRead = 0;
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    unz_s *s;
+    file_in_zip_read_info_s *pfile_in_zip_read_info;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     pfile_in_zip_read_info = s->pfile_in_zip_read;
 
     if (pfile_in_zip_read_info == NULL)
         return UNZ_PARAMERROR;
 
-
     if ((pfile_in_zip_read_info->read_buffer == NULL))
         return UNZ_END_OF_LIST_OF_FILE;
     if (len == 0)
         return 0;
 
-    pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
+    pfile_in_zip_read_info->stream.next_out = (Bytef *) buf;
 
-    pfile_in_zip_read_info->stream.avail_out = (uInt)len;
+    pfile_in_zip_read_info->stream.avail_out = (uInt) len;
 
     if ((len > pfile_in_zip_read_info->rest_read_uncompressed) &&
-            (!(pfile_in_zip_read_info->raw)))
+        (!(pfile_in_zip_read_info->raw)))
         pfile_in_zip_read_info->stream.avail_out =
-            (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
+            (uInt) pfile_in_zip_read_info->rest_read_uncompressed;
 
     if ((len > pfile_in_zip_read_info->rest_read_compressed +
-            pfile_in_zip_read_info->stream.avail_in) &&
-            (pfile_in_zip_read_info->raw))
+         pfile_in_zip_read_info->stream.avail_in) &&
+        (pfile_in_zip_read_info->raw))
         pfile_in_zip_read_info->stream.avail_out =
-            (uInt)pfile_in_zip_read_info->rest_read_compressed +
+            (uInt) pfile_in_zip_read_info->rest_read_compressed +
             pfile_in_zip_read_info->stream.avail_in;
 
     while (pfile_in_zip_read_info->stream.avail_out > 0)
     {
         if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
-                (pfile_in_zip_read_info->rest_read_compressed > 0))
+            (pfile_in_zip_read_info->rest_read_compressed > 0))
         {
             uInt uReadThis = UNZ_BUFSIZE;
             if (pfile_in_zip_read_info->rest_read_compressed < uReadThis)
-                uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
+                uReadThis = (uInt) pfile_in_zip_read_info->rest_read_compressed;
             if (uReadThis == 0)
                 return UNZ_EOF;
             if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
-                    pfile_in_zip_read_info->filestream,
-                    pfile_in_zip_read_info->pos_in_zipfile +
-                    pfile_in_zip_read_info->byte_before_the_zipfile,
-                    ZLIB_FILEFUNC_SEEK_SET) != 0)
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->pos_in_zipfile +
+                      pfile_in_zip_read_info->byte_before_the_zipfile,
+                      ZLIB_FILEFUNC_SEEK_SET) != 0)
                 return UNZ_ERRNO;
             if (ZREAD(pfile_in_zip_read_info->z_filefunc,
-                    pfile_in_zip_read_info->filestream,
-                    pfile_in_zip_read_info->read_buffer,
-                    uReadThis) != uReadThis)
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->read_buffer,
+                      uReadThis) != uReadThis)
                 return UNZ_ERRNO;
 
-
 #            ifndef NOUNCRYPT
             if (s->encrypted)
             {
                 uInt i;
-                for (i = 0;i < uReadThis;i++)
+                for (i = 0; i < uReadThis; i++)
                     pfile_in_zip_read_info->read_buffer[i] =
                         zdecode(s->keys, s->pcrc_32_tab,
                                 pfile_in_zip_read_info->read_buffer[i]);
             }
 #            endif
 
-
             pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
 
             pfile_in_zip_read_info->rest_read_compressed -= uReadThis;
 
             pfile_in_zip_read_info->stream.next_in =
-                (Bytef*)pfile_in_zip_read_info->read_buffer;
-            pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+                (Bytef *) pfile_in_zip_read_info->read_buffer;
+            pfile_in_zip_read_info->stream.avail_in = (uInt) uReadThis;
         }
 
-        if ((pfile_in_zip_read_info->compression_method == 0) || (pfile_in_zip_read_info->raw))
+        if ((pfile_in_zip_read_info->compression_method == 0) ||
+            (pfile_in_zip_read_info->raw))
         {
-            uInt uDoCopy, i ;
+            uInt uDoCopy,
+             i;
 
             if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
-                    (pfile_in_zip_read_info->rest_read_compressed == 0))
+                (pfile_in_zip_read_info->rest_read_compressed == 0))
                 return (iRead == 0) ? UNZ_EOF : iRead;
 
             if (pfile_in_zip_read_info->stream.avail_out <
-                    pfile_in_zip_read_info->stream.avail_in)
-                uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+                pfile_in_zip_read_info->stream.avail_in)
+                uDoCopy = pfile_in_zip_read_info->stream.avail_out;
             else
-                uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+                uDoCopy = pfile_in_zip_read_info->stream.avail_in;
 
-            for (i = 0;i < uDoCopy;i++)
+            for (i = 0; i < uDoCopy; i++)
                 *(pfile_in_zip_read_info->stream.next_out + i) =
                     *(pfile_in_zip_read_info->stream.next_in + i);
 
             pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
-                    pfile_in_zip_read_info->stream.next_out,
-                    uDoCopy);
+                                                  pfile_in_zip_read_info->
+                                                  stream.next_out, uDoCopy);
             pfile_in_zip_read_info->rest_read_uncompressed -= uDoCopy;
             pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
             pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
@@ -1372,7 +1469,8 @@
         }
         else
         {
-            uLong uTotalOutBefore, uTotalOutAfter;
+            uLong uTotalOutBefore,
+             uTotalOutAfter;
             const Bytef *bufBefore;
             uLong uOutThis;
             int flush = Z_SYNC_FLUSH;
@@ -1381,11 +1479,11 @@
             bufBefore = pfile_in_zip_read_info->stream.next_out;
 
             /*
-            if ((pfile_in_zip_read_info->rest_read_uncompressed ==
-                     pfile_in_zip_read_info->stream.avail_out) &&
-                (pfile_in_zip_read_info->rest_read_compressed == 0))
-                flush = Z_FINISH;
-            */
+               if ((pfile_in_zip_read_info->rest_read_uncompressed ==
+               pfile_in_zip_read_info->stream.avail_out) &&
+               (pfile_in_zip_read_info->rest_read_compressed == 0))
+               flush = Z_FINISH;
+             */
             err = inflate(&pfile_in_zip_read_info->stream, flush);
 
             if ((err >= 0) && (pfile_in_zip_read_info->stream.msg))
@@ -1396,12 +1494,11 @@
 
             pfile_in_zip_read_info->crc32 =
                 crc32(pfile_in_zip_read_info->crc32, bufBefore,
-                        (uInt)(uOutThis));
+                      (uInt) (uOutThis));
 
-            pfile_in_zip_read_info->rest_read_uncompressed -=
-                uOutThis;
+            pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
 
-            iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+            iRead += (uInt) (uTotalOutAfter - uTotalOutBefore);
 
             if (err == Z_STREAM_END)
                 return (iRead == 0) ? UNZ_EOF : iRead;
@@ -1415,38 +1512,40 @@
     return err;
 }
 
-
 /*
   Give the current position in uncompressed data
 */
-extern z_off_t ZEXPORT unztell(file)
+extern z_off_t ZEXPORT
+unztell(
+    file)
     unzFile file;
 {
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    unz_s *s;
+    file_in_zip_read_info_s *pfile_in_zip_read_info;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     pfile_in_zip_read_info = s->pfile_in_zip_read;
 
     if (pfile_in_zip_read_info == NULL)
         return UNZ_PARAMERROR;
 
-    return (z_off_t)pfile_in_zip_read_info->stream.total_out;
+    return (z_off_t) pfile_in_zip_read_info->stream.total_out;
 }
 
-
 /*
   return 1 if the end of file was reached, 0 elsewhere
 */
-extern int ZEXPORT unzeof(file)
+extern int ZEXPORT
+unzeof(
+    file)
     unzFile file;
 {
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    unz_s *s;
+    file_in_zip_read_info_s *pfile_in_zip_read_info;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     pfile_in_zip_read_info = s->pfile_in_zip_read;
 
     if (pfile_in_zip_read_info == NULL)
@@ -1458,8 +1557,6 @@
         return 0;
 }
 
-
-
 /*
   Read extra field from the current file (opened by unzOpenCurrentFile)
   This is the local-header version of the extra field (sometimes, there is
@@ -1472,81 +1569,84 @@
   the return value is the number of bytes copied in buf, or (if <0)
     the error code
 */
-extern int ZEXPORT unzGetLocalExtrafield(file, buf, len)
+extern int ZEXPORT
+unzGetLocalExtrafield(
+    file,
+    buf,
+    len)
     unzFile file;
-voidp buf;
-unsigned len;
+    voidp buf;
+    unsigned len;
 {
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    unz_s *s;
+    file_in_zip_read_info_s *pfile_in_zip_read_info;
     uInt read_now;
     uLong size_to_read;
 
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     pfile_in_zip_read_info = s->pfile_in_zip_read;
 
     if (pfile_in_zip_read_info == NULL)
         return UNZ_PARAMERROR;
 
     size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
-            pfile_in_zip_read_info->pos_local_extrafield);
+                    pfile_in_zip_read_info->pos_local_extrafield);
 
     if (buf == NULL)
-        return (int)size_to_read;
+        return (int) size_to_read;
 
     if (len > size_to_read)
-        read_now = (uInt)size_to_read;
+        read_now = (uInt) size_to_read;
     else
-        read_now = (uInt)len ;
+        read_now = (uInt) len;
 
     if (read_now == 0)
         return 0;
 
     if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
-            pfile_in_zip_read_info->filestream,
-            pfile_in_zip_read_info->offset_local_extrafield +
-            pfile_in_zip_read_info->pos_local_extrafield,
-            ZLIB_FILEFUNC_SEEK_SET) != 0)
+              pfile_in_zip_read_info->filestream,
+              pfile_in_zip_read_info->offset_local_extrafield +
+              pfile_in_zip_read_info->pos_local_extrafield,
+              ZLIB_FILEFUNC_SEEK_SET) != 0)
         return UNZ_ERRNO;
 
     if (ZREAD(pfile_in_zip_read_info->z_filefunc,
-            pfile_in_zip_read_info->filestream,
-            buf, read_now) != read_now)
+              pfile_in_zip_read_info->filestream, buf, read_now) != read_now)
         return UNZ_ERRNO;
 
-    return (int)read_now;
+    return (int) read_now;
 }
 
 /*
   Close the file in zip opened with unzipOpenCurrentFile
   Return UNZ_CRCERROR if all the file was read but the CRC is not good
 */
-extern int ZEXPORT unzCloseCurrentFile(file)
+extern int ZEXPORT
+unzCloseCurrentFile(
+    file)
     unzFile file;
 {
     int err = UNZ_OK;
 
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    unz_s *s;
+    file_in_zip_read_info_s *pfile_in_zip_read_info;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     pfile_in_zip_read_info = s->pfile_in_zip_read;
 
     if (pfile_in_zip_read_info == NULL)
         return UNZ_PARAMERROR;
 
-
     if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
-            (!pfile_in_zip_read_info->raw))
+        (!pfile_in_zip_read_info->raw))
     {
         if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
             err = UNZ_CRCERROR;
     }
 
-
     TRYFREE(pfile_in_zip_read_info->read_buffer);
     pfile_in_zip_read_info->read_buffer = NULL;
     if (pfile_in_zip_read_info->stream_initialised)
@@ -1560,51 +1660,59 @@
     return err;
 }
 
-
 /*
   Get the global comment string of the ZipFile, in the szComment buffer.
   uSizeBuf is the size of the szComment buffer.
   return the number of byte copied or an error code <0
 */
-extern int ZEXPORT unzGetGlobalComment(file, szComment, uSizeBuf)
+extern int ZEXPORT
+unzGetGlobalComment(
+    file,
+    szComment,
+    uSizeBuf)
     unzFile file;
-char *szComment;
-uLong uSizeBuf;
+    char *szComment;
+    uLong uSizeBuf;
 {
-    unz_s* s;
-    uLong uReadThis ;
+    unz_s *s;
+    uLong uReadThis;
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
 
     uReadThis = uSizeBuf;
     if (uReadThis > s->gi.size_comment)
         uReadThis = s->gi.size_comment;
 
-    if (ZSEEK(s->z_filefunc, s->filestream, s->central_pos + 22, ZLIB_FILEFUNC_SEEK_SET) != 0)
+    if (ZSEEK
+        (s->z_filefunc, s->filestream, s->central_pos + 22,
+         ZLIB_FILEFUNC_SEEK_SET) != 0)
         return UNZ_ERRNO;
 
     if (uReadThis > 0)
     {
         *szComment = '\0';
-        if (ZREAD(s->z_filefunc, s->filestream, szComment, uReadThis) != uReadThis)
+        if (ZREAD(s->z_filefunc, s->filestream, szComment, uReadThis) !=
+            uReadThis)
             return UNZ_ERRNO;
     }
 
     if ((szComment) && (uSizeBuf > s->gi.size_comment))
         *(szComment + s->gi.size_comment) = '\0';
-    return (int)uReadThis;
+    return (int) uReadThis;
 }
 
 /* Additions by RX '2004 */
-extern uLong ZEXPORT unzGetOffset(file)
+extern uLong ZEXPORT
+unzGetOffset(
+    file)
     unzFile file;
 {
-    unz_s* s;
+    unz_s *s;
 
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
     if (!s->current_file_ok)
         return 0;
     if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
@@ -1613,22 +1721,25 @@
     return s->pos_in_central_dir;
 }
 
-extern int ZEXPORT unzSetOffset(file, pos)
+extern int ZEXPORT
+unzSetOffset(
+    file,
+    pos)
     unzFile file;
-uLong pos;
+    uLong pos;
 {
-    unz_s* s;
+    unz_s *s;
     int err;
 
     if (file == NULL)
         return UNZ_PARAMERROR;
-    s = (unz_s*)file;
+    s = (unz_s *) file;
 
     s->pos_in_central_dir = pos;
-    s->num_file = s->gi.number_entry;      /* hack */
+    s->num_file = s->gi.number_entry;   /* hack */
     err = unzlocal_GetCurrentFileInfoInternal(file, &s->cur_file_info,
-            &s->cur_file_info_internal,
-            NULL, 0, NULL, 0, NULL, 0);
+                                              &s->cur_file_info_internal,
+                                              NULL, 0, NULL, 0, NULL, 0);
     s->current_file_ok = (err == UNZ_OK);
     return err;
 }

Modified: webservices/axis2/trunk/c/util/src/network_handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/util/src/network_handler.c?rev=580207&r1=580206&r2=580207&view=diff
==============================================================================
--- webservices/axis2/trunk/c/util/src/network_handler.c (original)
+++ webservices/axis2/trunk/c/util/src/network_handler.c Thu Sep 27 20:28:06 2007
@@ -72,11 +72,13 @@
 
         if (lphost)
         {
-            sock_addr.sin_addr.s_addr = ((struct in_addr *) lphost->h_addr)->s_addr;
+            sock_addr.sin_addr.s_addr =
+                ((struct in_addr *) lphost->h_addr)->s_addr;
         }
         else
         {
-            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_ADDRESS, AXIS2_FAILURE);
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_ADDRESS,
+                            AXIS2_FAILURE);
             return AXIS2_INVALID_SOCKET;
         }
     }
@@ -90,10 +92,12 @@
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }
-    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &nodelay, sizeof(nodelay));
+    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &nodelay,
+               sizeof(nodelay));
     ll.l_onoff = 1;
     ll.l_linger = 5;
-    setsockopt(sock, SOL_SOCKET, SO_LINGER, (const char *) &ll, sizeof(struct linger));
+    setsockopt(sock, SOL_SOCKET, SO_LINGER, (const char *) &ll,
+               sizeof(struct linger));
     return sock;
 }
 
@@ -135,12 +139,14 @@
     /* Bind the socket to our port number */
     if (bind(sock, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0)
     {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_BIND_FAILED, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_BIND_FAILED,
+                        AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }
     if (listen(sock, 50) < 0)
     {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_LISTEN_FAILED, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_LISTEN_FAILED,
+                        AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }
     return sock;
@@ -206,7 +212,8 @@
     cli_len = sizeof(cli_addr);
     cli_socket = accept(svr_socket, (struct sockaddr *) &cli_addr, &cli_len);
     if (cli_socket < 0)
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[Axis2][network_handler] Socket accept \
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "[Axis2][network_handler] Socket accept \
                 failed");
 
     setsockopt(svr_socket, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));

Modified: webservices/axis2/trunk/c/util/src/param.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/util/src/param.c?rev=580207&r1=580206&r2=580207&view=diff
==============================================================================
--- webservices/axis2/trunk/c/util/src/param.c (original)
+++ webservices/axis2/trunk/c/util/src/param.c Thu Sep 27 20:28:06 2007
@@ -180,7 +180,8 @@
         axutil_hash_index_t *i = NULL;
         void *v = NULL;
 
-        for (i = axutil_hash_first(param->attrs, env); i; i = axutil_hash_next(env, i))
+        for (i = axutil_hash_first(param->attrs, env); i;
+             i = axutil_hash_next(env, i))
         {
             axutil_hash_this(i, NULL, NULL, &v);
             axutil_generic_obj_free(v, env);
@@ -219,7 +220,9 @@
         {
             axutil_param_t *param = NULL;
 
-            param = (axutil_param_t *) axutil_array_list_get(param->value_list, env, i);
+            param =
+                (axutil_param_t *) axutil_array_list_get(param->value_list, env,
+                                                         i);
             axutil_param_free(param, env);
         }
         axutil_array_list_free(param->value_list, env);
@@ -265,7 +268,8 @@
         axutil_hash_index_t *i = NULL;
         void *v = NULL;
 
-        for (i = axutil_hash_first(param->attrs, env); i; i = axutil_hash_next(env, i))
+        for (i = axutil_hash_first(param->attrs, env); i;
+             i = axutil_hash_next(env, i))
         {
             axutil_hash_this(i, NULL, NULL, &v);
             axutil_generic_obj_free(v, env);
@@ -283,7 +287,9 @@
         {
             axutil_param_t *param_l = NULL;
 
-            param_l = (axutil_param_t *) axutil_array_list_get(param->value_list, env, i);
+            param_l =
+                (axutil_param_t *) axutil_array_list_get(param->value_list, env,
+                                                         i);
             if (param_l)
             {
                 axutil_param_free(param_l, env);

Modified: webservices/axis2/trunk/c/util/src/param_container.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/util/src/param_container.c?rev=580207&r1=580206&r2=580207&view=diff
==============================================================================
--- webservices/axis2/trunk/c/util/src/param_container.c (original)
+++ webservices/axis2/trunk/c/util/src/param_container.c Thu Sep 27 20:28:06 2007
@@ -33,7 +33,9 @@
     AXIS2_ENV_CHECK(env, NULL);
 
     param_container =
-        (axutil_param_container_t *) AXIS2_MALLOC(env->allocator, sizeof(axutil_param_container_t));
+        (axutil_param_container_t *) AXIS2_MALLOC(env->allocator,
+                                                  sizeof
+                                                  (axutil_param_container_t));
 
     if (!param_container)
     {
@@ -131,10 +133,12 @@
     param_name = axutil_param_get_name(param, env);
     if (!param_name)
     {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM,
+                        AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    axutil_hash_set(param_container->params, param_name, AXIS2_HASH_KEY_STRING, param);
+    axutil_hash_set(param_container->params, param_name, AXIS2_HASH_KEY_STRING,
+                    param);
 
     return AXIS2_SUCCESS;
 }
@@ -146,7 +150,8 @@
     const axis2_char_t * name)
 {
     return (axutil_param_t
-            *) (axutil_hash_get(param_container->params, name, AXIS2_HASH_KEY_STRING));
+            *) (axutil_hash_get(param_container->params, name,
+                                AXIS2_HASH_KEY_STRING));
 }
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
@@ -172,7 +177,8 @@
          index_i = axutil_hash_next(env, index_i))
     {
         axutil_hash_this(index_i, NULL, NULL, &value);
-        status = axutil_array_list_add(param_container->params_list, env, value);
+        status =
+            axutil_array_list_add(param_container->params_list, env, value);
         if (AXIS2_SUCCESS != status)
         {
             axutil_array_list_free(param_container->params_list, env);
@@ -195,7 +201,8 @@
 
     param =
         (axutil_param_t
-         *) (axutil_hash_get(param_container->params, param_name, AXIS2_HASH_KEY_STRING));
+         *) (axutil_hash_get(param_container->params, param_name,
+                             AXIS2_HASH_KEY_STRING));
     if (!param)
     {
         /* In this case we consider param is not locked */

Modified: webservices/axis2/trunk/c/util/src/platforms/unix/uuid_gen_unix.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/util/src/platforms/unix/uuid_gen_unix.c?rev=580207&r1=580206&r2=580207&view=diff
==============================================================================
--- webservices/axis2/trunk/c/util/src/platforms/unix/uuid_gen_unix.c (original)
+++ webservices/axis2/trunk/c/util/src/platforms/unix/uuid_gen_unix.c Thu Sep 27 20:28:06 2007
@@ -199,9 +199,11 @@
         return NULL;
     }
     memcpy(mac, uuid_struct->mac_addr, 6);
-    sprintf(mac_hex, "%02x%02x%02x%02x%02x%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-    sprintf(uuid_str, "%08x-%04x-%04x-%04x-%s", uuid_struct->time_low, uuid_struct->time_mid,
-            uuid_struct->time_high_version, uuid_struct->clock_variant, mac_hex);
+    sprintf(mac_hex, "%02x%02x%02x%02x%02x%02x", mac[0], mac[1], mac[2], mac[3],
+            mac[4], mac[5]);
+    sprintf(uuid_str, "%08x-%04x-%04x-%04x-%s", uuid_struct->time_low,
+            uuid_struct->time_mid, uuid_struct->time_high_version,
+            uuid_struct->clock_variant, mac_hex);
     free(uuid_struct);
     uuid_struct = NULL;
     return uuid_str;



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message