static void parse_devtree(const char *filename)
{
FILE *f;
void *dt;
f = fopen(filename, "rb");
if (!f)
goto err;
fseek(f, 0, SEEK_END);
machine_devtree_size = ftell(f);
fseek(f, 0, SEEK_SET);
dt = qemu_malloc(machine_devtree_size);
if (!dt)
goto err_close;
machine_devtree = dt;
if (fread(dt, machine_devtree_size, 1, f) != 1)
goto err_close;
if (fdt_check_header(dt))
goto err_close;
create_cpus(dt);
create_ram(dt);
scan_devtree(dt);
fixup_irqs();
fclose(f);
return;
err_close:
fclose(f);
err:
fprintf(stderr, "Failed to load device tree\n");
exit(1);
}
int main(int argc, char* argv[]) {
int c;
char *dbname = (char *)DBNAME;
char *dbinst = (char *)DBINST;
char *hostname = (char *)HOSTNAME;
char *datadir = NULL;
char *verdesc = NULL;
char *verstr = NULL;
char *prefix = NULL;
unsigned int version = 0;
char *schemastr = NULL;
unsigned short usage = 0;
unsigned short dblist = 0;
unsigned short schemalist = 0;
unsigned short prefixlist = 0;
unsigned short trusted = 1;
unsigned char term = '\0';
// source files
char udd_sql3[BUFLEN] = NULLSTR;
char cert_yaml[BUFLEN] = NULLSTR;
char gfxids_yaml[BUFLEN] = NULLSTR;
char iconids_yaml[BUFLEN] = NULLSTR;
char typeids_yaml[BUFLEN] = NULLSTR;
char blueprints_yaml[BUFLEN] = NULLSTR;
// SQL things
int db3_rc;
SQLRETURN ret;
SQLCHAR connStrOut[BUFLEN] = NULLSTR;
SQLCHAR dsn[BUFLEN] = NULLSTR;
SQLCHAR auth[BUFLEN] = NULLSTR;
SQLCHAR usr[BUFLEN] = NULLSTR;
SQLCHAR pwd[BUFLEN] = NULLSTR;
SQLSMALLINT connStrLen;
// set globals
GZIP_FLAG = 1;
JSONP_FLAG = 1;
SCHEMA = 0;
JSON_DIR = NULL;
H_ENV = SQL_NULL_HENV;
H_DBC = SQL_NULL_HDBC;
H_DBC2 = SQL_NULL_HDBC;
DB3_UD = NULL;
while ((c = getopt(argc, argv, "i:o:d:u:p:n:N:s:x:hvXDSZP")) != -1) {
switch (c) {
case 'i':
datadir = (char *)malloc(BUFLEN);
strlcpy(datadir, optarg, BUFLEN);
term = datadir[strlen(datadir) - 1];
if (term != PATHSEP) {
strlcat(datadir, SZPATHSEP, BUFLEN);
}
break;
case 'o':
JSON_DIR = (char *)malloc(BUFLEN);
strlcpy(JSON_DIR, optarg, BUFLEN);
term = JSON_DIR[strlen(JSON_DIR) - 1];
if (term != PATHSEP) {
strlcat(JSON_DIR, SZPATHSEP, BUFLEN);
}
break;
case 'x':
prefix = (char *)malloc(BUFLEN);
strlcpy(prefix, optarg, BUFLEN);
break;
case 'd':
dbname = (char *)malloc(BUFLEN);
strlcpy(dbname, optarg, BUFLEN);
break;
case 'n':
verstr = (char *)malloc(BUFLEN);
strlcpy(verstr, optarg, BUFLEN);
break;
case 'N':
verdesc = (char *)malloc(BUFLEN);
strlcpy(verdesc, optarg, BUFLEN);
break;
case 's':
schemastr = (char *)malloc(BUFLEN);
strlcpy(schemastr, optarg, BUFLEN);
break;
case 'S':
schemalist = 1;
break;
case 'v':
printf("sdd2json version %d.%d.%d", SDD2JSON_V_MAJOR, SDD2JSON_V_MINOR, SDD2JSON_V_PATCH);
return 0;
case 'D':
dblist = 1;
break;
case 'u':
trusted = 0;
strlcpy(usr, optarg, BUFLEN);
break;
case 'p':
trusted = 0;
strlcpy(pwd, optarg, BUFLEN);
break;
case 'P':
JSONP_FLAG = 0;
break;
case 'Z':
GZIP_FLAG = 0;
break;
case 'X':
prefixlist = 1;
case '?':
printf("\n");
usage = 1;
break;
}
}
if (1 == schemalist) {
for (unsigned int i = 0; i < VERS_N; i++) {
printf("%s:\tversion %d;\tschema %d\n", VERS[i].version_desc, VERS[i].version_id, VERS[i].schema_id);
}
return 0;
}
if (1 == prefixlist) {
printf("\tcrp\n");
printf("\tdgm\n");
printf("\tinv\n");
printf("\tmap\n");
printf("\tram\n");
printf("\tsta\n");
return 0;
}
if (usage < 1 && datadir == NULL) {
fprintf(stderr, "EVE static data dir path is required\n");
usage = 1;
}
if (usage < 1 && verstr == NULL) {
fprintf(stderr, "static data version ID is required\n");
usage = 1;
}
if (usage > 0) return dump_usage();
// parse version/schema from params and known values
if (verstr != NULL) {
version = atoi(verstr);
}
if (version == 0) {
fprintf(stderr, "the static data version ID provided is invalid: %s\n", verstr);
return 1;
}
unsigned int found_version = 0;
for (unsigned int i = 0; i < VERS_N; i++) {
if (VERS[i].version_id == version) {
found_version = 1;
SCHEMA = VERS[i].schema_id;
if (NULL == verdesc) {
verdesc = (char *)malloc(BUFLEN);
strlcpy(verdesc, VERS[i].version_desc, BUFLEN);
}
break;
}
}
if (1 != found_version) {
fprintf(stderr, "warning: using unknown static data version ID: %d\n", version);
}
if (schemastr != NULL) {
if (0 != SCHEMA) {
fprintf(stderr, "warning: overriding known schema ID\n");
}
SCHEMA = atoi(schemastr);
}
if (0 == SCHEMA) {
fprintf(stderr, "schema ID is required\n");
return 1;
}
printf("static data: '%s', version %d, schema %d\n", verdesc, version, SCHEMA);
// validate input/schema
printf("checking input: %s - ", datadir);
if (ACCESS(datadir, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access output path\n");
return 1;
}
if (SCHEMA >= 100038) {
strlcpy(cert_yaml, datadir, BUFLEN);
strlcat(cert_yaml, "certificates.yaml", BUFLEN);
if (ACCESS(cert_yaml, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access %s\n", cert_yaml);
return 1;
}
}
if (SCHEMA >= 100038) {
strlcpy(gfxids_yaml, datadir, BUFLEN);
strlcat(gfxids_yaml, "graphicIDs.yaml", BUFLEN);
if (ACCESS(gfxids_yaml, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access %s\n", gfxids_yaml);
return 1;
}
}
if (SCHEMA >= 100038) {
strlcpy(iconids_yaml, datadir, BUFLEN);
strlcat(iconids_yaml, "iconIDs.yaml", BUFLEN);
if (ACCESS(iconids_yaml, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access %s\n", iconids_yaml);
return 1;
}
}
if (SCHEMA >= 100038) {
strlcpy(typeids_yaml, datadir, BUFLEN);
strlcat(typeids_yaml, "typeIDs.yaml", BUFLEN);
if (ACCESS(typeids_yaml, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access %s\n", typeids_yaml);
return 1;
}
}
if (SCHEMA >= 100038) {
strlcpy(udd_sql3, datadir, BUFLEN);
strlcat(udd_sql3, "universeDataDx.db", BUFLEN);
if (ACCESS(udd_sql3, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access %s\n", udd_sql3);
return 1;
}
}
if (SCHEMA >= 100038) {
strlcpy(blueprints_yaml, datadir, BUFLEN);
strlcat(blueprints_yaml, "blueprints.yaml", BUFLEN);
if (ACCESS(blueprints_yaml, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access %s\n", blueprints_yaml);
return 1;
}
}
printf("OK\n");
// validate output
if (JSON_DIR == NULL) {
JSON_DIR = (char *)malloc(2 * BUFLEN);
strlcpy(JSON_DIR, datadir, 2 * BUFLEN);
strlcat(JSON_DIR, SDD, 2* BUFLEN);
strlcat(JSON_DIR, SZPATHSEP, 2 * BUFLEN);
}
printf("checking output: %s - ", JSON_DIR);
if (ACCESS(JSON_DIR, 0) != 0) {
if (MKDIR(JSON_DIR) != 0) {
printf("err\n");
fprintf(stderr, "could not create output path\n");
return 1;
}
if (ACCESS(JSON_DIR, 0) != 0) {
printf("err\n");
fprintf(stderr, "could not access output path\n");
return 1;
}
}
printf("OK\n");
// connect to SQLLITE dbs
printf("connecting to [%s] - ", udd_sql3);
db3_rc = sqlite3_open(udd_sql3, &DB3_UD);
if (SQLITE_OK != db3_rc) return dump_db3_error(DB3_UD, 1);
printf("OK\n");
// connect to SQL server
if (0 != trusted) {
SNPRINTF(auth, BUFLEN, "Trusted_Connection=yes");
}
else {
SNPRINTF(auth, BUFLEN, "User ID=%s;Password=%s", usr, pwd);
}
printf("connecting to [%s\\%s] using [%s] - ", hostname, dbinst, auth);
ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HENV, &H_ENV);
if (!SQL_SUCCEEDED(ret)) return dump_sql_error(ret, SQL_HANDLE_ENV, H_ENV, 1);
ret = SQLSetEnvAttr(H_ENV, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3_80, 0);
if (!SQL_SUCCEEDED(ret)) return dump_sql_error(ret, SQL_HANDLE_ENV, H_ENV, 1);
if (dblist > 0) {
printf("list drivers\n");
unsigned short ret = check_drivers(1);
close_handles();
return ret;
}
if (0 != check_drivers(0)) {
printf("err\n");
fprintf(stderr, "SQL server driver not found\n");
close_handles();
return 1;
}
ret = SQLAllocHandle(SQL_HANDLE_DBC, H_ENV, &H_DBC);
if (!SQL_SUCCEEDED(ret)) return dump_sql_error(ret, SQL_HANDLE_ENV, H_ENV, 1);
ret = SQLAllocHandle(SQL_HANDLE_DBC, H_ENV, &H_DBC2);
if (!SQL_SUCCEEDED(ret)) return dump_sql_error(ret, SQL_HANDLE_ENV, H_ENV, 1);
SNPRINTF(dsn, BUFLEN, "Driver={%s};Server=%s\\%s;Database=%s;%s;", SQLDRV, hostname, dbinst, dbname, auth);
ret = SQLDriverConnect(H_DBC, NULL, dsn, strnlen(dsn, BUFLEN), connStrOut, BUFLEN, &connStrLen, SQL_DRIVER_NOPROMPT);
if (!SQL_SUCCEEDED(ret)) return dump_sql_error(ret, SQL_HANDLE_DBC, H_DBC, 1);
ret = SQLDriverConnect(H_DBC2, NULL, dsn, strnlen(dsn, BUFLEN), connStrOut, BUFLEN, &connStrLen, SQL_DRIVER_NOPROMPT);
if (!SQL_SUCCEEDED(ret)) return dump_sql_error(ret, SQL_HANDLE_DBC, H_DBC2, 1);
printf("OK\n");
// create metainfo file
char metafile[BUFLEN] = NULLSTR;
strlcpy(metafile, JSON_DIR, BUFLEN);
strlcat(metafile, "metainf.json", BUFLEN);
FILE *f = fopen(metafile, "w");
if (f == NULL) {
printf("err\n");
fprintf(stderr, "error opening meta file: %s", metafile);
close_handles();
return 1;
}
printf("OK\n");
fprintf(f, "{\n");
fprintf(f, "\"formatID\":%d,\n", FORMAT_ID);
fprintf(f, "\"schema\":%d,\n", SCHEMA);
fprintf(f, "\"copy\":\"%s\",\n", CCPR);
fprintf(f, "\"version\":%d,\n", version);
fprintf(f, "\"verdesc\":\"%s\",\n", verdesc);
fprintf(f, "\"tables\":{\n");
// do stuff
int rc = 0;
int comma = 0;
if (NULL == prefix || strncmp(prefix, "crp", 3) == 0) {
if (comma++ > 0) fprintf(f, ",\n");
rc = create_crp(f);
if (rc != 0) {
close_handles();
fclose(f);
return 1;
}
}
if (NULL == prefix || strncmp(prefix, "dgm", 3) == 0) {
if (comma++ > 0) fprintf(f, ",\n");
rc = create_dgm(f, cert_yaml);
if (rc != 0) {
close_handles();
fclose(f);
return 1;
}
}
if (NULL == prefix || strncmp(prefix, "inv", 3) == 0) {
if (comma++ > 0) fprintf(f, ",\n");
rc = create_inv(f, typeids_yaml, iconids_yaml);
if (rc != 0) {
close_handles();
fclose(f);
return 1;
}
}
if (NULL == prefix || strncmp(prefix, "map", 3) == 0) {
if (comma++ > 0) fprintf(f, ",\n");
rc = create_map(f);
if (0 != rc) {
close_handles();
fclose(f);
return 1;
}
}
if (NULL == prefix || strncmp(prefix, "ram", 3) == 0) {
if (comma++ > 0) fprintf(f, ",\n");
ret = create_ram(f, blueprints_yaml);
if (!SQL_SUCCEEDED(ret)) {
close_handles();
fclose(f);
return 1;
}
}
if (NULL == prefix || strncmp(prefix, "sta", 3) == 0) {
if (comma++ > 0) fprintf(f, ",\n");
ret = create_sta(f);
if (!SQL_SUCCEEDED(ret)) {
close_handles();
fclose(f);
return 1;
}
}
fprintf(f, "\n}\n"); // end of sources
// clean up connections
fprintf(f, "}\n");
fclose(f);
printf("metainf - ", metafile);
post_file("metainf");
close_handles();
free(datadir);
free(verdesc);
free(verstr);
free(prefix);
free(JSON_DIR);
printf("\nall done!\n");
return 0;
}
