VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/USBIdDatabaseGenerator.cpp@ 72899

Last change on this file since 72899 was 69500, checked in by vboxsync, 7 years ago

*: scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.1 KB
Line 
1/* $Id: USBIdDatabaseGenerator.cpp 69500 2017-10-28 15:14:05Z vboxsync $ */
2/** @file
3 * USB device vendor and product ID database - generator.
4 */
5
6/*
7 * Copyright (C) 2015-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#include <stdio.h>
23
24#include <algorithm>
25#include <map>
26#include <string>
27#include <vector>
28
29#include <iprt/initterm.h>
30#include <iprt/message.h>
31#include <iprt/string.h>
32#include <iprt/stream.h>
33
34#include "../include/USBIdDatabase.h"
35
36
37/*
38 * Include the string table generator.
39 */
40#define BLDPROG_STRTAB_MAX_STRLEN (USB_ID_DATABASE_MAX_STRING - 1)
41#ifdef USB_ID_DATABASE_WITH_COMPRESSION
42# define BLDPROG_STRTAB_WITH_COMPRESSION
43#else
44# undef BLDPROG_STRTAB_WITH_COMPRESSION
45#endif
46#define BLDPROG_STRTAB_WITH_CAMEL_WORDS
47#undef BLDPROG_STRTAB_PURE_ASCII
48#include <iprt/bldprog-strtab-template.cpp.h>
49
50
51
52/*********************************************************************************************************************************
53* Global Variables *
54*********************************************************************************************************************************/
55/** For verbose output. */
56static bool g_fVerbose = false;
57
58
59/*********************************************************************************************************************************
60* Defined Constants And Macros *
61*********************************************************************************************************************************/
62// error codes (complements RTEXITCODE_XXX).
63#define ERROR_OPEN_FILE (12)
64#define ERROR_IN_PARSE_LINE (13)
65#define ERROR_DUPLICATE_ENTRY (14)
66#define ERROR_WRONG_FILE_FORMAT (15)
67#define ERROR_TOO_MANY_PRODUCTS (16)
68
69
70/*********************************************************************************************************************************
71* Structures and Typedefs *
72*********************************************************************************************************************************/
73struct VendorRecord
74{
75 size_t vendorID;
76 size_t iProduct;
77 size_t cProducts;
78 std::string str;
79 BLDPROGSTRING StrRef;
80};
81
82struct ProductRecord
83{
84 size_t key;
85 size_t vendorID;
86 size_t productID;
87 std::string str;
88 BLDPROGSTRING StrRef;
89};
90
91typedef std::vector<ProductRecord> ProductsSet;
92typedef std::vector<VendorRecord> VendorsSet;
93
94
95/*********************************************************************************************************************************
96* Global Variables *
97*********************************************************************************************************************************/
98static ProductsSet g_products;
99static VendorsSet g_vendors;
100
101/** The size of all the raw strings, including terminators. */
102static size_t g_cbRawStrings = 0;
103
104
105
106bool operator < (const ProductRecord& lh, const ProductRecord& rh)
107{
108 return lh.key < rh.key;
109}
110
111bool operator < (const VendorRecord& lh, const VendorRecord& rh)
112{
113 return lh.vendorID < rh.vendorID;
114}
115
116bool operator == (const ProductRecord& lh, const ProductRecord& rh)
117{
118 return lh.key == rh.key;
119}
120
121bool operator == (const VendorRecord& lh, const VendorRecord& rh)
122{
123 return lh.vendorID == rh.vendorID;
124}
125
126
127/*
128 * Input file parsing.
129 */
130static int ParseAlias(char *pszLine, size_t& id, std::string& desc)
131{
132 /* First there's a hexadeciman number. */
133 uint32_t uVal;
134 char *pszNext;
135 int rc = RTStrToUInt32Ex(pszLine, &pszNext, 16, &uVal);
136 if ( rc == VWRN_TRAILING_CHARS
137 || rc == VWRN_TRAILING_SPACES
138 || rc == VINF_SUCCESS)
139 {
140 /* Skip the whipespace following it and at the end of the line. */
141 pszNext = RTStrStripL(pszNext);
142 if (*pszNext != '\0')
143 {
144 rc = RTStrValidateEncoding(pszNext);
145 if (RT_SUCCESS(rc))
146 {
147 size_t cchDesc = strlen(pszNext);
148 if (cchDesc <= USB_ID_DATABASE_MAX_STRING)
149 {
150 id = uVal;
151 desc = pszNext;
152 g_cbRawStrings += cchDesc + 1;
153 return RTEXITCODE_SUCCESS;
154 }
155 RTMsgError("String to long: %zu", cchDesc);
156 }
157 else
158 RTMsgError("Invalid encoding: '%s' (rc=%Rrc)", pszNext, rc);
159 }
160 else
161 RTMsgError("Error parsing '%s'", pszLine);
162 }
163 else
164 RTMsgError("Error converting number at the start of '%s': %Rrc", pszLine, rc);
165 return ERROR_IN_PARSE_LINE;
166}
167
168static int ParseUsbIds(PRTSTREAM pInStrm, const char *pszFile)
169{
170 /*
171 * State data.
172 */
173 VendorRecord vendor = { 0, 0, 0, "" };
174
175 /*
176 * Process the file line-by-line.
177 *
178 * The generic format is that we have top level entries (vendors) starting
179 * in position 0 with sub entries starting after one or more, depending on
180 * the level, tab characters.
181 *
182 * Specifically, the list of vendors and their products will always start
183 * with a vendor line followed by indented products. The first character
184 * on the vendor line is a hex digit (four in total) that makes up the
185 * vendor ID. The product lines equally starts with a 4 digit hex ID value.
186 *
187 * Other lists are assumed to have first lines that doesn't start with any
188 * lower case hex digit.
189 */
190 uint32_t iLine = 0;;
191 for (;;)
192 {
193 char szLine[_4K];
194 int rc = RTStrmGetLine(pInStrm, szLine, sizeof(szLine));
195 if (RT_SUCCESS(rc))
196 {
197 iLine++;
198
199 /* Check for vendor line. */
200 char chType = szLine[0];
201 if ( RT_C_IS_XDIGIT(chType)
202 && RT_C_IS_SPACE(szLine[4])
203 && RT_C_IS_XDIGIT(szLine[1])
204 && RT_C_IS_XDIGIT(szLine[2])
205 && RT_C_IS_XDIGIT(szLine[3]) )
206 {
207 if (ParseAlias(szLine, vendor.vendorID, vendor.str) == 0)
208 g_vendors.push_back(vendor);
209 else
210 return RTMsgErrorExit((RTEXITCODE)ERROR_IN_PARSE_LINE,
211 "%s(%d): Error in parsing vendor line: '%s'", pszFile, iLine, szLine);
212 }
213 /* Check for product line. */
214 else if (szLine[0] == '\t' && vendor.vendorID != 0)
215 {
216 ProductRecord product = { 0, vendor.vendorID, 0, "" };
217 if (ParseAlias(&szLine[1], product.productID, product.str) == 0)
218 {
219 product.key = RT_MAKE_U32(product.productID, product.vendorID);
220 Assert(product.vendorID == vendor.vendorID);
221 g_products.push_back(product);
222 }
223 else
224 return RTMsgErrorExit((RTEXITCODE)ERROR_IN_PARSE_LINE, "Error in parsing product line: '%s'", szLine);
225 }
226 /* If not a blank or comment line, it is some other kind of data.
227 So, make sure the vendor ID is cleared so we don't try process
228 the sub-items of in some other list as products. */
229 else if ( chType != '#'
230 && chType != '\0'
231 && *RTStrStripL(szLine) != '\0')
232 vendor.vendorID = 0;
233 }
234 else if (rc == VERR_EOF)
235 return RTEXITCODE_SUCCESS;
236 else
237 return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrmGetLine failed: %Rrc", rc);
238 }
239}
240
241static void WriteSourceFile(FILE *pOut, const char *argv0, PBLDPROGSTRTAB pStrTab)
242{
243 fprintf(pOut,
244 "/** @file\n"
245 " * USB device vendor and product ID database - Autogenerated by %s\n"
246 " */\n"
247 "\n"
248 "/*\n"
249 " * Copyright (C) 2015-2016 Oracle Corporation\n"
250 " *\n"
251 " * This file is part of VirtualBox Open Source Edition(OSE), as\n"
252 " * available from http ://www.virtualbox.org. This file is free software;\n"
253 " * you can redistribute it and / or modify it under the terms of the GNU\n"
254 " * General Public License(GPL) as published by the Free Software\n"
255 " * Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
256 " * VirtualBox OSE distribution.VirtualBox OSE is distributed in the\n"
257 " * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n"
258 " */"
259 "\n"
260 "\n"
261 "#include \"USBIdDatabase.h\"\n"
262 "\n",
263 argv0);
264
265 BldProgStrTab_WriteStringTable(pStrTab, pOut, "", "USBIdDatabase::s_", "StrTab");
266
267 fputs("/**\n"
268 " * USB devices aliases array.\n"
269 " * Format: VendorId, ProductId, Vendor Name, Product Name\n"
270 " * The source of the list is http://www.linux-usb.org/usb.ids\n"
271 " */\n"
272 "USBIDDBPROD const USBIdDatabase::s_aProducts[] =\n"
273 "{\n", pOut);
274 for (ProductsSet::iterator itp = g_products.begin(); itp != g_products.end(); ++itp)
275 fprintf(pOut, " { 0x%04x },\n", (unsigned)itp->productID);
276 fputs("};\n"
277 "\n"
278 "\n"
279 "const RTBLDPROGSTRREF USBIdDatabase::s_aProductNames[] =\n"
280 "{\n", pOut);
281 for (ProductsSet::iterator itp = g_products.begin(); itp != g_products.end(); ++itp)
282 fprintf(pOut, "{ 0x%06x, 0x%02x },\n", itp->StrRef.offStrTab, (unsigned)itp->StrRef.cchString);
283 fputs("};\n"
284 "\n"
285 "const size_t USBIdDatabase::s_cProducts = RT_ELEMENTS(USBIdDatabase::s_aProducts);\n"
286 "\n", pOut);
287
288 fputs("USBIDDBVENDOR const USBIdDatabase::s_aVendors[] =\n"
289 "{\n", pOut);
290 for (VendorsSet::iterator itv = g_vendors.begin(); itv != g_vendors.end(); ++itv)
291 fprintf(pOut, " { 0x%04x, 0x%04x, 0x%04x },\n", (unsigned)itv->vendorID, (unsigned)itv->iProduct, (unsigned)itv->cProducts);
292 fputs("};\n"
293 "\n"
294 "\n"
295 "const RTBLDPROGSTRREF USBIdDatabase::s_aVendorNames[] =\n"
296 "{\n", pOut);
297 for (VendorsSet::iterator itv = g_vendors.begin(); itv != g_vendors.end(); ++itv)
298 fprintf(pOut, "{ 0x%06x, 0x%02x },\n", itv->StrRef.offStrTab, (unsigned)itv->StrRef.cchString);
299 fputs("};\n"
300 "\n"
301 "const size_t USBIdDatabase::s_cVendors = RT_ELEMENTS(USBIdDatabase::s_aVendors);\n"
302 "\n", pOut);
303}
304
305static int usage(FILE *pOut, const char *argv0)
306{
307 fprintf(pOut, "Usage: %s [linux.org usb list file] [custom usb list file] [-o output file]\n", argv0);
308 return RTEXITCODE_SYNTAX;
309}
310
311
312int main(int argc, char *argv[])
313{
314 /*
315 * Initialize IPRT and convert argv to UTF-8.
316 */
317 int rc = RTR3InitExe(argc, &argv, 0);
318 if (RT_FAILURE(rc))
319 return RTMsgInitFailure(rc);
320
321 /*
322 * Parse arguments and read input files.
323 */
324 if (argc < 4)
325 {
326 usage(stderr, argv[0]);
327 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Insufficient arguments.");
328 }
329 g_products.reserve(20000);
330 g_vendors.reserve(3500);
331
332 const char *pszOutFile = NULL;
333 for (int i = 1; i < argc; i++)
334 {
335 if (strcmp(argv[i], "-o") == 0)
336 {
337 pszOutFile = argv[++i];
338 continue;
339 }
340 if ( strcmp(argv[i], "-h") == 0
341 || strcmp(argv[i], "-?") == 0
342 || strcmp(argv[i], "--help") == 0)
343 {
344 usage(stdout, argv[0]);
345 return RTEXITCODE_SUCCESS;
346 }
347
348 PRTSTREAM pInStrm;
349 rc = RTStrmOpen(argv[i], "r", &pInStrm);
350 if (RT_FAILURE(rc))
351 return RTMsgErrorExit((RTEXITCODE)ERROR_OPEN_FILE,
352 "Failed to open file '%s' for reading: %Rrc", argv[i], rc);
353
354 rc = ParseUsbIds(pInStrm, argv[i]);
355 RTStrmClose(pInStrm);
356 if (rc != 0)
357 {
358 RTMsgError("Failed parsing USB devices file '%s'", argv[i]);
359 return rc;
360 }
361 }
362
363 /*
364 * Due to USBIDDBVENDOR::iProduct, there is currently a max of 64KB products.
365 * (Not a problem as we've only have less that 54K products currently.)
366 */
367 if (g_products.size() > _64K)
368 return RTMsgErrorExit((RTEXITCODE)ERROR_TOO_MANY_PRODUCTS,
369 "More than 64K products is not supported: %u products", g_products.size());
370
371 /*
372 * Sort the IDs and fill in the iProduct and cProduct members.
373 */
374 sort(g_products.begin(), g_products.end());
375 sort(g_vendors.begin(), g_vendors.end());
376
377 size_t iProduct = 0;
378 for (size_t iVendor = 0; iVendor < g_vendors.size(); iVendor++)
379 {
380 size_t const idVendor = g_vendors[iVendor].vendorID;
381 g_vendors[iVendor].iProduct = iProduct;
382 if ( iProduct < g_products.size()
383 && g_products[iProduct].vendorID <= idVendor)
384 {
385 if (g_products[iProduct].vendorID == idVendor)
386 do
387 iProduct++;
388 while ( iProduct < g_products.size()
389 && g_products[iProduct].vendorID == idVendor);
390 else
391 return RTMsgErrorExit((RTEXITCODE)ERROR_IN_PARSE_LINE, "product without vendor after sorting. impossible!");
392 }
393 g_vendors[iVendor].cProducts = iProduct - g_vendors[iVendor].iProduct;
394 }
395
396 /*
397 * Verify that all IDs are unique.
398 */
399 ProductsSet::iterator ita = adjacent_find(g_products.begin(), g_products.end());
400 if (ita != g_products.end())
401 return RTMsgErrorExit((RTEXITCODE)ERROR_DUPLICATE_ENTRY, "Duplicate alias detected: idProduct=%#06x", ita->productID);
402
403 /*
404 * Build the string table.
405 * Do string compression and create the string table.
406 */
407 BLDPROGSTRTAB StrTab;
408 if (!BldProgStrTab_Init(&StrTab, g_products.size() + g_vendors.size()))
409 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory!");
410
411 for (ProductsSet::iterator it = g_products.begin(); it != g_products.end(); ++it)
412 {
413 it->StrRef.pszString = (char *)it->str.c_str();
414 BldProgStrTab_AddString(&StrTab, &it->StrRef);
415 }
416 for (VendorsSet::iterator it = g_vendors.begin(); it != g_vendors.end(); ++it)
417 {
418 it->StrRef.pszString = (char *)it->str.c_str();
419 BldProgStrTab_AddString(&StrTab, &it->StrRef);
420 }
421
422 if (!BldProgStrTab_CompileIt(&StrTab, g_fVerbose))
423 return RTMsgErrorExit(RTEXITCODE_FAILURE, "BldProgStrTab_CompileIt failed!\n");
424
425 /*
426 * Print stats. Making a little extra effort to get it all on one line.
427 */
428 size_t const cbVendorEntry = sizeof(USBIdDatabase::s_aVendors[0]) + sizeof(USBIdDatabase::s_aVendorNames[0]);
429 size_t const cbProductEntry = sizeof(USBIdDatabase::s_aProducts[0]) + sizeof(USBIdDatabase::s_aProductNames[0]);
430
431 size_t cbOldRaw = (g_products.size() + g_vendors.size()) * sizeof(const char *) * 2 + g_cbRawStrings;
432 size_t cbRaw = g_vendors.size() * cbVendorEntry + g_products.size() * cbProductEntry + g_cbRawStrings;
433 size_t cbActual = g_vendors.size() * cbVendorEntry + g_products.size() * cbProductEntry + StrTab.cchStrTab;
434#ifdef USB_ID_DATABASE_WITH_COMPRESSION
435 cbActual += sizeof(StrTab.aCompDict);
436#endif
437
438 char szMsg1[32];
439 RTStrPrintf(szMsg1, sizeof(szMsg1),"Total %zu bytes", cbActual);
440 char szMsg2[64];
441 RTStrPrintf(szMsg2, sizeof(szMsg2)," old version %zu bytes + relocs (%zu%% save)",
442 cbOldRaw, (cbOldRaw - cbActual) * 100 / cbOldRaw);
443 if (cbActual < cbRaw)
444 RTMsgInfo("%s - saving %zu%% (%zu bytes);%s", szMsg1, (cbRaw - cbActual) * 100 / cbRaw, cbRaw - cbActual, szMsg2);
445 else
446 RTMsgInfo("%s - wasting %zu bytes;%s", szMsg1, cbActual - cbRaw, szMsg2);
447
448 /*
449 * Produce the source file.
450 */
451 if (!pszOutFile)
452 return RTMsgErrorExit((RTEXITCODE)ERROR_OPEN_FILE, "Output file is not specified.");
453
454 FILE *pOut = fopen(pszOutFile, "w");
455 if (!pOut)
456 return RTMsgErrorExit((RTEXITCODE)ERROR_OPEN_FILE, "Error opening '%s' for writing", pszOutFile);
457
458 WriteSourceFile(pOut, argv[0], &StrTab);
459
460 if (ferror(pOut))
461 return RTMsgErrorExit((RTEXITCODE)ERROR_OPEN_FILE, "Error writing '%s'!", pszOutFile);
462 if (fclose(pOut) != 0)
463 return RTMsgErrorExit((RTEXITCODE)ERROR_OPEN_FILE, "Error closing '%s'!", pszOutFile);
464
465 return RTEXITCODE_SUCCESS;
466}
467
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette