diff options
Diffstat (limited to 'knowndrives.cpp')
| -rw-r--r-- | knowndrives.cpp | 996 |
1 files changed, 996 insertions, 0 deletions
diff --git a/knowndrives.cpp b/knowndrives.cpp new file mode 100644 index 0000000..3e399cf --- /dev/null +++ b/knowndrives.cpp @@ -0,0 +1,996 @@ +/* + * knowndrives.cpp + * + * Home page of code is: https://www.smartmontools.org + * + * Copyright (C) 2003-11 Philip Williams, Bruce Allen + * Copyright (C) 2008-21 Christian Franke + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#include "config.h" + +#include <stdio.h> +#include "atacmds.h" +#include "knowndrives.h" +#include "utility.h" + +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#ifdef _WIN32 +#include <io.h> // access() +#endif + +#include <stdexcept> + +const char * knowndrives_cpp_cvsid = "$Id: knowndrives.cpp 5376 2022-05-01 12:49:30Z chrfranke $" + KNOWNDRIVES_H_CVSID; + +#define MODEL_STRING_LENGTH 40 +#define FIRMWARE_STRING_LENGTH 8 +#define TABLEPRINTWIDTH 19 + + +// Builtin table of known drives. +// Used as a default if not read from +// "/usr/{,/local}share/smartmontools/drivedb.h" +// or any other file specified by '-B' option, +// see read_default_drive_databases() below. +// The drive_settings structure is described in drivedb.h. +const drive_settings builtin_knowndrives[] = { +#include "drivedb.h" +}; + +const unsigned builtin_knowndrives_size = + sizeof(builtin_knowndrives) / sizeof(builtin_knowndrives[0]); + +/// Drive database class. Stores custom entries read from file. +/// Provides transparent access to concatenation of custom and +/// default table. +class drive_database +{ +public: + drive_database(); + + ~drive_database(); + + /// Get total number of entries. + unsigned size() const + { return m_custom_tab.size() + m_builtin_size; } + + /// Get number of custom entries. + unsigned custom_size() const + { return m_custom_tab.size(); } + + /// Array access. + const drive_settings & operator[](unsigned i); + + /// Append new custom entry. + void push_back(const drive_settings & src); + + /// Append builtin table. + void append(const drive_settings * builtin_tab, unsigned builtin_size) + { m_builtin_tab = builtin_tab; m_builtin_size = builtin_size; } + +private: + const drive_settings * m_builtin_tab; + unsigned m_builtin_size; + + std::vector<drive_settings> m_custom_tab; + std::vector<char *> m_custom_strings; + + const char * copy_string(const char * str); + + drive_database(const drive_database &); + void operator=(const drive_database &); +}; + +drive_database::drive_database() +: m_builtin_tab(0), m_builtin_size(0) +{ +} + +drive_database::~drive_database() +{ + for (unsigned i = 0; i < m_custom_strings.size(); i++) + delete [] m_custom_strings[i]; +} + +const drive_settings & drive_database::operator[](unsigned i) +{ + return (i < m_custom_tab.size() ? m_custom_tab[i] + : m_builtin_tab[i - m_custom_tab.size()] ); +} + +void drive_database::push_back(const drive_settings & src) +{ + drive_settings dest; + dest.modelfamily = copy_string(src.modelfamily); + dest.modelregexp = copy_string(src.modelregexp); + dest.firmwareregexp = copy_string(src.firmwareregexp); + dest.warningmsg = copy_string(src.warningmsg); + dest.presets = copy_string(src.presets); + m_custom_tab.push_back(dest); +} + +const char * drive_database::copy_string(const char * src) +{ + size_t len = strlen(src); + char * dest = new char[len+1]; + memcpy(dest, src, len+1); + try { + m_custom_strings.push_back(dest); + } + catch (...) { + delete [] dest; throw; + } + return dest; +} + + +/// The drive database. +static drive_database knowndrives; + + +enum dbentry_type { + DBENTRY_VERSION, + DBENTRY_ATA_DEFAULT, + DBENTRY_ATA, + DBENTRY_USB +}; + +// Return type of entry +static dbentry_type get_modelfamily_type(const char * modelfamily) +{ + if (modelfamily[0] == 'V' && str_starts_with(modelfamily, "VERSION:")) + return DBENTRY_VERSION; + else if (modelfamily[0] == 'D' && !strcmp(modelfamily, "DEFAULT")) + return DBENTRY_ATA_DEFAULT; + else if (modelfamily[0] == 'U' && str_starts_with(modelfamily, "USB:")) + return DBENTRY_USB; + else + return DBENTRY_ATA; +} + +static inline dbentry_type get_dbentry_type(const drive_settings * dbentry) +{ + return get_modelfamily_type(dbentry->modelfamily); +} + +// Extract "BRANCH/REV" from "VERSION: ..." string. +static void parse_version(std::string & dbversion, const char * verstr) +{ + static const regular_expression regex( + "^VERSION: ([0-9]+\\.[0-9]+)(/([0-9]+) | \\$[^0-9]* ([0-9]+) )" + // (1 )( (3 ) (4 ) ) + ); + const int nmatch = 1+4; + regular_expression::match_range match[nmatch]; + if (!regex.execute(verstr, nmatch, match)) + return; + dbversion.assign(verstr + match[1].rm_so, match[1].rm_eo - match[1].rm_so); + int i = (match[3].rm_so >= 0 ? 3 : 4); // "BRANCH/REV" or "BRANCH ... SVN-REV" + dbversion += '/'; + dbversion.append(verstr + match[i].rm_so, match[i].rm_eo - match[i].rm_so); +} + +// Compile regular expression, print message on failure. +static bool compile(regular_expression & regex, const char *pattern) +{ + if (!regex.compile(pattern)) { + pout("Internal error: unable to compile regular expression \"%s\": %s\n" + "Please inform smartmontools developers at " PACKAGE_BUGREPORT "\n", + pattern, regex.get_errmsg()); + return false; + } + return true; +} + +// Compile & match a regular expression. +static bool match(const char * pattern, const char * str) +{ + regular_expression regex; + if (!compile(regex, pattern)) + return false; + return regex.full_match(str); +} + +// Searches knowndrives[] for a drive with the given model number and firmware +// string. If either the drive's model or firmware strings are not set by the +// manufacturer then values of NULL may be used. Returns the entry of the +// first match in knowndrives[] or 0 if no match if found. +static const drive_settings * lookup_drive(const char * model, const char * firmware, + std::string * dbversion = nullptr) +{ + if (!model) + model = ""; + if (!firmware) + firmware = ""; + + for (unsigned i = 0; i < knowndrives.size(); i++) { + dbentry_type t = get_dbentry_type(&knowndrives[i]); + // Get version if requested + if (t == DBENTRY_VERSION) { + if (dbversion) + parse_version(*dbversion, knowndrives[i].modelfamily); + continue; + } + + // Skip DEFAULT and USB entries + if (t != DBENTRY_ATA) + continue; + + // Check whether model matches the regular expression in knowndrives[i]. + if (!match(knowndrives[i].modelregexp, model)) + continue; + + // Model matches, now check firmware. "" matches always. + if (!( !*knowndrives[i].firmwareregexp + || match(knowndrives[i].firmwareregexp, firmware))) + continue; + + // Found + return &knowndrives[i]; + } + + // Not found + return 0; +} + + +// Parse drive or USB options in preset string, return false on error. +static bool parse_db_presets(const char * presets, ata_vendor_attr_defs * defs, + firmwarebug_defs * firmwarebugs, std::string * type) +{ + for (int i = 0; ; ) { + i += strspn(presets+i, " \t"); + if (!presets[i]) + break; + char opt, arg[80+1+13]; int len = -1; + if (!(sscanf(presets+i, "-%c %80[^ ]%n", &opt, arg, &len) >= 2 && len > 0)) + return false; + if (opt == 'v' && defs) { + // Parse "-v N,format[,name[,HDD|SSD]]" + if (!parse_attribute_def(arg, *defs, (firmwarebugs ? PRIOR_DATABASE : PRIOR_DEFAULT))) + return false; + } + else if (opt == 'F' && firmwarebugs) { + firmwarebug_defs bug; + if (!parse_firmwarebug_def(arg, bug)) + return false; + // Don't set if user specified '-F none'. + if (!firmwarebugs->is_set(BUG_NONE)) + firmwarebugs->set(bug); + } + else if (opt == 'd' && type) { + // TODO: Check valid types + *type = arg; + } + else + return false; + + i += len; + } + return true; +} + +// Parse '-v' options in default preset string, return false on error. +static inline bool parse_default_presets(const char * presets, + ata_vendor_attr_defs & defs) +{ + return parse_db_presets(presets, &defs, 0, 0); +} + +// Parse '-v' and '-F' options in preset string, return false on error. +static inline bool parse_presets(const char * presets, + ata_vendor_attr_defs & defs, + firmwarebug_defs & firmwarebugs) +{ + return parse_db_presets(presets, &defs, &firmwarebugs, 0); +} + +// Parse '-d' option in preset string, return false on error. +static inline bool parse_usb_type(const char * presets, std::string & type) +{ + return parse_db_presets(presets, 0, 0, &type); +} + +// Parse "USB: [DEVICE] ; [BRIDGE]" string +static void parse_usb_names(const char * names, usb_dev_info & info) +{ + int n1 = -1, n2 = -1, n3 = -1; + sscanf(names, "USB: %n%*[^;]%n; %n", &n1, &n2, &n3); + if (0 < n1 && n1 < n2) + info.usb_device.assign(names+n1, n2-n1); + else + sscanf(names, "USB: ; %n", &n3); + if (0 < n3) + info.usb_bridge = names+n3; +} + +// Search drivedb for USB device with vendor:product ID. +int lookup_usb_device(int vendor_id, int product_id, int bcd_device, + usb_dev_info & info, usb_dev_info & info2) +{ + // Format strings to match + char usb_id_str[16], bcd_dev_str[16]; + snprintf(usb_id_str, sizeof(usb_id_str), "0x%04x:0x%04x", vendor_id, product_id); + if (bcd_device >= 0) + snprintf(bcd_dev_str, sizeof(bcd_dev_str), "0x%04x", bcd_device); + else + bcd_dev_str[0] = 0; + + int found = 0; + for (unsigned i = 0; i < knowndrives.size(); i++) { + const drive_settings & dbentry = knowndrives[i]; + + // Skip drive entries + if (get_dbentry_type(&dbentry) != DBENTRY_USB) + continue; + + // Check whether USB vendor:product ID matches + if (!match(dbentry.modelregexp, usb_id_str)) + continue; + + // Parse '-d type' + usb_dev_info d; + if (!parse_usb_type(dbentry.presets, d.usb_type)) + return 0; // Syntax error + parse_usb_names(dbentry.modelfamily, d); + + // If two entries with same vendor:product ID have different + // types, use bcd_device (if provided by OS) to select entry. + if ( *dbentry.firmwareregexp && *bcd_dev_str + && match(dbentry.firmwareregexp, bcd_dev_str)) { + // Exact match including bcd_device + info = d; found = 1; + break; + } + else if (!found) { + // First match without bcd_device + info = d; found = 1; + } + else if (info.usb_type != d.usb_type) { + // Another possible match with different type + info2 = d; found = 2; + break; + } + + // Stop search at first matching entry with empty bcd_device + if (!*dbentry.firmwareregexp) + break; + } + + return found; +} + +// Shows one entry of knowndrives[], returns #errors. +static int showonepreset(const drive_settings * dbentry) +{ + // Basic error check + if (!( dbentry + && dbentry->modelfamily + && dbentry->modelregexp && *dbentry->modelregexp + && dbentry->firmwareregexp + && dbentry->warningmsg + && dbentry->presets )) { + pout("Invalid drive database entry. Please report\n" + "this error to smartmontools developers at " PACKAGE_BUGREPORT ".\n"); + return 1; + } + + dbentry_type type = get_dbentry_type(dbentry); + bool usb = (type == DBENTRY_USB); + + // print and check model and firmware regular expressions + int errcnt = 0; + regular_expression regex; + pout("%-*s %s\n", TABLEPRINTWIDTH, (!usb ? "MODEL REGEXP:" : "USB Vendor:Product:"), + dbentry->modelregexp); + if (!compile(regex, dbentry->modelregexp)) + errcnt++; + + pout("%-*s %s\n", TABLEPRINTWIDTH, (!usb ? "FIRMWARE REGEXP:" : "USB bcdDevice:"), + *dbentry->firmwareregexp ? dbentry->firmwareregexp : ".*"); // preserve old output (TODO: Change) + if (*dbentry->firmwareregexp && !compile(regex, dbentry->firmwareregexp)) + errcnt++; + + if (!usb) { + pout("%-*s %s\n", TABLEPRINTWIDTH, "MODEL FAMILY:", dbentry->modelfamily); + + // if there are any presets, then show them + firmwarebug_defs firmwarebugs; + bool first_preset = true; + if (*dbentry->presets) { + ata_vendor_attr_defs defs; + if (type == DBENTRY_ATA_DEFAULT) { + if (!parse_default_presets(dbentry->presets, defs)) { + pout("Syntax error in DEFAULT option string \"%s\"\n", dbentry->presets); + errcnt++; + } + } + else { + if (!parse_presets(dbentry->presets, defs, firmwarebugs)) { + pout("Syntax error in preset option string \"%s\"\n", dbentry->presets); + errcnt++; + } + } + + for (int i = 0; i < MAX_ATTRIBUTE_NUM; i++) { + if (defs[i].priority != PRIOR_DEFAULT || !defs[i].name.empty()) { + std::string name = ata_get_smart_attr_name(i, defs); + // Use leading zeros instead of spaces so that everything lines up. + pout("%-*s %03d %s\n", TABLEPRINTWIDTH, first_preset ? "ATTRIBUTE OPTIONS:" : "", + i, name.c_str()); + // Check max name length suitable for smartctl -A output + const unsigned maxlen = 23; + if (name.size() > maxlen) { + pout("%*s\n", TABLEPRINTWIDTH+6+maxlen, "Error: Attribute name too long ------^"); + errcnt++; + } + first_preset = false; + } + } + } + if (first_preset) + pout("%-*s %s\n", TABLEPRINTWIDTH, "ATTRIBUTE OPTIONS:", "None preset; no -v options are required."); + + // describe firmwarefix + for (int b = BUG_NOLOGDIR; b <= BUG_XERRORLBA; b++) { + if (!firmwarebugs.is_set((firmwarebug_t)b)) + continue; + const char * fixdesc; + switch ((firmwarebug_t)b) { + case BUG_NOLOGDIR: + fixdesc = "Avoids reading GP/SMART Log Directories (same as -F nologdir)"; + break; + case BUG_SAMSUNG: + fixdesc = "Fixes byte order in some SMART data (same as -F samsung)"; + break; + case BUG_SAMSUNG2: + fixdesc = "Fixes byte order in some SMART data (same as -F samsung2)"; + break; + case BUG_SAMSUNG3: + fixdesc = "Fixes completed self-test reported as in progress (same as -F samsung3)"; + break; + case BUG_XERRORLBA: + fixdesc = "Fixes LBA byte ordering in Ext. Comprehensive SMART error log (same as -F xerrorlba)"; + break; + default: + fixdesc = "UNKNOWN"; errcnt++; + break; + } + pout("%-*s %s\n", TABLEPRINTWIDTH, "OTHER PRESETS:", fixdesc); + } + } + else { + // Print USB info + usb_dev_info info; parse_usb_names(dbentry->modelfamily, info); + pout("%-*s %s\n", TABLEPRINTWIDTH, "USB Device:", + (!info.usb_device.empty() ? info.usb_device.c_str() : "[unknown]")); + pout("%-*s %s\n", TABLEPRINTWIDTH, "USB Bridge:", + (!info.usb_bridge.empty() ? info.usb_bridge.c_str() : "[unknown]")); + + if (*dbentry->presets && !parse_usb_type(dbentry->presets, info.usb_type)) { + pout("Syntax error in USB type string \"%s\"\n", dbentry->presets); + errcnt++; + } + pout("%-*s %s\n", TABLEPRINTWIDTH, "USB Type", + (!info.usb_type.empty() ? info.usb_type.c_str() : "[unsupported]")); + } + + // Print any special warnings + if (*dbentry->warningmsg) + pout("%-*s %s\n", TABLEPRINTWIDTH, "WARNINGS:", dbentry->warningmsg); + return errcnt; +} + +// Shows all presets for drives in knowndrives[]. +// Returns #syntax errors. +int showallpresets() +{ + // loop over all entries in the knowndrives[] table, printing them + // out in a nice format + int errcnt = 0; + for (unsigned i = 0; i < knowndrives.size(); i++) { + errcnt += showonepreset(&knowndrives[i]); + pout("\n"); + } + + pout("Total number of entries :%5u\n" + "Entries read from file(s):%5u\n\n", + knowndrives.size(), knowndrives.custom_size()); + + pout("For information about adding a drive to the database see the FAQ on the\n"); + pout("smartmontools home page: " PACKAGE_URL "\n"); + + if (errcnt > 0) + pout("\nFound %d syntax error(s) in database.\n" + "Please inform smartmontools developers at " PACKAGE_BUGREPORT "\n", errcnt); + return errcnt; +} + +// Shows all matching presets for a drive in knowndrives[]. +// Returns # matching entries. +int showmatchingpresets(const char *model, const char *firmware) +{ + int cnt = 0; + const char * firmwaremsg = (firmware ? firmware : "(any)"); + + for (unsigned i = 0; i < knowndrives.size(); i++) { + if (!match(knowndrives[i].modelregexp, model)) + continue; + if ( firmware && *knowndrives[i].firmwareregexp + && !match(knowndrives[i].firmwareregexp, firmware)) + continue; + // Found + if (++cnt == 1) + pout("Drive found in smartmontools Database. Drive identity strings:\n" + "%-*s %s\n" + "%-*s %s\n" + "match smartmontools Drive Database entry:\n", + TABLEPRINTWIDTH, "MODEL:", model, TABLEPRINTWIDTH, "FIRMWARE:", firmwaremsg); + else if (cnt == 2) + pout("and match these additional entries:\n"); + showonepreset(&knowndrives[i]); + pout("\n"); + } + if (cnt == 0) + pout("No presets are defined for this drive. Its identity strings:\n" + "MODEL: %s\n" + "FIRMWARE: %s\n" + "do not match any of the known regular expressions.\n", + model, firmwaremsg); + return cnt; +} + +// Shows the presets (if any) that are available for the given drive. +void show_presets(const ata_identify_device * drive) +{ + char model[MODEL_STRING_LENGTH+1], firmware[FIRMWARE_STRING_LENGTH+1]; + + // get the drive's model/firmware strings + ata_format_id_string(model, drive->model, sizeof(model)-1); + ata_format_id_string(firmware, drive->fw_rev, sizeof(firmware)-1); + + // and search to see if they match values in the table + const drive_settings * dbentry = lookup_drive(model, firmware); + if (!dbentry) { + // no matches found + pout("No presets are defined for this drive. Its identity strings:\n" + "MODEL: %s\n" + "FIRMWARE: %s\n" + "do not match any of the known regular expressions.\n" + "Use -P showall to list all known regular expressions.\n", + model, firmware); + return; + } + + // We found a matching drive. Print out all information about it. + pout("Drive found in smartmontools Database. Drive identity strings:\n" + "%-*s %s\n" + "%-*s %s\n" + "match smartmontools Drive Database entry:\n", + TABLEPRINTWIDTH, "MODEL:", model, TABLEPRINTWIDTH, "FIRMWARE:", firmware); + showonepreset(dbentry); +} + +// Searches drive database and sets preset vendor attribute +// options in defs and firmwarebugs. +// Values that have already been set will not be changed. +// Returns pointer to database entry or nullptr if none found +const drive_settings * lookup_drive_apply_presets( + const ata_identify_device * drive, ata_vendor_attr_defs & defs, + firmwarebug_defs & firmwarebugs, std::string & dbversion) +{ + // get the drive's model/firmware strings + char model[MODEL_STRING_LENGTH+1], firmware[FIRMWARE_STRING_LENGTH+1]; + ata_format_id_string(model, drive->model, sizeof(model)-1); + ata_format_id_string(firmware, drive->fw_rev, sizeof(firmware)-1); + + // Look up the drive in knowndrives[]. + const drive_settings * dbentry = lookup_drive(model, firmware, &dbversion); + if (!dbentry) + return 0; + + if (*dbentry->presets) { + // Apply presets + if (!parse_presets(dbentry->presets, defs, firmwarebugs)) + pout("Syntax error in preset option string \"%s\"\n", dbentry->presets); + } + return dbentry; +} + + +///////////////////////////////////////////////////////////////////////////// +// Parser for drive database files + +// Abstract pointer to read file input. +// Operations supported: c = *p; c = p[1]; ++p; +class stdin_iterator +{ +public: + explicit stdin_iterator(FILE * f) + : m_f(f), m_next(0) { get(); get(); } + + stdin_iterator & operator++() + { get(); return *this; } + + char operator*() const + { return m_c; } + + char operator[](int i) const + { + if (i != 1) + fail(); + return m_next; + } + +private: + FILE * m_f; + char m_c, m_next; + void get(); + void fail() const; +}; + +void stdin_iterator::get() +{ + m_c = m_next; + int ch = getc(m_f); + m_next = (ch != EOF ? ch : 0); +} + +void stdin_iterator::fail() const +{ + throw std::runtime_error("stdin_iterator: wrong usage"); +} + + +// Use above as parser input 'pointer'. Can easily be changed later +// to e.g. 'const char *' if above is too slow. +typedef stdin_iterator parse_ptr; + +// Skip whitespace and comments. +static parse_ptr skip_white(parse_ptr src, const char * path, int & line) +{ + for ( ; ; ++src) switch (*src) { + case ' ': case '\t': + continue; + + case '\n': + ++line; + continue; + + case '/': + switch (src[1]) { + case '/': + // skip '// comment' + ++src; ++src; + while (*src && *src != '\n') + ++src; + if (*src) + ++line; + break; + case '*': + // skip '/* comment */' + ++src; ++src; + for (;;) { + if (!*src) { + pout("%s(%d): Missing '*/'\n", path, line); + return src; + } + char c = *src; ++src; + if (c == '\n') + ++line; + else if (c == '*' && *src == '/') + break; + } + break; + default: + return src; + } + continue; + + default: + return src; + } +} + +// Info about a token. +struct token_info +{ + char type; + int line; + std::string value; + + token_info() : type(0), line(0) { } +}; + +// Get next token. +static parse_ptr get_token(parse_ptr src, token_info & token, const char * path, int & line) +{ + src = skip_white(src, path, line); + switch (*src) { + case '{': case '}': case ',': + // Simple token + token.type = *src; token.line = line; + ++src; + break; + + case '"': + // String constant + token.type = '"'; token.line = line; + token.value = ""; + do { + for (++src; *src != '"'; ++src) { + char c = *src; + if (!c || c == '\n' || (c == '\\' && !src[1])) { + pout("%s(%d): Missing terminating '\"'\n", path, line); + token.type = '?'; token.line = line; + return src; + } + if (c == '\\') { + c = *++src; + switch (c) { + case 'n' : c = '\n'; break; + case '\n': ++line; break; + case '\\': case '"': break; + default: + pout("%s(%d): Unknown escape sequence '\\%c'\n", path, line, c); + token.type = '?'; token.line = line; + continue; + } + } + token.value += c; + } + // Lookahead to detect string constant concatenation + src = skip_white(++src, path, line); + } while (*src == '"'); + break; + + case 0: + // EOF + token.type = 0; token.line = line; + break; + + default: + pout("%s(%d): Syntax error, invalid char '%c'\n", path, line, *src); + token.type = '?'; token.line = line; + while (*src && *src != '\n') + ++src; + break; + } + + return src; +} + +// Parse drive database from abstract input pointer. +static bool parse_drive_database(parse_ptr src, drive_database & db, const char * path) +{ + int state = 0, field = 0; + std::string values[5]; + bool ok = true; + + token_info token; int line = 1; + src = get_token(src, token, path, line); + for (;;) { + // EOF is ok after '}', trailing ',' is also allowed. + if (!token.type && (state == 0 || state == 4)) + break; + + // Check expected token + const char expect[] = "{\",},"; + if (token.type != expect[state]) { + if (token.type != '?') + pout("%s(%d): Syntax error, '%c' expected\n", path, token.line, expect[state]); + ok = false; + // Skip to next entry + while (token.type && token.type != '{') + src = get_token(src, token, path, line); + state = 0; + if (token.type) + continue; + break; + } + + // Interpret parser state + switch (state) { + case 0: // ... ^{...} + state = 1; field = 0; + break; + case 1: // {... ^"..." ...} + switch (field) { + case 1: case 2: + if (!token.value.empty()) { + regular_expression regex; + if (!regex.compile(token.value.c_str())) { + pout("%s(%d): Error in regular expression: %s\n", path, token.line, regex.get_errmsg()); + ok = false; + } + } + else if (field == 1) { + pout("%s(%d): Missing regular expression for drive model\n", path, token.line); + ok = false; + } + break; + case 4: + if (!token.value.empty()) { + // Syntax check + switch (get_modelfamily_type(values[0].c_str())) { + case DBENTRY_ATA_DEFAULT: { + ata_vendor_attr_defs defs; + if (!parse_default_presets(token.value.c_str(), defs)) { + pout("%s(%d): Syntax error in DEFAULT option string\n", path, token.line); + ok = false; + } + } break; + default: { // DBENTRY_ATA + ata_vendor_attr_defs defs; firmwarebug_defs fix; + if (!parse_presets(token.value.c_str(), defs, fix)) { + pout("%s(%d): Syntax error in preset option string\n", path, token.line); + ok = false; + } + } break; + case DBENTRY_USB: { + std::string type; + if (!parse_usb_type(token.value.c_str(), type)) { + pout("%s(%d): Syntax error in USB type string\n", path, token.line); + ok = false; + } + } break; + } + } + break; + } + values[field] = token.value; + state = (++field < 5 ? 2 : 3); + break; + case 2: // {... "..."^, ...} + state = 1; + break; + case 3: // {...^}, ... + { + drive_settings entry; + entry.modelfamily = values[0].c_str(); + entry.modelregexp = values[1].c_str(); + entry.firmwareregexp = values[2].c_str(); + entry.warningmsg = values[3].c_str(); + entry.presets = values[4].c_str(); + db.push_back(entry); + } + state = 4; + break; + case 4: // {...}^, ... + state = 0; + break; + default: + pout("Bad state %d\n", state); + return false; + } + src = get_token(src, token, path, line); + } + return ok; +} + +// Read drive database from file. +bool read_drive_database(const char * path) +{ + stdio_file f(path, "r" +#ifdef __CYGWIN__ // Allow files with '\r\n'. + "t" +#endif + ); + if (!f) { + pout("%s: cannot open drive database file\n", path); + return false; + } + + return parse_drive_database(parse_ptr(f), knowndrives, path); +} + +// Get path for additional database file +const char * get_drivedb_path_add() +{ +#ifndef _WIN32 + return SMARTMONTOOLS_SYSCONFDIR"/smart_drivedb.h"; +#else + static std::string path = get_exe_dir() + "/drivedb-add.h"; + return path.c_str(); +#endif +} + +#ifdef SMARTMONTOOLS_DRIVEDBDIR + +// Get path for default database file +const char * get_drivedb_path_default() +{ +#ifndef _WIN32 + return SMARTMONTOOLS_DRIVEDBDIR"/drivedb.h"; +#else + static std::string path = get_exe_dir() + "/drivedb.h"; + return path.c_str(); +#endif +} + +#endif + +// Read drive databases from standard places. +static bool read_default_drive_databases() +{ + // Read file for local additions: /{,usr/local/}etc/smart_drivedb.h + const char * db1 = get_drivedb_path_add(); + if (!access(db1, 0)) { + if (!read_drive_database(db1)) + return false; + } + +#ifdef SMARTMONTOOLS_DRIVEDBDIR + // Read file from package: /usr/{,local/}share/smartmontools/drivedb.h + const char * db2 = get_drivedb_path_default(); + if (!access(db2, 0)) { + if (!read_drive_database(db2)) + return false; + } + else +#endif + { + // Append builtin table. + knowndrives.append(builtin_knowndrives, builtin_knowndrives_size); + } + + return true; +} + +static ata_vendor_attr_defs default_attr_defs; + +// Initialize default_attr_defs. +static bool init_default_attr_defs() +{ + // Lookup default entry + const drive_settings * entry = 0; + for (unsigned i = 0; i < knowndrives.size(); i++) { + if (get_dbentry_type(&knowndrives[i]) != DBENTRY_ATA_DEFAULT) + continue; + entry = &knowndrives[i]; + break; + } + + if (!entry) { + // Fall back to builtin database + for (unsigned i = 0; i < builtin_knowndrives_size; i++) { + if (get_dbentry_type(&builtin_knowndrives[i]) != DBENTRY_ATA_DEFAULT) + continue; + entry = &builtin_knowndrives[i]; + break; + } + + if (!entry) + throw std::logic_error("DEFAULT entry missing in builtin drive database"); + + pout("Warning: DEFAULT entry missing in drive database file(s)\n"); + } + + if (!parse_default_presets(entry->presets, default_attr_defs)) { + pout("Syntax error in DEFAULT drive database entry\n"); + return false; + } + + return true; +} + +// Init default db entry and optionally read drive databases from standard places. +bool init_drive_database(bool use_default_db) +{ + if (use_default_db && !read_default_drive_databases()) + return false; + + return init_default_attr_defs(); +} + +// Get vendor attribute options from default db entry. +const ata_vendor_attr_defs & get_default_attr_defs() +{ + return default_attr_defs; +} |