summaryrefslogtreecommitdiff
path: root/extra
diff options
context:
space:
mode:
Diffstat (limited to 'extra')
-rw-r--r--extra/.cvsignore10
-rw-r--r--extra/Attic/print_defaults.c125
-rw-r--r--extra/Makefile.am29
-rw-r--r--extra/comp_err.c275
-rw-r--r--extra/my_print_defaults.c125
-rw-r--r--extra/perror.c207
-rw-r--r--extra/replace.c1080
-rw-r--r--extra/resolveip.c204
8 files changed, 2055 insertions, 0 deletions
diff --git a/extra/.cvsignore b/extra/.cvsignore
new file mode 100644
index 00000000000..e0042c405cc
--- /dev/null
+++ b/extra/.cvsignore
@@ -0,0 +1,10 @@
+.deps
+.libs
+Makefile
+Makefile.in
+comp_err
+my_print_defaults
+perror
+print_defaults
+replace
+resolveip
diff --git a/extra/Attic/print_defaults.c b/extra/Attic/print_defaults.c
new file mode 100644
index 00000000000..a6e67e4949e
--- /dev/null
+++ b/extra/Attic/print_defaults.c
@@ -0,0 +1,125 @@
+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA */
+
+/*
+** print_default.c:
+** Print all parameters in a default file that will be given to some program.
+**
+** Written by Monty
+*/
+
+#include <global.h>
+#include <my_sys.h>
+#include <getopt.h>
+
+const char *config_file="my"; /* Default config file */
+
+static struct option long_options[] =
+{
+ {"config-file", required_argument, 0, 'c'},
+ {"defaults-file", required_argument, 0, 'c'},
+ {"no-defaults", no_argument, 0, 'd'},
+ {"help", no_argument, 0, '?'},
+ {"version", no_argument, 0, 'V'},
+ {0, 0, 0, 0}
+};
+
+static void usage(my_bool version)
+{
+ printf("%s Ver 1.1 for %s at %s\n",my_progname,SYSTEM_TYPE,
+ MACHINE_TYPE);
+ if (version)
+ return;
+ puts("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");
+ puts("Prints all arguments that is give to some program using the default files");
+ printf("Usage: %s [OPTIONS] groups\n",my_progname);
+ printf("\n\
+ -c, --config-file=# --defaults-file=#\n\
+ The config file to use (default '%s')\n\
+ --no-defaults Return an empty string (useful for scripts)\n\
+ -?, --help Display this help message and exit.\n\
+ -V, --version Output version information and exit.\n",
+ config_file);
+ printf("\nExample usage: %s --config-file=my client mysql\n",my_progname);
+}
+
+static int get_options(int *argc,char ***argv)
+{
+ int c,option_index;
+
+ while ((c=getopt_long(*argc,*argv,"c:V?I",
+ long_options, &option_index)) != EOF)
+ {
+ switch (c) {
+ case 'c':
+ config_file=optarg;
+ break;
+ case 'n':
+ exit(0);
+ case 'I':
+ case '?':
+ usage(0);
+ exit(0);
+ case 'V':
+ usage(1);
+ exit(0);
+ }
+ }
+ (*argc)-=optind;
+ (*argv)+=optind;
+ if (*argc < 1)
+ {
+ usage(0);
+ return 1;
+ }
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ int count;
+ char **load_default_groups, *tmp_arguments[2],
+ **argument, **arguments;
+ MY_INIT(argv[0]);
+
+ /*
+ ** Check out the args
+ */
+ if (get_options(&argc,&argv))
+ exit(1);
+ if (!(load_default_groups=(char**) my_malloc((argc+2)*sizeof(char*),
+ MYF(MY_WME))))
+ exit(1);
+
+ for (count=0; *argv ; argv++,count++)
+ load_default_groups[count]= *argv;
+ load_default_groups[count]=0;
+
+ count=1;
+ arguments=tmp_arguments;
+ arguments[0]=my_progname;
+ arguments[1]=0;
+ load_defaults(config_file, (const char **) load_default_groups,
+ &count, &arguments);
+
+ for (argument= arguments+1 ; *argument ; argument++)
+ puts(*argument);
+ my_free((char*) load_default_groups,MYF(0));
+ free_defaults(arguments);
+
+ exit(0);
+}
diff --git a/extra/Makefile.am b/extra/Makefile.am
new file mode 100644
index 00000000000..8fd41221cfe
--- /dev/null
+++ b/extra/Makefile.am
@@ -0,0 +1,29 @@
+# Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+#
+# 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; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+INCLUDES = @MT_INCLUDES@ -I$(srcdir)/../include -I../include -I..
+LDADD = @CLIENT_EXTRA_LDFLAGS@ ../mysys/libmysys.a \
+ ../dbug/libdbug.a ../strings/libmystrings.a
+bin_PROGRAMS = replace comp_err perror resolveip my_print_defaults
+
+OMIT_DEPENDENCIES = pthread.h stdio.h __stdio.h stdlib.h __stdlib.h math.h\
+ __math.h time.h __time.h unistd.h __unistd.h types.h \
+ xtypes.h ac-types.h posix.h string.h __string.h \
+ errno.h socket.h inet.h dirent.h netdb.h \
+ cleanup.h cond.h debug_out.h fd.h kernel.h mutex.h \
+ prio_queue.h pthread_attr.h pthread_once.h queue.h\
+ sleep.h specific.h version.h pwd.h timers.h uio.h \
+ cdefs.h machdep.h signal.h __signal.h
diff --git a/extra/comp_err.c b/extra/comp_err.c
new file mode 100644
index 00000000000..198bdffb0db
--- /dev/null
+++ b/extra/comp_err.c
@@ -0,0 +1,275 @@
+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA */
+
+/* Saves all errmesg in a header file, updated by me, in a compact file */
+
+#include <global.h>
+#include <m_ctype.h>
+#include <my_sys.h>
+#include <m_string.h>
+
+#define MAXLENGTH 1000
+#define MAX_ROWS 1000
+#define MAX_FILES 10
+
+int row_count;
+uint file_pos[MAX_ROWS],file_row_pos[MAX_FILES];
+my_string saved_row[MAX_ROWS];
+uchar file_head[]= { 254,254,2,1 };
+
+static void get_options(int *argc,char **argv[]);
+static int count_rows(FILE *from,pchar c, pchar c2);
+static int remember_rows(FILE *from,pchar c);
+static int copy_rows(FILE *to);
+
+
+ /* Functions defined in this file */
+
+int main(int argc,char *argv[])
+{
+ int i,error,files,length;
+ uchar head[32];
+ FILE *from,*to;
+ MY_INIT(argv[0]);
+
+ get_options(&argc,&argv);
+ error=1;
+ row_count=files=0;
+
+ to=0;
+ for ( ; argc-- > 1 ; argv++)
+ {
+ file_row_pos[files++] = row_count;
+
+ if ((from = fopen(*argv,"r")) == NULL)
+ {
+ fprintf(stderr,"Can't open file '%s'\n",*argv);
+ return(1);
+ }
+
+ VOID(count_rows(from,'"','}')); /* Calculate start-info */
+ if (remember_rows(from,'}') < 0) /* Remember rows */
+ {
+ fprintf(stderr,"Can't find textrows in '%s'\n",*argv);
+ fclose(from);
+ goto end;
+ }
+ fclose(from);
+ }
+
+ if ((to=my_fopen(*argv,O_WRONLY | FILE_BINARY,MYF(0))) == NULL)
+ {
+ fprintf(stderr,"Can't create file '%s'\n",*argv);
+ return(1);
+ }
+
+ fseek(to,(long) (32+row_count*2),0);
+ if (copy_rows(to))
+ goto end;
+
+ length=ftell(to)-32-row_count*2;
+
+ bzero((gptr) head,32); /* Save Header & pointers */
+ bmove((byte*) head,(byte*) file_head,4);
+ head[4]=files;
+ int2store(head+6,length);
+ int2store(head+8,row_count);
+ for (i=0 ; i<files ; i++)
+ {
+ int2store(head+10+i+i,file_row_pos[i]);
+ }
+
+ fseek(to,0l,0);
+ if (fwrite(head,1,32,to) != 32)
+ goto end;
+
+ for (i=0 ; i<row_count ; i++)
+ {
+ int2store(head,file_pos[i]);
+ if (fwrite(head,1,2,to) != 2)
+ goto end;
+ }
+ error=0;
+ printf("Found %d messages in language file %s\n",row_count,*argv);
+
+ end:
+ if (to)
+ fclose(to);
+ if (error)
+ fprintf(stderr,"Can't uppdate messagefile %s, errno: %d\n",*argv,errno);
+
+ exit(error);
+ return(0);
+} /* main */
+
+
+ /* Read options */
+
+static void get_options(argc,argv)
+register int *argc;
+register char **argv[];
+{
+ int help=0;
+ char *pos,*progname;
+
+ progname= (*argv)[0];
+ while (--*argc >0 && *(pos = *(++*argv)) == '-' ) {
+ while (*++pos)
+ switch(*pos) {
+ case '#':
+ DBUG_PUSH (++pos);
+ *(pos--) = '\0'; /* Skippa argument */
+ break;
+ case 'V':
+ printf("%s (Compile errormessage) Ver 1.3\n",progname);
+ break;
+ case 'I':
+ case '?':
+ printf(" %s (Compile errormessage) Ver 1.3\n",progname);
+ puts("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");
+ printf("Usage: %s [-?] [-I] [-V] fromfile[s] tofile\n",progname);
+ puts("Options: -Info -Version\n");
+ help=1;
+ break;
+ default:
+ fprintf(stderr,"illegal option: -%c\n",*pos);
+ fprintf(stderr,"legal options: -?IV\n");
+ break;
+ }
+ }
+ if (*argc < 2)
+ {
+ if (!help)
+ printf("Usage: %s [-?] [-I] [-V] fromfile[s] tofile\n",progname);
+ exit(-1);
+ }
+ return;
+} /* get_options */
+
+
+ /* Count rows in from-file until row that start with char is found */
+
+static int count_rows(from,c,c2)
+FILE *from;
+pchar c,c2;
+{
+ int count;
+ long pos;
+ char rad[MAXLENGTH];
+ DBUG_ENTER("count_rows");
+
+ pos=ftell(from); count=0;
+ while (fgets(rad,MAXLENGTH,from) != NULL)
+ {
+ if (rad[0] == c || rad[0] == c2)
+ break;
+ count++;
+ pos=ftell(from);
+ }
+ fseek(from,pos,0); /* Position to beginning of last row */
+ DBUG_PRINT("exit",("count: %d",count));
+ DBUG_RETURN(count);
+} /* count_rows */
+
+
+ /* Read rows and remember them until row that start with char */
+ /* Converts row as a C-compiler would convert a textstring */
+
+static int remember_rows(from,c)
+FILE *from;
+pchar c;
+{
+ int i,nr,start_count,found_end;
+ char row[MAXLENGTH],*pos;
+ DBUG_ENTER("remember_rows");
+
+ start_count=row_count; found_end=0;
+ while (fgets(row,MAXLENGTH,from) != NULL)
+ {
+ if (row[0] == c)
+ {
+ found_end=1;
+ break;
+ }
+ for (pos=row ; *pos ;)
+ {
+ if (*pos == '\\')
+ {
+ switch (*++pos) {
+ case '\\':
+ case '"':
+ VOID(strmov(pos-1,pos));
+ break;
+ case 'n':
+ pos[-1]='\n';
+ VOID(strmov(pos,pos+1));
+ break;
+ default:
+ if (*pos >= '0' && *pos <'8')
+ {
+ nr=0;
+ for (i=0 ; i<3 && (*pos >= '0' && *pos <'8' ) ; i++)
+ nr=nr*8+ (*(pos++) -'0');
+ pos-=i;
+ pos[-1]=nr;
+ VOID(strmov(pos,pos+i));
+ }
+ else if (*pos)
+ VOID(strmov(pos-1,pos)); /* Remove '\' */
+ }
+ }
+ else pos++;
+ }
+ while (pos >row+1 && *pos != '"')
+ pos--;
+
+ if (!(saved_row[row_count] = (my_string) my_malloc((uint) (pos-row),
+ MYF(MY_WME))))
+ DBUG_RETURN(-1);
+ *pos=0;
+ VOID(strmov(saved_row[row_count],row+1));
+ row_count++;
+ }
+ if (row_count-start_count == 0 && ! found_end)
+ DBUG_RETURN(-1); /* Found nothing */
+ DBUG_RETURN(row_count-start_count);
+} /* remember_rows */
+
+
+ /* Copy rows from memory to file and remember position */
+
+
+static int copy_rows(to)
+FILE *to;
+{
+ int row_nr;
+ long start_pos;
+ DBUG_ENTER("copy_rows");
+
+ start_pos=ftell(to);
+ for (row_nr =0 ; row_nr < row_count; row_nr++)
+ {
+ file_pos[row_nr]= (int) (ftell(to)-start_pos);
+ if (fputs(saved_row[row_nr],to) == EOF || fputc('\0',to) == EOF)
+ {
+ fprintf(stderr,"Can't write to outputfile\n");
+ DBUG_RETURN(1);
+ }
+ my_free((gptr) saved_row[row_nr],MYF(0));
+ }
+ DBUG_RETURN(0);
+} /* copy_rows */
diff --git a/extra/my_print_defaults.c b/extra/my_print_defaults.c
new file mode 100644
index 00000000000..a6e67e4949e
--- /dev/null
+++ b/extra/my_print_defaults.c
@@ -0,0 +1,125 @@
+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA */
+
+/*
+** print_default.c:
+** Print all parameters in a default file that will be given to some program.
+**
+** Written by Monty
+*/
+
+#include <global.h>
+#include <my_sys.h>
+#include <getopt.h>
+
+const char *config_file="my"; /* Default config file */
+
+static struct option long_options[] =
+{
+ {"config-file", required_argument, 0, 'c'},
+ {"defaults-file", required_argument, 0, 'c'},
+ {"no-defaults", no_argument, 0, 'd'},
+ {"help", no_argument, 0, '?'},
+ {"version", no_argument, 0, 'V'},
+ {0, 0, 0, 0}
+};
+
+static void usage(my_bool version)
+{
+ printf("%s Ver 1.1 for %s at %s\n",my_progname,SYSTEM_TYPE,
+ MACHINE_TYPE);
+ if (version)
+ return;
+ puts("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");
+ puts("Prints all arguments that is give to some program using the default files");
+ printf("Usage: %s [OPTIONS] groups\n",my_progname);
+ printf("\n\
+ -c, --config-file=# --defaults-file=#\n\
+ The config file to use (default '%s')\n\
+ --no-defaults Return an empty string (useful for scripts)\n\
+ -?, --help Display this help message and exit.\n\
+ -V, --version Output version information and exit.\n",
+ config_file);
+ printf("\nExample usage: %s --config-file=my client mysql\n",my_progname);
+}
+
+static int get_options(int *argc,char ***argv)
+{
+ int c,option_index;
+
+ while ((c=getopt_long(*argc,*argv,"c:V?I",
+ long_options, &option_index)) != EOF)
+ {
+ switch (c) {
+ case 'c':
+ config_file=optarg;
+ break;
+ case 'n':
+ exit(0);
+ case 'I':
+ case '?':
+ usage(0);
+ exit(0);
+ case 'V':
+ usage(1);
+ exit(0);
+ }
+ }
+ (*argc)-=optind;
+ (*argv)+=optind;
+ if (*argc < 1)
+ {
+ usage(0);
+ return 1;
+ }
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ int count;
+ char **load_default_groups, *tmp_arguments[2],
+ **argument, **arguments;
+ MY_INIT(argv[0]);
+
+ /*
+ ** Check out the args
+ */
+ if (get_options(&argc,&argv))
+ exit(1);
+ if (!(load_default_groups=(char**) my_malloc((argc+2)*sizeof(char*),
+ MYF(MY_WME))))
+ exit(1);
+
+ for (count=0; *argv ; argv++,count++)
+ load_default_groups[count]= *argv;
+ load_default_groups[count]=0;
+
+ count=1;
+ arguments=tmp_arguments;
+ arguments[0]=my_progname;
+ arguments[1]=0;
+ load_defaults(config_file, (const char **) load_default_groups,
+ &count, &arguments);
+
+ for (argument= arguments+1 ; *argument ; argument++)
+ puts(*argument);
+ my_free((char*) load_default_groups,MYF(0));
+ free_defaults(arguments);
+
+ exit(0);
+}
diff --git a/extra/perror.c b/extra/perror.c
new file mode 100644
index 00000000000..b6d32d50868
--- /dev/null
+++ b/extra/perror.c
@@ -0,0 +1,207 @@
+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA */
+
+/* Return error-text for system error messages and nisam messages */
+
+#define PERROR_VERSION "2.2"
+
+#include <global.h>
+#include <my_sys.h>
+#include <m_string.h>
+#include <errno.h>
+#include <getopt.h>
+
+
+static struct option long_options[] =
+{
+ {"help", no_argument, 0, '?'},
+ {"info", no_argument, 0, 'I'},
+ {"all", no_argument, 0, 'a'},
+ {"verbose", no_argument, 0, 'v'},
+ {"version", no_argument, 0, 'V'},
+ {0, 0, 0, 0}
+};
+
+typedef struct ha_errors {
+ int errcode;
+ const char *msg;
+} HA_ERRORS;
+
+static int verbose=0,print_all_codes=0;
+
+static HA_ERRORS ha_errlist[]=
+{
+ { 120,"Didn't find key on read or update" },
+ { 121,"Duplicate key on write or update" },
+ { 123,"Someone has changed the row since it was read; Update with is recoverable" },
+ { 124,"Wrong index given to function" },
+ { 126,"Index file is crashed / Wrong file format" },
+ { 127,"Record-file is crashed" },
+ { 131,"Command not supported by database" },
+ { 132,"Old database file" },
+ { 133,"No record read before update" },
+ { 134,"Record was already deleted (or record file crashed)" },
+ { 135,"No more room in record file" },
+ { 136,"No more room in index file" },
+ { 137,"No more records (read after end of file)" },
+ { 138,"Unsupported extension used for table" },
+ { 139,"Too big row (>= 24 M)"},
+ { 140,"Wrong create options"},
+ { 141,"Dupplicate unique on write or update"},
+ { 0,NullS },
+};
+
+
+static void print_version(void)
+{
+ printf("%s Ver %s, for %s (%s)\n",my_progname,PERROR_VERSION,
+ SYSTEM_TYPE,MACHINE_TYPE);
+}
+
+static void usage(void)
+{
+ print_version();
+ puts("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");
+ printf("Usage: %s [OPTIONS] [ERRORCODES]\n",my_progname);
+ printf("\n\
+ -?, --help Displays this help and exits.\n\
+ -I, --info Synonym for the above.");
+#ifdef HAVE_SYS_ERRLIST
+ printf("\n\
+ -a, --all Print all the error messages and the number.");
+#endif
+ printf("\n\
+ -v, --verbose Print info about various stages.\n\
+ -V, --version Displays version information and exits.\n");
+}
+
+
+static int get_options(int *argc,char ***argv)
+{
+ int c,option_index;
+
+ while ((c=getopt_long(*argc,*argv,"avVI?",long_options,
+ &option_index)) != EOF)
+ {
+ switch (c) {
+#ifdef HAVE_SYS_ERRLIST
+ case 'a':
+ print_all_codes=1;
+ break;
+#endif
+ case 'v':
+ verbose=1;
+ break;
+ case 'V':
+ print_version();
+ exit(0);
+ break;
+ case 'I':
+ case '?':
+ usage();
+ exit(0);
+ break;
+ default:
+ fprintf(stderr,"%s: Illegal option character '%c'\n",
+ my_progname,opterr);
+ return(1);
+ break;
+ }
+ }
+ (*argc)-=optind;
+ (*argv)+=optind;
+ if (!*argc && !print_all_codes)
+ {
+ usage();
+ return 1;
+ }
+ return 0;
+} /* get_options */
+
+
+static const char *get_ha_error_msg(int code)
+{
+ HA_ERRORS *ha_err_ptr;
+
+ for (ha_err_ptr=ha_errlist ; ha_err_ptr->errcode ;ha_err_ptr++)
+ if (ha_err_ptr->errcode == code)
+ return ha_err_ptr->msg;
+ return NullS;
+}
+
+
+int main(int argc,char *argv[])
+{
+ int error,code,found;
+ const char *msg;
+ MY_INIT(argv[0]);
+
+ if (get_options(&argc,&argv))
+ exit(1);
+
+ error=0;
+#ifdef HAVE_SYS_ERRLIST
+ if (print_all_codes)
+ {
+ HA_ERRORS *ha_err_ptr;
+ for (code=1 ; code < sys_nerr ; code++)
+ {
+ if (sys_errlist[code][0])
+ { /* Skipp if no error-text */
+ printf("%3d = %s\n",code,sys_errlist[code]);
+ }
+ }
+ for (ha_err_ptr=ha_errlist ; ha_err_ptr->errcode ;ha_err_ptr++)
+ printf("%3d = %s\n",ha_err_ptr->errcode,ha_err_ptr->msg);
+ }
+ else
+#endif
+ {
+ for ( ; argc-- > 0 ; argv++)
+ {
+ found=0;
+ code=atoi(*argv);
+ msg = strerror(code);
+ if (msg)
+ {
+ found=1;
+ if (verbose)
+ printf("%3d = %s\n",code,msg);
+ else
+ puts(msg);
+ }
+ if (!(msg=get_ha_error_msg(code)))
+ {
+ if (!found)
+ {
+ fprintf(stderr,"Illegal error code: %d\n",code);
+ error=1;
+ }
+ }
+ else
+ {
+ if (verbose)
+ printf("%3d = %s\n",code,msg);
+ else
+ puts(msg);
+ }
+ }
+ }
+ exit(error);
+ return error;
+}
+
diff --git a/extra/replace.c b/extra/replace.c
new file mode 100644
index 00000000000..44f117c7969
--- /dev/null
+++ b/extra/replace.c
@@ -0,0 +1,1080 @@
+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA */
+
+/* Replace strings in textfile
+ This program replace strings in a file or on stdin/stdout.
+ It accepts a list of from-strings and to-strings and replaces all
+ occurents of from-strings to to-strings.
+ The first occurents of a found string is matched. If there are more than
+ one possibly replace the longer from-string is replaced.
+ Special characters in from string:
+ \^ Match start of line.
+ \$ Match end of line.
+ \b Match space-character, start of line or end of line.
+ For end \b the next replace starts locking at the end space-character.
+ An \b alone or in a string matches only a space-character.
+ \r, \t, \v as in C.
+ The programs make a DFA-state-machine of the strings and the speed isn't
+ dependent on the count of replace-strings (only of the number of replaces).
+ A line is assumed ending with \n or \0.
+ There are no limit exept memory on length of strings.
+
+ Written by Monty.
+ fill_buffer_retaining() is taken from gnu-grep and modified.
+*/
+
+#define DONT_USE_RAID
+#include <global.h>
+#include <m_ctype.h>
+#include <my_sys.h>
+#include <m_string.h>
+#include <errno.h>
+
+#define PC_MALLOC 256 /* Bytes for pointers */
+#define PS_MALLOC 512 /* Bytes for data */
+
+typedef struct st_pointer_array { /* when using array-strings */
+ TYPELIB typelib; /* Pointer to strings */
+ byte *str; /* Strings is here */
+ int7 *flag; /* Flag about each var. */
+ uint array_allocs,max_count,length,max_length;
+} POINTER_ARRAY;
+
+#define SPACE_CHAR 256
+#define START_OF_LINE 257
+#define END_OF_LINE 258
+#define LAST_CHAR_CODE 259
+
+typedef struct st_replace {
+ bool found;
+ struct st_replace *next[256];
+} REPLACE;
+
+typedef struct st_replace_found {
+ bool found;
+ char *replace_string;
+ uint to_offset;
+ int from_offset;
+} REPLACE_STRING;
+
+#ifndef WORD_BIT
+#define WORD_BIT (8*sizeof(uint))
+#endif
+
+ /* functions defined in this file */
+
+extern int main(int argc,char * *argv);
+static int static_get_options(int *argc,char * * *argv);
+static int get_replace_strings(int *argc,char * * *argv,
+ POINTER_ARRAY *from_array,
+ POINTER_ARRAY *to_array);
+int insert_pointer_name(POINTER_ARRAY *pa, my_string name);
+void free_pointer_array(POINTER_ARRAY *pa);
+static int convert_pipe(REPLACE *,FILE *,FILE *);
+static int convert_file(REPLACE *, my_string);
+REPLACE *init_replace(my_string *from, my_string *to,uint count, my_string
+ word_end_chars);
+uint replace_strings(REPLACE *rep, my_string *start,uint *max_length,
+ my_string from);
+static int initialize_buffer(void);
+static void reset_buffer(void);
+static void free_buffer(void);
+
+static int silent=0,verbose=0,updated=0;
+
+ /* The main program */
+
+int main(argc,argv)
+int argc;
+char *argv[];
+{
+ int i,error;
+ char word_end_chars[256],*pos;
+ POINTER_ARRAY from,to;
+ REPLACE *replace;
+ MY_INIT(argv[0]);
+
+ if (static_get_options(&argc,&argv))
+ exit(1);
+ if (get_replace_strings(&argc,&argv,&from,&to))
+ exit(1);
+
+ for (i=1,pos=word_end_chars ; i < 256 ; i++)
+ if (isspace(i))
+ *pos++=i;
+ *pos=0;
+ if (!(replace=init_replace((char**) from.typelib.type_names,
+ (char**) to.typelib.type_names,
+ (uint) from.typelib.count,word_end_chars)))
+ exit(1);
+ free_pointer_array(&from);
+ free_pointer_array(&to);
+ if (initialize_buffer())
+ return 1;
+
+ error=0;
+ if (argc == 0)
+ error=convert_pipe(replace,stdin,stdout);
+ else
+ {
+ while (argc--)
+ {
+ error=convert_file(replace,*(argv++));
+ }
+ }
+ free_buffer();
+ my_end(verbose ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
+ exit(error ? 2 : 0);
+ return 0; /* No compiler warning */
+} /* main */
+
+
+ /* reads options */
+ /* Initiates DEBUG - but no debugging here ! */
+
+static int static_get_options(argc,argv)
+register int *argc;
+register char **argv[];
+{
+ int help,version,opt;
+ char *pos;
+
+ silent=verbose=help=0;
+
+ while (--*argc > 0 && *(pos = *(++*argv)) == '-' && pos[1] != '-') {
+ while (*++pos)
+ {
+ version=0;
+ switch((opt= *pos)) {
+ case 's':
+ silent=1;
+ break;
+ case 'v':
+ verbose=1;
+ break;
+ case '#':
+ DBUG_PUSH (++pos);
+ pos= (char*) " "; /* Skipp rest of arguments */
+ break;
+ case 'V':
+ version=1;
+ case 'I':
+ case '?':
+ help=1; /* Help text written */
+ printf("%s Ver 1.3 for %s at %s\n",my_progname,SYSTEM_TYPE,
+ MACHINE_TYPE);
+ if (version)
+ break;
+ puts("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");
+ puts("This program replace strings in a file or on stdin/stdout.\n"
+ "It accepts a list of from-strings and to-strings and replaces\n"
+ "all occurents of from-strings to to-strings.\n"
+ "The first occurents of a found string is matched. Longer matches\n"
+ "are prefered before shorter matches.\n\n"
+ "Special characters in from string:\n"
+ " \\^ Match start of line.\n"
+ " \\$ Match end of line.\n"
+ " \\b Match space-character, start of line or end of line.\n"
+ " For a end \\b the next replace starts locking at the end\n"
+ " space-character. A \\b alone in a string matches only a\n"
+ " space-character.\n");
+ printf("Usage: %s [-?svIV] from to from to ... -- [files]\n", my_progname);
+ puts("or");
+ printf("Usage: %s [-?svIV] from to from to ... < fromfile > tofile\n", my_progname);
+ puts("");
+ puts("Options: -? or -I \"Info\" -s \"silent\" -v \"verbose\"");
+ break;
+ default:
+ fprintf(stderr,"illegal option: -%c\n",*pos);
+ break;
+ }
+ }
+ }
+ if (*argc == 0)
+ {
+ if (!help)
+ my_message(0,"No replace options given",MYF(ME_BELL));
+ exit(0); /* Don't use as pipe */
+ }
+ return(0);
+} /* static_get_options */
+
+
+static int get_replace_strings(argc,argv,from_array,to_array)
+register int *argc;
+register char **argv[];
+POINTER_ARRAY *from_array,*to_array;
+{
+ char *pos;
+
+ bzero((char*) from_array,sizeof(from_array[0]));
+ bzero((char*) to_array,sizeof(to_array[0]));
+ while (*argc > 0 && (*(pos = *(*argv)) != '-' || pos[1] != '-' || pos[2]))
+ {
+ insert_pointer_name(from_array,pos);
+ (*argc)--;
+ (*argv)++;
+ if (!*argc || !strcmp(**argv,"--"))
+ {
+ my_message(0,"No to-string for last from-string",MYF(ME_BELL));
+ return 1;
+ }
+ insert_pointer_name(to_array,**argv);
+ (*argc)--;
+ (*argv)++;
+ }
+ if (*argc)
+ { /* Skipp "--" argument */
+ (*argc)--;
+ (*argv)++;
+ }
+ return 0;
+}
+
+int insert_pointer_name(reg1 POINTER_ARRAY *pa,my_string name)
+{
+ uint i,length,old_count;
+ byte *new_pos;
+ const char **new_array;
+ DBUG_ENTER("insert_pointer_name");
+
+ if (! pa->typelib.count)
+ {
+ if (!(pa->typelib.type_names=(const char **)
+ my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
+ (sizeof(my_string)+sizeof(*pa->flag))*
+ (sizeof(my_string)+sizeof(*pa->flag))),MYF(MY_WME))))
+ DBUG_RETURN(-1);
+ if (!(pa->str= (byte*) my_malloc((uint) (PS_MALLOC-MALLOC_OVERHEAD),
+ MYF(MY_WME))))
+ {
+ my_free((gptr) pa->typelib.type_names,MYF(0));
+ DBUG_RETURN (-1);
+ }
+ pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(byte*)+
+ sizeof(*pa->flag));
+ pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
+ pa->length=0;
+ pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
+ pa->array_allocs=1;
+ }
+ length=strlen(name)+1;
+ if (pa->length+length >= pa->max_length)
+ {
+ if (!(new_pos= (byte*) my_realloc((gptr) pa->str,
+ (uint) (pa->max_length+PS_MALLOC),
+ MYF(MY_WME))))
+ DBUG_RETURN(1);
+ if (new_pos != pa->str)
+ {
+ my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa->str);
+ for (i=0 ; i < pa->typelib.count ; i++)
+ pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
+ char*);
+ pa->str=new_pos;
+ }
+ pa->max_length+=PS_MALLOC;
+ }
+ if (pa->typelib.count >= pa->max_count-1)
+ {
+ int len;
+ pa->array_allocs++;
+ len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
+ if (!(new_array=(const char **) my_realloc((gptr) pa->typelib.type_names,
+ (uint) len/
+ (sizeof(byte*)+sizeof(*pa->flag))*
+ (sizeof(byte*)+sizeof(*pa->flag)),
+ MYF(MY_WME))))
+ DBUG_RETURN(1);
+ pa->typelib.type_names=new_array;
+ old_count=pa->max_count;
+ pa->max_count=len/(sizeof(byte*) + sizeof(*pa->flag));
+ pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
+ memcpy((byte*) pa->flag,(my_string) (pa->typelib.type_names+old_count),
+ old_count*sizeof(*pa->flag));
+ }
+ pa->flag[pa->typelib.count]=0; /* Reset flag */
+ pa->typelib.type_names[pa->typelib.count++]= pa->str+pa->length;
+ pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
+ VOID(strmov(pa->str+pa->length,name));
+ pa->length+=length;
+ DBUG_RETURN(0);
+} /* insert_pointer_name */
+
+
+ /* free pointer array */
+
+void free_pointer_array(pa)
+reg1 POINTER_ARRAY *pa;
+{
+ if (pa->typelib.count)
+ {
+ pa->typelib.count=0;
+ my_free((gptr) pa->typelib.type_names,MYF(0));
+ pa->typelib.type_names=0;
+ my_free((gptr) pa->str,MYF(0));
+ }
+ return;
+} /* free_pointer_array */
+
+
+ /* Code for replace rutines */
+
+#define SET_MALLOC_HUNC 64
+
+typedef struct st_rep_set {
+ uint *bits; /* Pointer to used sets */
+ short next[LAST_CHAR_CODE]; /* Pointer to next sets */
+ uint found_len; /* Best match to date */
+ int found_offset;
+ uint table_offset;
+ uint size_of_bits; /* For convinience */
+} REP_SET;
+
+typedef struct st_rep_sets {
+ uint count; /* Number of sets */
+ uint extra; /* Extra sets in buffer */
+ uint invisible; /* Sets not chown */
+ uint size_of_bits;
+ REP_SET *set,*set_buffer;
+ uint *bit_buffer;
+} REP_SETS;
+
+typedef struct st_found_set {
+ uint table_offset;
+ int found_offset;
+} FOUND_SET;
+
+typedef struct st_follow {
+ int chr;
+ uint table_offset;
+ uint len;
+} FOLLOWS;
+
+
+static int init_sets(REP_SETS *sets,uint states);
+static REP_SET *make_new_set(REP_SETS *sets);
+static void make_sets_invisible(REP_SETS *sets);
+static void free_last_set(REP_SETS *sets);
+static void free_sets(REP_SETS *sets);
+static void set_bit(REP_SET *set, uint bit);
+static void clear_bit(REP_SET *set, uint bit);
+static void or_bits(REP_SET *to,REP_SET *from);
+static void copy_bits(REP_SET *to,REP_SET *from);
+static int cmp_bits(REP_SET *set1,REP_SET *set2);
+static int get_next_bit(REP_SET *set,uint lastpos);
+static int find_set(REP_SETS *sets,REP_SET *find);
+static int find_found(FOUND_SET *found_set,uint table_offset,
+ int found_offset);
+static uint start_at_word(my_string pos);
+static uint end_of_word(my_string pos);
+static uint replace_len(my_string pos);
+
+static uint found_sets=0;
+
+
+ /* Init a replace structure for further calls */
+
+REPLACE *init_replace(my_string *from, my_string *to,uint count,
+ my_string word_end_chars)
+{
+ uint i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;
+ int used_sets,chr,default_state;
+ char used_chars[LAST_CHAR_CODE],is_word_end[256];
+ my_string pos,to_pos,*to_array;
+ REP_SETS sets;
+ REP_SET *set,*start_states,*word_states,*new_set;
+ FOLLOWS *follow,*follow_ptr;
+ REPLACE *replace;
+ FOUND_SET *found_set;
+ REPLACE_STRING *rep_str;
+ DBUG_ENTER("init_replace");
+
+ /* Count number of states */
+ for (i=result_len=max_length=0 , states=2 ; i < count ; i++)
+ {
+ len=replace_len(from[i]);
+ if (!len)
+ {
+ errno=EINVAL;
+ my_message(0,"No to-string for last from-string",MYF(ME_BELL));
+ DBUG_RETURN(0);
+ }
+ states+=len+1;
+ result_len+=strlen(to[i])+1;
+ if (len > max_length)
+ max_length=len;
+ }
+ bzero((char*) is_word_end,sizeof(is_word_end));
+ for (i=0 ; word_end_chars[i] ; i++)
+ is_word_end[(uchar) word_end_chars[i]]=1;
+
+ if (init_sets(&sets,states))
+ DBUG_RETURN(0);
+ found_sets=0;
+ if (!(found_set= (FOUND_SET*) my_malloc(sizeof(FOUND_SET)*max_length*count,
+ MYF(MY_WME))))
+ {
+ free_sets(&sets);
+ DBUG_RETURN(0);
+ }
+ VOID(make_new_set(&sets)); /* Set starting set */
+ make_sets_invisible(&sets); /* Hide previus sets */
+ used_sets=-1;
+ word_states=make_new_set(&sets); /* Start of new word */
+ start_states=make_new_set(&sets); /* This is first state */
+ if (!(follow=(FOLLOWS*) my_malloc((states+2)*sizeof(FOLLOWS),MYF(MY_WME))))
+ {
+ free_sets(&sets);
+ my_free((gptr) found_set,MYF(0));
+ DBUG_RETURN(0);
+ }
+
+ /* Init follow_ptr[] */
+ for (i=0, states=1, follow_ptr=follow+1 ; i < count ; i++)
+ {
+ if (from[i][0] == '\\' && from[i][1] == '^')
+ {
+ set_bit(start_states,states+1);
+ if (!from[i][2])
+ {
+ start_states->table_offset=i;
+ start_states->found_offset=1;
+ }
+ }
+ else if (from[i][0] == '\\' && from[i][1] == '$')
+ {
+ set_bit(start_states,states);
+ set_bit(word_states,states);
+ if (!from[i][2] && start_states->table_offset == (uint) ~0)
+ {
+ start_states->table_offset=i;
+ start_states->found_offset=0;
+ }
+ }
+ else
+ {
+ set_bit(word_states,states);
+ if (from[i][0] == '\\' && (from[i][1] == 'b' && from[i][2]))
+ set_bit(start_states,states+1);
+ else
+ set_bit(start_states,states);
+ }
+ for (pos=from[i], len=0; *pos ; pos++)
+ {
+ if (*pos == '\\' && *(pos+1))
+ {
+ pos++;
+ switch (*pos) {
+ case 'b':
+ follow_ptr->chr = SPACE_CHAR;
+ break;
+ case '^':
+ follow_ptr->chr = START_OF_LINE;
+ break;
+ case '$':
+ follow_ptr->chr = END_OF_LINE;
+ break;
+ case 'r':
+ follow_ptr->chr = '\r';
+ break;
+ case 't':
+ follow_ptr->chr = '\t';
+ break;
+ case 'v':
+ follow_ptr->chr = '\v';
+ break;
+ default:
+ follow_ptr->chr = (uchar) *pos;
+ break;
+ }
+ }
+ else
+ follow_ptr->chr= (uchar) *pos;
+ follow_ptr->table_offset=i;
+ follow_ptr->len= ++len;
+ follow_ptr++;
+ }
+ follow_ptr->chr=0;
+ follow_ptr->table_offset=i;
+ follow_ptr->len=len;
+ follow_ptr++;
+ states+=(uint) len+1;
+ }
+
+
+ for (set_nr=0,pos=0 ; set_nr < sets.count ; set_nr++)
+ {
+ set=sets.set+set_nr;
+ default_state= 0; /* Start from beginning */
+
+ /* If end of found-string not found or start-set with current set */
+
+ for (i= (uint) ~0; (i=get_next_bit(set,i)) ;)
+ {
+ if (!follow[i].chr)
+ {
+ if (! default_state)
+ default_state= find_found(found_set,set->table_offset,
+ set->found_offset+1);
+ }
+ }
+ copy_bits(sets.set+used_sets,set); /* Save set for changes */
+ if (!default_state)
+ or_bits(sets.set+used_sets,sets.set); /* Can restart from start */
+
+ /* Find all chars that follows current sets */
+ bzero((char*) used_chars,sizeof(used_chars));
+ for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
+ {
+ used_chars[follow[i].chr]=1;
+ if ((follow[i].chr == SPACE_CHAR && !follow[i+1].chr &&
+ follow[i].len > 1) || follow[i].chr == END_OF_LINE)
+ used_chars[0]=1;
+ }
+
+ /* Mark word_chars used if \b is in state */
+ if (used_chars[SPACE_CHAR])
+ for (pos= word_end_chars ; *pos ; pos++)
+ used_chars[(int) (uchar) *pos] = 1;
+
+ /* Handle other used characters */
+ for (chr= 0 ; chr < 256 ; chr++)
+ {
+ if (! used_chars[chr])
+ set->next[chr]= chr ? default_state : -1;
+ else
+ {
+ new_set=make_new_set(&sets);
+ set=sets.set+set_nr; /* if realloc */
+ new_set->table_offset=set->table_offset;
+ new_set->found_len=set->found_len;
+ new_set->found_offset=set->found_offset+1;
+ found_end=0;
+
+ for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
+ {
+ if (!follow[i].chr || follow[i].chr == chr ||
+ (follow[i].chr == SPACE_CHAR &&
+ (is_word_end[chr] ||
+ (!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
+ (follow[i].chr == END_OF_LINE && ! chr))
+ {
+ if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
+ follow[i].len > found_end)
+ found_end=follow[i].len;
+ if (chr && follow[i].chr)
+ set_bit(new_set,i+1); /* To next set */
+ else
+ set_bit(new_set,i);
+ }
+ }
+ if (found_end)
+ {
+ new_set->found_len=0; /* Set for testing if first */
+ bits_set=0;
+ for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
+ {
+ if ((follow[i].chr == SPACE_CHAR ||
+ follow[i].chr == END_OF_LINE) && ! chr)
+ bit_nr=i+1;
+ else
+ bit_nr=i;
+ if (follow[bit_nr-1].len < found_end ||
+ (new_set->found_len &&
+ (chr == 0 || !follow[bit_nr].chr)))
+ clear_bit(new_set,i);
+ else
+ {
+ if (chr == 0 || !follow[bit_nr].chr)
+ { /* best match */
+ new_set->table_offset=follow[bit_nr].table_offset;
+ if (chr || (follow[i].chr == SPACE_CHAR ||
+ follow[i].chr == END_OF_LINE))
+ new_set->found_offset=found_end; /* New match */
+ new_set->found_len=found_end;
+ }
+ bits_set++;
+ }
+ }
+ if (bits_set == 1)
+ {
+ set->next[chr] = find_found(found_set,
+ new_set->table_offset,
+ new_set->found_offset);
+ free_last_set(&sets);
+ }
+ else
+ set->next[chr] = find_set(&sets,new_set);
+ }
+ else
+ set->next[chr] = find_set(&sets,new_set);
+ }
+ }
+ }
+
+ /* Alloc replace structure for the replace-state-machine */
+
+ if ((replace=(REPLACE*) my_malloc(sizeof(REPLACE)*(sets.count)+
+ sizeof(REPLACE_STRING)*(found_sets+1)+
+ sizeof(my_string)*count+result_len,
+ MYF(MY_WME | MY_ZEROFILL))))
+ {
+ rep_str=(REPLACE_STRING*) (replace+sets.count);
+ to_array=(my_string*) (rep_str+found_sets+1);
+ to_pos=(my_string) (to_array+count);
+ for (i=0 ; i < count ; i++)
+ {
+ to_array[i]=to_pos;
+ to_pos=strmov(to_pos,to[i])+1;
+ }
+ rep_str[0].found=1;
+ rep_str[0].replace_string=0;
+ for (i=1 ; i <= found_sets ; i++)
+ {
+ pos=from[found_set[i-1].table_offset];
+ rep_str[i].found= !bcmp(pos,"\\^",3) ? 2 : 1;
+ rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
+ rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
+ rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
+ end_of_word(pos);
+ }
+ for (i=0 ; i < sets.count ; i++)
+ {
+ for (j=0 ; j < 256 ; j++)
+ if (sets.set[i].next[j] >= 0)
+ replace[i].next[j]=replace+sets.set[i].next[j];
+ else
+ replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
+ }
+ }
+ my_free((gptr) follow,MYF(0));
+ free_sets(&sets);
+ my_free((gptr) found_set,MYF(0));
+ DBUG_PRINT("exit",("Replace table has %d states",sets.count));
+ DBUG_RETURN(replace);
+}
+
+
+static int init_sets(REP_SETS *sets,uint states)
+{
+ bzero((char*) sets,sizeof(*sets));
+ sets->size_of_bits=((states+7)/8);
+ if (!(sets->set_buffer=(REP_SET*) my_malloc(sizeof(REP_SET)*SET_MALLOC_HUNC,
+ MYF(MY_WME))))
+ return 1;
+ if (!(sets->bit_buffer=(uint*) my_malloc(sizeof(uint)*sets->size_of_bits*
+ SET_MALLOC_HUNC,MYF(MY_WME))))
+ {
+ my_free((gptr) sets->set,MYF(0));
+ return 1;
+ }
+ return 0;
+}
+
+ /* Make help sets invisible for nicer codeing */
+
+static void make_sets_invisible(REP_SETS *sets)
+{
+ sets->invisible=sets->count;
+ sets->set+=sets->count;
+ sets->count=0;
+}
+
+static REP_SET *make_new_set(REP_SETS *sets)
+{
+ uint i,count,*bit_buffer;
+ REP_SET *set;
+ if (sets->extra)
+ {
+ sets->extra--;
+ set=sets->set+ sets->count++;
+ bzero((char*) set->bits,sizeof(uint)*sets->size_of_bits);
+ bzero((char*) &set->next[0],sizeof(set->next[0])*LAST_CHAR_CODE);
+ set->found_offset=0;
+ set->found_len=0;
+ set->table_offset= (uint) ~0;
+ set->size_of_bits=sets->size_of_bits;
+ return set;
+ }
+ count=sets->count+sets->invisible+SET_MALLOC_HUNC;
+ if (!(set=(REP_SET*) my_realloc((gptr) sets->set_buffer,
+ sizeof(REP_SET)*count,
+ MYF(MY_WME))))
+ return 0;
+ sets->set_buffer=set;
+ sets->set=set+sets->invisible;
+ if (!(bit_buffer=(uint*) my_realloc((gptr) sets->bit_buffer,
+ (sizeof(uint)*sets->size_of_bits)*count,
+ MYF(MY_WME))))
+ return 0;
+ sets->bit_buffer=bit_buffer;
+ for (i=0 ; i < count ; i++)
+ {
+ sets->set_buffer[i].bits=bit_buffer;
+ bit_buffer+=sets->size_of_bits;
+ }
+ sets->extra=SET_MALLOC_HUNC;
+ return make_new_set(sets);
+}
+
+static void free_last_set(REP_SETS *sets)
+{
+ sets->count--;
+ sets->extra++;
+ return;
+}
+
+static void free_sets(REP_SETS *sets)
+{
+ my_free((gptr)sets->set_buffer,MYF(0));
+ my_free((gptr)sets->bit_buffer,MYF(0));
+ return;
+}
+
+static void set_bit(REP_SET *set, uint bit)
+{
+ set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);
+ return;
+}
+
+static void clear_bit(REP_SET *set, uint bit)
+{
+ set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));
+ return;
+}
+
+
+static void or_bits(REP_SET *to,REP_SET *from)
+{
+ reg1 uint i;
+ for (i=0 ; i < to->size_of_bits ; i++)
+ to->bits[i]|=from->bits[i];
+ return;
+}
+
+static void copy_bits(REP_SET *to,REP_SET *from)
+{
+ memcpy((byte*) to->bits,(byte*) from->bits,
+ (size_t) (sizeof(uint) * to->size_of_bits));
+}
+
+static int cmp_bits(REP_SET *set1,REP_SET *set2)
+{
+ return bcmp((byte*) set1->bits,(byte*) set2->bits,
+ sizeof(uint) * set1->size_of_bits);
+}
+
+
+ /* Get next set bit from set. */
+
+static int get_next_bit(REP_SET *set,uint lastpos)
+{
+ uint pos,*start,*end,bits;
+
+ start=set->bits+ ((lastpos+1) / WORD_BIT);
+ end=set->bits + set->size_of_bits;
+ bits=start[0] & ~((1 << ((lastpos+1) % WORD_BIT)) -1);
+
+ while (! bits && ++start < end)
+ bits=start[0];
+ if (!bits)
+ return 0;
+ pos=(uint) (start-set->bits)*WORD_BIT;
+ while (! (bits & 1))
+ {
+ bits>>=1;
+ pos++;
+ }
+ return pos;
+}
+
+ /* find if there is a same set in sets. If there is, use it and
+ free given set, else put in given set in sets and return it's
+ position */
+
+static int find_set(REP_SETS *sets,REP_SET *find)
+{
+ uint i;
+ for (i=0 ; i < sets->count-1 ; i++)
+ {
+ if (!cmp_bits(sets->set+i,find))
+ {
+ free_last_set(sets);
+ return i;
+ }
+ }
+ return i; /* return new postion */
+}
+
+ /* find if there is a found_set with same table_offset & found_offset
+ If there is return offset to it, else add new offset and return pos.
+ Pos returned is -offset-2 in found_set_structure because it's is
+ saved in set->next and set->next[] >= 0 points to next set and
+ set->next[] == -1 is reserved for end without replaces.
+ */
+
+static int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)
+{
+ int i;
+ for (i=0 ; (uint) i < found_sets ; i++)
+ if (found_set[i].table_offset == table_offset &&
+ found_set[i].found_offset == found_offset)
+ return -i-2;
+ found_set[i].table_offset=table_offset;
+ found_set[i].found_offset=found_offset;
+ found_sets++;
+ return -i-2; /* return new postion */
+}
+
+ /* Return 1 if regexp starts with \b or ends with \b*/
+
+static uint start_at_word(my_string pos)
+{
+ return (((!bcmp(pos,"\\b",2) && pos[2]) || !bcmp(pos,"\\^",2)) ? 1 : 0);
+}
+
+static uint end_of_word(my_string pos)
+{
+ my_string end=strend(pos);
+ return ((end > pos+2 && !bcmp(end-2,"\\b",2)) ||
+ (end >= pos+2 && !bcmp(end-2,"\\$",2))) ?
+ 1 : 0;
+}
+
+
+static uint replace_len(my_string str)
+{
+ uint len=0;
+ while (*str)
+ {
+ if (str[0] == '\\' && str[1])
+ str++;
+ str++;
+ len++;
+ }
+ return len;
+}
+
+
+ /* The actual loop */
+
+uint replace_strings(REPLACE *rep, my_string *start,uint *max_length, my_string from)
+{
+ reg1 REPLACE *rep_pos;
+ reg2 REPLACE_STRING *rep_str;
+ my_string to,end,pos,new;
+
+ end=(to= *start) + *max_length-1;
+ rep_pos=rep+1;
+ for(;;)
+ {
+ while (!rep_pos->found)
+ {
+ rep_pos= rep_pos->next[(uchar) *from];
+ if (to == end)
+ {
+ (*max_length)+=8192;
+ if (!(new=my_realloc(*start,*max_length,MYF(MY_WME))))
+ return (uint) -1;
+ to=new+(to - *start);
+ end=(*start=new)+ *max_length-1;
+ }
+ *to++= *from++;
+ }
+ if (!(rep_str = ((REPLACE_STRING*) rep_pos))->replace_string)
+ return (uint) (to - *start)-1;
+ updated=1; /* Some my_string is replaced */
+ to-=rep_str->to_offset;
+ for (pos=rep_str->replace_string; *pos ; pos++)
+ {
+ if (to == end)
+ {
+ (*max_length)*=2;
+ if (!(new=my_realloc(*start,*max_length,MYF(MY_WME))))
+ return (uint) -1;
+ to=new+(to - *start);
+ end=(*start=new)+ *max_length-1;
+ }
+ *to++= *pos;
+ }
+ if (!*(from-=rep_str->from_offset) && rep_pos->found != 2)
+ return (uint) (to - *start);
+ rep_pos=rep;
+ }
+}
+
+static char *buffer; /* The buffer itself, grown as needed. */
+static int bufbytes; /* Number of bytes in the buffer. */
+static int bufread,my_eof; /* Number of bytes to get with each read(). */
+static uint bufalloc;
+static char *out_buff;
+static uint out_length;
+
+static int initialize_buffer()
+{
+ bufread = 8192;
+ bufalloc = bufread + bufread / 2;
+ if (!(buffer = my_malloc(bufalloc+1,MYF(MY_WME))))
+ return 1;
+ bufbytes=my_eof=0;
+ out_length=bufread;
+ if (!(out_buff=my_malloc(out_length,MYF(MY_WME))))
+ return(1);
+ return 0;
+}
+
+static void reset_buffer()
+{
+ bufbytes=my_eof=0;
+}
+
+static void free_buffer()
+{
+ my_free(buffer,MYF(MY_WME));
+ my_free(out_buff,MYF(MY_WME));
+}
+
+
+/* Fill the buffer retaining the last n bytes at the beginning of the
+ newly filled buffer (for backward context). Returns the number of new
+ bytes read from disk. */
+
+static int fill_buffer_retaining(fd,n)
+File fd;
+int n;
+{
+ int i;
+
+ /* See if we need to grow the buffer. */
+ if ((int) bufalloc - n <= bufread)
+ {
+ while ((int) bufalloc - n <= bufread)
+ {
+ bufalloc *= 2;
+ bufread *= 2;
+ }
+ buffer = my_realloc(buffer, bufalloc+1, MYF(MY_WME));
+ if (! buffer)
+ return(-1);
+ }
+
+ /* Shift stuff down. */
+ bmove(buffer,buffer+bufbytes-n,(uint) n);
+ bufbytes = n;
+
+ if (my_eof)
+ return 0;
+
+ /* Read in new stuff. */
+ if ((i=(int) my_read(fd, buffer + bufbytes, (uint) bufread,MYF(MY_WME))) < 0)
+ return -1;
+
+ /* Kludge to pretend every nonempty file ends with a newline. */
+ if (i == 0 && bufbytes > 0 && buffer[bufbytes - 1] != '\n')
+ {
+ my_eof = i = 1;
+ buffer[bufbytes] = '\n';
+ }
+
+ bufbytes += i;
+ return i;
+}
+
+ /* Return 0 if convert is ok */
+ /* Global variable update is set if something was changed */
+
+static int convert_pipe(rep,in,out)
+REPLACE *rep;
+FILE *in,*out;
+{
+ int retain,error;
+ uint length;
+ char save_char,*end_of_line,*start_of_line;
+ DBUG_ENTER("convert_pipe");
+
+ updated=retain=0;
+ reset_buffer();
+
+ while ((error=fill_buffer_retaining(fileno(in),retain)) > 0)
+ {
+ end_of_line=buffer ;
+ buffer[bufbytes]=0; /* Sentinel */
+ for (;;)
+ {
+ start_of_line=end_of_line;
+ while (end_of_line[0] != '\n' && end_of_line[0])
+ end_of_line++;
+ if (end_of_line == buffer+bufbytes)
+ {
+ retain=end_of_line - start_of_line;
+ break; /* No end of line, read more */
+ }
+ save_char=end_of_line[0];
+ end_of_line[0]=0;
+ end_of_line++;
+ if ((length=replace_strings(rep,&out_buff,&out_length,start_of_line)) ==
+ (uint) -1)
+ return 1;
+ if (!my_eof)
+ out_buff[length++]=save_char; /* Don't write added newline */
+ if (my_fwrite(out,out_buff,length,MYF(MY_WME | MY_NABP)))
+ DBUG_RETURN(1);
+ }
+ }
+ DBUG_RETURN(error);
+}
+
+
+static int convert_file(rep,name)
+REPLACE *rep;
+my_string name;
+{
+ int error;
+ FILE *in,*out;
+ char dir_buff[FN_REFLEN],*tempname;
+ DBUG_ENTER("convert_file");
+
+ if (!(in=my_fopen(name,O_RDONLY,MYF(MY_WME))))
+ DBUG_RETURN(1);
+ dirname_part(dir_buff,name);
+ tempname=my_tempnam(dir_buff,"PR",MYF(MY_WME));
+ if (!(out=my_fopen(tempname,(int) (O_WRONLY | O_CREAT),
+ MYF(MY_WME))))
+ {
+ (*free)(tempname);
+ my_fclose(in,MYF(0));
+ DBUG_RETURN(1);
+ }
+
+ error=convert_pipe(rep,in,out);
+ my_fclose(in,MYF(0)); my_fclose(out,MYF(0));
+
+ if (updated && ! error)
+ my_redel(name,tempname,MYF(MY_WME | MY_LINK_WARNING));
+ else
+ my_delete(tempname,MYF(MY_WME));
+ (*free)(tempname);
+ if (!silent && ! error)
+ {
+ if (updated)
+ printf("%s converted\n",name);
+ else if (verbose)
+ printf("%s left unchanged\n",name);
+ }
+ DBUG_RETURN(error);
+}
diff --git a/extra/resolveip.c b/extra/resolveip.c
new file mode 100644
index 00000000000..d739f8de244
--- /dev/null
+++ b/extra/resolveip.c
@@ -0,0 +1,204 @@
+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA */
+
+/* Resolves IP's to hostname and hostnames to IP's */
+
+#define RESOLVE_VERSION "2.0"
+
+#include <global.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#ifndef HAVE_BROKEN_NETINET_INCLUDES
+#include <netinet/in.h>
+#endif
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <m_ctype.h>
+#include <my_sys.h>
+#include <getopt.h>
+
+#if !defined(_AIX) && !defined(HAVE_UNIXWARE7_THREADS) && !defined(HAVE_UNIXWARE7_POSIX) && !defined(h_errno)
+extern int h_errno;
+#endif
+
+static int silent=0;
+
+static struct option long_options[] =
+{
+ {"help", no_argument, 0, '?'},
+ {"info", no_argument, 0, 'I'},
+ {"silent", no_argument, 0, 's'},
+ {"version", no_argument, 0, 'V'},
+ {0, 0, 0, 0}
+};
+
+
+static void print_version(void)
+{
+ printf("%s Ver %s, for %s (%s)\n",my_progname,RESOLVE_VERSION,
+ SYSTEM_TYPE,MACHINE_TYPE);
+}
+
+
+static void usage(void)
+{
+ print_version();
+ puts("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");
+ puts("Get hostname based on IP-address or IP-address based on hostname.\n");
+ printf("Usage: %s [OPTIONS] hostname or IP-address\n",my_progname);
+ printf("\n\
+ -?, --help Displays this help and exits.\n\
+ -I, --info Synonym for the above.\n\
+ -s, --silent Be more silent.\n\
+ -V, --version Displays version information and exits.\n");
+}
+
+/*static my_string load_default_groups[]= { "resolveip","client",0 }; */
+
+static int get_options(int *argc,char ***argv)
+{
+ int c,option_index;
+
+ /* load_defaults("my",load_default_groups,argc,argv); */
+ while ((c=getopt_long(*argc,*argv,"?IsV",
+ long_options, &option_index)) != EOF)
+ {
+ switch (c) {
+ case 's':
+ silent=1;
+ break;
+ case 'V': print_version(); exit(0);
+ case 'I':
+ case '?':
+ usage();
+ exit(0);
+ default:
+ fprintf(stderr,"%s: Illegal option character '%c'\n",
+ my_progname,opterr);
+ return(1);
+ break;
+ }
+ }
+ (*argc)-=optind;
+ (*argv)+=optind;
+ if (*argc == 0)
+ {
+ usage();
+ return 1;
+ }
+ return 0;
+} /* get_options */
+
+
+
+int main(int argc, char **argv)
+{
+ struct hostent *hpaddr;
+ u_long taddr;
+ char *ip,**q;
+ int error=0;
+
+ MY_INIT(argv[0]);
+
+ if (get_options(&argc,&argv))
+ exit(1);
+
+ while (argc--)
+ {
+ ip = *argv++;
+
+ if (isdigit(ip[0]))
+ {
+ taddr = inet_addr(ip);
+ if (taddr == htonl(INADDR_BROADCAST))
+ {
+ puts("Broadcast");
+ continue;
+ }
+ if (taddr == htonl(INADDR_ANY))
+ {
+ if (!taddr)
+ puts("Null-IP-Addr");
+ else
+ puts("Old-Bcast");
+ continue;
+ }
+
+ hpaddr = gethostbyaddr((char*) &(taddr), sizeof(struct in_addr),AF_INET);
+ if (hpaddr)
+ {
+ if (silent)
+ puts(hpaddr->h_name);
+ else
+ {
+ printf ("Host name of %s is %s", ip,hpaddr->h_name);
+ for (q = hpaddr->h_aliases; *q != 0; q++)
+ (void) printf(", %s", *q);
+ puts("");
+ }
+ }
+ else
+ {
+ error=2;
+ fprintf(stderr,"%s: Unable to find hostname for '%s'\n",my_progname,
+ ip);
+ }
+ }
+ else
+ {
+ hpaddr = gethostbyname(ip);
+ if (!hpaddr)
+ {
+ const char *err;
+ fprintf(stderr,"%s: Unable to find hostid for '%s'",my_progname,ip);
+ switch (h_errno) {
+ case HOST_NOT_FOUND: err="host not found"; break;
+ case TRY_AGAIN: err="try again"; break;
+ case NO_RECOVERY: err="no recovery"; break;
+ case NO_DATA: err="no_data"; break;
+ default: err=0;
+ }
+ if (err)
+ fprintf(stderr,": %s\n",err);
+ else
+ fprintf(stderr,"\n");
+ error=2;
+ }
+ else if (silent)
+ {
+ struct in_addr in;
+ memcpy((char*) &in.s_addr, (char*) *hpaddr->h_addr_list,
+ sizeof (in.s_addr));
+ puts(inet_ntoa(in));
+ }
+ else
+ {
+ char **p;
+ for (p = hpaddr->h_addr_list; *p != 0; p++)
+ {
+ struct in_addr in;
+ memcpy(&in.s_addr, *p, sizeof (in.s_addr));
+ printf ("IP address of %s is %s\n",ip,inet_ntoa(in));
+ }
+ }
+ }
+ }
+ exit(error);
+}
+
+
+
View Lorry Controller Status