1/*
2**********************************************************************
3*   Copyright (C) 2009-2011, International Business Machines
4*   Corporation and others.  All Rights Reserved.
5**********************************************************************
6*
7* File gencfu.c
8*/
9
10//--------------------------------------------------------------------
11//
12//   Tool for generating Unicode Confusable data files (.cfu files).
13//   .cfu files contain the compiled of the confusable data
14//   derived from the Unicode Consortium data described in
15//   Unicode UAX 39.
16//
17//   Usage:  gencfu [options] -r confusables-file.txt -w whole-script-confusables.txt  -o output-file.cfu
18//
19//       options:   -v         verbose
20//                  -? or -h   help
21//
22//   The input rule filew is are plain text files containing confusable character
23//    definitions in the input format defined by Unicode UAX39 for the files
24//    confusables.txt and confusablesWholeScript.txt.  This source (.txt) format
25//    is also accepted direaccepted by ICU spoof detedtors.  The
26//    files must be encoded in utf-8 format, with or without a BOM.
27//
28//--------------------------------------------------------------------
29
30#include "unicode/utypes.h"
31#include "unicode/unistr.h"
32#include "unicode/uclean.h"
33#include "unicode/udata.h"
34#include "unicode/putil.h"
35
36#include "uoptions.h"
37#include "unewdata.h"
38#include "ucmndata.h"
39#include "uspoof_impl.h"
40#include "cmemory.h"
41
42#include <stdio.h>
43#include <stdlib.h>
44#include <string.h>
45
46U_NAMESPACE_USE
47
48static char *progName;
49static UOption options[]={
50    UOPTION_HELP_H,             /* 0 */
51    UOPTION_HELP_QUESTION_MARK, /* 1 */
52    UOPTION_VERBOSE,            /* 2 */
53    { "rules", NULL, NULL, NULL, 'r', UOPT_REQUIRES_ARG, 0 },   /* 3 */
54    { "wsrules", NULL, NULL, NULL, 'w', UOPT_REQUIRES_ARG, 0},  /* 4 */
55    { "out",   NULL, NULL, NULL, 'o', UOPT_REQUIRES_ARG, 0 },   /* 5 */
56    UOPTION_ICUDATADIR,         /* 6 */
57    UOPTION_DESTDIR,            /* 7 */
58    UOPTION_COPYRIGHT,          /* 8 */
59};
60
61void usageAndDie(int retCode) {
62        printf("Usage: %s [-v] [-options] -r confusablesRules.txt -w wholeScriptConfusables.txt -o output-file\n", progName);
63        printf("\tRead in Unicode confusable character definitions and write out the binary data\n"
64            "options:\n"
65            "\t-h or -? or --help  this usage text\n"
66            "\t-V or --version     show a version message\n"
67            "\t-c or --copyright   include a copyright notice\n"
68            "\t-v or --verbose     turn on verbose output\n"
69            "\t-i or --icudatadir  directory for locating any needed intermediate data files,\n"
70            "\t                    followed by path, defaults to %s\n"
71            "\t-d or --destdir     destination directory, followed by the path\n",
72            u_getDataDirectory());
73        exit (retCode);
74}
75
76
77#if UCONFIG_NO_REGULAR_EXPRESSIONS || UCONFIG_NO_NORMALIZATION || UCONFIG_NO_FILE_IO
78
79/* dummy UDataInfo cf. udata.h */
80static UDataInfo dummyDataInfo = {
81    sizeof(UDataInfo),
82    0,
83
84    U_IS_BIG_ENDIAN,
85    U_CHARSET_FAMILY,
86    U_SIZEOF_UCHAR,
87    0,
88
89    { 0, 0, 0, 0 },                 /* dummy dataFormat */
90    { 0, 0, 0, 0 },                 /* dummy formatVersion */
91    { 0, 0, 0, 0 }                  /* dummy dataVersion */
92};
93
94#else
95
96//
97//  Set up the ICU data header, defined in ucmndata.h
98//
99DataHeader dh ={
100    {sizeof(DataHeader),           // Struct MappedData
101        0xda,
102        0x27},
103
104    {                               // struct UDataInfo
105        sizeof(UDataInfo),          //     size
106        0,                          //     reserved
107        U_IS_BIG_ENDIAN,
108        U_CHARSET_FAMILY,
109        U_SIZEOF_UCHAR,
110        0,                          //     reserved
111
112    { 0x43, 0x66, 0x75, 0x20 },     //     dataFormat="Cfu "
113    { 0xff, 0, 0, 0 },              //     formatVersion.  Filled in later with values
114                                    //      from the  builder.  The  values declared
115                                    //      here should never appear in any real data.
116        { 5, 1, 0, 0 }              //   dataVersion (Unicode version)
117    }};
118
119#endif
120
121// Forward declaration for function for reading source files.
122static const char *readFile(const char *fileName, int32_t *len);
123
124//----------------------------------------------------------------------------
125//
126//  main      for gencfu
127//
128//----------------------------------------------------------------------------
129int  main(int argc, char **argv) {
130    UErrorCode  status = U_ZERO_ERROR;
131    const char *confFileName;
132    const char *confWSFileName;
133    const char *outFileName;
134    const char *outDir = NULL;
135    const char *copyright = NULL;
136
137    //
138    // Pick up and check the command line arguments,
139    //    using the standard ICU tool utils option handling.
140    //
141    U_MAIN_INIT_ARGS(argc, argv);
142    progName = argv[0];
143    argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);
144    if(argc<0) {
145        // Unrecognized option
146        fprintf(stderr, "error in command line argument \"%s\"\n", argv[-argc]);
147        usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
148    }
149
150    if(options[0].doesOccur || options[1].doesOccur) {
151        //  -? or -h for help.
152        usageAndDie(0);
153    }
154
155    if (!(options[3].doesOccur && options[4].doesOccur && options[5].doesOccur)) {
156        fprintf(stderr, "confusables file, whole script confusables file and output file must all be specified.\n");
157        usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
158    }
159    confFileName   = options[3].value;
160    confWSFileName = options[4].value;
161    outFileName    = options[5].value;
162
163    if (options[6].doesOccur) {
164        u_setDataDirectory(options[6].value);
165    }
166
167    status = U_ZERO_ERROR;
168
169    /* Combine the directory with the file name */
170    if(options[7].doesOccur) {
171        outDir = options[7].value;
172    }
173    if (options[8].doesOccur) {
174        copyright = U_COPYRIGHT_STRING;
175    }
176
177#if UCONFIG_NO_REGULAR_EXPRESSIONS || UCONFIG_NO_NORMALIZATION || UCONFIG_NO_FILE_IO
178    // spoof detection data file parsing is dependent on regular expressions.
179    // TODO: have the tool return an error status.  Requires fixing the ICU data build
180    //       so that it doesn't abort entirely on that error.
181
182    UNewDataMemory *pData;
183    char msg[1024];
184
185    /* write message with just the name */
186    sprintf(msg, "gencfu writes dummy %s because of UCONFIG_NO_REGULAR_EXPRESSIONS and/or UCONFIG_NO_NORMALIZATION and/or UCONFIG_NO_FILE_IO, see uconfig.h", outFileName);
187    fprintf(stderr, "%s\n", msg);
188
189    /* write the dummy data file */
190    pData = udata_create(outDir, NULL, outFileName, &dummyDataInfo, NULL, &status);
191    udata_writeBlock(pData, msg, strlen(msg));
192    udata_finish(pData, &status);
193    return (int)status;
194
195#else
196    /* Initialize ICU */
197    u_init(&status);
198    if (U_FAILURE(status)) {
199        fprintf(stderr, "%s: can not initialize ICU.  status = %s\n",
200            argv[0], u_errorName(status));
201        exit(1);
202    }
203    status = U_ZERO_ERROR;
204
205    //  Read in the confusables source file
206
207    int32_t      confusablesLen = 0;
208    const char  *confusables = readFile(confFileName, &confusablesLen);
209    if (confusables == NULL) {
210        printf("gencfu: error reading file  \"%s\"\n", confFileName);
211        exit(-1);
212    }
213
214    int32_t     wsConfusablesLen = 0;
215    const char *wsConfsables =  readFile(confWSFileName, &wsConfusablesLen);
216    if (wsConfsables == NULL) {
217        printf("gencfu: error reading file  \"%s\"\n", confFileName);
218        exit(-1);
219    }
220
221    //
222    //  Create the Spoof Detector from the source confusables files.
223    //     This will compile the data.
224    //
225    UParseError parseError;
226    parseError.line = 0;
227    parseError.offset = 0;
228    int32_t errType;
229    USpoofChecker *sc = uspoof_openFromSource(confusables, confusablesLen,
230                                              wsConfsables, wsConfusablesLen,
231                                              &errType, &parseError, &status);
232    if (U_FAILURE(status)) {
233        const char *errFile =
234            (errType == USPOOF_WHOLE_SCRIPT_CONFUSABLE)? confWSFileName : confFileName;
235        fprintf(stderr, "gencfu: uspoof_openFromSource error \"%s\"  at file %s, line %d, column %d\n",
236                u_errorName(status), errFile, (int)parseError.line, (int)parseError.offset);
237        exit(status);
238    };
239
240
241    //
242    //  Get the compiled rule data from the USpoofChecker.
243    //
244    uint32_t        outDataSize;
245    uint8_t        *outData;
246    outDataSize = uspoof_serialize(sc, NULL, 0, &status);
247    if (status != U_BUFFER_OVERFLOW_ERROR) {
248        fprintf(stderr, "gencfu: uspoof_serialize() returned %s\n", u_errorName(status));
249        exit(status);
250    }
251    status = U_ZERO_ERROR;
252    outData = new uint8_t[outDataSize];
253    uspoof_serialize(sc, outData, outDataSize, &status);
254
255    // Copy the data format version numbers from the spoof data header into the UDataMemory header.
256
257    uprv_memcpy(dh.info.formatVersion,
258                reinterpret_cast<SpoofDataHeader *>(outData)->fFormatVersion,
259                sizeof(dh.info.formatVersion));
260
261    //
262    //  Create the output file
263    //
264    size_t bytesWritten;
265    UNewDataMemory *pData;
266    pData = udata_create(outDir, NULL, outFileName, &(dh.info), copyright, &status);
267    if(U_FAILURE(status)) {
268        fprintf(stderr, "gencfu: Could not open output file \"%s\", \"%s\"\n",
269                         outFileName, u_errorName(status));
270        exit(status);
271    }
272
273
274    //  Write the data itself.
275    udata_writeBlock(pData, outData, outDataSize);
276    // finish up
277    bytesWritten = udata_finish(pData, &status);
278    if(U_FAILURE(status)) {
279        fprintf(stderr, "gencfu: Error %d writing the output file\n", status);
280        exit(status);
281    }
282
283    if (bytesWritten != outDataSize) {
284        fprintf(stderr, "gencfu: Error writing to output file \"%s\"\n", outFileName);
285        exit(-1);
286    }
287
288    uspoof_close(sc);
289    delete [] outData;
290    delete [] confusables;
291    delete [] wsConfsables;
292    u_cleanup();
293    printf("gencfu: tool completed successfully.\n");
294    return 0;
295#endif   // UCONFIG_NO_REGULAR_EXPRESSIONS
296}
297
298
299 //
300 //  Read in a confusables source file
301 //
302 static const char *readFile(const char *fileName, int32_t *len) {
303    char       *result;
304    long        fileSize;
305    FILE        *file;
306
307    file = fopen(fileName, "rb");
308    if( file == 0 ) {
309        return NULL;
310    }
311    fseek(file, 0, SEEK_END);
312    fileSize = ftell(file);
313    fseek(file, 0, SEEK_SET);
314    result = new char[fileSize+10];
315    if (result==NULL) {
316        fclose(file);
317        return NULL;
318    }
319
320    long t = fread(result, 1, fileSize, file);
321    if (t != fileSize)  {
322        delete [] result;
323        fclose(file);
324        return NULL;
325    }
326    result[fileSize]=0;
327    *len = static_cast<int32_t>(fileSize);
328    fclose(file);
329    return result;
330 }
331