�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: archive_reader.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Copyright (c) 2007, 2010, Oracle and/or its affiliates

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA */

#include &quot;azlib.h&quot;
#include &lt;string.h&gt;
#include &lt;assert.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;
#include &lt;m_ctype.h&gt;
#include &lt;m_string.h&gt;
#include &lt;my_getopt.h&gt;
#include &lt;mysql_version.h&gt;

#define BUFFER_LEN 1024
#define ARCHIVE_ROW_HEADER_SIZE 4

#define VER &quot;0.1&quot;

static void get_options(int *argc,char * * *argv);
static void print_version(void);
static void usage(void);
static const char *opt_tmpdir;
static const char *new_auto_increment;
unsigned long long new_auto_increment_value;
static const char *load_default_groups[]= { &quot;archive_reader&quot;, 0 };
static char **default_argv;
int opt_check, opt_force, opt_quiet, opt_backup= 0, opt_extract_frm;
int opt_autoincrement;

int main(int argc, char *argv[])
{
  unsigned int ret;
  azio_stream reader_handle;

  MY_INIT(argv[0]);
  get_options(&amp;argc, &amp;argv);

  if (argc &lt; 1)
  {
    printf(&quot;No file specified. \n&quot;);
    return 0;
  }

  if (!(ret= azopen(&amp;reader_handle, argv[0], O_RDONLY|O_BINARY)))
  {
    printf(&quot;Could not open Archive file\n&quot;);
    return 0;
  }

  if (opt_autoincrement)
  {
    azio_stream writer_handle;

    if (new_auto_increment_value)
    {
      if (reader_handle.auto_increment &gt;= new_auto_increment_value)
      {
        printf(&quot;Value is lower then current value\n&quot;);
        goto end;
      }
    }
    else
    {
      new_auto_increment_value= reader_handle.auto_increment + 1;
    }

    if (!(ret= azopen(&amp;writer_handle, argv[0], O_CREAT|O_RDWR|O_BINARY)))
    {
      printf(&quot;Could not open file for update: %s\n&quot;, argv[0]);
      goto end;
    }

    writer_handle.auto_increment= new_auto_increment_value;

    azclose(&amp;writer_handle);
    azflush(&amp;reader_handle, Z_SYNC_FLUSH);
  }

  printf(&quot;Version %u\n&quot;, reader_handle.version);
  if (reader_handle.version &gt; 2)
  {
    printf(&quot;\tMinor version %u\n&quot;, reader_handle.minor_version);
    printf(&quot;\tStart position %llu\n&quot;, (unsigned long long)reader_handle.start);
    printf(&quot;\tBlock size %u\n&quot;, reader_handle.block_size);
    printf(&quot;\tRows %llu\n&quot;, reader_handle.rows);
    printf(&quot;\tAutoincrement %llu\n&quot;, reader_handle.auto_increment);
    printf(&quot;\tCheck Point %llu\n&quot;, reader_handle.check_point);
    printf(&quot;\tForced Flushes %llu\n&quot;, reader_handle.forced_flushes);
    printf(&quot;\tLongest Row %u\n&quot;, reader_handle.longest_row);
    printf(&quot;\tShortest Row %u\n&quot;, reader_handle.shortest_row);
    printf(&quot;\tState %s\n&quot;, ( reader_handle.dirty ? &quot;dirty&quot; : &quot;clean&quot;));
    printf(&quot;\tFRM stored at %u\n&quot;, reader_handle.frm_start_pos);
    printf(&quot;\tComment stored at %u\n&quot;, reader_handle.comment_start_pos);
    printf(&quot;\tData starts at %u\n&quot;, (unsigned int)reader_handle.start);
    if (reader_handle.frm_start_pos)
      printf(&quot;\tFRM length %u\n&quot;, reader_handle.frm_length);
    if (reader_handle.comment_start_pos)
    {
      char *comment = (char *) my_malloc(reader_handle.comment_length,
                                         MYF(MY_WME));
      if (comment)
      {
        azread_comment(&amp;reader_handle, comment);
        printf(&quot;\tComment length %u\n\t\t%.*s\n&quot;,
               reader_handle.comment_length, 
               reader_handle.comment_length, comment);
        my_free(comment,MYF(0));
      }
    }
  }
  else
  {
    goto end;
  }

  printf(&quot;\n&quot;);

  if (opt_check)
  {
    uchar size_buffer[ARCHIVE_ROW_HEADER_SIZE];
    int error;
    unsigned int x;
    unsigned int read;
    unsigned int row_len;
    unsigned long long row_count= 0;
    char buffer;

    while ((read= azread(&amp;reader_handle, (uchar *)size_buffer, 
                        ARCHIVE_ROW_HEADER_SIZE, &amp;error)))
    {
      if (error == Z_STREAM_ERROR ||  (read &amp;&amp; read &lt; ARCHIVE_ROW_HEADER_SIZE))
      {
        printf(&quot;Table is damaged\n&quot;);
        goto end;
      }

      /* If we read nothing we are at the end of the file */
      if (read == 0 || read != ARCHIVE_ROW_HEADER_SIZE)
        break;

      row_len=  uint4korr(size_buffer);
      row_count++;

      if (row_len &gt; reader_handle.longest_row)
      {
        printf(&quot;Table is damaged, row %llu is invalid\n&quot;, 
               row_count);
        goto end;
      }


      for (read= x= 0; x &lt; row_len ; x++) 
      {
        read+= (unsigned int)azread(&amp;reader_handle, &amp;buffer, sizeof(char), &amp;error); 
        if (!read)
          break;
      }


      if (row_len != read)
      {
        printf(&quot;Row length did not match row (at %llu). %u != %u \n&quot;, 
               row_count, row_len, read);
        goto end;
      }
    }

    if (0)
    {
      printf(&quot;Table is damaged\n&quot;);
      goto end;
    }
    else
    {
      printf(&quot;Found %llu rows\n&quot;, row_count);
    }
  }

  if (opt_backup)
  {
    uchar size_buffer[ARCHIVE_ROW_HEADER_SIZE];
    int error;
    unsigned int read;
    unsigned int row_len;
    unsigned long long row_count= 0;
    char *buffer;

    azio_stream writer_handle;

    buffer= (char *) my_malloc(reader_handle.longest_row, MYF(0));
    if (buffer == NULL)
    {
      printf(&quot;Could not allocate memory for row %llu\n&quot;, row_count);
      goto end;
    }


    if (!(ret= azopen(&amp;writer_handle, argv[1], O_CREAT|O_RDWR|O_BINARY)))
    {
      printf(&quot;Could not open file for backup: %s\n&quot;, argv[1]);
      goto end;
    }

    writer_handle.auto_increment= reader_handle.auto_increment;
    if (reader_handle.frm_length)
    {
      char *ptr;
      ptr= (char *)my_malloc(sizeof(char) * reader_handle.frm_length, MYF(0));
      azread_frm(&amp;reader_handle, ptr);
      azwrite_frm(&amp;writer_handle, ptr, reader_handle.frm_length);
      my_free(ptr);
    }

    if (reader_handle.comment_length)
    {
      char *ptr;
      ptr= (char *)my_malloc(sizeof(char) * reader_handle.comment_length, MYF(0));
      azread_comment(&amp;reader_handle, ptr);
      azwrite_comment(&amp;writer_handle, ptr, reader_handle.comment_length);
      my_free(ptr);
    }

    while ((read= azread(&amp;reader_handle, (uchar *)size_buffer, 
                        ARCHIVE_ROW_HEADER_SIZE, &amp;error)))
    {
      if (error == Z_STREAM_ERROR ||  (read &amp;&amp; read &lt; ARCHIVE_ROW_HEADER_SIZE))
      {
        printf(&quot;Table is damaged\n&quot;);
        goto end;
      }

      /* If we read nothing we are at the end of the file */
      if (read == 0 || read != ARCHIVE_ROW_HEADER_SIZE)
        break;

      row_len=  uint4korr(size_buffer);

      row_count++;

      memcpy(buffer, size_buffer, ARCHIVE_ROW_HEADER_SIZE);

      read= (unsigned int)azread(&amp;reader_handle, buffer + ARCHIVE_ROW_HEADER_SIZE, 
                                 row_len, &amp;error); 

      DBUG_ASSERT(read == row_len);

      azwrite(&amp;writer_handle, buffer, row_len + ARCHIVE_ROW_HEADER_SIZE);


      if (row_len != read)
      {
        printf(&quot;Row length did not match row (at %llu). %u != %u \n&quot;, 
               row_count, row_len, read);
        goto end;
      }

      if (reader_handle.rows == writer_handle.rows)
        break;
    }

    my_free(buffer, MYF(0));

    azclose(&amp;writer_handle);
  }

  if (opt_extract_frm)
  {
    File frm_file;
    char *ptr;
    frm_file= my_open(argv[1], O_CREAT|O_RDWR|O_BINARY, MYF(0));
    ptr= (char *)my_malloc(sizeof(char) * reader_handle.frm_length, MYF(0));
    azread_frm(&amp;reader_handle, ptr);
    my_write(frm_file, (uchar*) ptr, reader_handle.frm_length, MYF(0));
    my_close(frm_file, MYF(0));
    my_free(ptr);
  }

end:
  printf(&quot;\n&quot;);
  azclose(&amp;reader_handle);

  return 0;
}

static my_bool
get_one_option(int optid,
	       const struct my_option *opt __attribute__((unused)),
	       char *argument)
{
  switch (optid) {
  case &#039;b&#039;:
    opt_backup= 1;
    break;
  case &#039;c&#039;:
    opt_check= 1;
    break;
  case &#039;e&#039;:
    opt_extract_frm= 1;
    break;
  case &#039;f&#039;:
    opt_force= 1;
    printf(&quot;Not implemented yet\n&quot;);
    break;
  case &#039;q&#039;:
    opt_quiet= 1;
    printf(&quot;Not implemented yet\n&quot;);
    break;
  case &#039;V&#039;:
    print_version();
    exit(0);
  case &#039;t&#039;:
    printf(&quot;Not implemented yet\n&quot;);
    break;
  case &#039;A&#039;:
    opt_autoincrement= 1;
    if (argument)
      new_auto_increment_value= strtoull(argument, NULL, 0);
    else
      new_auto_increment_value= 0;
    break;
  case &#039;?&#039;:
    usage();
    exit(0);
  case &#039;#&#039;:
    if (argument == disabled_my_option)
    {
      DBUG_POP();
    }
    else
    {
      DBUG_PUSH(argument ? argument : &quot;d:t:o,/tmp/archive_reader.trace&quot;);
    }
    break;
  }
  return 0;
}

static struct my_option my_long_options[] =
{
  {&quot;backup&quot;, &#039;b&#039;,
   &quot;Make a backup of an archive table.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;check&quot;, &#039;c&#039;, &quot;Check table for errors.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
#ifndef DBUG_OFF
  {&quot;debug&quot;, &#039;#&#039;,
   &quot;Output debug log. Often this is &#039;d:t:o,filename&#039;.&quot;,
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
  {&quot;extract-frm&quot;, &#039;e&#039;,
   &quot;Extract the frm file.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;force&quot;, &#039;f&#039;,
   &quot;Restart with -r if there are any errors in the table.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;help&quot;, &#039;?&#039;,
   &quot;Display this help and exit.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;quick&quot;, &#039;q&#039;, &quot;Faster repair by not modifying the data file.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;repair&quot;, &#039;r&#039;, &quot;Repair a damaged Archive version 3 or above file.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;set-auto-increment&quot;, &#039;A&#039;,
   &quot;Force auto_increment to start at this or higher value. If no value is given, then sets the next auto_increment value to the highest used value for the auto key + 1.&quot;,
   &amp;new_auto_increment, &amp;new_auto_increment,
   0, GET_ULL, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;silent&quot;, &#039;s&#039;,
   &quot;Only print errors. One can use two -s to make archive_reader very silent.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;tmpdir&quot;, &#039;t&#039;,
   &quot;Path for temporary files.&quot;,
   &amp;opt_tmpdir,
   0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;version&quot;, &#039;V&#039;,
   &quot;Print version and exit.&quot;,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};

static void usage(void)
{
  print_version();
  puts(&quot;Copyright 2007-2008 MySQL AB, 2008 Sun Microsystems, Inc.&quot;);
  puts(&quot;This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n&quot;);
  puts(&quot;Read and modify Archive files directly\n&quot;);
  printf(&quot;Usage: %s [OPTIONS] file_to_be_looked_at [file_for_backup]\n&quot;, my_progname);
  print_defaults(&quot;my&quot;, load_default_groups);
  my_print_help(my_long_options);
}

static void get_options(int *argc, char ***argv)
{
  load_defaults_or_exit(&quot;my&quot;, load_default_groups, argc, argv);
  default_argv= *argv;

  handle_options(argc, argv, my_long_options, get_one_option);

  if (*argc == 0)
  {
    usage();
    exit(-1);
  }

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