int
read_cache(void)
{
FILE *fr;
LIST_MEMBER *pentry;
char Line[LINESIZE + 1];
int result = 0;
Line[LINESIZE] = '\0';
fr = fopen(cache_name, "r");
if (!fr)
{
l2l_dbg(1, "Open %s failed\n", cache_name);
return 2;
}
cache.phead = cache.ptail = NULL;
while (fgets(Line, LINESIZE, fr) != NULL)
{
pentry = cache_entry_create(Line);
if (!pentry)
{
l2l_dbg(2, "** Create entry failed of: %s\n", Line);
}
else
entry_insert(&cache, pentry);
}
fclose(fr);
return result;
}
static void
log_file(FILE *outFile, char *fileName, int line)
{
int i = 0, min = 0, max = 0;
char s[LINESIZE];
FILE *src;
strcpy(s, opt_SourcesPath);
strcat(s, fileName);
max = line + opt_SrcPlus;
if ((src = fopen(s, "r")))
{
min = line - opt_Source;
min = (min < 0) ? 0 : min;
while (i < max && fgets(s, LINESIZE, src))
{
if (i >= min)
{
if (i == line)
log(outFile, "| ----\n");
log(outFile, "| %4.4d %s", i + 1, s);
}
i++;
}
fclose(src);
if ( i < min )
log(outFile, "| S--- source has only %d lines! (check source/revision)\n", i);
}
else
l2l_dbg(1, "Can't open: %s (check " SOURCES_ENV ")\n", s);
}
static int
translate_file(const char *cpath, size_t offset, char *toString)
{
size_t base = 0;
LIST_MEMBER *pentry = NULL;
int res = 0;
char *path, *dpath;
dpath = path = convert_path(cpath);
if (!path)
return 1;
// The path could be absolute:
if (get_ImageBase(path, &base))
{
pentry = entry_lookup(&cache, path);
if (pentry)
{
path = pentry->path;
base = pentry->ImageBase;
if (base == INVALID_BASE)
{
l2l_dbg(1, "No, or invalid base address: %s\n", path);
res = 2;
}
}
else
{
l2l_dbg(1, "Not found in cache: %s\n", path);
res = 3;
}
}
if (!res)
{
res = process_file(path, offset, toString);
}
free(dpath);
return res;
}
static int
process_file(const char *file_name, size_t offset, char *toString)
{
void *FileData;
size_t FileSize;
int res = 1;
FileData = load_file(file_name, &FileSize);
if (!FileData)
{
l2l_dbg(0, "An error occured loading '%s'\n", file_name);
}
else
{
res = process_data(FileData, offset, toString);
free(FileData);
}
return res;
}
static int
process_data(const void *FileData, size_t offset, char *toString)
{
int res;
PIMAGE_SECTION_HEADER PERosSymSectionHeader = get_sectionheader((char *)FileData);
if (!PERosSymSectionHeader)
return 2;
res = print_offset((char *)FileData + PERosSymSectionHeader->PointerToRawData, offset, toString);
if (res)
{
if (toString)
sprintf(toString, "??:0");
else
printf("??:0");
l2l_dbg(1, "Offset not found: %x\n", (unsigned int)offset);
summ.offset_errors++;
}
return res;
}
static int
unpack_iso(char *dir, char *iso)
{
char Line[LINESIZE];
int res = 0;
char iso_tmp[PATH_MAX];
int iso_copied = 0;
FILE *fiso;
strcpy(iso_tmp, iso);
if ((fiso = fopen(iso, "a")) == NULL)
{
l2l_dbg(1, "Open of %s failed (locked for writing?), trying to copy first\n", iso);
strcat(iso_tmp, "~");
if (copy_file(iso, iso_tmp))
return 3;
iso_copied = 1;
}
else
fclose(fiso);
sprintf(Line, UNZIP_FMT, opt_7z, iso_tmp, dir);
if (system(Line) < 0)
{
l2l_dbg(0, "\nCannot unpack %s (check 7z path!)\n", iso_tmp);
l2l_dbg(1, "Failed to execute: '%s'\n", Line);
res = 1;
}
else
{
l2l_dbg(2, "\nUnpacking reactos.cab in %s\n", dir);
sprintf(Line, UNZIP_FMT_CAB, opt_7z, dir, dir);
if (system(Line) < 0)
{
l2l_dbg(0, "\nCannot unpack reactos.cab in %s\n", dir);
l2l_dbg(1, "Failed to execute: '%s'\n", Line);
res = 2;
}
}
if (iso_copied)
remove(iso_tmp);
return res;
}
int optionInit(int argc, const char **argv)
{
int i;
char *s;
opt_mod = "a";
strcpy(opt_dir, "");
strcpy(opt_logFile, "");
strcpy(opt_7z, CMD_7Z);
strcpy(opt_SourcesPath, "");
if ((s = getenv(SOURCES_ENV)))
strcpy(opt_SourcesPath, s);
revinfo.rev = getRevision(NULL, 1);
revinfo.range = DEF_RANGE;
revinfo.buildrev = getTBRevision(opt_dir);
l2l_dbg(1, "Trunk build revision: %d\n", revinfo.buildrev);
strcpy(opt_scanned, "");
//The user introduced "log2lines.exe" or "log2lines.exe /?"
//Let's help the user
if ((argc == 1) ||
((argc == 2) && (argv[1][0] == '/') && (argv[1][1] == '?')))
{
opt_help++;
usage(1);
return -1;
}
for (i = 1; i < argc; i++)
{
if ((argv[i][0] == '-') && (i+1 < argc))
{
//Because these arguments can contain spaces we cant use getopt(), a known bug:
switch (argv[i][1])
{
case 'd':
strcpy(opt_dir, argv[i+1]);
break;
case 'L':
opt_mod = "w";
//fall through
case 'l':
strcpy(opt_logFile, argv[i+1]);
break;
case 'P':
free(opt_Pipe);
opt_Pipe = malloc(LINESIZE);
strcpy(opt_Pipe, argv[i+1]);
break;
case 'z':
strcpy(opt_7z, argv[i+1]);
break;
}
}
strcat(opt_scanned, argv[i]);
strcat(opt_scanned, " ");
}
l2l_dbg(4,"opt_scanned=[%s]\n",opt_scanned);
return 0;
}
int optionParse(int argc, const char **argv)
{
int i;
int optCount = 0;
int opt;
while (-1 != (opt = getopt(argc, (char **const)argv, optchars)))
{
switch (opt)
{
case 'b':
opt_buffered++;
break;
case 'c':
opt_console++;
break;
case 'd':
optCount++;
//just count, see optionInit()
break;
case 'f':
opt_force++;
break;
case 'h':
opt_help++;
usage(1);
return -1;
break;
case 'F':
opt_exit++;
opt_force++;
break;
case 'l':
optCount++;
//just count, see optionInit()
break;
case 'm':
opt_mark++;
break;
case 'M':
opt_Mark++;
break;
case 'r':
opt_raw++;
break;
case 'P':
optCount++;
//just count, see optionInit()
break;
case 'R':
optCount++;
free(opt_Revision);
opt_Revision = malloc(LINESIZE);
sscanf(optarg, "%s", opt_Revision);
if (strcmp(opt_Revision, "check") == 0)
opt_Revision_check ++;
break;
case 's':
opt_stats++;
break;
case 'S':
optCount++;
i = sscanf(optarg, "%d+%d,%s", &opt_Source, &opt_SrcPlus, opt_SourcesPath);
if (i == 1)
sscanf(optarg, "%*d,%s", opt_SourcesPath);
l2l_dbg(3, "Sources option parse result: %d+%d,\"%s\"\n", opt_Source, opt_SrcPlus, opt_SourcesPath);
if (opt_Source)
{
/* need to retranslate for source info: */
opt_undo++;
opt_redo++;
opt_Revision_check ++;
}
break;
case 't':
opt_twice++;
break;
case 'T':
opt_twice++;
opt_Twice++;
break;
case 'u':
opt_undo++;
break;
case 'U':
opt_undo++;
opt_redo++;
break;
case 'v':
opt_verbose++;
break;
case 'z':
optCount++;
strcpy(opt_7z, optarg);
break;
default:
usage(0);
return -2;
break;
}
optCount++;
}
if(opt_console)
{
l2l_dbg(2, "Note: use 's' command in console mode. Statistics option disabled\n");
opt_stats = 0;
}
if (opt_SourcesPath[0])
{
strcat(opt_SourcesPath, PATH_STR);
}
if (!opt_dir[0])
{
strcpy(opt_dir, opt_SourcesPath);
strcat(opt_dir, DEF_OPT_DIR);
}
return optCount;
}
int
main(int argc, const char **argv)
{
int res = 0;
int optCount = 0;
dbgIn = stdin;
conOut = stdout;
(void)conIn;
(void)dbgOut;
memset(&cache, 0, sizeof(LIST));
memset(&sources, 0, sizeof(LIST));
stat_clear(&summ);
memset(&revinfo, 0, sizeof(REVINFO));
clearLastLine();
optionInit(argc, argv);
optCount = optionParse(argc, argv);
if (optCount < 0)
{
return optCount;
}
argc -= optCount;
if (opt_Revision && (strcmp(opt_Revision, "update") == 0))
{
res = updateSvnlog();
return res;
}
if (check_directory(opt_force))
return 3;
create_cache(opt_force, 0);
if (opt_exit)
return 0;
read_cache();
l2l_dbg(4, "Cache read complete\n");
if (set_LogFile(&logFile))
return 2;
l2l_dbg(4, "opt_logFile processed\n");
if (opt_Pipe)
{
l2l_dbg(3, "Command line: \"%s\"\n",opt_Pipe);
if (!(dbgIn = POPEN(opt_Pipe, "r")))
{
dbgIn = stdin; //restore
l2l_dbg(0, "Could not popen '%s' (%s)\n", opt_Pipe, strerror(errno));
free(opt_Pipe); opt_Pipe = NULL;
}
}
l2l_dbg(4, "opt_Pipe processed\n");
if (argc > 1)
{ // translate {<exefile> <offset>}
int i = 1;
const char *exefile = NULL;
const char *offset = NULL;
char Line[LINESIZE + 1];
while (i < argc)
{
Line[0] = '\0';
offset = argv[optCount + i++];
if (isOffset(offset))
{
if (exefile)
{
l2l_dbg(2, "translating %s %s\n", exefile, offset);
translate_file(exefile, my_atoi(offset), Line);
printf("%s\n", Line);
report(conOut);
}
else
{
l2l_dbg(0, "<exefile> expected\n");
res = 3;
break;
}
}
else
{
// Not an offset so must be an exefile:
exefile = offset;
}
}
}
else
{ // translate logging from stdin
translate_files(dbgIn, conOut);
}
if (logFile)
fclose(logFile);
if (opt_Pipe)
PCLOSE(dbgIn);
return res;
}
int
check_directory(int force)
{
char Line[LINESIZE];
char freeldr_path[PATH_MAX];
char iso_path[PATH_MAX];
char compressed_7z_path[PATH_MAX];
char *check_iso;
char *check_dir;
check_iso = strrchr(opt_dir, '.');
l2l_dbg(1, "Checking directory: %s\n", opt_dir);
if (check_iso && PATHCMP(check_iso, ".7z") == 0)
{
l2l_dbg(1, "Checking 7z image: %s\n", opt_dir);
// First attempt to decompress to an .iso image
strcpy(compressed_7z_path, opt_dir);
if ((check_dir = strrchr(compressed_7z_path, PATH_CHAR)))
*check_dir = '\0';
else
strcpy(compressed_7z_path, "."); // default to current dir
sprintf(Line, UNZIP_FMT_7Z, opt_7z, opt_dir, compressed_7z_path);
/* This of course only works if the .7z and .iso basenames are identical
* which is normally true for ReactOS trunk builds:
*/
strcpy(check_iso, ".iso");
if (!file_exists(opt_dir) || force)
{
l2l_dbg(1, "Decompressing 7z image: %s\n", opt_dir);
if (system(Line) < 0)
{
l2l_dbg(0, "\nCannot decompress to iso image %s\n", opt_dir);
l2l_dbg(1, "Failed to execute: '%s'\n", Line);
return 2;
}
}
else
l2l_dbg(2, "%s already decompressed\n", opt_dir);
}
if (check_iso && PATHCMP(check_iso, ".iso") == 0)
{
l2l_dbg(1, "Checking ISO image: %s\n", opt_dir);
if (file_exists(opt_dir))
{
l2l_dbg(2, "ISO image exists: %s\n", opt_dir);
strcpy(iso_path, opt_dir);
*check_iso = '\0';
sprintf(freeldr_path, "%s" PATH_STR "freeldr.ini", opt_dir);
if (!file_exists(freeldr_path) || force)
{
l2l_dbg(0, "Unpacking %s to: %s ...", iso_path, opt_dir);
unpack_iso(opt_dir, iso_path);
l2l_dbg(0, "... done\n");
}
else
l2l_dbg(2, "%s already unpacked in: %s\n", iso_path, opt_dir);
}
else
{
l2l_dbg(0, "ISO image not found: %s\n", opt_dir);
return 1;
}
}
strcpy(cache_name, opt_dir);
if (cleanable(opt_dir))
strcat(cache_name, ALT_PATH_STR CACHEFILE);
else
strcat(cache_name, PATH_STR CACHEFILE);
strcpy(tmp_name, cache_name);
strcat(tmp_name, "~");
return 0;
}
int
create_cache(int force, int skipImageBase)
{
FILE *fr, *fw;
char Line[LINESIZE + 1], *Fname = NULL;
int len, err;
size_t ImageBase;
if ((fw = fopen(tmp_name, "w")) == NULL)
{
l2l_dbg(1, "Apparently %s is not writable (mounted ISO?), using current dir\n", tmp_name);
cache_name = basename(cache_name);
tmp_name = basename(tmp_name);
}
else
{
l2l_dbg(3, "%s is writable\n", tmp_name);
fclose(fw);
remove(tmp_name);
}
if (force)
{
l2l_dbg(3, "Removing %s ...\n", cache_name);
remove(cache_name);
}
else
{
if (file_exists(cache_name))
{
l2l_dbg(3, "Cache %s already exists\n", cache_name);
return 0;
}
}
Line[LINESIZE] = '\0';
remove(tmp_name);
l2l_dbg(0, "Scanning %s ...\n", opt_dir);
snprintf(Line, LINESIZE, DIR_FMT, opt_dir, tmp_name);
l2l_dbg(1, "Executing: %s\n", Line);
if (system(Line) != 0)
{
l2l_dbg(0, "Cannot list directory %s\n", opt_dir);
l2l_dbg(1, "Failed to execute: '%s'\n", Line);
remove(tmp_name);
return 2;
}
l2l_dbg(0, "Creating cache ...");
if ((fr = fopen(tmp_name, "r")) != NULL)
{
if ((fw = fopen(cache_name, "w")) != NULL)
{
while (fgets(Line, LINESIZE, fr) != NULL)
{
len = strlen(Line);
if (!len)
continue;
Fname = Line + len - 1;
if (*Fname == '\n')
*Fname = '\0';
while (Fname > Line && *Fname != PATH_CHAR)
Fname--;
if (*Fname == PATH_CHAR)
Fname++;
if (*Fname && !skipImageBase)
{
if ((err = get_ImageBase(Line, &ImageBase)) == 0)
fprintf(fw, "%s|%s|%0x\n", Fname, Line, (unsigned int)ImageBase);
else
l2l_dbg(3, "%s|%s|%0x, ERR=%d\n", Fname, Line, (unsigned int)ImageBase, err);
}
}
fclose(fw);
}
l2l_dbg(0, "... done\n");
fclose(fr);
}
remove(tmp_name);
return 0;
}