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 46 U_NAMESPACE_USE 47 48 static char *progName; 49 static 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 61 void 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 */ 80 static 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 // 99 DataHeader 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. 122 static const char *readFile(const char *fileName, int32_t *len); 123 124 //---------------------------------------------------------------------------- 125 // 126 // main for gencfu 127 // 128 //---------------------------------------------------------------------------- 129 int 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
