USBIdDatabaseGenerator.cpp@ 96407

Last change on this file since 96407 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 17.4 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: