summaryrefslogtreecommitdiff
path: root/source3/utils
diff options
context:
space:
mode:
authorJeremy Allison <jra@samba.org>1997-08-30 01:13:39 +0000
committerJeremy Allison <jra@samba.org>1997-08-30 01:13:39 +0000
commit57408548f3cc717116b5eb3fe7381f0568ac473d (patch)
treeb737f76ab503056b83227f123bc70ce61ae938ba /source3/utils
parentd95652780ac67b41b935511cd6dbdf94b3de371e (diff)
downloadsamba-57408548f3cc717116b5eb3fe7381f0568ac473d.tar.gz
samba-57408548f3cc717116b5eb3fe7381f0568ac473d.tar.bz2
samba-57408548f3cc717116b5eb3fe7381f0568ac473d.zip
Adding codepage definition files and codepage file compiler/decompiler.
Adding install/uninstall scripts for compiled codepage files. Preparing for dynamic codepage loading. Jeremy (jallison@whistle.com) (This used to be commit e3fc9533bd87d0d520e3dac98261e42370907b11)
Diffstat (limited to 'source3/utils')
-rw-r--r--source3/utils/make_smbcodepage.c472
1 files changed, 472 insertions, 0 deletions
diff --git a/source3/utils/make_smbcodepage.c b/source3/utils/make_smbcodepage.c
new file mode 100644
index 0000000000..c8b4fea8bc
--- /dev/null
+++ b/source3/utils/make_smbcodepage.c
@@ -0,0 +1,472 @@
+/*
+ Unix SMB/Netbios implementation.
+ Version 1.9.
+ Create codepage files from codepage_def.XXX files.
+
+ Copyright (C) Jeremy Allison 1997
+
+ 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+static char *prog_name = NULL;
+
+/*
+ * Print program usage and die.
+ */
+
+void codepage_usage(const char *progname)
+{
+ fprintf(stderr, "Usage is : %s [c|d] <codepage> <inputfile> <outputfile>\n",
+ progname);
+ exit(1);
+}
+
+/*
+ * Read a line from a buffer into a line buffer. Ensure null
+ * terminated.
+ */
+
+void read_line( char **buf, char *line_buf, int size)
+{
+ char *p = *buf;
+ int num = 0;
+
+ for(; *p && (*p != '\n'); p++)
+ {
+ if(num < (size - 1))
+ line_buf[num++] = *p;
+ }
+ if(*p)
+ p++; /* Go past the '\n' */
+ line_buf[num] = '\0';
+ *buf = p;
+}
+
+/*
+ * Strip comment lines and blank lines from the data.
+ * Copies into a new buffer and frees the old.
+ * Returns the number of lines copied.
+ */
+
+int clean_data( char **buf, uint32 *size)
+{
+ char linebuf[512];
+ char *p = *buf;
+ int num_lines = 0;
+ char *newbuf = (char *)malloc( *size + 1);
+ char *newbuf_p = NULL;
+
+ if(newbuf == NULL)
+ {
+ fprintf(stderr, "%s: malloc fail for size %d.\n", prog_name, *size + 1);
+ exit(1);
+ }
+
+ newbuf_p = newbuf;
+ *newbuf_p = '\0';
+
+ while( *p )
+ {
+ char *cp;
+
+ read_line( &p, linebuf, sizeof(linebuf));
+ /* Null terminate after comment. */
+ if((cp = strchr( linebuf, '#'))!= NULL)
+ *cp = '\0';
+
+ for(cp = linebuf;*cp && isspace(*cp); cp++)
+ ;
+
+ if(*cp == '\0')
+ continue;
+
+ strcpy(newbuf_p, cp);
+ num_lines++;
+ newbuf_p += (strlen(newbuf_p) + 1);
+ }
+
+ free(*buf);
+ *buf = newbuf;
+ return num_lines;
+}
+
+/*
+ * Parse a byte from a codepage file.
+ */
+
+BOOL parse_byte(char *buf, unsigned char *bp)
+{
+ unsigned int b;
+ char *endptr = NULL;
+
+ b = (unsigned int)strtol(buf, &endptr, 0);
+ if(endptr == buf || b > 255)
+ return False;
+
+ *bp = (unsigned char)b;
+ return True;
+}
+
+/*
+ * Parse a bool from a codepage file.
+ */
+
+BOOL parse_bool(char *buf, unsigned char *bp)
+{
+ if(isdigit(*buf))
+ {
+ char *endptr = NULL;
+
+ *bp = (unsigned char)strtol(buf, &endptr, 0);
+ if(endptr == buf )
+ return False;
+ if(*bp != 0)
+ *bp = 1;
+ } else {
+ if(strcasecmp(buf, "True") && strcasecmp(buf, "False"))
+ return False;
+ if(strcasecmp(buf, "True")==0)
+ *bp = 1;
+ else
+ *bp = 0;
+ }
+ return True;
+}
+
+/*
+ * Print a parse error and exit.
+ */
+
+void parse_error(char *buf, char *msg)
+{
+ fprintf(stderr, "%s: %s whilst parsing line \n%s\n", prog_name,
+ msg, buf);
+ exit(1);
+}
+
+/*
+ * Create a compiled codepage file from a codepage definition file.
+ */
+
+int do_compile(int codepage, const char *input_file, const char *output_file)
+{
+ FILE *fp = NULL;
+ uint32 size = 0;
+ char *buf = NULL;
+ char output_buf[CODEPAGE_HEADER_SIZE + 512];
+ int num_lines = 0;
+ int i = 0;
+ struct stat st;
+
+ /* Get the size of the input file. Read the entire thing into memory. */
+ if(stat((char *)input_file, &st)!= 0)
+ {
+ fprintf(stderr, "%s: failed to get the file size for file %s. Error was %s\n",
+ prog_name, input_file, strerror(errno));
+ exit(1);
+ }
+
+ size = (uint32)st.st_size;
+
+ /* I don't believe these things should be bigger than 100k :-) */
+ if(size > 100*1024)
+ {
+ fprintf(stderr, "%s: filesize %d is too large for a codepage definition file. \
+The maximum size I will believe is 100k.\n", prog_name, size);
+ exit(1);
+ }
+
+ if((fp = fopen(input_file, "r")) == NULL)
+ {
+ fprintf(stderr, "%s: cannot open file %s for input.\n", prog_name, input_file);
+ exit(1);
+ }
+
+ /* As we will be reading text, allocate one more byte for a '\0' */
+ if((buf = (char *)malloc( size + 1 )) == NULL)
+ {
+ fprintf(stderr, "%s: malloc fail for size %d.\n", prog_name, size + 1);
+ fclose(fp);
+ exit(1);
+ }
+
+ if(fread( buf, 1, size, fp) != size)
+ {
+ fprintf(stderr, "%s: read failed for file %s. Error was %s.\n", prog_name,
+ input_file, strerror(errno));
+ free((char *)buf);
+ fclose(fp);
+ exit(1);
+ }
+
+ /* Null terminate the text read. */
+ buf[size] = '\0';
+
+ /* Go through the data line by line, strip out comments (anything
+ after a '#' to end-of-line) and blank lines. The rest should be
+ the codepage data.
+ */
+
+ num_lines = clean_data( &buf, &size);
+
+ /* There can be a maximum of 128 lines. */
+ if(num_lines > 128)
+ {
+ fprintf(stderr, "%s: There can be a maximum 128 lines of data in a codepage \
+definition file. File %s has %d.\n", prog_name, input_file, num_lines);
+ exit(1);
+ }
+
+ /* Setup the output file header. */
+ SSVAL(output_buf,CODEPAGE_VERSION_OFFSET,CODEPAGE_FILE_VERSION_ID);
+ SSVAL(output_buf,CODEPAGE_CLIENT_CODEPAGE_OFFSET,(uint16)codepage);
+ SIVAL(output_buf,CODEPAGE_LENGTH_OFFSET,(num_lines * 4));
+
+ /* Now convert the lines into the compiled form. */
+ for(i = 0; i < num_lines; i++)
+ {
+ char token_buf[512];
+ char *p = buf;
+ unsigned char b = 0;
+
+ /* Get the 'lower' value. */
+ if(!next_token(&p, token_buf, NULL))
+ parse_error(buf, "cannot parse first value");
+ if(!parse_byte( token_buf, &b))
+ parse_error(buf, "first value doesn't resolve to a byte");
+
+ /* Add this to the output buffer. */
+ SCVAL(output_buf,CODEPAGE_HEADER_SIZE+(i*4),b);
+
+ /* Get the 'upper' value. */
+ if(!next_token(&p, token_buf, NULL))
+ parse_error(buf, "cannot parse second value");
+ if(!parse_byte( token_buf, &b))
+ parse_error(buf, "second value doesn't resolve to a byte");
+
+ /* Add this to the output buffer. */
+ SCVAL(output_buf,CODEPAGE_HEADER_SIZE+(i*4) + 1,b);
+
+ /* Get the 'upper to lower' value. */
+ if(!next_token(&p, token_buf, NULL))
+ parse_error(buf, "cannot parse third value");
+ if(!parse_bool( token_buf, &b))
+ parse_error(buf, "third value doesn't resolve to a boolean");
+
+ /* Add this to the output buffer. */
+ SCVAL(output_buf,CODEPAGE_HEADER_SIZE+(i*4) + 2,b);
+
+ /* Get the 'lower to upper' value. */
+ if(!next_token(&p, token_buf, NULL))
+ parse_error(buf, "cannot parse fourth value");
+ if(!parse_bool( token_buf, &b))
+ parse_error(buf, "fourth value doesn't resolve to a boolean");
+
+ /* Add this to the output buffer. */
+ SCVAL(output_buf,CODEPAGE_HEADER_SIZE+(i*4) + 3,b);
+
+ buf += (strlen(buf) + 1);
+ }
+
+ /* Now write out the output_buf. */
+ if((fp = fopen(output_file, "w"))==NULL)
+ {
+ fprintf(stderr, "%s: Cannot open output file %s. Error was %s.\n",
+ prog_name, output_file, strerror(errno));
+ exit(1);
+ }
+
+ if(fwrite(output_buf, 1, CODEPAGE_HEADER_SIZE + (num_lines*4), fp) !=
+ CODEPAGE_HEADER_SIZE + (num_lines*4))
+ {
+ fprintf(stderr, "%s: Cannot write output file %s. Error was %s.\n",
+ prog_name, output_file, strerror(errno));
+ exit(1);
+ }
+
+ fclose(fp);
+
+ return 0;
+}
+
+/*
+ * Placeholder for now.
+ */
+
+int do_decompile( int codepage, const char *input_file, const char *output_file)
+{
+ uint32 size = 0;
+ struct stat st;
+ char header_buf[CODEPAGE_HEADER_SIZE];
+ char *buf = NULL;
+ FILE *fp = NULL;
+ int num_lines = 0;
+ int i = 0;
+
+ /* Get the size of the input file. Read the entire thing into memory. */
+ if(stat((char *)input_file, &st)!= 0)
+ {
+ fprintf(stderr, "%s: failed to get the file size for file %s. Error was %s\n",
+ prog_name, input_file, strerror(errno));
+ exit(1);
+ }
+
+ size = (uint32)st.st_size;
+
+ if( size < CODEPAGE_HEADER_SIZE || size > (CODEPAGE_HEADER_SIZE + 256))
+ {
+ fprintf(stderr, "%s: file %s is an incorrect size for a \
+code page file.\n", prog_name, input_file);
+ exit(1);
+ }
+
+ /* Read the first 8 bytes of the codepage file - check
+ the version number and code page number. All the data
+ is held in little endian format.
+ */
+
+ if((fp = fopen( input_file, "r")) == NULL)
+ {
+ fprintf(stderr, "%s: cannot open file %s. Error was %s\n",
+ prog_name, input_file, strerror(errno));
+ exit(1);
+ }
+
+ if(fread( header_buf, 1, CODEPAGE_HEADER_SIZE, fp)!=CODEPAGE_HEADER_SIZE)
+ {
+ fprintf(stderr, "%s: cannot read header from file %s. Error was %s\n",
+ prog_name, input_file, strerror(errno));
+ exit(1);
+ }
+
+ /* Check the version value */
+ if(SVAL(header_buf,CODEPAGE_VERSION_OFFSET) != CODEPAGE_FILE_VERSION_ID)
+ {
+ fprintf(stderr, "%s: filename %s has incorrect version id. \
+Needed %hu, got %hu.\n",
+ prog_name, input_file, (uint16)CODEPAGE_FILE_VERSION_ID,
+ SVAL(header_buf,CODEPAGE_VERSION_OFFSET));
+ exit(1);
+ }
+
+ /* Check the codepage matches */
+ if(SVAL(header_buf,CODEPAGE_CLIENT_CODEPAGE_OFFSET) != (uint16)codepage)
+ {
+ fprintf(stderr, "%s: filename %s has incorrect codepage. \
+Needed %hu, got %hu.\n",
+ prog_name, input_file, (uint16)codepage,
+ SVAL(header_buf,CODEPAGE_CLIENT_CODEPAGE_OFFSET));
+ exit(1);
+ }
+
+ /* Check the length is correct. */
+ if(IVAL(header_buf,CODEPAGE_LENGTH_OFFSET) !=
+ (unsigned int)(size - CODEPAGE_HEADER_SIZE))
+ {
+ fprintf(stderr, "%s: filename %s has incorrect size headers. \
+Needed %u, got %u.\n", prog_name, input_file, size - CODEPAGE_HEADER_SIZE,
+ IVAL(header_buf,CODEPAGE_LENGTH_OFFSET));
+ exit(1);
+ }
+
+ size -= CODEPAGE_HEADER_SIZE; /* Remove header */
+
+ /* Make sure the size is a multiple of 4. */
+ if((size % 4 ) != 0)
+ {
+ fprintf(stderr, "%s: filename %s has a codepage size not a \
+multiple of 4.\n", prog_name, input_file);
+ exit(1);
+ }
+
+ /* Allocate space for the code page file and read it all in. */
+ if((buf = (char *)malloc( size )) == NULL)
+ {
+ fprintf (stderr, "%s: malloc fail for size %d.\n",
+ prog_name, size );
+ exit(1);
+ }
+
+ if(fread( buf, 1, size, fp)!=size)
+ {
+ fprintf(stderr, "%s: read fail on file %s. Error was %s.\n",
+ prog_name, input_file, strerror(errno));
+ exit(1);
+ }
+
+ fclose(fp);
+
+ /* Now dump the codepage into an ascii file. */
+ if((fp = fopen(output_file, "w")) == NULL)
+ {
+ fprintf(stderr, "%s: cannot open file %s. Error was %s\n",
+ prog_name, output_file, strerror(errno));
+ exit(1);
+ }
+
+ fprintf(fp, "#\n# Codepage definition file for IBM Code Page %d.\n#\n",
+ codepage);
+ fprintf(fp, "# This file was automatically generated.\n#\n");
+ fprintf(fp, "# defines lower->upper mapping.\n");
+ fprintf(fp, "#\n#The columns are :\n# lower\tupper\tu-t-l\tl-t-u\n#\n");
+
+ num_lines = size / 4;
+ for( i = 0; i < num_lines; i++)
+ {
+ fprintf(fp, "0x%02X\t0x%02X\t%s\t%s\n", CVAL(buf, (i*4)), CVAL(buf, (i*4)+1),
+ CVAL(buf, (i*4)+2) ? "True" : "False",
+ CVAL(buf, (i*4)+3) ? "True" : "False");
+ }
+ fclose(fp);
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ int codepage = 0;
+ char *input_file = NULL;
+ char *output_file = NULL;
+ BOOL compile = False;
+
+ prog_name = argv[0];
+
+ if(argc != 5)
+ codepage_usage(prog_name);
+
+ if(argv[1][0] != 'c' && argv[1][0] != 'C' && argv[1][0] != 'd' &&
+ argv[1][0] != 'D')
+ codepage_usage(prog_name);
+
+ input_file = argv[3];
+ output_file = argv[4];
+
+ /* Are we compiling or decompiling. */
+ if(argv[1][0] == 'c' || argv[1][0] == 'C')
+ compile = True;
+
+ /* Convert the second argument into a client codepage value. */
+ if((codepage = atoi(argv[2])) == 0)
+ {
+ fprintf(stderr, "%s: %s is not a valid codepage.\n", prog_name, argv[2]);
+ exit(1);
+ }
+
+ if(compile)
+ return do_compile( codepage, input_file, output_file);
+ else
+ return do_decompile( codepage, input_file, output_file);
+}