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