�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Farchive%2F'>archive</a>/</p><hr><h3>✏️ Editing: azio.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
  azio is a modified version of gzio. It  makes use of mysys and removes mallocs.
    -Brian Aker
*/

/* gzio.c -- IO on .gz files
 * Copyright (C) 1995-2005 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 *
 */

/* @(#) $Id$ */

#include &quot;azlib.h&quot;

#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

#include &quot;my_sys.h&quot;

static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
static int const az_magic[3] = {0xfe, 0x03, 0x01}; /* az magic header */

/* gzip flag uchar */
#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
#define COMMENT      0x10 /* bit 4 set: file comment present */
#define RESERVED     0xE0 /* bits 5..7: reserved */

int az_open(azio_stream *s, const char *path, int Flags, File  fd);
int do_flush(azio_stream *file, int flush);
int    get_byte(azio_stream *s);
void   check_header(azio_stream *s);
int write_header(azio_stream *s);
int    destroy(azio_stream *s);
void putLong(File file, uLong x);
uLong  getLong(azio_stream *s);
void read_header(azio_stream *s, unsigned char *buffer);

#ifdef HAVE_PSI_INTERFACE
extern PSI_file_key arch_key_file_data;
#endif

/* ===========================================================================
  Opens a gzip (.gz) file for reading or writing. The mode parameter
  is as in fopen (&quot;rb&quot; or &quot;wb&quot;). The file is given either by file descriptor
  or path name (if fd == -1).
  az_open returns NULL if the file could not be opened or if there was
  insufficient memory to allocate the (de)compression state; errno
  can be checked to distinguish the two cases (if errno is zero, the
  zlib error is Z_MEM_ERROR).
*/
int az_open (azio_stream *s, const char *path, int Flags, File fd)
{
  int err;
  int level = Z_DEFAULT_COMPRESSION; /* compression level */
  int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */

  s-&gt;stream.zalloc = my_az_allocator;
  s-&gt;stream.zfree = my_az_free;
  s-&gt;stream.opaque = (voidpf)0;
  memset(s-&gt;inbuf, 0, AZ_BUFSIZE_READ);
  memset(s-&gt;outbuf, 0, AZ_BUFSIZE_WRITE);
  s-&gt;stream.next_in = s-&gt;inbuf;
  s-&gt;stream.next_out = s-&gt;outbuf;
  s-&gt;stream.avail_in = s-&gt;stream.avail_out = 0;
  s-&gt;z_err = Z_OK;
  s-&gt;z_eof = 0;
  s-&gt;in = 0;
  s-&gt;out = 0;
  s-&gt;back = EOF;
  s-&gt;crc = 0;
  s-&gt;transparent = 0;
  s-&gt;mode = &#039;r&#039;;
  s-&gt;version = (unsigned char)az_magic[1]; /* this needs to be a define to version */
  s-&gt;minor_version= (unsigned char) az_magic[2]; /* minor version */
  s-&gt;dirty= AZ_STATE_CLEAN;
  s-&gt;start= 0;

  /*
    We do our own version of append by nature. 
    We must always have write access to take card of the header.
  */
  DBUG_ASSERT(Flags | O_APPEND);
  DBUG_ASSERT(Flags | O_WRONLY);

  if (Flags &amp; O_RDWR) 
    s-&gt;mode = &#039;w&#039;;

  if (s-&gt;mode == &#039;w&#039;) 
  {
    err = deflateInit2(&amp;(s-&gt;stream), level,
                       Z_DEFLATED, -MAX_WBITS, 8, strategy);
    /* windowBits is passed &lt; 0 to suppress zlib header */

    s-&gt;stream.next_out = s-&gt;outbuf;
    if (err != Z_OK)
    {
      destroy(s);
      return Z_NULL;
    }
  } else {
    s-&gt;stream.next_in  = s-&gt;inbuf;

    err = inflateInit2(&amp;(s-&gt;stream), -MAX_WBITS);
    /* windowBits is passed &lt; 0 to tell that there is no zlib header.
     * Note that in this case inflate *requires* an extra &quot;dummy&quot; byte
     * after the compressed stream in order to complete decompression and
     * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
     * present after the compressed stream.
   */
    if (err != Z_OK)
    {
      destroy(s);
      return Z_NULL;
    }
  }
  s-&gt;stream.avail_out = AZ_BUFSIZE_WRITE;

  errno = 0;
  s-&gt;file = fd &lt; 0 ? mysql_file_open(arch_key_file_data, path, Flags, MYF(0)) : fd;
  DBUG_EXECUTE_IF(&quot;simulate_archive_open_failure&quot;,
  {
    if (s-&gt;file &gt;= 0)
    {
      my_close(s-&gt;file, MYF(0));
      s-&gt;file= -1;
      my_errno= EMFILE;
    }
  });

  if (s-&gt;file &lt; 0 ) 
  {
    destroy(s);
    return Z_NULL;
  }

  if (Flags &amp; O_CREAT || Flags &amp; O_TRUNC) 
  {
    s-&gt;rows= 0;
    s-&gt;forced_flushes= 0;
    s-&gt;shortest_row= 0;
    s-&gt;longest_row= 0;
    s-&gt;auto_increment= 0;
    s-&gt;check_point= 0;
    s-&gt;comment_start_pos= 0;
    s-&gt;comment_length= 0;
    s-&gt;frm_start_pos= 0;
    s-&gt;frm_length= 0;
    s-&gt;dirty= 1; /* We create the file dirty */
    s-&gt;start = AZHEADER_SIZE + AZMETA_BUFFER_SIZE;
    write_header(s);
    my_seek(s-&gt;file, 0, MY_SEEK_END, MYF(0));
  }
  else if (s-&gt;mode == &#039;w&#039;) 
  {
    uchar buffer[AZHEADER_SIZE + AZMETA_BUFFER_SIZE];
    my_pread(s-&gt;file, buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE, 0,
             MYF(0));
    read_header(s, buffer); /* skip the .az header */
    my_seek(s-&gt;file, 0, MY_SEEK_END, MYF(0));
  }
  else
  {
    /* Reset values in case of old version of archive file */
    s-&gt;rows= 0;
    s-&gt;forced_flushes= 0;
    s-&gt;shortest_row= 0;
    s-&gt;longest_row= 0;
    s-&gt;auto_increment= 0;
    s-&gt;check_point= 0;
    s-&gt;comment_start_pos= 0;
    s-&gt;comment_length= 0;
    s-&gt;frm_start_pos= 0;
    s-&gt;frm_length= 0;
    check_header(s); /* skip the .az header */
  }

  return 1;
}


int write_header(azio_stream *s)
{
  char buffer[AZHEADER_SIZE + AZMETA_BUFFER_SIZE];
  char *ptr= buffer;

  if (s-&gt;version == 1)
    return 0;

  s-&gt;block_size= AZ_BUFSIZE_WRITE;
  s-&gt;version = (unsigned char)az_magic[1];
  s-&gt;minor_version = (unsigned char)az_magic[2];


  /* Write a very simple .az header: */
  memset(buffer, 0, AZHEADER_SIZE + AZMETA_BUFFER_SIZE);
  *(ptr + AZ_MAGIC_POS)= (char) az_magic[0];
  *(ptr + AZ_VERSION_POS)= (unsigned char)s-&gt;version;
  *(ptr + AZ_MINOR_VERSION_POS)= (unsigned char)s-&gt;minor_version;
  *(ptr + AZ_BLOCK_POS)= (unsigned char)(s-&gt;block_size/1024); /* Reserved for block size */
  *(ptr + AZ_STRATEGY_POS)= (unsigned char)Z_DEFAULT_STRATEGY; /* Compression Type */

  int4store(ptr + AZ_FRM_POS, s-&gt;frm_start_pos); /* FRM Block */
  int4store(ptr + AZ_FRM_LENGTH_POS, s-&gt;frm_length); /* FRM Block */
  int4store(ptr + AZ_COMMENT_POS, s-&gt;comment_start_pos); /* COMMENT Block */
  int4store(ptr + AZ_COMMENT_LENGTH_POS, s-&gt;comment_length); /* COMMENT Block */
  int4store(ptr + AZ_META_POS, 0); /* Meta Block */
  int4store(ptr + AZ_META_LENGTH_POS, 0); /* Meta Block */
  int8store(ptr + AZ_START_POS, (unsigned long long)s-&gt;start); /* Start of Data Block Index Block */
  int8store(ptr + AZ_ROW_POS, (unsigned long long)s-&gt;rows); /* Start of Data Block Index Block */
  int8store(ptr + AZ_FLUSH_POS, (unsigned long long)s-&gt;forced_flushes); /* Start of Data Block Index Block */
  int8store(ptr + AZ_CHECK_POS, (unsigned long long)s-&gt;check_point); /* Start of Data Block Index Block */
  int8store(ptr + AZ_AUTOINCREMENT_POS, (unsigned long long)s-&gt;auto_increment); /* Start of Data Block Index Block */
  int4store(ptr+ AZ_LONGEST_POS , s-&gt;longest_row); /* Longest row */
  int4store(ptr+ AZ_SHORTEST_POS, s-&gt;shortest_row); /* Shorest row */
  int4store(ptr+ AZ_FRM_POS, 
            AZHEADER_SIZE + AZMETA_BUFFER_SIZE); /* FRM position */
  *(ptr + AZ_DIRTY_POS)= (unsigned char)s-&gt;dirty; /* Start of Data Block Index Block */

  /* Always begin at the beginning, and end there as well */
  return my_pwrite(s-&gt;file, (uchar*) buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE,
                   0, MYF(MY_NABP)) ? 1 : 0;
}

/* ===========================================================================
  Opens a gzip (.gz) file for reading or writing.
*/
int azopen(azio_stream *s, const char *path, int Flags)
{
  return az_open(s, path, Flags, -1);
}

/* ===========================================================================
  Associate a gzFile with the file descriptor fd. fd is not dup&#039;ed here
  to mimic the behavio(u)r of fdopen.
*/
int azdopen(azio_stream *s, File fd, int Flags)
{
  if (fd &lt; 0) return 0;

  return az_open (s, NULL, Flags, fd);
}

/* ===========================================================================
  Read a byte from a azio_stream; update next_in and avail_in. Return EOF
  for end of file.
  IN assertion: the stream s has been sucessfully opened for reading.
*/
int get_byte(azio_stream *s)
{
  if (s-&gt;z_eof) return EOF;
  if (s-&gt;stream.avail_in == 0) 
  {
    errno = 0;
    s-&gt;stream.avail_in= (uInt) mysql_file_read(s-&gt;file, (uchar *)s-&gt;inbuf,
                                               AZ_BUFSIZE_READ, MYF(0));
    if (s-&gt;stream.avail_in == 0) 
    {
      s-&gt;z_eof = 1;
      return EOF;
    }
    else if (s-&gt;stream.avail_in == (uInt) -1)
    {
      s-&gt;z_eof= 1;
      s-&gt;z_err= Z_ERRNO;
      return EOF;
    }
    s-&gt;stream.next_in = s-&gt;inbuf;
  }
  s-&gt;stream.avail_in--;
  return *(s-&gt;stream.next_in)++;
}

/* ===========================================================================
  Check the gzip header of a azio_stream opened for reading. Set the stream
  mode to transparent if the gzip magic header is not present; set s-&gt;err
  to Z_DATA_ERROR if the magic header is present but the rest of the header
  is incorrect.
  IN assertion: the stream s has already been created sucessfully;
  s-&gt;stream.avail_in is zero for the first time, but may be non-zero
  for concatenated .gz files.
*/
void check_header(azio_stream *s)
{
  int method; /* method uchar */
  int flags;  /* flags uchar */
  uInt len;
  int c;

  /* Assure two bytes in the buffer so we can peek ahead -- handle case
    where first byte of header is at the end of the buffer after the last
    gzip segment */
  len = s-&gt;stream.avail_in;
  if (len &lt; 2) {
    if (len) s-&gt;inbuf[0] = s-&gt;stream.next_in[0];
    errno = 0;
    len = (uInt)mysql_file_read(s-&gt;file, (uchar *)s-&gt;inbuf + len,
                                AZ_BUFSIZE_READ &gt;&gt; len, MYF(0));
    if (len == (uInt)-1) s-&gt;z_err = Z_ERRNO;
    s-&gt;stream.avail_in += len;
    s-&gt;stream.next_in = s-&gt;inbuf;
    if (s-&gt;stream.avail_in &lt; 2) {
      s-&gt;transparent = s-&gt;stream.avail_in;
      return;
    }
  }

  /* Peek ahead to check the gzip magic header */
  if ( s-&gt;stream.next_in[0] == gz_magic[0]  &amp;&amp; s-&gt;stream.next_in[1] == gz_magic[1])
  {
    read_header(s, s-&gt;stream.next_in);
    s-&gt;stream.avail_in -= 2;
    s-&gt;stream.next_in += 2;

    /* Check the rest of the gzip header */
    method = get_byte(s);
    flags = get_byte(s);
    if (method != Z_DEFLATED || (flags &amp; RESERVED) != 0) {
      s-&gt;z_err = Z_DATA_ERROR;
      return;
    }

    /* Discard time, xflags and OS code: */
    for (len = 0; len &lt; 6; len++) (void)get_byte(s);

    if ((flags &amp; EXTRA_FIELD) != 0) { /* skip the extra field */
      len  =  (uInt)get_byte(s);
      len += ((uInt)get_byte(s))&lt;&lt;8;
      /* len is garbage if EOF but the loop below will quit anyway */
      while (len-- != 0 &amp;&amp; get_byte(s) != EOF) ;
    }
    if ((flags &amp; ORIG_NAME) != 0) { /* skip the original file name */
      while ((c = get_byte(s)) != 0 &amp;&amp; c != EOF) ;
    }
    if ((flags &amp; COMMENT) != 0) {   /* skip the .gz file comment */
      while ((c = get_byte(s)) != 0 &amp;&amp; c != EOF) ;
    }
    if ((flags &amp; HEAD_CRC) != 0) {  /* skip the header crc */
      for (len = 0; len &lt; 2; len++) (void)get_byte(s);
    }
    s-&gt;z_err = s-&gt;z_eof ? Z_DATA_ERROR : Z_OK;
    if (!s-&gt;start)
      s-&gt;start= my_tell(s-&gt;file, MYF(0)) - s-&gt;stream.avail_in;
  }
  else if ( s-&gt;stream.next_in[0] == az_magic[0]  &amp;&amp; s-&gt;stream.next_in[1] == az_magic[1])
  {
    unsigned char buffer[AZHEADER_SIZE + AZMETA_BUFFER_SIZE];

    for (len = 0; len &lt; (AZHEADER_SIZE + AZMETA_BUFFER_SIZE); len++) 
      buffer[len]= get_byte(s);
    s-&gt;z_err = s-&gt;z_eof ? Z_DATA_ERROR : Z_OK;
    read_header(s, buffer);
    for (; len &lt; s-&gt;start; len++) 
      get_byte(s);
  }
  else
  {
    s-&gt;z_err = Z_OK;

    return;
  }
}

void read_header(azio_stream *s, unsigned char *buffer)
{
  if (buffer[0] == az_magic[0]  &amp;&amp; buffer[1] == az_magic[1])
  {
    uchar tmp[AZ_FRMVER_LEN + 2];

    s-&gt;version= (unsigned int)buffer[AZ_VERSION_POS];
    s-&gt;minor_version= (unsigned int)buffer[AZ_MINOR_VERSION_POS];
    s-&gt;block_size= 1024 * buffer[AZ_BLOCK_POS];
    s-&gt;start= (unsigned long long)uint8korr(buffer + AZ_START_POS);
    s-&gt;rows= (unsigned long long)uint8korr(buffer + AZ_ROW_POS);
    s-&gt;check_point= (unsigned long long)uint8korr(buffer + AZ_CHECK_POS);
    s-&gt;forced_flushes= (unsigned long long)uint8korr(buffer + AZ_FLUSH_POS);
    s-&gt;auto_increment= (unsigned long long)uint8korr(buffer + AZ_AUTOINCREMENT_POS);
    s-&gt;longest_row= (unsigned int)uint4korr(buffer + AZ_LONGEST_POS);
    s-&gt;shortest_row= (unsigned int)uint4korr(buffer + AZ_SHORTEST_POS);
    s-&gt;frm_start_pos= (unsigned int)uint4korr(buffer + AZ_FRM_POS);
    s-&gt;frm_length= (unsigned int)uint4korr(buffer + AZ_FRM_LENGTH_POS);
    s-&gt;comment_start_pos= (unsigned int)uint4korr(buffer + AZ_COMMENT_POS);
    s-&gt;comment_length= (unsigned int)uint4korr(buffer + AZ_COMMENT_LENGTH_POS);
    s-&gt;dirty= (unsigned int)buffer[AZ_DIRTY_POS];

    /*
      we&#039;ll hard-code the current frm format for now, to avoid
      changing archive table versions.
    */
    if (s-&gt;frm_length == 0 ||
        my_pread(s-&gt;file, tmp,  sizeof(tmp), s-&gt;frm_start_pos + 64, MYF(MY_NABP)) ||
        tmp[0] != 0 || tmp[1] != AZ_FRMVER_LEN)
    {
      s-&gt;frmver_length= 0;
    }
    else
    {
      s-&gt;frmver_length= tmp[1];
      memcpy(s-&gt;frmver, tmp+2, s-&gt;frmver_length);
    }
  }
  else if (buffer[0] == gz_magic[0]  &amp;&amp; buffer[1] == gz_magic[1])
  {
    /*
      Set version number to previous version (1).
    */
    s-&gt;version= 1;
    s-&gt;auto_increment= 0;
    s-&gt;frm_length= 0;
    s-&gt;longest_row= 0;
    s-&gt;shortest_row= 0;
  } else {
    /*
      Unknown version.
      Most probably due to a corrupt archive.
    */
    s-&gt;dirty= AZ_STATE_DIRTY;
    s-&gt;z_err= Z_VERSION_ERROR;
  }
}

/* ===========================================================================
 * Cleanup then free the given azio_stream. Return a zlib error code.
 Try freeing in the reverse order of allocations.
 */
int destroy (azio_stream *s)
{
  int err = Z_OK;

  if (s-&gt;stream.state != NULL) 
  {
    if (s-&gt;mode == &#039;w&#039;) 
      err = deflateEnd(&amp;(s-&gt;stream));
    else if (s-&gt;mode == &#039;r&#039;) 
      err = inflateEnd(&amp;(s-&gt;stream));
  }

  if (s-&gt;file &gt; 0 &amp;&amp; my_close(s-&gt;file, MYF(0))) 
      err = Z_ERRNO;

  s-&gt;file= -1;

  if (s-&gt;z_err &lt; 0) err = s-&gt;z_err;

  return err;
}

/* ===========================================================================
  Reads the given number of uncompressed bytes from the compressed file.
  azread returns the number of bytes actually read (0 for end of file).
*/
unsigned int ZEXPORT azread ( azio_stream *s, voidp buf, size_t len, int *error)
{
  Bytef *start = (Bytef*)buf; /* starting point for crc computation */
  Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
  *error= 0;

  if (s-&gt;mode != &#039;r&#039;)
  { 
    *error= Z_STREAM_ERROR;
    return 0;
  }

  if (s-&gt;z_err == Z_DATA_ERROR || s-&gt;z_err == Z_ERRNO)
  { 
    *error= s-&gt;z_err;
    return 0;
  }

  if (s-&gt;z_err == Z_STREAM_END)  /* EOF */
  { 
    return 0;
  }

  next_out = (Byte*)buf;
  s-&gt;stream.next_out = (Bytef*)buf;
  s-&gt;stream.avail_out = (uInt)len;

  if (s-&gt;stream.avail_out &amp;&amp; s-&gt;back != EOF) {
    *next_out++ = s-&gt;back;
    s-&gt;stream.next_out++;
    s-&gt;stream.avail_out--;
    s-&gt;back = EOF;
    s-&gt;out++;
    start++;
    if (s-&gt;last) {
      s-&gt;z_err = Z_STREAM_END;
      { 
        return 1;
      }
    }
  }

  while (s-&gt;stream.avail_out != 0) {

    if (s-&gt;transparent) {
      /* Copy first the lookahead bytes: */
      uInt n = s-&gt;stream.avail_in;
      if (n &gt; s-&gt;stream.avail_out) n = s-&gt;stream.avail_out;
      if (n &gt; 0) {
        memcpy(s-&gt;stream.next_out, s-&gt;stream.next_in, n);
        next_out += n;
        s-&gt;stream.next_out = (Bytef *)next_out;
        s-&gt;stream.next_in   += n;
        s-&gt;stream.avail_out -= n;
        s-&gt;stream.avail_in  -= n;
      }
      if (s-&gt;stream.avail_out &gt; 0) 
      {
        s-&gt;stream.avail_out -=
          (uInt)mysql_file_read(s-&gt;file, (uchar *)next_out,
                                s-&gt;stream.avail_out, MYF(0));
      }
      len -= s-&gt;stream.avail_out;
      s-&gt;in  += len;
      s-&gt;out += len;
      if (len == 0) s-&gt;z_eof = 1;
      { 
        return (uint)len;
      }
    }
    if (s-&gt;stream.avail_in == 0 &amp;&amp; !s-&gt;z_eof) {

      errno = 0;
      s-&gt;stream.avail_in = (uInt)mysql_file_read(s-&gt;file, (uchar *)s-&gt;inbuf,
                                                 AZ_BUFSIZE_READ, MYF(0));
      if (s-&gt;stream.avail_in == 0) 
      {
        s-&gt;z_eof = 1;
      }
      s-&gt;stream.next_in = (Bytef *)s-&gt;inbuf;
    }
    s-&gt;in += s-&gt;stream.avail_in;
    s-&gt;out += s-&gt;stream.avail_out;
    s-&gt;z_err = inflate(&amp;(s-&gt;stream), Z_NO_FLUSH);
    s-&gt;in -= s-&gt;stream.avail_in;
    s-&gt;out -= s-&gt;stream.avail_out;

    if (s-&gt;z_err == Z_STREAM_END) {
      /* Check CRC and original size */
      s-&gt;crc = crc32(s-&gt;crc, start, (uInt)(s-&gt;stream.next_out - start));
      start = s-&gt;stream.next_out;

      if (getLong(s) != s-&gt;crc) {
        s-&gt;z_err = Z_DATA_ERROR;
      } else {
        (void)getLong(s);
        /* The uncompressed length returned by above getlong() may be
         * different from s-&gt;out in case of concatenated .gz files.
         * Check for such files:
       */
        check_header(s);
        if (s-&gt;z_err == Z_OK) 
        {
          inflateReset(&amp;(s-&gt;stream));
          s-&gt;crc = crc32(0L, Z_NULL, 0);
        }
      }
    }
    if (s-&gt;z_err != Z_OK || s-&gt;z_eof) break;
  }
  s-&gt;crc = crc32(s-&gt;crc, start, (uInt)(s-&gt;stream.next_out - start));

  if (len == s-&gt;stream.avail_out &amp;&amp;
      (s-&gt;z_err == Z_DATA_ERROR || s-&gt;z_err == Z_ERRNO))
  {
    *error= s-&gt;z_err;

    return 0;
  }

  return (uint)(len - s-&gt;stream.avail_out);
}


/* ===========================================================================
  Writes the given number of uncompressed bytes into the compressed file.
  azwrite returns the number of bytes actually written (0 in case of error).
*/
unsigned int azwrite (azio_stream *s, const voidp buf, unsigned int len)
{
  s-&gt;stream.next_in = (Bytef*)buf;
  s-&gt;stream.avail_in = len;

  s-&gt;rows++;

  while (s-&gt;stream.avail_in != 0) 
  {
    if (s-&gt;stream.avail_out == 0) 
    {

      s-&gt;stream.next_out = s-&gt;outbuf;
      if (mysql_file_write(s-&gt;file, (uchar *)s-&gt;outbuf, AZ_BUFSIZE_WRITE, 
                           MYF(0)) != AZ_BUFSIZE_WRITE) 
      {
        s-&gt;z_err = Z_ERRNO;
        break;
      }
      s-&gt;stream.avail_out = AZ_BUFSIZE_WRITE;
    }
    s-&gt;in += s-&gt;stream.avail_in;
    s-&gt;out += s-&gt;stream.avail_out;
    s-&gt;z_err = deflate(&amp;(s-&gt;stream), Z_NO_FLUSH);
    s-&gt;in -= s-&gt;stream.avail_in;
    s-&gt;out -= s-&gt;stream.avail_out;
    if (s-&gt;z_err != Z_OK) break;
  }
  s-&gt;crc = crc32(s-&gt;crc, (const Bytef *)buf, len);

  if (len &gt; s-&gt;longest_row)
    s-&gt;longest_row= len;

  if (len &lt; s-&gt;shortest_row || !(s-&gt;shortest_row))
    s-&gt;shortest_row= len;

  return (unsigned int)(len - s-&gt;stream.avail_in);
}


/* ===========================================================================
  Flushes all pending output into the compressed file. The parameter
  flush is as in the deflate() function.
*/
int do_flush (azio_stream *s, int flush)
{
  uInt len;
  int done = 0;
  my_off_t afterwrite_pos;

  if (s == NULL || s-&gt;mode != &#039;w&#039;) return Z_STREAM_ERROR;

  s-&gt;stream.avail_in = 0; /* should be zero already anyway */

  for (;;) 
  {
    len = AZ_BUFSIZE_WRITE - s-&gt;stream.avail_out;

    if (len != 0) 
    {
      s-&gt;check_point= my_tell(s-&gt;file, MYF(0));
      if ((uInt)mysql_file_write(s-&gt;file, (uchar *)s-&gt;outbuf, len, MYF(0)) != len) 
      {
        s-&gt;z_err = Z_ERRNO;
        return Z_ERRNO;
      }
      s-&gt;stream.next_out = s-&gt;outbuf;
      s-&gt;stream.avail_out = AZ_BUFSIZE_WRITE;
    }
    if (done) break;
    s-&gt;out += s-&gt;stream.avail_out;
    s-&gt;z_err = deflate(&amp;(s-&gt;stream), flush);
    s-&gt;out -= s-&gt;stream.avail_out;

    /* Ignore the second of two consecutive flushes: */
    if (len == 0 &amp;&amp; s-&gt;z_err == Z_BUF_ERROR) s-&gt;z_err = Z_OK;

    /* deflate has finished flushing only when it hasn&#039;t used up
     * all the available space in the output buffer:
   */
    done = (s-&gt;stream.avail_out != 0 || s-&gt;z_err == Z_STREAM_END);

    if (s-&gt;z_err != Z_OK &amp;&amp; s-&gt;z_err != Z_STREAM_END) break;
  }

  if (flush == Z_FINISH)
    s-&gt;dirty= AZ_STATE_CLEAN; /* Mark it clean, we should be good now */
  else
    s-&gt;dirty= AZ_STATE_SAVED; /* Mark it clean, we should be good now */

  afterwrite_pos= my_tell(s-&gt;file, MYF(0));
  write_header(s);
  my_seek(s-&gt;file, afterwrite_pos, SEEK_SET, MYF(0));

  return  s-&gt;z_err == Z_STREAM_END ? Z_OK : s-&gt;z_err;
}

int ZEXPORT azflush (azio_stream *s, int flush)
{
  int err;

  if (s-&gt;mode == &#039;r&#039;) 
  {
    unsigned char buffer[AZHEADER_SIZE + AZMETA_BUFFER_SIZE];
    my_pread(s-&gt;file, (uchar*) buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE, 0,
             MYF(0));
    read_header(s, buffer); /* skip the .az header */

    return Z_OK;
  }
  else
  {
    s-&gt;forced_flushes++;
    err= do_flush(s, flush);

    if (err) return err;
    my_sync(s-&gt;file, MYF(0));
    return  s-&gt;z_err == Z_STREAM_END ? Z_OK : s-&gt;z_err;
  }
}

/* ===========================================================================
  Rewinds input file.
*/
int azrewind (azio_stream *s)
{
  if (s == NULL || s-&gt;mode != &#039;r&#039;) return -1;

  s-&gt;z_err = Z_OK;
  s-&gt;z_eof = 0;
  s-&gt;back = EOF;
  s-&gt;stream.avail_in = 0;
  s-&gt;stream.next_in = (Bytef *)s-&gt;inbuf;
  s-&gt;crc = crc32(0L, Z_NULL, 0);
  if (!s-&gt;transparent) (void)inflateReset(&amp;s-&gt;stream);
  s-&gt;in = 0;
  s-&gt;out = 0;
  return my_seek(s-&gt;file, (int)s-&gt;start, MY_SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR;
}

/* ===========================================================================
  Sets the starting position for the next azread or azwrite on the given
  compressed file. The offset represents a number of bytes in the
  azseek returns the resulting offset location as measured in bytes from
  the beginning of the uncompressed stream, or -1 in case of error.
  SEEK_END is not implemented, returns error.
  In this version of the library, azseek can be extremely slow.
*/
my_off_t azseek (azio_stream *s, my_off_t offset, int whence)
{

  if (s == NULL || whence == SEEK_END ||
      s-&gt;z_err == Z_ERRNO || s-&gt;z_err == Z_DATA_ERROR) {
    return -1L;
  }

  if (s-&gt;mode == &#039;w&#039;) 
  {
    if (whence == SEEK_SET) 
      offset -= s-&gt;in;

    /* At this point, offset is the number of zero bytes to write. */
    /* There was a zmemzero here if inbuf was null -Brian */
    while (offset &gt; 0)  
    {
      uInt size = AZ_BUFSIZE_READ;
      if (offset &lt; AZ_BUFSIZE_READ) size = (uInt)offset;

      size = azwrite(s, s-&gt;inbuf, size);
      if (size == 0) return -1L;

      offset -= size;
    }
    return s-&gt;in;
  }
  /* Rest of function is for reading only */

  /* compute absolute position */
  if (whence == SEEK_CUR) {
    offset += s-&gt;out;
  }

  if (s-&gt;transparent) {
    /* map to my_seek */
    s-&gt;back = EOF;
    s-&gt;stream.avail_in = 0;
    s-&gt;stream.next_in = (Bytef *)s-&gt;inbuf;
    if (my_seek(s-&gt;file, offset, MY_SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR) return -1L;

    s-&gt;in = s-&gt;out = offset;
    return offset;
  }

  /* For a negative seek, rewind and use positive seek */
  if (offset &gt;= s-&gt;out) {
    offset -= s-&gt;out;
  } else if (azrewind(s)) {
    return -1L;
  }
  /* offset is now the number of bytes to skip. */

  if (offset &amp;&amp; s-&gt;back != EOF) {
    s-&gt;back = EOF;
    s-&gt;out++;
    offset--;
    if (s-&gt;last) s-&gt;z_err = Z_STREAM_END;
  }
  while (offset &gt; 0)  {
    int error;
    unsigned int size = AZ_BUFSIZE_WRITE;
    if (offset &lt; AZ_BUFSIZE_WRITE) size = (int)offset;

    size = azread(s, s-&gt;outbuf, size, &amp;error);
    if (error &lt; 0) return -1L;
    offset -= size;
  }
  return s-&gt;out;
}

/* ===========================================================================
  Returns the starting position for the next azread or azwrite on the
  given compressed file. This position represents a number of bytes in the
  uncompressed data stream.
*/
my_off_t ZEXPORT aztell (azio_stream *file)
{
  return azseek(file, 0L, SEEK_CUR);
}


/* ===========================================================================
  Outputs a long in LSB order to the given file
*/
void putLong (File file, uLong x)
{
  int n;
  uchar buffer[1];

  for (n = 0; n &lt; 4; n++) 
  {
    buffer[0]= (int)(x &amp; 0xff);
    mysql_file_write(file, buffer, 1, MYF(0));
    x &gt;&gt;= 8;
  }
}

/* ===========================================================================
  Reads a long in LSB order from the given azio_stream. Sets z_err in case
  of error.
*/
uLong getLong (azio_stream *s)
{
  uLong x = (uLong)get_byte(s);
  int c;

  x += ((uLong)get_byte(s))&lt;&lt;8;
  x += ((uLong)get_byte(s))&lt;&lt;16;
  c = get_byte(s);
  if (c == EOF) s-&gt;z_err = Z_DATA_ERROR;
  x += ((uLong)c)&lt;&lt;24;
  return x;
}

/* ===========================================================================
  Flushes all pending output if necessary, closes the compressed file
  and deallocates all the (de)compression state.
*/
int azclose (azio_stream *s)
{

  if (s == NULL) return Z_STREAM_ERROR;
  
  if (s-&gt;file &lt; 1) return Z_OK;

  if (s-&gt;mode == &#039;w&#039;) 
  {
    if (do_flush(s, Z_FINISH) != Z_OK)
    {
      destroy(s);
      return Z_ERRNO;
    }

    putLong(s-&gt;file, s-&gt;crc);
    putLong(s-&gt;file, (uLong)(s-&gt;in &amp; 0xffffffff));
    s-&gt;dirty= AZ_STATE_CLEAN;
    s-&gt;check_point= my_tell(s-&gt;file, MYF(0));
    write_header(s);
  }

  return destroy(s);
}

/*
  Though this was added to support MySQL&#039;s FRM file, anything can be 
  stored in this location.
*/
int azwrite_frm(azio_stream *s, const uchar *blob, size_t length)
{
  if (s-&gt;mode == &#039;r&#039;) 
    return 1;

  if (s-&gt;rows &gt; 0) 
    return 1;

  s-&gt;frm_start_pos= (uint) s-&gt;start;
  s-&gt;frm_length= (uint)length;
  s-&gt;start+= length;

  if (my_pwrite(s-&gt;file, blob, s-&gt;frm_length,
                s-&gt;frm_start_pos, MYF(MY_NABP)) ||
      write_header(s) ||
      (my_seek(s-&gt;file, 0, MY_SEEK_END, MYF(0)) == MY_FILEPOS_ERROR))
    return 1;

  return 0;
}

int azread_frm(azio_stream *s, uchar *blob)
{
  return my_pread(s-&gt;file, blob, s-&gt;frm_length,
                  s-&gt;frm_start_pos, MYF(MY_NABP)) ? 1 : 0;
}


/*
  Simple comment field
*/
int azwrite_comment(azio_stream *s, const char *blob, size_t length)
{
  if (s-&gt;mode == &#039;r&#039;) 
    return 1;

  if (s-&gt;rows &gt; 0) 
    return 1;

  s-&gt;comment_start_pos= (uint) s-&gt;start;
  s-&gt;comment_length= (uint)length;
  s-&gt;start+= length;

  my_pwrite(s-&gt;file, (uchar*) blob, s-&gt;comment_length, s-&gt;comment_start_pos,
            MYF(0));

  write_header(s);
  my_seek(s-&gt;file, 0, MY_SEEK_END, MYF(0));

  return 0;
}

int azread_comment(azio_stream *s, char *blob)
{
  my_pread(s-&gt;file, (uchar*) blob, s-&gt;comment_length, s-&gt;comment_start_pos,
           MYF(0));

  return 0;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Farchive'>🔙 Back</a></p>