2000-02-18 03:38:33 +08:00
|
|
|
/* cygcheck.cc
|
|
|
|
|
|
|
|
This file is part of Cygwin.
|
|
|
|
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
|
|
details. */
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2005-11-23 01:19:17 +08:00
|
|
|
#include <stdarg.h>
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <string.h>
|
2002-09-19 11:48:19 +08:00
|
|
|
#include <sys/time.h>
|
2023-01-28 21:59:39 +08:00
|
|
|
#include <sys/stat.h>
|
2002-09-18 01:13:21 +08:00
|
|
|
#include <ctype.h>
|
2017-02-25 03:55:14 +08:00
|
|
|
#include <fcntl.h>
|
2023-01-30 00:21:28 +08:00
|
|
|
#include <math.h>
|
2003-03-01 11:38:19 +08:00
|
|
|
#include <io.h>
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <windows.h>
|
2005-11-23 01:19:17 +08:00
|
|
|
#include <wininet.h>
|
2023-01-28 21:59:39 +08:00
|
|
|
#include <shlwapi.h>
|
2003-03-01 11:38:19 +08:00
|
|
|
#include "path.h"
|
2009-03-14 22:56:20 +08:00
|
|
|
#include "wide_path.h"
|
2023-01-29 21:13:25 +08:00
|
|
|
#include "cygcheck.h"
|
2003-09-11 10:56:40 +08:00
|
|
|
#include <getopt.h>
|
2021-05-26 16:59:03 +08:00
|
|
|
#include <cygwin/version.h>
|
2023-01-28 21:59:39 +08:00
|
|
|
#define cygwin_internal cygwin_internal_dontuse
|
2021-05-26 16:59:03 +08:00
|
|
|
#include <sys/cygwin.h>
|
2023-01-28 21:59:39 +08:00
|
|
|
#undef cygwin_internal
|
2013-04-23 17:44:36 +08:00
|
|
|
#define _NOMNTENT_MACROS
|
2021-05-26 16:59:03 +08:00
|
|
|
#include <mntent.h>
|
2010-08-28 19:22:37 +08:00
|
|
|
#include "loadlib.h"
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2023-02-09 21:41:12 +08:00
|
|
|
#ifndef PRODUCT_IOTENTERPRISES
|
|
|
|
#define PRODUCT_IOTENTERPRISES 0x000000bf
|
|
|
|
#endif
|
|
|
|
|
2012-07-12 00:41:51 +08:00
|
|
|
#ifndef max
|
|
|
|
#define max __max
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef alloca
|
2004-10-15 01:35:46 +08:00
|
|
|
#define alloca __builtin_alloca
|
2012-07-12 00:41:51 +08:00
|
|
|
#endif
|
2004-10-15 01:35:46 +08:00
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
extern "C" {
|
|
|
|
uintptr_t (*cygwin_internal) (cygwin_getinfo_types, ...);
|
|
|
|
WCHAR cygwin_dll_path[32768];
|
|
|
|
};
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
int verbose = 0;
|
|
|
|
int registry = 0;
|
|
|
|
int sysinfo = 0;
|
|
|
|
int givehelp = 0;
|
2000-09-29 19:20:53 +08:00
|
|
|
int keycheck = 0;
|
2001-11-11 14:07:36 +08:00
|
|
|
int check_setup = 0;
|
2003-09-12 00:24:26 +08:00
|
|
|
int dump_only = 0;
|
2003-08-16 04:26:11 +08:00
|
|
|
int find_package = 0;
|
|
|
|
int list_package = 0;
|
2005-11-23 01:19:17 +08:00
|
|
|
int grep_packages = 0;
|
2023-01-28 21:59:39 +08:00
|
|
|
int info_packages = 0;
|
2023-01-29 21:13:25 +08:00
|
|
|
int info_selector = 0;
|
2023-01-28 21:59:39 +08:00
|
|
|
int search_packages = 0;
|
2023-02-09 04:05:18 +08:00
|
|
|
int search_selector = 0;
|
2009-10-31 21:26:37 +08:00
|
|
|
int del_orphaned_reg = 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2023-01-29 21:13:25 +08:00
|
|
|
#define INFO_INST 0x01
|
|
|
|
#define INFO_CURR 0x02
|
|
|
|
#define INFO_PREV 0x04
|
|
|
|
#define INFO_TEST 0x08
|
2023-02-09 04:05:18 +08:00
|
|
|
#define INFO_ALL 0x0f
|
|
|
|
#define INFO_DEPS 0x10
|
|
|
|
#define INFO_BLDDEPS 0x20
|
|
|
|
|
|
|
|
#define SRCH_REQS 0x40
|
|
|
|
#define SRCH_BLDREQS 0x80
|
2023-01-29 21:13:25 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
static char emptystr[] = "";
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
#ifdef __GNUC__
|
|
|
|
typedef long long longlong;
|
|
|
|
#else
|
|
|
|
typedef __int64 longlong;
|
|
|
|
#endif
|
|
|
|
|
2007-08-04 03:41:48 +08:00
|
|
|
/* In dump_setup.cc */
|
2001-11-12 08:14:27 +08:00
|
|
|
void dump_setup (int, char **, bool);
|
2003-08-16 04:26:11 +08:00
|
|
|
void package_find (int, char **);
|
|
|
|
void package_list (int, char **);
|
2007-08-04 03:41:48 +08:00
|
|
|
/* In bloda.cc */
|
|
|
|
void dump_dodgy_apps (int verbose);
|
2001-11-11 14:07:36 +08:00
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static const char *known_env_vars[] = {
|
2000-02-18 03:38:33 +08:00
|
|
|
"c_include_path",
|
|
|
|
"compiler_path",
|
|
|
|
"cxx_include_path",
|
|
|
|
"cygwin",
|
|
|
|
"cygwin32",
|
|
|
|
"dejagnu",
|
|
|
|
"expect",
|
|
|
|
"gcc_default_options",
|
|
|
|
"gcc_exec_prefix",
|
|
|
|
"home",
|
|
|
|
"ld_library_path",
|
|
|
|
"library_path",
|
|
|
|
"login",
|
|
|
|
"lpath",
|
|
|
|
"make_mode",
|
|
|
|
"makeflags",
|
|
|
|
"path",
|
|
|
|
"pwd",
|
|
|
|
"strace",
|
|
|
|
"tcl_library",
|
|
|
|
"user",
|
|
|
|
0
|
|
|
|
};
|
|
|
|
|
2000-10-28 13:00:00 +08:00
|
|
|
struct
|
|
|
|
{
|
2000-02-18 03:38:33 +08:00
|
|
|
const char *name;
|
|
|
|
int missing_is_good;
|
2000-10-28 13:00:00 +08:00
|
|
|
}
|
2002-03-07 11:13:17 +08:00
|
|
|
static common_apps[] = {
|
2003-02-07 12:51:26 +08:00
|
|
|
{"awk", 0},
|
2000-10-28 13:39:38 +08:00
|
|
|
{"bash", 0},
|
|
|
|
{"cat", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"certutil", 0},
|
|
|
|
{"clinfo", 0},
|
|
|
|
{"comp", 0},
|
|
|
|
{"convert", 0},
|
2003-02-07 12:51:26 +08:00
|
|
|
{"cp", 0},
|
2000-10-28 13:39:38 +08:00
|
|
|
{"cpp", 1},
|
2005-12-30 03:23:46 +08:00
|
|
|
{"crontab", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"curl", 0},
|
|
|
|
{"expand", 0},
|
2000-10-28 13:39:38 +08:00
|
|
|
{"find", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"ftp", 0},
|
2000-10-28 13:39:38 +08:00
|
|
|
{"gcc", 0},
|
|
|
|
{"gdb", 0},
|
2003-02-07 12:51:26 +08:00
|
|
|
{"grep", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"hostname", 0},
|
2005-12-15 11:36:14 +08:00
|
|
|
{"kill", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"klist", 0},
|
2000-10-28 13:39:38 +08:00
|
|
|
{"ld", 0},
|
|
|
|
{"ls", 0},
|
|
|
|
{"make", 0},
|
2003-02-07 12:51:26 +08:00
|
|
|
{"mv", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"nslookup", 0},
|
2006-01-20 05:16:38 +08:00
|
|
|
{"patch", 0},
|
2005-12-15 11:36:14 +08:00
|
|
|
{"perl", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"replace", 0},
|
2003-02-07 12:51:26 +08:00
|
|
|
{"rm", 0},
|
|
|
|
{"sed", 0},
|
2000-10-28 13:39:38 +08:00
|
|
|
{"sh", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"shutdown", 0},
|
|
|
|
{"sort", 0},
|
|
|
|
{"ssh", 0},
|
2003-02-07 12:51:26 +08:00
|
|
|
{"tar", 0},
|
2005-12-15 11:36:14 +08:00
|
|
|
{"test", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"timeout", 0},
|
2005-12-30 03:23:46 +08:00
|
|
|
{"vi", 0},
|
|
|
|
{"vim", 0},
|
2019-05-23 23:47:36 +08:00
|
|
|
{"whoami", 0},
|
2000-10-28 13:39:38 +08:00
|
|
|
{0, 0}
|
2000-02-18 03:38:33 +08:00
|
|
|
};
|
|
|
|
|
2009-10-31 21:26:37 +08:00
|
|
|
/* Options without ASCII single char representation. */
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
CO_DELETE_KEYS = 0x100,
|
|
|
|
};
|
|
|
|
|
2006-01-20 04:17:11 +08:00
|
|
|
static int num_paths, max_paths;
|
2007-06-04 09:57:16 +08:00
|
|
|
struct pathlike
|
|
|
|
{
|
|
|
|
char *dir;
|
|
|
|
bool issys;
|
2008-09-13 06:43:10 +08:00
|
|
|
void check_existence (const char *fn, int showall, int verbose,
|
|
|
|
char* first, const char *ext1 = "",
|
|
|
|
const char *ext2 = "");
|
2007-06-04 09:57:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
pathlike *paths;
|
2006-01-20 04:17:11 +08:00
|
|
|
int first_nonsys_path;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2004-11-18 13:20:23 +08:00
|
|
|
void
|
|
|
|
eprintf (const char *format, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
va_start (ap, format);
|
|
|
|
vfprintf (stderr, format, ap);
|
|
|
|
va_end (ap);
|
|
|
|
}
|
|
|
|
|
2000-12-16 12:53:30 +08:00
|
|
|
/*
|
2004-11-11 09:56:02 +08:00
|
|
|
* display_error() is used to report failure modes
|
2000-12-16 12:53:30 +08:00
|
|
|
*/
|
2002-02-28 00:10:17 +08:00
|
|
|
static int
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error (const char *name, bool show_error, bool print_failed)
|
2000-12-16 12:53:30 +08:00
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
fprintf (stderr, "cygcheck: %s", name);
|
2004-11-11 09:17:29 +08:00
|
|
|
if (show_error)
|
2007-06-04 09:57:16 +08:00
|
|
|
fprintf (stderr, "%s: %lu\n",
|
2004-11-11 09:17:29 +08:00
|
|
|
print_failed ? " failed" : "", GetLastError ());
|
|
|
|
else
|
2007-06-04 09:57:16 +08:00
|
|
|
fprintf (stderr, "%s\n",
|
2004-11-11 09:17:29 +08:00
|
|
|
print_failed ? " failed" : "");
|
2000-12-16 12:53:30 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
static int
|
|
|
|
display_error (const char *name)
|
|
|
|
{
|
|
|
|
return display_error (name, true, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
display_error (const char *fmt, const char *x)
|
|
|
|
{
|
|
|
|
char buf[4000];
|
2009-03-14 22:56:20 +08:00
|
|
|
snprintf (buf, sizeof buf, fmt, x);
|
2007-06-04 09:57:16 +08:00
|
|
|
return display_error (buf, false, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
display_error_fmt (const char *fmt, ...)
|
|
|
|
{
|
|
|
|
char buf[4000];
|
|
|
|
va_list va;
|
|
|
|
|
|
|
|
va_start (va, fmt);
|
2009-03-14 22:56:20 +08:00
|
|
|
vsnprintf (buf, sizeof buf, fmt, va);
|
2007-06-04 09:57:16 +08:00
|
|
|
return display_error (buf, false, false);
|
|
|
|
}
|
|
|
|
|
2005-11-23 01:19:17 +08:00
|
|
|
/* Display a WinInet error message, and close a variable number of handles.
|
|
|
|
(Passed a list of handles terminated by NULL.) */
|
|
|
|
static int
|
|
|
|
display_internet_error (const char *message, ...)
|
|
|
|
{
|
|
|
|
DWORD err = GetLastError ();
|
|
|
|
TCHAR err_buf[256];
|
|
|
|
va_list hptr;
|
|
|
|
HINTERNET h;
|
|
|
|
|
|
|
|
/* in the case of a successful connection but 404 response, there is no
|
|
|
|
win32 error message, but we still get passed a message to display. */
|
|
|
|
if (err)
|
|
|
|
{
|
|
|
|
if (FormatMessage (FORMAT_MESSAGE_FROM_HMODULE,
|
2007-06-04 09:57:16 +08:00
|
|
|
GetModuleHandle ("wininet.dll"), err, 0, err_buf,
|
|
|
|
sizeof (err_buf), NULL) == 0)
|
|
|
|
strcpy (err_buf, "(Unknown error)");
|
2005-11-23 01:19:17 +08:00
|
|
|
|
2008-09-13 06:43:10 +08:00
|
|
|
fprintf (stderr, "cygcheck: %s: %s (win32 error %lu)\n", message,
|
2007-06-04 09:57:16 +08:00
|
|
|
err_buf, err);
|
2005-11-23 01:19:17 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
fprintf (stderr, "cygcheck: %s\n", message);
|
|
|
|
|
|
|
|
va_start (hptr, message);
|
|
|
|
while ((h = va_arg (hptr, HINTERNET)) != 0)
|
2013-11-19 19:14:36 +08:00
|
|
|
InternetCloseHandle (h);
|
2005-11-23 01:19:17 +08:00
|
|
|
va_end (hptr);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
static inline char *
|
|
|
|
stpcpy (char *d, const char *s)
|
|
|
|
{
|
|
|
|
while ((*d++ = *s++))
|
|
|
|
;
|
|
|
|
return --d;
|
|
|
|
}
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static void
|
2007-06-04 09:57:16 +08:00
|
|
|
add_path (char *s, int maxlen, bool issys)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
if (num_paths >= max_paths)
|
|
|
|
{
|
|
|
|
max_paths += 10;
|
2007-06-04 09:57:16 +08:00
|
|
|
/* Extend path array */
|
|
|
|
paths = (pathlike *) realloc (paths, (1 + max_paths) * sizeof (paths[0]));
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2007-06-04 09:57:16 +08:00
|
|
|
|
|
|
|
pathlike *pth = paths + num_paths;
|
|
|
|
|
|
|
|
/* Allocate space for directory in path list */
|
|
|
|
char *dir = (char *) calloc (maxlen + 2, sizeof (char));
|
|
|
|
if (dir == NULL)
|
2000-12-16 12:53:30 +08:00
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error ("add_path: calloc() failed");
|
2000-12-16 12:53:30 +08:00
|
|
|
return;
|
|
|
|
}
|
2007-06-04 09:57:16 +08:00
|
|
|
|
|
|
|
/* Copy input directory to path list */
|
|
|
|
memcpy (dir, s, maxlen);
|
|
|
|
|
|
|
|
/* Add a trailing slash by default */
|
|
|
|
char *e = strchr (dir, '\0');
|
|
|
|
if (e != dir && e[-1] != '\\')
|
|
|
|
strcpy (e, "\\");
|
|
|
|
|
|
|
|
/* Fill out this element */
|
|
|
|
pth->dir = dir;
|
|
|
|
pth->issys = issys;
|
|
|
|
pth[1].dir = NULL;
|
2000-02-18 03:38:33 +08:00
|
|
|
num_paths++;
|
|
|
|
}
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static void
|
2000-02-18 03:38:33 +08:00
|
|
|
init_paths ()
|
|
|
|
{
|
|
|
|
char tmp[4000], *sl;
|
2007-06-04 09:57:16 +08:00
|
|
|
add_path ((char *) ".", 1, true); /* to be replaced later */
|
2005-05-27 23:45:53 +08:00
|
|
|
|
2005-03-24 22:48:15 +08:00
|
|
|
if (GetCurrentDirectory (4000, tmp))
|
2007-06-04 09:57:16 +08:00
|
|
|
add_path (tmp, strlen (tmp), true);
|
2005-03-24 22:48:15 +08:00
|
|
|
else
|
2005-05-27 23:45:53 +08:00
|
|
|
display_error ("init_paths: GetCurrentDirectory()");
|
|
|
|
|
2000-12-16 12:53:30 +08:00
|
|
|
if (GetSystemDirectory (tmp, 4000))
|
2007-06-04 09:57:16 +08:00
|
|
|
add_path (tmp, strlen (tmp), true);
|
2000-12-16 12:53:30 +08:00
|
|
|
else
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("init_paths: GetSystemDirectory()");
|
2000-02-18 03:38:33 +08:00
|
|
|
sl = strrchr (tmp, '\\');
|
|
|
|
if (sl)
|
|
|
|
{
|
|
|
|
strcpy (sl, "\\SYSTEM");
|
2007-06-04 09:57:16 +08:00
|
|
|
add_path (tmp, strlen (tmp), true);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
GetWindowsDirectory (tmp, 4000);
|
2007-06-04 09:57:16 +08:00
|
|
|
add_path (tmp, strlen (tmp), true);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2001-11-11 11:06:59 +08:00
|
|
|
char *wpath = getenv ("PATH");
|
2006-01-20 04:17:11 +08:00
|
|
|
if (!wpath)
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error ("WARNING: PATH is not set\n", "");
|
2006-01-20 04:17:11 +08:00
|
|
|
else
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2001-11-11 11:06:59 +08:00
|
|
|
char *b, *e;
|
2000-02-18 03:38:33 +08:00
|
|
|
b = wpath;
|
|
|
|
while (1)
|
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
for (e = b; *e && *e != ';'; e++)
|
|
|
|
continue; /* loop terminates at first ';' or EOS */
|
|
|
|
if (strncmp(b, ".\\", 2) != 0)
|
|
|
|
add_path (b, e - b, false);
|
2000-02-18 03:38:33 +08:00
|
|
|
if (!*e)
|
|
|
|
break;
|
|
|
|
b = e + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
#define LINK_EXTENSION ".lnk"
|
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
void
|
|
|
|
pathlike::check_existence (const char *fn, int showall, int verbose,
|
|
|
|
char* first, const char *ext1, const char *ext2)
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
char file[4000];
|
2016-10-23 22:16:22 +08:00
|
|
|
snprintf (file, sizeof file, "%s%s%s%s", dir, fn, ext1, ext2);
|
2007-06-04 09:57:16 +08:00
|
|
|
|
2009-03-14 22:56:20 +08:00
|
|
|
wide_path wpath (file);
|
|
|
|
if (GetFileAttributesW (wpath) != (DWORD) - 1)
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
{
|
|
|
|
char *lastdot = strrchr (file, '.');
|
|
|
|
bool is_link = lastdot && !strcmp (lastdot, LINK_EXTENSION);
|
|
|
|
// If file is a link, fix up the extension before printing
|
|
|
|
if (is_link)
|
|
|
|
*lastdot = '\0';
|
|
|
|
if (showall)
|
|
|
|
printf ("Found: %s\n", file);
|
2007-06-04 09:57:16 +08:00
|
|
|
if (verbose && *first != '\0' && strcasecmp (first, file) != 0)
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
{
|
|
|
|
char *flastdot = strrchr (first, '.');
|
|
|
|
bool f_is_link = flastdot && !strcmp (flastdot, LINK_EXTENSION);
|
|
|
|
// if first is a link, fix up the extension before printing
|
|
|
|
if (f_is_link)
|
|
|
|
*flastdot = '\0';
|
|
|
|
printf ("Warning: %s hides %s\n", first, file);
|
|
|
|
if (f_is_link)
|
|
|
|
*flastdot = '.';
|
|
|
|
}
|
|
|
|
if (is_link)
|
|
|
|
*lastdot = '.';
|
2007-06-04 09:57:16 +08:00
|
|
|
if (!*first)
|
|
|
|
strcpy (first, file);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
static const char *
|
|
|
|
find_on_path (const char *in_file, const char *ext, bool showall = false,
|
|
|
|
bool search_sys = false, bool checklinks = false)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
static char rv[4000];
|
|
|
|
|
2016-10-23 21:57:40 +08:00
|
|
|
/* Sort of a kludge but we've already tested this once, so don't try it
|
|
|
|
again */
|
2007-06-04 09:57:16 +08:00
|
|
|
if (in_file == rv)
|
|
|
|
return in_file;
|
|
|
|
|
|
|
|
static pathlike abspath[2] =
|
|
|
|
{
|
|
|
|
{emptystr, 0},
|
|
|
|
{NULL, 0}
|
|
|
|
};
|
|
|
|
|
|
|
|
*rv = '\0';
|
|
|
|
if (!in_file)
|
2000-12-16 12:53:30 +08:00
|
|
|
{
|
2016-10-23 21:57:40 +08:00
|
|
|
display_error ("internal error find_on_path: NULL pointer for file",
|
|
|
|
false, false);
|
2000-12-16 12:53:30 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
if (!ext)
|
2000-12-16 12:53:30 +08:00
|
|
|
{
|
2016-10-23 21:57:40 +08:00
|
|
|
display_error ("internal error find_on_path: "
|
|
|
|
"NULL pointer for default_extension", false, false);
|
2000-12-16 12:53:30 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
const char *file;
|
|
|
|
pathlike *search_paths;
|
|
|
|
if (!strpbrk (in_file, ":/\\"))
|
2005-07-20 05:00:34 +08:00
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
file = in_file;
|
|
|
|
search_paths = paths;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
file = cygpath (in_file, NULL);
|
|
|
|
search_paths = abspath;
|
|
|
|
showall = false;
|
2005-07-20 05:00:34 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
if (!file)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2016-10-23 21:57:40 +08:00
|
|
|
display_error ("internal error find_on_path: "
|
|
|
|
"cygpath conversion failed for %s\n", in_file);
|
2007-06-04 09:57:16 +08:00
|
|
|
return 0;
|
|
|
|
}
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
char *hasext = strrchr (file, '.');
|
|
|
|
if (hasext && !strpbrk (hasext, "/\\"))
|
|
|
|
ext = "";
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
for (pathlike *pth = search_paths; pth->dir; pth++)
|
|
|
|
if (!pth->issys || search_sys)
|
|
|
|
{
|
|
|
|
pth->check_existence (file, showall, verbose, rv, ext);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
if (checklinks)
|
2016-10-23 21:57:40 +08:00
|
|
|
pth->check_existence (file, showall, verbose, rv, ext,
|
|
|
|
LINK_EXTENSION);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
if (!*ext)
|
|
|
|
continue;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
pth->check_existence (file, showall, verbose, rv);
|
|
|
|
if (checklinks)
|
|
|
|
pth->check_existence (file, showall, verbose, rv, LINK_EXTENSION);
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
return *rv ? rv : NULL;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define DID_NEW 1
|
|
|
|
#define DID_ACTIVE 2
|
|
|
|
#define DID_INACTIVE 3
|
|
|
|
|
|
|
|
struct Did
|
|
|
|
{
|
|
|
|
Did *next;
|
|
|
|
char *file;
|
|
|
|
int state;
|
|
|
|
};
|
2002-02-28 00:10:17 +08:00
|
|
|
static Did *did = 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static Did *
|
2007-06-04 09:57:16 +08:00
|
|
|
already_did (const char *file)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
Did *d;
|
|
|
|
for (d = did; d; d = d->next)
|
|
|
|
if (strcasecmp (d->file, file) == 0)
|
|
|
|
return d;
|
2002-01-18 10:57:10 +08:00
|
|
|
d = (Did *) malloc (sizeof (Did));
|
2000-02-18 03:38:33 +08:00
|
|
|
d->file = strdup (file);
|
|
|
|
d->next = did;
|
|
|
|
d->state = DID_NEW;
|
|
|
|
did = d;
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Section
|
|
|
|
{
|
|
|
|
char name[8];
|
|
|
|
int virtual_size;
|
|
|
|
int virtual_address;
|
|
|
|
int size_of_raw_data;
|
|
|
|
int pointer_to_raw_data;
|
|
|
|
};
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static int
|
2000-02-18 03:38:33 +08:00
|
|
|
rva_to_offset (int rva, char *sections, int nsections, int *sz)
|
|
|
|
{
|
|
|
|
int i;
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (sections == NULL)
|
|
|
|
{
|
2004-11-16 13:16:59 +08:00
|
|
|
display_error ("rva_to_offset: NULL passed for sections", true, false);
|
2000-12-16 12:53:30 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
for (i = 0; i < nsections; i++)
|
|
|
|
{
|
|
|
|
Section *s = (Section *) (sections + i * 40);
|
|
|
|
#if 0
|
|
|
|
printf ("%08x < %08x < %08x ? %08x\n",
|
|
|
|
s->virtual_address, rva,
|
|
|
|
s->virtual_address + s->virtual_size, s->pointer_to_raw_data);
|
|
|
|
#endif
|
|
|
|
if (rva >= s->virtual_address
|
|
|
|
&& rva < s->virtual_address + s->virtual_size)
|
|
|
|
{
|
|
|
|
if (sz)
|
|
|
|
*sz = s->virtual_address + s->virtual_size - rva;
|
|
|
|
return rva - s->virtual_address + s->pointer_to_raw_data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0; /* punt */
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ExpDirectory
|
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
int timestamp;
|
|
|
|
short major_ver;
|
|
|
|
short minor_ver;
|
|
|
|
int name_rva;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ImpDirectory
|
2000-10-28 13:00:00 +08:00
|
|
|
{
|
|
|
|
unsigned characteristics;
|
|
|
|
unsigned timestamp;
|
|
|
|
unsigned forwarder_chain;
|
|
|
|
unsigned name_rva;
|
|
|
|
unsigned iat_rva;
|
|
|
|
};
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
static bool track_down (const char *file, const char *suffix, int lvl);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2000-06-25 11:18:54 +08:00
|
|
|
#define CYGPREFIX (sizeof ("%%% Cygwin ") - 1)
|
|
|
|
static void
|
|
|
|
cygwin_info (HANDLE h)
|
|
|
|
{
|
2000-12-16 12:53:30 +08:00
|
|
|
char *buf, *bufend, *buf_start = NULL;
|
2000-06-25 11:18:54 +08:00
|
|
|
const char *hello = " Cygwin DLL version info:\n";
|
|
|
|
DWORD size = GetFileSize (h, NULL);
|
|
|
|
DWORD n;
|
|
|
|
|
|
|
|
if (size == 0xffffffff)
|
|
|
|
return;
|
|
|
|
|
2000-12-16 12:53:30 +08:00
|
|
|
buf_start = buf = (char *) calloc (1, size + 1);
|
|
|
|
if (buf == NULL)
|
|
|
|
{
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("cygwin_info: calloc()");
|
2000-12-16 12:53:30 +08:00
|
|
|
return;
|
|
|
|
}
|
2000-06-25 11:18:54 +08:00
|
|
|
|
|
|
|
(void) SetFilePointer (h, 0, NULL, FILE_BEGIN);
|
|
|
|
if (!ReadFile (h, buf, size, &n, NULL))
|
2000-12-16 12:53:30 +08:00
|
|
|
{
|
|
|
|
free (buf_start);
|
|
|
|
return;
|
|
|
|
}
|
2000-06-25 11:18:54 +08:00
|
|
|
|
2002-01-22 11:17:59 +08:00
|
|
|
static char dummy[] = "\0\0\0\0\0\0\0";
|
|
|
|
char *dll_major = dummy;
|
2000-06-25 11:18:54 +08:00
|
|
|
bufend = buf + size;
|
|
|
|
while (buf < bufend)
|
|
|
|
if ((buf = (char *) memchr (buf, '%', bufend - buf)) == NULL)
|
2000-10-28 13:00:00 +08:00
|
|
|
break;
|
2000-06-25 11:18:54 +08:00
|
|
|
else if (strncmp ("%%% Cygwin ", buf, CYGPREFIX) != 0)
|
2000-10-28 13:00:00 +08:00
|
|
|
buf++;
|
2000-06-25 11:18:54 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
char *p = strchr (buf += CYGPREFIX, '\n');
|
2000-12-16 12:53:30 +08:00
|
|
|
if (!p)
|
|
|
|
break;
|
2001-11-11 11:06:59 +08:00
|
|
|
if (strncasecmp (buf, "dll major:", 10) == 0)
|
|
|
|
{
|
|
|
|
dll_major = buf + 11;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
char *s, pbuf[80];
|
|
|
|
int len;
|
|
|
|
len = 1 + p - buf;
|
|
|
|
if (strncasecmp (buf, "dll minor:", 10) != 0)
|
|
|
|
s = buf;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char c = dll_major[1];
|
|
|
|
dll_major[1] = '\0';
|
|
|
|
int maj = atoi (dll_major);
|
|
|
|
dll_major[1] = c;
|
|
|
|
int min = atoi (dll_major + 1);
|
2002-03-07 11:13:17 +08:00
|
|
|
sprintf (pbuf, "DLL version: %d.%d.%.*s", maj, min, len - 11,
|
|
|
|
buf + 11);
|
2001-11-11 11:06:59 +08:00
|
|
|
len = strlen (s = pbuf);
|
|
|
|
}
|
|
|
|
if (strncmp (s, "dll", 3) == 0)
|
|
|
|
memcpy (s, "DLL", 3);
|
|
|
|
else if (strncmp (s, "api", 3) == 0)
|
|
|
|
memcpy (s, "API", 3);
|
|
|
|
else if (islower (*s))
|
|
|
|
*s = toupper (*s);
|
|
|
|
fprintf (stdout, "%s %.*s", hello, len, s);
|
2000-06-25 11:18:54 +08:00
|
|
|
hello = "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*hello)
|
|
|
|
puts ("");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
free (buf_start);
|
2000-06-25 11:18:54 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static void
|
2000-06-25 11:18:54 +08:00
|
|
|
dll_info (const char *path, HANDLE fh, int lvl, int recurse)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
DWORD junk;
|
|
|
|
int i;
|
2013-07-08 00:57:11 +08:00
|
|
|
if (is_symlink (fh))
|
|
|
|
{
|
|
|
|
if (!verbose)
|
|
|
|
puts ("");
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char buf[PATH_MAX + 1] = "";
|
|
|
|
readlink (fh, buf, sizeof(buf) - 1);
|
|
|
|
printf (" (symlink to %s)\n", buf);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
int pe_header_offset = get_dword (fh, 0x3c);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (GetLastError () != NO_ERROR)
|
|
|
|
display_error ("get_dword");
|
2013-04-23 17:44:36 +08:00
|
|
|
WORD arch = get_word (fh, pe_header_offset + 4);
|
|
|
|
if (GetLastError () != NO_ERROR)
|
|
|
|
display_error ("get_word");
|
|
|
|
#ifdef __x86_64__
|
|
|
|
if (arch != IMAGE_FILE_MACHINE_AMD64)
|
|
|
|
{
|
2013-07-08 00:57:11 +08:00
|
|
|
puts (verbose ? " (not x86_64 dll)" : "\n");
|
2013-04-23 17:44:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
int base_off = 108;
|
|
|
|
#else
|
2022-10-28 17:37:02 +08:00
|
|
|
#error unimplemented for this target
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2000-02-18 03:38:33 +08:00
|
|
|
int opthdr_ofs = pe_header_offset + 4 + 20;
|
|
|
|
unsigned short v[6];
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (path == NULL)
|
|
|
|
{
|
2004-11-16 13:16:59 +08:00
|
|
|
display_error ("dll_info: NULL passed for path", true, false);
|
2000-12-16 12:53:30 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-03-07 11:13:17 +08:00
|
|
|
if (SetFilePointer (fh, opthdr_ofs + 40, 0, FILE_BEGIN) ==
|
|
|
|
INVALID_SET_FILE_POINTER && GetLastError () != NO_ERROR)
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: SetFilePointer()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (!ReadFile (fh, &v, sizeof (v), &junk, 0))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: Readfile()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
if (verbose)
|
|
|
|
printf (" - os=%d.%d img=%d.%d sys=%d.%d\n",
|
|
|
|
v[0], v[1], v[2], v[3], v[4], v[5]);
|
|
|
|
else
|
|
|
|
printf ("\n");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
int num_entries = get_dword (fh, opthdr_ofs + base_off + 0);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (GetLastError () != NO_ERROR)
|
|
|
|
display_error ("get_dword");
|
2013-04-23 17:44:36 +08:00
|
|
|
int export_rva = get_dword (fh, opthdr_ofs + base_off + 4);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (GetLastError () != NO_ERROR)
|
|
|
|
display_error ("get_dword");
|
2013-04-23 17:44:36 +08:00
|
|
|
int export_size = get_dword (fh, opthdr_ofs + base_off + 8);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (GetLastError () != NO_ERROR)
|
|
|
|
display_error ("get_dword");
|
2013-04-23 17:44:36 +08:00
|
|
|
int import_rva = get_dword (fh, opthdr_ofs + base_off + 12);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (GetLastError () != NO_ERROR)
|
|
|
|
display_error ("get_dword");
|
2013-04-23 17:44:36 +08:00
|
|
|
int import_size = get_dword (fh, opthdr_ofs + base_off + 16);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (GetLastError () != NO_ERROR)
|
|
|
|
display_error ("get_dword");
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
int nsections = get_word (fh, pe_header_offset + 4 + 2);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (nsections == -1)
|
|
|
|
display_error ("get_word");
|
2000-02-18 03:38:33 +08:00
|
|
|
char *sections = (char *) malloc (nsections * 40);
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (SetFilePointer (fh, pe_header_offset + 4 + 20 +
|
|
|
|
get_word (fh, pe_header_offset + 4 + 16), 0,
|
|
|
|
FILE_BEGIN) == INVALID_SET_FILE_POINTER
|
|
|
|
&& GetLastError () != NO_ERROR)
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: SetFilePointer()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (!ReadFile (fh, sections, nsections * 40, &junk, 0))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: Readfile()");
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
if (verbose && num_entries >= 1 && export_size > 0)
|
|
|
|
{
|
|
|
|
int expsz;
|
|
|
|
int expbase = rva_to_offset (export_rva, sections, nsections, &expsz);
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
if (expbase)
|
|
|
|
{
|
2002-03-07 11:13:17 +08:00
|
|
|
if (SetFilePointer (fh, expbase, 0, FILE_BEGIN) ==
|
|
|
|
INVALID_SET_FILE_POINTER && GetLastError () != NO_ERROR)
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: SetFilePointer()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
unsigned char *exp = (unsigned char *) malloc (expsz);
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (!ReadFile (fh, exp, expsz, &junk, 0))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: Readfile()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
ExpDirectory *ed = (ExpDirectory *) exp;
|
|
|
|
int ofs = ed->name_rva - export_rva;
|
2013-04-23 17:44:36 +08:00
|
|
|
time_t ts = ed->timestamp; /* timestamp is only 4 bytes! */
|
|
|
|
struct tm *tm = localtime (&ts);
|
|
|
|
if (tm && tm->tm_year < 60)
|
2000-02-18 03:38:33 +08:00
|
|
|
tm->tm_year += 2000;
|
2013-04-23 17:44:36 +08:00
|
|
|
if (tm && tm->tm_year < 200)
|
2000-02-18 03:38:33 +08:00
|
|
|
tm->tm_year += 1900;
|
|
|
|
printf ("%*c", lvl + 2, ' ');
|
2013-04-23 17:44:36 +08:00
|
|
|
printf ("\"%s\" v%d.%d", exp + ofs,
|
2000-02-18 03:38:33 +08:00
|
|
|
ed->major_ver, ed->minor_ver);
|
2013-04-23 17:44:36 +08:00
|
|
|
if (tm)
|
|
|
|
printf (" ts=%04d-%02d-%02d %02d:%02d",
|
|
|
|
tm->tm_year, tm->tm_mon + 1, tm->tm_mday,
|
|
|
|
tm->tm_hour, tm->tm_min);
|
|
|
|
putchar ('\n');
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_entries >= 2 && import_size > 0 && recurse)
|
|
|
|
{
|
|
|
|
int impsz;
|
|
|
|
int impbase = rva_to_offset (import_rva, sections, nsections, &impsz);
|
|
|
|
if (impbase)
|
|
|
|
{
|
2002-03-07 11:13:17 +08:00
|
|
|
if (SetFilePointer (fh, impbase, 0, FILE_BEGIN) ==
|
|
|
|
INVALID_SET_FILE_POINTER && GetLastError () != NO_ERROR)
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: SetFilePointer()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
unsigned char *imp = (unsigned char *) malloc (impsz);
|
2000-12-16 12:53:30 +08:00
|
|
|
if (imp == NULL)
|
|
|
|
{
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: malloc()");
|
2000-12-16 12:53:30 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ReadFile (fh, imp, impsz, &junk, 0))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dll_info: Readfile()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
ImpDirectory *id = (ImpDirectory *) imp;
|
|
|
|
for (i = 0; id[i].name_rva; i++)
|
|
|
|
{
|
|
|
|
/* int ofs = id[i].name_rva - import_rva; */
|
|
|
|
track_down ((char *) imp + id[i].name_rva - import_rva,
|
|
|
|
(char *) ".dll", lvl + 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-06-25 11:18:54 +08:00
|
|
|
if (strstr (path, "\\cygwin1.dll"))
|
|
|
|
cygwin_info (fh);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2005-07-06 05:41:37 +08:00
|
|
|
// Return true on success, false if error printed
|
|
|
|
static bool
|
2007-06-04 09:57:16 +08:00
|
|
|
track_down (const char *file, const char *suffix, int lvl)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2000-12-16 12:53:30 +08:00
|
|
|
if (file == NULL)
|
|
|
|
{
|
2004-11-16 13:16:59 +08:00
|
|
|
display_error ("track_down: NULL passed for file", true, false);
|
2005-07-06 05:41:37 +08:00
|
|
|
return false;
|
2000-12-16 12:53:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (suffix == NULL)
|
|
|
|
{
|
2004-11-16 13:16:59 +08:00
|
|
|
display_error ("track_down: NULL passed for suffix", false, false);
|
2005-07-06 05:41:37 +08:00
|
|
|
return false;
|
2000-12-16 12:53:30 +08:00
|
|
|
}
|
|
|
|
|
2007-06-04 09:57:16 +08:00
|
|
|
const char *path = find_on_path (file, suffix, false, true);
|
2000-02-18 03:38:33 +08:00
|
|
|
if (!path)
|
|
|
|
{
|
2015-08-31 03:32:56 +08:00
|
|
|
/* The api-ms-win-*.dll files are in system32/downlevel and not in the
|
|
|
|
DLL search path, so find_on_path doesn't find them. Since they are
|
|
|
|
never actually linked against by the executables, they are of no
|
|
|
|
interest to us. Skip any error message in not finding them. */
|
|
|
|
if (strncasecmp (file, "api-ms-win-", 11) || strcasecmp (suffix, ".dll"))
|
|
|
|
display_error ("track_down: could not find %s\n", file);
|
2005-07-06 05:41:37 +08:00
|
|
|
return false;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Did *d = already_did (file);
|
|
|
|
switch (d->state)
|
|
|
|
{
|
|
|
|
case DID_NEW:
|
|
|
|
break;
|
|
|
|
case DID_ACTIVE:
|
|
|
|
if (verbose)
|
|
|
|
{
|
|
|
|
if (lvl)
|
|
|
|
printf ("%*c", lvl, ' ');
|
|
|
|
printf ("%s", path);
|
|
|
|
printf (" (recursive)\n");
|
|
|
|
}
|
2005-07-06 05:41:37 +08:00
|
|
|
return true;
|
2000-02-18 03:38:33 +08:00
|
|
|
case DID_INACTIVE:
|
|
|
|
if (verbose)
|
|
|
|
{
|
|
|
|
if (lvl)
|
|
|
|
printf ("%*c", lvl, ' ');
|
|
|
|
printf ("%s", path);
|
|
|
|
printf (" (already done)\n");
|
|
|
|
}
|
2005-07-06 05:41:37 +08:00
|
|
|
return true;
|
2000-12-16 12:53:30 +08:00
|
|
|
default:
|
|
|
|
break;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lvl)
|
|
|
|
printf ("%*c", lvl, ' ');
|
|
|
|
|
|
|
|
printf ("%s", path);
|
|
|
|
|
2009-03-14 22:56:20 +08:00
|
|
|
wide_path wpath (path);
|
2000-10-28 13:00:00 +08:00
|
|
|
HANDLE fh =
|
2009-03-14 22:56:20 +08:00
|
|
|
CreateFileW (wpath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
2000-02-18 03:38:33 +08:00
|
|
|
if (fh == INVALID_HANDLE_VALUE)
|
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error ("cannot open - '%s'\n", path);
|
2005-07-06 05:41:37 +08:00
|
|
|
return false;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
d->state = DID_ACTIVE;
|
|
|
|
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (is_exe (fh))
|
|
|
|
dll_info (path, fh, lvl, 1);
|
|
|
|
else if (is_symlink (fh))
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error ("%s is a symlink instead of a DLL\n", path);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
int magic = get_word (fh, 0x0);
|
|
|
|
if (magic == -1)
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error ("get_word");
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
magic &= 0x00FFFFFF;
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error_fmt ("%s is not a DLL: magic number %x (%d) '%s'\n",
|
|
|
|
path, magic, magic, (char *)&magic);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
d->state = DID_INACTIVE;
|
2000-12-16 12:53:30 +08:00
|
|
|
if (!CloseHandle (fh))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("track_down: CloseHandle()");
|
2005-07-06 05:41:37 +08:00
|
|
|
return true;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static void
|
2000-02-18 03:38:33 +08:00
|
|
|
ls (char *f)
|
|
|
|
{
|
2009-03-14 22:56:20 +08:00
|
|
|
wide_path wpath (f);
|
|
|
|
HANDLE h = CreateFileW (wpath, GENERIC_READ,
|
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
|
|
0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
|
2000-02-18 03:38:33 +08:00
|
|
|
BY_HANDLE_FILE_INFORMATION info;
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (!GetFileInformationByHandle (h, &info))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("ls: GetFileInformationByHandle()");
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
SYSTEMTIME systime;
|
2000-12-16 12:53:30 +08:00
|
|
|
|
|
|
|
if (!FileTimeToSystemTime (&info.ftLastWriteTime, &systime))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("ls: FileTimeToSystemTime()");
|
2000-02-18 03:38:33 +08:00
|
|
|
printf ("%5dk %04d/%02d/%02d %s",
|
|
|
|
(((int) info.nFileSizeLow) + 512) / 1024,
|
2000-10-28 13:00:00 +08:00
|
|
|
systime.wYear, systime.wMonth, systime.wDay, f);
|
2000-06-25 11:18:54 +08:00
|
|
|
dll_info (f, h, 16, 0);
|
2000-12-16 12:53:30 +08:00
|
|
|
if (!CloseHandle (h))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("ls: CloseHandle()");
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2008-03-12 01:20:02 +08:00
|
|
|
/* Remove filename from 's' and return directory name without trailing
|
|
|
|
backslash, or NULL if 's' doesn't seem to have a dirname. */
|
|
|
|
static char *
|
|
|
|
dirname (const char *s)
|
|
|
|
{
|
2009-03-14 22:56:20 +08:00
|
|
|
static char buf[PATH_MAX];
|
2008-03-12 01:20:02 +08:00
|
|
|
|
|
|
|
if (!s)
|
|
|
|
return NULL;
|
|
|
|
|
2009-03-14 22:56:20 +08:00
|
|
|
strncpy (buf, s, PATH_MAX);
|
|
|
|
buf[PATH_MAX - 1] = '\0'; // in case strlen(s) > PATH_MAX
|
2008-03-12 01:20:02 +08:00
|
|
|
char *lastsep = strrchr (buf, '\\');
|
|
|
|
if (!lastsep)
|
|
|
|
return NULL; // no backslash -> no dirname
|
|
|
|
else if (lastsep - buf <= 2 && buf[1] == ':')
|
|
|
|
lastsep[1] = '\0'; // can't remove backslash of "x:\"
|
|
|
|
else
|
|
|
|
*lastsep = '\0';
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
// Find a real application on the path (possibly following symlinks)
|
2007-06-04 09:57:16 +08:00
|
|
|
static const char *
|
|
|
|
find_app_on_path (const char *app, bool showall = false)
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
const char *papp = find_on_path (app, ".exe", showall, false, true);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
|
2009-05-05 02:51:08 +08:00
|
|
|
if (!papp)
|
|
|
|
return NULL;
|
|
|
|
|
2009-03-14 22:56:20 +08:00
|
|
|
wide_path wpath (papp);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
HANDLE fh =
|
2009-03-14 22:56:20 +08:00
|
|
|
CreateFileW (wpath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (fh == INVALID_HANDLE_VALUE)
|
2007-06-04 09:57:16 +08:00
|
|
|
return NULL;
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
|
|
|
|
if (is_symlink (fh))
|
|
|
|
{
|
2008-03-12 02:43:11 +08:00
|
|
|
static char tmp[SYMLINK_MAX + 1];
|
2008-03-12 01:20:02 +08:00
|
|
|
if (!readlink (fh, tmp, SYMLINK_MAX))
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
display_error("readlink failed");
|
2011-12-18 07:39:47 +08:00
|
|
|
|
2008-03-12 01:20:02 +08:00
|
|
|
/* Resolve the linkname relative to the directory of the link. */
|
|
|
|
char *ptr = cygpath_rel (dirname (papp), tmp, NULL);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
printf (" -> %s\n", ptr);
|
|
|
|
if (!strchr (ptr, '\\'))
|
|
|
|
{
|
|
|
|
char *lastsep;
|
2008-03-12 02:43:11 +08:00
|
|
|
strncpy (tmp, cygpath (papp, NULL), SYMLINK_MAX);
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
lastsep = strrchr (tmp, '\\');
|
2008-03-12 02:43:11 +08:00
|
|
|
strncpy (lastsep+1, ptr, SYMLINK_MAX - (lastsep-tmp));
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
ptr = tmp;
|
|
|
|
}
|
|
|
|
if (!CloseHandle (fh))
|
|
|
|
display_error ("find_app_on_path: CloseHandle()");
|
2008-03-12 01:20:02 +08:00
|
|
|
/* FIXME: We leak the ptr returned by cygpath() here which is a
|
2011-12-18 07:39:47 +08:00
|
|
|
malloc()d string. */
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
return find_app_on_path (ptr, showall);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CloseHandle (fh))
|
|
|
|
display_error ("find_app_on_path: CloseHandle()");
|
|
|
|
return papp;
|
|
|
|
}
|
|
|
|
|
2005-07-06 05:41:37 +08:00
|
|
|
// Return true on success, false if error printed
|
|
|
|
static bool
|
2007-06-04 09:57:16 +08:00
|
|
|
cygcheck (const char *app)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
const char *papp = find_app_on_path (app, 1);
|
2000-02-18 03:38:33 +08:00
|
|
|
if (!papp)
|
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
display_error ("could not find '%s'\n", app);
|
2005-07-06 05:41:37 +08:00
|
|
|
return false;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2007-06-04 09:57:16 +08:00
|
|
|
|
|
|
|
char *s;
|
|
|
|
char *sep = strpbrk (papp, ":/\\");
|
|
|
|
if (!sep)
|
|
|
|
{
|
|
|
|
static char dot[] = ".";
|
|
|
|
s = dot;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
int n = sep - papp;
|
|
|
|
s = (char *) malloc (n + 2);
|
|
|
|
memcpy ((char *) s, papp, n);
|
|
|
|
strcpy (s + n, "\\");
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2007-06-04 09:57:16 +08:00
|
|
|
|
|
|
|
paths[0].dir = s;
|
|
|
|
did = NULL;
|
|
|
|
return track_down (papp, ".exe", 0);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
struct RegInfo
|
2000-10-28 13:00:00 +08:00
|
|
|
{
|
|
|
|
RegInfo *prev;
|
|
|
|
char *name;
|
|
|
|
HKEY key;
|
|
|
|
};
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static void
|
2000-02-18 03:38:33 +08:00
|
|
|
show_reg (RegInfo * ri, int nest)
|
|
|
|
{
|
|
|
|
if (!ri)
|
|
|
|
return;
|
|
|
|
show_reg (ri->prev, 1);
|
|
|
|
if (nest)
|
|
|
|
printf ("%s\\", ri->name);
|
|
|
|
else
|
|
|
|
printf ("%s\n", ri->name);
|
|
|
|
}
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static void
|
2009-01-17 19:59:16 +08:00
|
|
|
scan_registry (RegInfo * prev, HKEY hKey, char *name, int cygwin, bool wow64)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
RegInfo ri;
|
|
|
|
ri.prev = prev;
|
|
|
|
ri.name = name;
|
|
|
|
ri.key = hKey;
|
|
|
|
|
|
|
|
char *cp;
|
|
|
|
for (cp = name; *cp; cp++)
|
2009-01-17 19:59:16 +08:00
|
|
|
if (strncasecmp (cp, "Cygwin", 6) == 0)
|
|
|
|
cygwin = 1;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
DWORD num_subkeys, max_subkey_len, num_values;
|
|
|
|
DWORD max_value_len, max_valdata_len, i;
|
|
|
|
if (RegQueryInfoKey (hKey, 0, 0, 0, &num_subkeys, &max_subkey_len, 0,
|
|
|
|
&num_values, &max_value_len, &max_valdata_len, 0, 0)
|
|
|
|
!= ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
char tmp[400];
|
|
|
|
FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError (),
|
2000-10-28 13:00:00 +08:00
|
|
|
MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), tmp, 400, 0);
|
2000-02-18 03:38:33 +08:00
|
|
|
printf ("RegQueryInfoKey: %s\n", tmp);
|
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-01-17 19:59:16 +08:00
|
|
|
if (cygwin)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
show_reg (&ri, 0);
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
char *value_name = (char *) malloc (max_value_len + 1);
|
2000-12-16 12:53:30 +08:00
|
|
|
if (value_name == NULL)
|
|
|
|
{
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("scan_registry: malloc()");
|
2000-12-16 12:53:30 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
char *value_data = (char *) malloc (max_valdata_len + 1);
|
2000-12-16 12:53:30 +08:00
|
|
|
if (value_data == NULL)
|
|
|
|
{
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("scan_registry: malloc()");
|
2000-12-16 12:53:30 +08:00
|
|
|
return;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
for (i = 0; i < num_values; i++)
|
|
|
|
{
|
|
|
|
DWORD dlen = max_valdata_len + 1;
|
|
|
|
DWORD nlen = max_value_len + 1;
|
|
|
|
DWORD type;
|
|
|
|
RegEnumValue (hKey, i, value_name, &nlen, 0,
|
|
|
|
&type, (BYTE *) value_data, &dlen);
|
|
|
|
{
|
|
|
|
printf (" %s = ", i ? value_name : "(default)");
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case REG_DWORD:
|
|
|
|
printf ("0x%08x\n", *(unsigned *) value_data);
|
|
|
|
break;
|
|
|
|
case REG_EXPAND_SZ:
|
|
|
|
case REG_SZ:
|
2006-01-13 01:43:53 +08:00
|
|
|
printf ("'%s'\n", value_data);
|
2000-02-18 03:38:33 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf ("(unsupported type)\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free (value_name);
|
|
|
|
free (value_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *subkey_name = (char *) malloc (max_subkey_len + 1);
|
|
|
|
for (i = 0; i < num_subkeys; i++)
|
|
|
|
{
|
2000-10-28 13:00:00 +08:00
|
|
|
if (RegEnumKey (hKey, i, subkey_name, max_subkey_len + 1) ==
|
|
|
|
ERROR_SUCCESS)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
HKEY sKey;
|
2009-01-17 19:59:16 +08:00
|
|
|
/* Don't recurse more than one level into the WOW64 subkey since
|
|
|
|
that would lead to an endless recursion. */
|
|
|
|
if (!strcasecmp (subkey_name, "Wow6432Node"))
|
|
|
|
{
|
|
|
|
if (wow64)
|
|
|
|
continue;
|
|
|
|
wow64 = true;
|
|
|
|
}
|
2001-11-12 08:14:27 +08:00
|
|
|
if (RegOpenKeyEx (hKey, subkey_name, 0, KEY_READ, &sKey)
|
2000-02-18 03:38:33 +08:00
|
|
|
== ERROR_SUCCESS)
|
|
|
|
{
|
2009-01-17 19:59:16 +08:00
|
|
|
scan_registry (&ri, sKey, subkey_name, cygwin, wow64);
|
2000-12-16 12:53:30 +08:00
|
|
|
if (RegCloseKey (sKey) != ERROR_SUCCESS)
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("scan_registry: RegCloseKey()");
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free (subkey_name);
|
|
|
|
}
|
|
|
|
|
2003-03-01 11:38:19 +08:00
|
|
|
void
|
2009-10-28 19:41:27 +08:00
|
|
|
pretty_id ()
|
2003-03-01 11:38:19 +08:00
|
|
|
{
|
|
|
|
char *groups[16384];
|
|
|
|
|
|
|
|
char *id = cygpath ("/bin/id.exe", NULL);
|
2003-09-11 10:56:40 +08:00
|
|
|
for (char *p = id; (p = strchr (p, '/')); p++)
|
2003-03-01 11:38:19 +08:00
|
|
|
*p = '\\';
|
|
|
|
|
|
|
|
if (access (id, X_OK))
|
2004-01-24 07:04:27 +08:00
|
|
|
{
|
2006-01-13 01:43:53 +08:00
|
|
|
fprintf (stderr, "'id' program not found\n");
|
2004-01-24 07:04:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2003-03-01 11:38:19 +08:00
|
|
|
|
|
|
|
char buf[16384];
|
2008-12-31 09:44:36 +08:00
|
|
|
snprintf (buf, sizeof (buf), "\"%s\"", id);
|
|
|
|
FILE *f = popen (buf, "rt");
|
|
|
|
|
2004-01-24 07:04:27 +08:00
|
|
|
buf[0] = '\0';
|
2003-03-01 11:38:19 +08:00
|
|
|
fgets (buf, sizeof (buf), f);
|
2004-10-04 17:42:08 +08:00
|
|
|
pclose (f);
|
2004-01-24 07:04:27 +08:00
|
|
|
char *uid = strtok (buf, ")");
|
|
|
|
if (uid)
|
|
|
|
uid += strlen ("uid=");
|
|
|
|
else
|
2004-10-15 01:35:46 +08:00
|
|
|
{
|
2006-01-13 01:43:53 +08:00
|
|
|
fprintf (stderr, "garbled output from 'id' command - no uid= found\n");
|
2004-10-15 21:57:56 +08:00
|
|
|
return;
|
2004-10-15 01:35:46 +08:00
|
|
|
}
|
2004-01-24 07:04:27 +08:00
|
|
|
char *gid = strtok (NULL, ")");
|
|
|
|
if (gid)
|
|
|
|
gid += strlen ("gid=") + 1;
|
|
|
|
else
|
2004-10-15 01:35:46 +08:00
|
|
|
{
|
2006-01-13 01:43:53 +08:00
|
|
|
fprintf (stderr, "garbled output from 'id' command - no gid= found\n");
|
2004-10-15 21:57:56 +08:00
|
|
|
return;
|
2004-10-15 01:35:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
char **ng = groups - 1;
|
2004-10-18 09:44:55 +08:00
|
|
|
size_t len_uid = strlen ("UID: )") + strlen (uid);
|
|
|
|
size_t len_gid = strlen ("GID: )") + strlen (gid);
|
2004-10-18 07:31:23 +08:00
|
|
|
*++ng = groups[0] = (char *) alloca (len_uid + 1);
|
|
|
|
*++ng = groups[1] = (char *) alloca (len_gid + 1);
|
2004-10-15 01:35:46 +08:00
|
|
|
sprintf (groups[0], "UID: %s)", uid);
|
|
|
|
sprintf (groups[1], "GID: %s)", gid);
|
|
|
|
size_t sz = max (len_uid, len_gid);
|
|
|
|
while ((*++ng = strtok (NULL, ",")))
|
2003-03-01 11:38:19 +08:00
|
|
|
{
|
|
|
|
char *p = strchr (*ng, '\n');
|
|
|
|
if (p)
|
|
|
|
*p = '\0';
|
2004-10-15 01:35:46 +08:00
|
|
|
if (ng == groups + 2)
|
2003-06-13 10:36:12 +08:00
|
|
|
*ng += strlen (" groups=");
|
2003-03-01 11:38:19 +08:00
|
|
|
size_t len = strlen (*ng);
|
|
|
|
if (sz < len)
|
|
|
|
sz = len;
|
|
|
|
}
|
2004-10-15 21:57:56 +08:00
|
|
|
ng--;
|
2003-03-01 11:38:19 +08:00
|
|
|
|
2009-10-28 19:41:27 +08:00
|
|
|
printf ("\nOutput from %s\n", id);
|
2004-10-15 21:57:56 +08:00
|
|
|
int n = 80 / (int) ++sz;
|
2004-10-18 18:25:38 +08:00
|
|
|
int i = n > 2 ? n - 2 : 0;
|
2004-10-15 21:57:56 +08:00
|
|
|
sz = -sz;
|
|
|
|
for (char **g = groups; g <= ng; g++)
|
|
|
|
if ((g != ng) && (++i < n))
|
2013-04-23 17:44:36 +08:00
|
|
|
printf ("%*s", (int) sz, *g);
|
2004-10-15 01:35:46 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
puts (*g);
|
|
|
|
i = 0;
|
|
|
|
}
|
2003-03-01 11:38:19 +08:00
|
|
|
}
|
|
|
|
|
2005-05-23 17:54:44 +08:00
|
|
|
/* This dumps information about each installed cygwin service, if cygrunsrv
|
|
|
|
is available. */
|
|
|
|
void
|
|
|
|
dump_sysinfo_services ()
|
|
|
|
{
|
|
|
|
char buf[1024];
|
|
|
|
char buf2[1024];
|
|
|
|
FILE *f;
|
2005-08-17 08:52:43 +08:00
|
|
|
bool no_services = false;
|
2005-05-27 23:45:53 +08:00
|
|
|
|
2005-05-23 17:54:44 +08:00
|
|
|
if (givehelp)
|
2005-05-27 23:45:53 +08:00
|
|
|
printf ("\nChecking for any Cygwin services... %s\n\n",
|
|
|
|
verbose ? "" : "(use -v for more detail)");
|
2005-05-23 17:54:44 +08:00
|
|
|
else
|
|
|
|
fputc ('\n', stdout);
|
2005-05-27 23:45:53 +08:00
|
|
|
|
2005-05-23 17:54:44 +08:00
|
|
|
/* find the location of cygrunsrv.exe */
|
2005-05-27 23:45:53 +08:00
|
|
|
char *cygrunsrv = cygpath ("/bin/cygrunsrv.exe", NULL);
|
2005-05-23 17:54:44 +08:00
|
|
|
for (char *p = cygrunsrv; (p = strchr (p, '/')); p++)
|
|
|
|
*p = '\\';
|
|
|
|
|
|
|
|
if (access (cygrunsrv, X_OK))
|
|
|
|
{
|
|
|
|
puts ("Can't find the cygrunsrv utility, skipping services check.\n");
|
|
|
|
return;
|
|
|
|
}
|
2005-05-27 23:45:53 +08:00
|
|
|
|
2005-05-23 17:54:44 +08:00
|
|
|
/* check for a recent cygrunsrv */
|
2008-12-31 09:44:36 +08:00
|
|
|
snprintf (buf, sizeof (buf), "\"%s\" --version", cygrunsrv);
|
2005-05-27 23:45:53 +08:00
|
|
|
if ((f = popen (buf, "rt")) == NULL)
|
2005-05-23 17:54:44 +08:00
|
|
|
{
|
|
|
|
printf ("Failed to execute '%s', skipping services check.\n", buf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
int maj, min;
|
|
|
|
int ret = fscanf (f, "cygrunsrv V%u.%u", &maj, &min);
|
|
|
|
if (ferror (f) || feof (f) || ret == EOF || maj < 1 || min < 10)
|
|
|
|
{
|
2016-10-23 21:57:40 +08:00
|
|
|
puts ("The version of cygrunsrv installed is too old to dump "
|
|
|
|
"service info.\n");
|
2005-05-23 17:54:44 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-10-23 04:14:34 +08:00
|
|
|
pclose (f);
|
2005-05-27 23:45:53 +08:00
|
|
|
|
2005-08-17 08:52:43 +08:00
|
|
|
/* For verbose mode, just run cygrunsrv --list --verbose and copy output
|
|
|
|
verbatim; otherwise run cygrunsrv --list and then cygrunsrv --query for
|
|
|
|
each service. */
|
2016-10-23 21:57:40 +08:00
|
|
|
snprintf (buf, sizeof (buf),
|
|
|
|
(verbose ? "\"%s\" --list --verbose" : "\"%s\" --list"),
|
2005-08-17 08:52:43 +08:00
|
|
|
cygrunsrv);
|
2005-05-23 17:54:44 +08:00
|
|
|
if ((f = popen (buf, "rt")) == NULL)
|
|
|
|
{
|
|
|
|
printf ("Failed to execute '%s', skipping services check.\n", buf);
|
|
|
|
return;
|
|
|
|
}
|
2005-05-27 23:45:53 +08:00
|
|
|
|
2005-08-17 08:52:43 +08:00
|
|
|
if (verbose)
|
2005-05-23 17:54:44 +08:00
|
|
|
{
|
2005-08-17 08:52:43 +08:00
|
|
|
/* copy output to stdout */
|
|
|
|
size_t nchars = 0;
|
|
|
|
while (!feof (f) && !ferror (f))
|
|
|
|
nchars += fwrite ((void *) buf, 1,
|
|
|
|
fread ((void *) buf, 1, sizeof (buf), f), stdout);
|
|
|
|
|
|
|
|
/* cygrunsrv outputs nothing if there are no cygwin services found */
|
|
|
|
if (nchars < 1)
|
|
|
|
no_services = true;
|
|
|
|
pclose (f);
|
2005-05-23 17:54:44 +08:00
|
|
|
}
|
2005-08-17 08:52:43 +08:00
|
|
|
else
|
2005-05-23 17:54:44 +08:00
|
|
|
{
|
2005-08-17 08:52:43 +08:00
|
|
|
/* read the output of --list, and then run --query for each service */
|
|
|
|
size_t nchars = fread ((void *) buf, 1, sizeof (buf) - 1, f);
|
|
|
|
buf[nchars] = 0;
|
2005-05-23 17:54:44 +08:00
|
|
|
pclose (f);
|
2005-05-27 23:45:53 +08:00
|
|
|
|
2005-08-17 08:52:43 +08:00
|
|
|
if (nchars > 0)
|
|
|
|
for (char *srv = strtok (buf, "\n"); srv; srv = strtok (NULL, "\n"))
|
|
|
|
{
|
2008-12-31 09:44:36 +08:00
|
|
|
snprintf (buf2, sizeof (buf2), "\"%s\" --query %s", cygrunsrv, srv);
|
2005-08-17 08:52:43 +08:00
|
|
|
if ((f = popen (buf2, "rt")) == NULL)
|
|
|
|
{
|
2016-10-23 21:57:40 +08:00
|
|
|
printf ("Failed to execute '%s', skipping services check.\n",
|
|
|
|
buf2);
|
2005-08-17 08:52:43 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* copy output to stdout */
|
|
|
|
while (!feof (f) && !ferror (f))
|
|
|
|
fwrite ((void *) buf2, 1,
|
|
|
|
fread ((void *) buf2, 1, sizeof (buf2), f), stdout);
|
|
|
|
pclose (f);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
no_services = true;
|
2005-05-23 17:54:44 +08:00
|
|
|
}
|
2005-08-17 08:52:43 +08:00
|
|
|
|
|
|
|
/* inform the user if nothing found */
|
|
|
|
if (no_services)
|
|
|
|
puts ("No Cygwin services found.\n");
|
2005-05-23 17:54:44 +08:00
|
|
|
}
|
|
|
|
|
2009-10-31 21:26:37 +08:00
|
|
|
enum handle_reg_t
|
|
|
|
{
|
|
|
|
PRINT_KEY,
|
|
|
|
DELETE_KEY
|
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
handle_reg_installation (handle_reg_t what)
|
|
|
|
{
|
|
|
|
HKEY key;
|
|
|
|
|
|
|
|
if (what == PRINT_KEY)
|
|
|
|
printf ("Cygwin installations found in the registry:\n");
|
|
|
|
for (int i = 0; i < 2; ++i)
|
|
|
|
if (RegOpenKeyEx (i ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
|
|
|
|
"SOFTWARE\\Cygwin\\Installations", 0,
|
|
|
|
what == DELETE_KEY ? KEY_READ | KEY_WRITE : KEY_READ,
|
|
|
|
&key)
|
|
|
|
== ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
char name[32], data[PATH_MAX];
|
|
|
|
DWORD nsize, dsize, type;
|
|
|
|
LONG ret;
|
|
|
|
|
|
|
|
for (DWORD index = 0;
|
|
|
|
(ret = RegEnumValue (key, index, name, (nsize = 32, &nsize), 0,
|
|
|
|
&type, (PBYTE) data,
|
|
|
|
(dsize = PATH_MAX, &dsize)))
|
|
|
|
!= ERROR_NO_MORE_ITEMS; ++index)
|
|
|
|
if (ret == ERROR_SUCCESS && dsize > 5)
|
|
|
|
{
|
|
|
|
char *path = data + 4;
|
|
|
|
if (path[1] != ':')
|
2011-12-18 07:39:47 +08:00
|
|
|
*(path += 2) = '\\';
|
2009-10-31 21:26:37 +08:00
|
|
|
if (what == PRINT_KEY)
|
|
|
|
printf (" %s Key: %s Path: %s", i ? "User: " : "System:",
|
|
|
|
name, path);
|
|
|
|
strcat (path, "\\bin\\cygwin1.dll");
|
|
|
|
if (what == PRINT_KEY)
|
|
|
|
printf ("%s\n", access (path, F_OK) ? " (ORPHANED)" : "");
|
|
|
|
else if (access (path, F_OK))
|
|
|
|
{
|
|
|
|
RegDeleteValue (key, name);
|
|
|
|
/* Start over since index is not reliable anymore. */
|
|
|
|
--i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
RegCloseKey (key);
|
|
|
|
}
|
|
|
|
if (what == PRINT_KEY)
|
|
|
|
printf ("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
print_reg_installations ()
|
|
|
|
{
|
|
|
|
handle_reg_installation (PRINT_KEY);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
del_orphaned_reg_installations ()
|
|
|
|
{
|
|
|
|
handle_reg_installation (DELETE_KEY);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unfortunately neither mingw nor Windows know this function. */
|
|
|
|
char *
|
|
|
|
memmem (char *haystack, size_t haystacklen,
|
2011-12-18 07:39:47 +08:00
|
|
|
const char *needle, size_t needlelen)
|
2009-10-31 21:26:37 +08:00
|
|
|
{
|
|
|
|
if (needlelen == 0)
|
|
|
|
return haystack;
|
|
|
|
while (needlelen <= haystacklen)
|
|
|
|
{
|
|
|
|
if (!memcmp (haystack, needle, needlelen))
|
2011-12-18 07:39:47 +08:00
|
|
|
return haystack;
|
2009-10-31 21:26:37 +08:00
|
|
|
haystack++;
|
|
|
|
haystacklen--;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-12-18 07:39:47 +08:00
|
|
|
|
2013-11-20 06:26:37 +08:00
|
|
|
extern "C" NTSTATUS NTAPI RtlGetVersion (PRTL_OSVERSIONINFOEXW);
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static void
|
2000-02-18 03:38:33 +08:00
|
|
|
dump_sysinfo ()
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
char tmp[4000];
|
|
|
|
time_t now;
|
2000-06-25 11:18:54 +08:00
|
|
|
char *found_cygwin_dll;
|
2005-05-23 17:54:44 +08:00
|
|
|
bool is_nt = false;
|
2009-01-16 20:10:02 +08:00
|
|
|
char osname[128];
|
2009-01-30 03:31:04 +08:00
|
|
|
DWORD obcaseinsensitive = 1;
|
|
|
|
HKEY key;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-10-21 18:59:40 +08:00
|
|
|
/* MSVCRT popen (called by pretty_id and dump_sysinfo_services) SEGVs if
|
|
|
|
COMSPEC isn't set correctly. Simply enforce it here. Using
|
|
|
|
Get/SetEnvironmentVariable to set the dir does *not* help, btw.
|
|
|
|
Apparently MSVCRT keeps its own copy of the environment and changing
|
|
|
|
that requires to use _wputenv. */
|
|
|
|
if (!_wgetenv (L"COMSPEC"))
|
|
|
|
{
|
|
|
|
WCHAR comspec[MAX_PATH + 17];
|
|
|
|
wcscpy (comspec, L"COMSPEC=");
|
|
|
|
GetSystemDirectoryW (comspec + 8, MAX_PATH);
|
|
|
|
wcsncat (comspec, L"\\cmd.exe", sizeof comspec);
|
|
|
|
_wputenv (comspec);
|
|
|
|
}
|
|
|
|
|
2004-03-22 01:58:14 +08:00
|
|
|
printf ("\nCygwin Configuration Diagnostics\n");
|
2000-02-18 03:38:33 +08:00
|
|
|
time (&now);
|
|
|
|
printf ("Current System Time: %s\n", ctime (&now));
|
|
|
|
|
2013-11-20 06:26:37 +08:00
|
|
|
RTL_OSVERSIONINFOEXW osversion;
|
|
|
|
osversion.dwOSVersionInfoSize = sizeof (RTL_OSVERSIONINFOEXW);
|
|
|
|
RtlGetVersion (&osversion);
|
2008-01-13 21:41:45 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
switch (osversion.dwPlatformId)
|
|
|
|
{
|
|
|
|
case VER_PLATFORM_WIN32_NT:
|
2005-05-23 17:54:44 +08:00
|
|
|
is_nt = true;
|
2015-08-31 03:34:24 +08:00
|
|
|
if (osversion.dwMajorVersion >= 6)
|
2008-01-13 21:41:45 +08:00
|
|
|
{
|
2013-11-20 06:26:37 +08:00
|
|
|
HMODULE k32 = GetModuleHandleW (L"kernel32.dll");
|
2008-01-13 21:41:45 +08:00
|
|
|
BOOL (WINAPI *GetProductInfo) (DWORD, DWORD, DWORD, DWORD, PDWORD) =
|
|
|
|
(BOOL (WINAPI *)(DWORD, DWORD, DWORD, DWORD, PDWORD))
|
|
|
|
GetProcAddress (k32, "GetProductInfo");
|
2015-08-31 03:34:24 +08:00
|
|
|
if (osversion.dwMajorVersion == 6)
|
|
|
|
switch (osversion.dwMinorVersion)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
strcpy (osname, osversion.wProductType == VER_NT_WORKSTATION
|
2023-02-09 21:41:12 +08:00
|
|
|
? "Vista" : "Server 2008");
|
2015-08-31 03:34:24 +08:00
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
strcpy (osname, osversion.wProductType == VER_NT_WORKSTATION
|
2023-02-09 21:41:12 +08:00
|
|
|
? "7" : "Server 2008 R2");
|
2015-08-31 03:34:24 +08:00
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
strcpy (osname, osversion.wProductType == VER_NT_WORKSTATION
|
2023-02-09 21:41:12 +08:00
|
|
|
? "8" : "Server 2012");
|
2015-08-31 03:34:24 +08:00
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
strcpy (osname, osversion.wProductType == VER_NT_WORKSTATION
|
2023-02-09 21:41:12 +08:00
|
|
|
? "8.1" : "Server 2012 R2");
|
2015-08-31 03:34:24 +08:00
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
default:
|
|
|
|
strcpy (osname, osversion.wProductType == VER_NT_WORKSTATION
|
2023-02-09 21:41:12 +08:00
|
|
|
? "10 Preview" : "Server 2016 Preview");
|
2015-08-31 03:34:24 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (osversion.dwMajorVersion == 10)
|
2012-10-09 20:47:40 +08:00
|
|
|
{
|
2021-10-22 00:33:35 +08:00
|
|
|
if (osversion.wProductType == VER_NT_WORKSTATION)
|
|
|
|
strcpy (osname, osversion.dwBuildNumber >= 22000 ? "11" : "10");
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (osversion.dwBuildNumber <= 14393)
|
2023-02-09 21:41:12 +08:00
|
|
|
strcpy (osname, "Server 2016");
|
2021-10-22 00:33:35 +08:00
|
|
|
else if (osversion.dwBuildNumber <= 17763)
|
2023-02-09 21:41:12 +08:00
|
|
|
strcpy (osname, "Server 2019");
|
2021-10-22 00:33:35 +08:00
|
|
|
else if (osversion.dwBuildNumber <= 20348)
|
2023-02-09 21:41:12 +08:00
|
|
|
strcpy (osname, "Server 2022");
|
2021-10-22 00:33:35 +08:00
|
|
|
else
|
2023-02-09 21:41:12 +08:00
|
|
|
strcpy (osname, "Server 20??");
|
2021-10-22 00:33:35 +08:00
|
|
|
}
|
2012-10-09 20:47:40 +08:00
|
|
|
}
|
2008-01-13 21:41:45 +08:00
|
|
|
DWORD prod;
|
|
|
|
if (GetProductInfo (osversion.dwMajorVersion,
|
|
|
|
osversion.dwMinorVersion,
|
|
|
|
osversion.wServicePackMajor,
|
|
|
|
osversion.wServicePackMinor,
|
|
|
|
&prod))
|
|
|
|
{
|
|
|
|
const char *products[] =
|
2011-12-18 07:39:47 +08:00
|
|
|
{
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x00000000 */ "",
|
|
|
|
/* 0x00000001 */ " Ultimate",
|
|
|
|
/* 0x00000002 */ " Home Basic",
|
|
|
|
/* 0x00000003 */ " Home Premium",
|
|
|
|
/* 0x00000004 */ " Enterprise",
|
|
|
|
/* 0x00000005 */ " Home Basic N",
|
|
|
|
/* 0x00000006 */ " Business",
|
|
|
|
/* 0x00000007 */ " Server Standard",
|
|
|
|
/* 0x00000008 */ " Server Datacenter",
|
|
|
|
/* 0x00000009 */ " Small Business Server",
|
|
|
|
/* 0x0000000a */ " Server Enterprise",
|
|
|
|
/* 0x0000000b */ " Starter",
|
|
|
|
/* 0x0000000c */ " Server Datacenter Core",
|
|
|
|
/* 0x0000000d */ " Server Standard Core",
|
|
|
|
/* 0x0000000e */ " Server Enterprise Core",
|
|
|
|
/* 0x0000000f */ " Server Enterprise for Itanium-based Systems",
|
2011-10-14 01:50:48 +08:00
|
|
|
/* 0x00000010 */ " Business N",
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x00000011 */ " Web Server",
|
|
|
|
/* 0x00000012 */ " HPC Edition",
|
|
|
|
/* 0x00000013 */ " Home Server",
|
|
|
|
/* 0x00000014 */ " Storage Server Express",
|
|
|
|
/* 0x00000015 */ " Storage Server Standard",
|
|
|
|
/* 0x00000016 */ " Storage Server Workgroup",
|
|
|
|
/* 0x00000017 */ " Storage Server Enterprise",
|
|
|
|
/* 0x00000018 */ " for Windows Essential Server Solutions",
|
2012-09-02 18:06:12 +08:00
|
|
|
/* 0x00000019 */ " Small Business Server Premium",
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x0000001a */ " Home Premium N",
|
|
|
|
/* 0x0000001b */ " Enterprise N",
|
|
|
|
/* 0x0000001c */ " Ultimate N",
|
|
|
|
/* 0x0000001d */ " Web Server Core",
|
|
|
|
/* 0x0000001e */ " Essential Business Server Management Server",
|
2013-11-19 18:43:10 +08:00
|
|
|
/* 0x0000001f */ " Essential Business Server Security Server",
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x00000020 */ " Essential Business Server Messaging Server",
|
|
|
|
/* 0x00000021 */ " Server Foundation",
|
2011-10-14 01:50:48 +08:00
|
|
|
/* 0x00000022 */ " Home Server 2011",
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x00000023 */ " without Hyper-V for Windows Essential Server Solutions",
|
|
|
|
/* 0x00000024 */ " Server Standard without Hyper-V",
|
|
|
|
/* 0x00000025 */ " Server Datacenter without Hyper-V",
|
|
|
|
/* 0x00000026 */ " Server Enterprise without Hyper-V",
|
|
|
|
/* 0x00000027 */ " Server Datacenter Core without Hyper-V",
|
|
|
|
/* 0x00000028 */ " Server Standard Core without Hyper-V",
|
|
|
|
/* 0x00000029 */ " Server Enterprise Core without Hyper-V",
|
|
|
|
/* 0x0000002a */ " Hyper-V Server",
|
2012-09-02 18:06:12 +08:00
|
|
|
/* 0x0000002b */ " Storage Server Express Core",
|
|
|
|
/* 0x0000002c */ " Storage Server Standard Core",
|
|
|
|
/* 0x0000002d */ " Storage Server Workgroup Core",
|
|
|
|
/* 0x0000002e */ " Storage Server Enterprise Core",
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x0000002f */ " Starter N",
|
|
|
|
/* 0x00000030 */ " Professional",
|
2009-11-27 18:01:50 +08:00
|
|
|
/* 0x00000031 */ " Professional N",
|
2013-11-19 18:43:10 +08:00
|
|
|
/* 0x00000032 */ " Small Business Server 2011 Essentials",
|
2012-09-02 18:06:12 +08:00
|
|
|
/* 0x00000033 */ " Server For SB Solutions",
|
|
|
|
/* 0x00000034 */ " Server Solutions Premium",
|
|
|
|
/* 0x00000035 */ " Server Solutions Premium Core",
|
|
|
|
/* 0x00000036 */ " Server For SB Solutions EM", /* per MSDN, 2012-09-01 */
|
|
|
|
/* 0x00000037 */ " Server For SB Solutions EM", /* per MSDN, 2012-09-01 */
|
2011-10-14 01:50:48 +08:00
|
|
|
/* 0x00000038 */ " Multipoint Server",
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x00000039 */ "",
|
|
|
|
/* 0x0000003a */ "",
|
2012-09-02 18:06:12 +08:00
|
|
|
/* 0x0000003b */ " Essential Server Solution Management",
|
|
|
|
/* 0x0000003c */ " Essential Server Solution Additional",
|
|
|
|
/* 0x0000003d */ " Essential Server Solution Management SVC",
|
|
|
|
/* 0x0000003e */ " Essential Server Solution Additional SVC",
|
|
|
|
/* 0x0000003f */ " Small Business Server Premium Core",
|
|
|
|
/* 0x00000040 */ " Server Hyper Core V",
|
2009-10-20 23:26:33 +08:00
|
|
|
/* 0x00000041 */ "",
|
|
|
|
/* 0x00000042 */ " Starter E",
|
|
|
|
/* 0x00000043 */ " Home Basic E",
|
|
|
|
/* 0x00000044 */ " Home Premium E",
|
|
|
|
/* 0x00000045 */ " Professional E",
|
|
|
|
/* 0x00000046 */ " Enterprise E",
|
2013-11-19 18:43:10 +08:00
|
|
|
/* 0x00000047 */ " Ultimate E",
|
2012-09-02 18:06:12 +08:00
|
|
|
/* 0x00000048 */ " Server Enterprise (Evaluation inst.)",
|
|
|
|
/* 0x00000049 */ "",
|
|
|
|
/* 0x0000004a */ "",
|
|
|
|
/* 0x0000004b */ "",
|
|
|
|
/* 0x0000004c */ " MultiPoint Server Standard",
|
|
|
|
/* 0x0000004d */ " MultiPoint Server Premium",
|
|
|
|
/* 0x0000004e */ "",
|
|
|
|
/* 0x0000004f */ " Server Standard (Evaluation inst.)",
|
|
|
|
/* 0x00000050 */ " Server Datacenter (Evaluation inst.)",
|
|
|
|
/* 0x00000051 */ "",
|
|
|
|
/* 0x00000052 */ "",
|
|
|
|
/* 0x00000053 */ "",
|
|
|
|
/* 0x00000054 */ " Enterprise N (Evaluation inst.)",
|
|
|
|
/* 0x00000055 */ "",
|
|
|
|
/* 0x00000056 */ "",
|
|
|
|
/* 0x00000057 */ "",
|
|
|
|
/* 0x00000058 */ "",
|
|
|
|
/* 0x00000059 */ "",
|
|
|
|
/* 0x0000005a */ "",
|
|
|
|
/* 0x0000005b */ "",
|
|
|
|
/* 0x0000005c */ "",
|
|
|
|
/* 0x0000005d */ "",
|
|
|
|
/* 0x0000005e */ "",
|
|
|
|
/* 0x0000005f */ " Storage Server Workgroup (Evaluation inst.)",
|
|
|
|
/* 0x00000060 */ " Storage Server Standard (Evaluation inst.)",
|
|
|
|
/* 0x00000061 */ "",
|
2015-08-31 03:34:24 +08:00
|
|
|
/* 0x00000062 */ " N",
|
|
|
|
/* 0x00000063 */ " China",
|
|
|
|
/* 0x00000064 */ " Single Language",
|
|
|
|
/* 0x00000065 */ " Home",
|
2012-09-02 18:06:12 +08:00
|
|
|
/* 0x00000066 */ "",
|
2015-08-31 03:46:58 +08:00
|
|
|
/* 0x00000067 */ " Professional with Media Center",
|
|
|
|
/* 0x00000068 */ " Mobile",
|
2015-08-31 03:34:24 +08:00
|
|
|
/* 0x00000069 */ "",
|
|
|
|
/* 0x0000006a */ "",
|
|
|
|
/* 0x0000006b */ "",
|
|
|
|
/* 0x0000006c */ "",
|
|
|
|
/* 0x0000006d */ "",
|
|
|
|
/* 0x0000006e */ "",
|
|
|
|
/* 0x0000006f */ "",
|
|
|
|
/* 0x00000070 */ "",
|
|
|
|
/* 0x00000071 */ "",
|
|
|
|
/* 0x00000072 */ "",
|
|
|
|
/* 0x00000073 */ "",
|
|
|
|
/* 0x00000074 */ "",
|
|
|
|
/* 0x00000075 */ "",
|
|
|
|
/* 0x00000076 */ "",
|
2023-02-08 05:19:33 +08:00
|
|
|
/* 0x00000077 */ " Team",
|
2015-08-31 03:34:24 +08:00
|
|
|
/* 0x00000078 */ "",
|
2015-08-31 03:46:58 +08:00
|
|
|
/* 0x00000079 */ " Education",
|
|
|
|
/* 0x0000007a */ " Education N",
|
2015-08-31 03:34:24 +08:00
|
|
|
/* 0x0000007b */ "",
|
|
|
|
/* 0x0000007c */ "",
|
2023-02-08 05:19:33 +08:00
|
|
|
/* 0x0000007d */ " Enterprise 2015 LTSB",
|
|
|
|
/* 0x0000007e */ " Enterprise 2015 LTSB N",
|
2015-08-31 03:34:24 +08:00
|
|
|
/* 0x0000007f */ "",
|
|
|
|
/* 0x00000080 */ "",
|
2023-02-08 05:19:33 +08:00
|
|
|
/* 0x00000081 */ " Enterprise 2015 LTSB Evaluation",
|
|
|
|
/* 0x00000082 */ " Enterprise 2015 LTSB N Evaluation",
|
|
|
|
/* 0x00000083 */ " IoT Core Commercial",
|
2015-08-31 03:34:24 +08:00
|
|
|
/* 0x00000084 */ "",
|
2015-08-31 03:46:58 +08:00
|
|
|
/* 0x00000085 */ " Mobile Enterprise",
|
2023-02-08 05:19:33 +08:00
|
|
|
/* 0x00000086 */ "",
|
|
|
|
/* 0x00000087 */ "",
|
|
|
|
/* 0x00000088 */ "",
|
|
|
|
/* 0x00000089 */ "",
|
|
|
|
/* 0x0000008a */ "",
|
|
|
|
/* 0x0000008b */ "",
|
|
|
|
/* 0x0000008c */ "",
|
|
|
|
/* 0x0000008d */ "",
|
|
|
|
/* 0x0000008e */ "",
|
|
|
|
/* 0x0000008f */ "",
|
|
|
|
/* 0x00000090 */ "",
|
|
|
|
/* 0x00000091 */ " Server Datacenter, Semi-Annual Channel (core installation)",
|
|
|
|
/* 0x00000092 */ " Server Standard, Semi-Annual Channel (core installation)",
|
|
|
|
/* 0x00000093 */ "",
|
|
|
|
/* 0x00000094 */ "",
|
|
|
|
/* 0x00000095 */ "",
|
|
|
|
/* 0x00000096 */ "",
|
|
|
|
/* 0x00000097 */ "",
|
|
|
|
/* 0x00000098 */ "",
|
|
|
|
/* 0x00000099 */ "",
|
|
|
|
/* 0x0000009a */ "",
|
|
|
|
/* 0x0000009b */ "",
|
|
|
|
/* 0x0000009c */ "",
|
|
|
|
/* 0x0000009d */ "",
|
|
|
|
/* 0x0000009e */ "",
|
|
|
|
/* 0x0000009f */ "",
|
|
|
|
/* 0x000000a0 */ "",
|
|
|
|
/* 0x000000a1 */ " Pro for Workstations",
|
|
|
|
/* 0x000000a2 */ " Pro for Workstations N",
|
|
|
|
/* 0x000000a3 */ "",
|
|
|
|
/* 0x000000a4 */ " Pro Education",
|
|
|
|
/* 0x000000a5 */ "",
|
|
|
|
/* 0x000000a6 */ "",
|
|
|
|
/* 0x000000a7 */ "",
|
|
|
|
/* 0x000000a8 */ "",
|
|
|
|
/* 0x000000a9 */ "",
|
|
|
|
/* 0x000000aa */ "",
|
|
|
|
/* 0x000000ab */ "",
|
|
|
|
/* 0x000000ac */ "",
|
|
|
|
/* 0x000000ad */ "",
|
|
|
|
/* 0x000000ae */ "",
|
|
|
|
/* 0x000000af */ " Enterprise for Virtual Desktops",
|
|
|
|
/* 0x000000b0 */ "",
|
|
|
|
/* 0x000000b1 */ "",
|
|
|
|
/* 0x000000b2 */ "",
|
|
|
|
/* 0x000000b3 */ "",
|
|
|
|
/* 0x000000b4 */ "",
|
|
|
|
/* 0x000000b5 */ "",
|
|
|
|
/* 0x000000b6 */ "",
|
|
|
|
/* 0x000000b7 */ "",
|
|
|
|
/* 0x000000b8 */ "",
|
|
|
|
/* 0x000000b9 */ "",
|
|
|
|
/* 0x000000ba */ "",
|
|
|
|
/* 0x000000bb */ "",
|
|
|
|
/* 0x000000bc */ " IoT Enterprise",
|
|
|
|
/* 0x000000bd */ "",
|
|
|
|
/* 0x000000be */ "",
|
|
|
|
/* 0x000000bf */ " IoT Enterprise LTSC",
|
2008-01-13 21:41:45 +08:00
|
|
|
};
|
|
|
|
if (prod == PRODUCT_UNLICENSED)
|
2011-12-18 07:39:47 +08:00
|
|
|
strcat (osname, "Unlicensed");
|
2023-02-09 21:41:12 +08:00
|
|
|
else if (prod > PRODUCT_IOTENTERPRISES)
|
2011-12-18 07:39:47 +08:00
|
|
|
strcat (osname, "");
|
2008-01-13 21:41:45 +08:00
|
|
|
else
|
2011-12-18 07:39:47 +08:00
|
|
|
strcat (osname, products[prod]);
|
2008-01-13 21:41:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
}
|
|
|
|
}
|
2001-11-10 01:18:36 +08:00
|
|
|
else
|
2008-01-13 21:41:45 +08:00
|
|
|
strcpy (osname, "NT");
|
2000-02-18 03:38:33 +08:00
|
|
|
break;
|
|
|
|
default:
|
2008-01-13 21:41:45 +08:00
|
|
|
strcpy (osname, "??");
|
2000-02-18 03:38:33 +08:00
|
|
|
break;
|
|
|
|
}
|
2013-11-20 06:26:37 +08:00
|
|
|
printf ("Windows %s Ver %lu.%lu Build %lu %ls\n", osname,
|
2001-11-13 05:55:39 +08:00
|
|
|
osversion.dwMajorVersion, osversion.dwMinorVersion,
|
|
|
|
osversion.dwPlatformId == VER_PLATFORM_WIN32_NT ?
|
2002-03-07 11:13:17 +08:00
|
|
|
osversion.dwBuildNumber : (osversion.dwBuildNumber & 0xffff),
|
2001-11-13 05:55:39 +08:00
|
|
|
osversion.dwPlatformId == VER_PLATFORM_WIN32_NT ?
|
2013-11-20 06:26:37 +08:00
|
|
|
osversion.szCSDVersion : L"");
|
2006-01-13 21:39:05 +08:00
|
|
|
|
2008-01-13 21:41:45 +08:00
|
|
|
if (osversion.dwPlatformId == VER_PLATFORM_WIN32s
|
|
|
|
|| osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
|
|
|
|
exit (EXIT_FAILURE);
|
2006-01-13 21:39:05 +08:00
|
|
|
|
2005-05-30 23:49:31 +08:00
|
|
|
if (GetSystemMetrics (SM_REMOTESESSION))
|
2006-01-13 21:39:05 +08:00
|
|
|
printf ("\nRunning in Terminal Service session\n");
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2006-01-13 21:39:05 +08:00
|
|
|
printf ("\nPath:");
|
2000-02-18 03:38:33 +08:00
|
|
|
char *s = getenv ("PATH"), *e;
|
2005-05-21 00:38:42 +08:00
|
|
|
if (!s)
|
|
|
|
puts ("");
|
|
|
|
else
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-05-21 00:38:42 +08:00
|
|
|
char sep = strchr (s, ';') ? ';' : ':';
|
|
|
|
int count_path_items = 0;
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
for (e = s; *e && *e != sep; e++);
|
|
|
|
if (e-s)
|
2013-04-23 17:44:36 +08:00
|
|
|
printf ("\t%.*s\n", (int) (e - s), s);
|
2005-05-21 00:38:42 +08:00
|
|
|
else
|
|
|
|
puts ("\t.");
|
|
|
|
count_path_items++;
|
|
|
|
if (!*e)
|
|
|
|
break;
|
|
|
|
s = e + 1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2003-03-01 11:38:19 +08:00
|
|
|
fflush (stdout);
|
|
|
|
|
2009-10-28 19:41:27 +08:00
|
|
|
pretty_id ();
|
2003-03-01 11:38:19 +08:00
|
|
|
|
2000-12-16 12:53:30 +08:00
|
|
|
if (!GetSystemDirectory (tmp, 4000))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("dump_sysinfo: GetSystemDirectory()");
|
2000-02-18 03:38:33 +08:00
|
|
|
printf ("\nSysDir: %s\n", tmp);
|
2000-12-16 12:53:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
GetWindowsDirectory (tmp, 4000);
|
|
|
|
printf ("WinDir: %s\n\n", tmp);
|
|
|
|
|
|
|
|
|
|
|
|
if (givehelp)
|
|
|
|
printf ("Here's some environment variables that may affect cygwin:\n");
|
|
|
|
for (i = 0; environ[i]; i++)
|
|
|
|
{
|
|
|
|
char *eq = strchr (environ[i], '=');
|
|
|
|
if (!eq)
|
|
|
|
continue;
|
|
|
|
/* int len = eq - environ[i]; */
|
|
|
|
for (j = 0; known_env_vars[j]; j++)
|
|
|
|
{
|
|
|
|
*eq = 0;
|
|
|
|
if (strcmp (environ[i], "PATH") == 0)
|
|
|
|
continue; /* we handle this one specially */
|
|
|
|
if (strcasecmp (environ[i], known_env_vars[j]) == 0)
|
2006-01-13 01:43:53 +08:00
|
|
|
printf ("%s = '%s'\n", environ[i], eq + 1);
|
2000-02-18 03:38:33 +08:00
|
|
|
*eq = '=';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf ("\n");
|
|
|
|
|
|
|
|
if (verbose)
|
|
|
|
{
|
|
|
|
if (givehelp)
|
|
|
|
printf ("Here's the rest of your environment variables:\n");
|
|
|
|
for (i = 0; environ[i]; i++)
|
|
|
|
{
|
|
|
|
int found = 0;
|
|
|
|
char *eq = strchr (environ[i], '=');
|
|
|
|
if (!eq)
|
|
|
|
continue;
|
|
|
|
/* int len = eq - environ[i]; */
|
|
|
|
for (j = 0; known_env_vars[j]; j++)
|
|
|
|
{
|
|
|
|
*eq = 0;
|
|
|
|
if (strcasecmp (environ[i], known_env_vars[j]) == 0)
|
|
|
|
found = 1;
|
|
|
|
*eq = '=';
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
{
|
|
|
|
*eq = 0;
|
2006-01-13 01:43:53 +08:00
|
|
|
printf ("%s = '%s'\n", environ[i], eq + 1);
|
2000-02-18 03:38:33 +08:00
|
|
|
*eq = '=';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf ("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (registry)
|
|
|
|
{
|
|
|
|
if (givehelp)
|
2009-01-17 19:59:16 +08:00
|
|
|
printf ("Scanning registry for keys with 'Cygwin' in them...\n");
|
|
|
|
scan_registry (0, HKEY_CURRENT_USER,
|
|
|
|
(char *) "HKEY_CURRENT_USER", 0, false);
|
|
|
|
scan_registry (0, HKEY_LOCAL_MACHINE,
|
|
|
|
(char *) "HKEY_LOCAL_MACHINE", 0, false);
|
2000-02-18 03:38:33 +08:00
|
|
|
printf ("\n");
|
|
|
|
}
|
|
|
|
else
|
2006-01-13 01:43:53 +08:00
|
|
|
printf ("Use '-r' to scan registry\n\n");
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2009-01-30 03:31:04 +08:00
|
|
|
if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
|
2011-12-18 07:39:47 +08:00
|
|
|
"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\kernel",
|
|
|
|
0, KEY_READ, &key) == ERROR_SUCCESS)
|
2009-01-30 03:31:04 +08:00
|
|
|
{
|
|
|
|
DWORD size;
|
|
|
|
RegQueryValueEx (key, "obcaseinsensitive", NULL, NULL,
|
2011-12-18 07:39:47 +08:00
|
|
|
(LPBYTE) &obcaseinsensitive, &size);
|
2009-01-30 03:31:04 +08:00
|
|
|
RegCloseKey (key);
|
|
|
|
}
|
2009-03-24 21:35:08 +08:00
|
|
|
printf ("obcaseinsensitive set to %lu\n\n", obcaseinsensitive);
|
2009-01-30 03:31:04 +08:00
|
|
|
|
2009-10-31 21:26:37 +08:00
|
|
|
print_reg_installations ();
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
if (givehelp)
|
|
|
|
{
|
|
|
|
printf ("Listing available drives...\n");
|
2004-10-21 08:06:37 +08:00
|
|
|
printf ("Drv Type Size Used Flags Name\n");
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2000-10-28 13:00:00 +08:00
|
|
|
int prev_mode =
|
|
|
|
SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
|
2000-02-18 03:38:33 +08:00
|
|
|
int drivemask = GetLogicalDrives ();
|
|
|
|
|
|
|
|
for (i = 0; i < 26; i++)
|
|
|
|
{
|
|
|
|
if (!(drivemask & (1 << i)))
|
|
|
|
continue;
|
|
|
|
char drive[4], name[200], fsname[200];
|
|
|
|
DWORD serno = 0, maxnamelen = 0, flags = 0;
|
2011-03-29 19:02:58 +08:00
|
|
|
name[0] = fsname[0] = 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
sprintf (drive, "%c:\\", i + 'a');
|
2004-10-25 23:49:36 +08:00
|
|
|
/* Report all errors, except if the Volume is ERROR_NOT_READY.
|
|
|
|
ERROR_NOT_READY is returned when removeable media drives are empty
|
|
|
|
(CD, floppy, etc.) */
|
2006-01-06 02:31:26 +08:00
|
|
|
if (!GetVolumeInformation (drive, name, sizeof (name), &serno,
|
|
|
|
&maxnamelen, &flags, fsname,
|
|
|
|
sizeof (fsname))
|
|
|
|
&& GetLastError () != ERROR_NOT_READY)
|
|
|
|
{
|
|
|
|
# define FMT "dump_sysinfo: GetVolumeInformation() for drive %c:"
|
|
|
|
char buf[sizeof (FMT)];
|
|
|
|
sprintf (buf, FMT, 'A' + i);
|
|
|
|
display_error (buf);
|
|
|
|
# undef FMT
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
int dtype = GetDriveType (drive);
|
|
|
|
char drive_type[4] = "unk";
|
|
|
|
switch (dtype)
|
|
|
|
{
|
|
|
|
case DRIVE_REMOVABLE:
|
|
|
|
strcpy (drive_type, "fd ");
|
|
|
|
break;
|
|
|
|
case DRIVE_FIXED:
|
|
|
|
strcpy (drive_type, "hd ");
|
|
|
|
break;
|
|
|
|
case DRIVE_REMOTE:
|
|
|
|
strcpy (drive_type, "net");
|
|
|
|
break;
|
|
|
|
case DRIVE_CDROM:
|
|
|
|
strcpy (drive_type, "cd ");
|
|
|
|
break;
|
|
|
|
case DRIVE_RAMDISK:
|
|
|
|
strcpy (drive_type, "ram");
|
|
|
|
break;
|
2000-12-16 12:53:30 +08:00
|
|
|
default:
|
|
|
|
strcpy (drive_type, "unk");
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
long capacity_mb = -1;
|
|
|
|
int percent_full = -1;
|
|
|
|
|
2013-11-19 18:43:10 +08:00
|
|
|
ULARGE_INTEGER free_me, free_bytes, total_bytes;
|
|
|
|
free_me.QuadPart = free_bytes.QuadPart = 0ULL;
|
|
|
|
total_bytes.QuadPart = 1ULL;
|
|
|
|
if (GetDiskFreeSpaceEx (drive, &free_me, &total_bytes, &free_bytes))
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2013-11-19 18:43:10 +08:00
|
|
|
capacity_mb = total_bytes.QuadPart / (1024L * 1024L);
|
|
|
|
percent_full = 100 - (int) ((100.0 * free_me.QuadPart)
|
|
|
|
/ total_bytes.QuadPart);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DWORD spc = 0, bps = 0, fc = 0, tc = 1;
|
|
|
|
if (GetDiskFreeSpace (drive, &spc, &bps, &fc, &tc))
|
|
|
|
{
|
|
|
|
capacity_mb = (spc * bps * tc) / (1024 * 1024);
|
|
|
|
percent_full = 100 - (int) ((100.0 * fc) / tc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printf ("%.2s %s %-6s ", drive, drive_type, fsname);
|
|
|
|
if (capacity_mb >= 0)
|
2004-10-21 08:06:37 +08:00
|
|
|
printf ("%7dMb %3d%% ", (int) capacity_mb, (int) percent_full);
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2004-10-21 08:06:37 +08:00
|
|
|
printf (" N/A N/A ");
|
2018-08-08 15:24:23 +08:00
|
|
|
printf ("%s %s %s %s %s %s %s %s\n",
|
2000-02-18 03:38:33 +08:00
|
|
|
flags & FS_CASE_IS_PRESERVED ? "CP" : " ",
|
|
|
|
flags & FS_CASE_SENSITIVE ? "CS" : " ",
|
|
|
|
flags & FS_UNICODE_STORED_ON_DISK ? "UN" : " ",
|
|
|
|
flags & FS_PERSISTENT_ACLS ? "PA" : " ",
|
|
|
|
flags & FS_FILE_COMPRESSION ? "FC" : " ",
|
|
|
|
flags & FS_VOL_IS_COMPRESSED ? "VC" : " ",
|
|
|
|
flags & FILE_VOLUME_QUOTAS ? "QU" : " ",
|
|
|
|
name);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetErrorMode (prev_mode);
|
|
|
|
if (givehelp)
|
|
|
|
{
|
2004-10-26 00:11:41 +08:00
|
|
|
puts ("\n"
|
2004-10-22 09:29:10 +08:00
|
|
|
"fd = floppy, hd = hard drive, cd = CD-ROM\n"
|
|
|
|
"net= Network Share, ram= RAM drive, unk= Unknown\n"
|
|
|
|
"CP = Case Preserving, CS = Case Sensitive, UN = Unicode\n"
|
|
|
|
"PA = Persistent ACLS, FC = File Compression, VC = Volume Compression");
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
printf ("\n");
|
|
|
|
|
2002-01-22 11:17:59 +08:00
|
|
|
unsigned ml_fsname = 4, ml_dir = 7, ml_type = 6;
|
2004-10-10 07:19:38 +08:00
|
|
|
bool ml_trailing = false;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2001-11-11 11:06:59 +08:00
|
|
|
struct mntent *mnt;
|
|
|
|
setmntent (0, 0);
|
|
|
|
while ((mnt = getmntent (0)))
|
|
|
|
{
|
2002-01-22 11:17:59 +08:00
|
|
|
unsigned n = (int) strlen (mnt->mnt_fsname);
|
2004-10-10 07:19:38 +08:00
|
|
|
ml_trailing |= (n > 1 && strchr ("\\/", mnt->mnt_fsname[n - 1]));
|
2001-11-11 11:06:59 +08:00
|
|
|
if (ml_fsname < n)
|
|
|
|
ml_fsname = n;
|
|
|
|
n = (int) strlen (mnt->mnt_dir);
|
2004-10-10 07:19:38 +08:00
|
|
|
ml_trailing |= (n > 1 && strchr ("\\/", mnt->mnt_dir[n - 1]));
|
2001-11-11 11:06:59 +08:00
|
|
|
if (ml_dir < n)
|
|
|
|
ml_dir = n;
|
|
|
|
}
|
|
|
|
|
2004-10-10 07:19:38 +08:00
|
|
|
if (ml_trailing)
|
|
|
|
puts ("Warning: Mount entries should not have a trailing (back)slash\n");
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
if (givehelp)
|
|
|
|
{
|
2000-10-28 13:00:00 +08:00
|
|
|
printf
|
|
|
|
("Mount entries: these map POSIX directories to your NT drives.\n");
|
|
|
|
printf ("%-*s %-*s %-*s %s\n", ml_fsname, "-NT-", ml_dir, "-POSIX-",
|
2000-02-18 03:38:33 +08:00
|
|
|
ml_type, "-Type-", "-Flags-");
|
|
|
|
}
|
|
|
|
|
|
|
|
setmntent (0, 0);
|
|
|
|
while ((mnt = getmntent (0)))
|
|
|
|
{
|
|
|
|
printf ("%-*s %-*s %-*s %s\n",
|
|
|
|
ml_fsname, mnt->mnt_fsname,
|
2000-10-28 13:00:00 +08:00
|
|
|
ml_dir, mnt->mnt_dir, ml_type, mnt->mnt_type, mnt->mnt_opts);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
printf ("\n");
|
|
|
|
|
|
|
|
if (givehelp)
|
2000-10-28 13:00:00 +08:00
|
|
|
printf
|
|
|
|
("Looking to see where common programs can be found, if at all...\n");
|
2000-02-18 03:38:33 +08:00
|
|
|
for (i = 0; common_apps[i].name; i++)
|
* cygcheck.cc (get_word, get_dword): Move to path.cc.
(LINK_EXTENSION): New macro.
(check_existence): New static function.
(find_on_path): Check for symbolic links if asked.
(dll_info): New error handling.
(track_down): Only call dll_info() for executables, display
an error for symlinks, and print magic number for others.
(find_app_on_path): New static function.
(cygcheck, dump_sysinfo): Call find_app_on_path() instead of
find_on_path().
* path.cc (cmp_shortcut_header): New static function.
(get_word, get_dword): Moved from cygcheck.cc.
(EXE_MAGIC, SHORTCUT_MAGIC, SYMLINK_COOKIE, SYMLINK_MAGIC): New
macros.
(is_exe, is_symlink, readlink): New functions.
* path.h (is_exe, is_symlink, readlink): Declare.
(get_word, get_dword): Ditto.
2006-10-06 01:24:13 +08:00
|
|
|
if (!find_app_on_path ((char *) common_apps[i].name, 1))
|
2000-10-28 13:00:00 +08:00
|
|
|
{
|
|
|
|
if (common_apps[i].missing_is_good)
|
|
|
|
printf ("Not Found: %s (good!)\n", common_apps[i].name);
|
|
|
|
else
|
|
|
|
printf ("Not Found: %s\n", common_apps[i].name);
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
printf ("\n");
|
|
|
|
|
|
|
|
if (givehelp)
|
2005-05-23 17:54:44 +08:00
|
|
|
printf ("Looking for various Cygwin DLLs... (-v gives version info)\n");
|
2004-10-27 09:28:07 +08:00
|
|
|
int cygwin_dll_count = 0;
|
2008-04-22 22:42:05 +08:00
|
|
|
char cygdll_path[32768];
|
2007-06-04 09:57:16 +08:00
|
|
|
for (pathlike *pth = paths; pth->dir; pth++)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2009-03-14 22:56:20 +08:00
|
|
|
WIN32_FIND_DATAW ffinfo;
|
2007-06-04 09:57:16 +08:00
|
|
|
sprintf (tmp, "%s*.*", pth->dir);
|
2009-03-14 22:56:20 +08:00
|
|
|
wide_path wpath (tmp);
|
|
|
|
HANDLE ff = FindFirstFileW (wpath, &ffinfo);
|
2000-02-18 03:38:33 +08:00
|
|
|
int found = (ff != INVALID_HANDLE_VALUE);
|
2000-06-25 11:18:54 +08:00
|
|
|
found_cygwin_dll = NULL;
|
2000-02-18 03:38:33 +08:00
|
|
|
while (found)
|
|
|
|
{
|
2009-03-14 22:56:20 +08:00
|
|
|
char f[FILENAME_MAX + 1];
|
|
|
|
wcstombs (f, ffinfo.cFileName, sizeof f);
|
2000-02-18 03:38:33 +08:00
|
|
|
if (strcasecmp (f + strlen (f) - 4, ".dll") == 0)
|
|
|
|
{
|
|
|
|
if (strncasecmp (f, "cyg", 3) == 0)
|
|
|
|
{
|
2007-06-04 09:57:16 +08:00
|
|
|
sprintf (tmp, "%s%s", pth->dir, f);
|
2000-06-25 11:18:54 +08:00
|
|
|
if (strcasecmp (f, "cygwin1.dll") == 0)
|
2004-10-27 09:28:07 +08:00
|
|
|
{
|
2008-04-22 22:42:05 +08:00
|
|
|
if (!cygwin_dll_count)
|
2011-12-18 07:39:47 +08:00
|
|
|
strcpy (cygdll_path, pth->dir);
|
2008-04-22 22:42:05 +08:00
|
|
|
if (!cygwin_dll_count
|
|
|
|
|| strcasecmp (cygdll_path, pth->dir) != 0)
|
|
|
|
cygwin_dll_count++;
|
2004-10-27 09:28:07 +08:00
|
|
|
found_cygwin_dll = strdup (tmp);
|
|
|
|
}
|
2000-06-25 11:18:54 +08:00
|
|
|
else
|
|
|
|
ls (tmp);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
}
|
2009-03-14 22:56:20 +08:00
|
|
|
found = FindNextFileW (ff, &ffinfo);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2000-06-25 11:18:54 +08:00
|
|
|
if (found_cygwin_dll)
|
|
|
|
{
|
|
|
|
ls (found_cygwin_dll);
|
|
|
|
free (found_cygwin_dll);
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
FindClose (ff);
|
|
|
|
}
|
2004-10-27 09:28:07 +08:00
|
|
|
if (cygwin_dll_count > 1)
|
|
|
|
puts ("Warning: There are multiple cygwin1.dlls on your path");
|
|
|
|
if (!cygwin_dll_count)
|
|
|
|
puts ("Warning: cygwin1.dll not found on your path");
|
2005-05-23 17:54:44 +08:00
|
|
|
|
2007-08-04 03:41:48 +08:00
|
|
|
dump_dodgy_apps (verbose);
|
|
|
|
|
2005-05-23 17:54:44 +08:00
|
|
|
if (is_nt)
|
|
|
|
dump_sysinfo_services ();
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2002-02-28 00:10:17 +08:00
|
|
|
static int
|
2000-09-29 19:20:53 +08:00
|
|
|
check_keys ()
|
|
|
|
{
|
2011-10-10 17:42:00 +08:00
|
|
|
HANDLE h = CreateFileW (L"CONIN$", GENERIC_READ | GENERIC_WRITE,
|
2000-10-28 13:00:00 +08:00
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
2000-09-29 19:20:53 +08:00
|
|
|
|
|
|
|
if (h == INVALID_HANDLE_VALUE || h == NULL)
|
2004-11-11 09:56:02 +08:00
|
|
|
return (display_error ("check_keys: Opening CONIN$"));
|
2000-09-29 19:20:53 +08:00
|
|
|
|
|
|
|
DWORD mode;
|
|
|
|
|
|
|
|
if (!GetConsoleMode (h, &mode))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("check_keys: GetConsoleMode()");
|
2000-09-29 19:20:53 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
mode &= ~ENABLE_PROCESSED_INPUT;
|
|
|
|
if (!SetConsoleMode (h, mode))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("check_keys: SetConsoleMode()");
|
2000-09-29 19:20:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
fputs ("\nThis key check works only in a console window,", stderr);
|
|
|
|
fputs (" _NOT_ in a terminal session!\n", stderr);
|
|
|
|
fputs ("Abort with Ctrl+C if in a terminal session.\n\n", stderr);
|
2006-01-13 01:43:53 +08:00
|
|
|
fputs ("Press 'q' to exit.\n", stderr);
|
2000-09-29 19:20:53 +08:00
|
|
|
|
|
|
|
INPUT_RECORD in, prev_in;
|
|
|
|
|
|
|
|
// Drop first <RETURN> key
|
2011-10-10 17:42:00 +08:00
|
|
|
ReadConsoleInputW (h, &in, 1, &mode);
|
2000-09-29 19:20:53 +08:00
|
|
|
|
|
|
|
memset (&in, 0, sizeof in);
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
prev_in = in;
|
2011-10-10 17:42:00 +08:00
|
|
|
if (!ReadConsoleInputW (h, &in, 1, &mode))
|
2004-11-11 09:56:02 +08:00
|
|
|
display_error ("check_keys: ReadConsoleInput()");
|
2000-09-29 19:20:53 +08:00
|
|
|
|
|
|
|
if (!memcmp (&in, &prev_in, sizeof in))
|
2000-10-28 13:00:00 +08:00
|
|
|
continue;
|
2000-09-29 19:20:53 +08:00
|
|
|
|
|
|
|
switch (in.EventType)
|
2000-10-28 13:00:00 +08:00
|
|
|
{
|
|
|
|
case KEY_EVENT:
|
2011-10-10 17:42:00 +08:00
|
|
|
printf ("%s %ux VK: 0x%04x VS: 0x%04x C: 0x%04x CTRL: ",
|
2000-10-28 13:00:00 +08:00
|
|
|
in.Event.KeyEvent.bKeyDown ? "Pressed " : "Released",
|
|
|
|
in.Event.KeyEvent.wRepeatCount,
|
|
|
|
in.Event.KeyEvent.wVirtualKeyCode,
|
|
|
|
in.Event.KeyEvent.wVirtualScanCode,
|
2011-10-10 17:42:00 +08:00
|
|
|
(unsigned char) in.Event.KeyEvent.uChar.UnicodeChar);
|
2000-10-28 13:00:00 +08:00
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & CAPSLOCK_ON ?
|
|
|
|
"CL " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY ?
|
|
|
|
"EK " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & LEFT_ALT_PRESSED ?
|
|
|
|
"LA " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & LEFT_CTRL_PRESSED ?
|
|
|
|
"LC " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & NUMLOCK_ON ?
|
|
|
|
"NL " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & RIGHT_ALT_PRESSED ?
|
|
|
|
"RA " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & RIGHT_CTRL_PRESSED ?
|
|
|
|
"RC " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & SCROLLLOCK_ON ?
|
|
|
|
"SL " : "-- ", stdout);
|
|
|
|
fputs (in.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED ?
|
|
|
|
"SH " : "-- ", stdout);
|
|
|
|
fputc ('\n', stdout);
|
|
|
|
break;
|
|
|
|
|
2000-12-16 12:53:30 +08:00
|
|
|
default:
|
|
|
|
break;
|
2000-10-28 13:00:00 +08:00
|
|
|
}
|
2000-09-29 19:20:53 +08:00
|
|
|
}
|
|
|
|
while (in.EventType != KEY_EVENT ||
|
2000-10-28 13:00:00 +08:00
|
|
|
in.Event.KeyEvent.bKeyDown != FALSE ||
|
2011-10-10 17:42:00 +08:00
|
|
|
in.Event.KeyEvent.uChar.UnicodeChar != L'q');
|
2000-09-29 19:20:53 +08:00
|
|
|
|
|
|
|
CloseHandle (h);
|
|
|
|
return 0;
|
|
|
|
}
|
2000-10-28 13:00:00 +08:00
|
|
|
|
2017-01-30 23:04:28 +08:00
|
|
|
/* These do not need to be escaped in application/x-www-form-urlencoded */
|
|
|
|
static const char safe_chars[] = "$-_.!*'(),";
|
2005-11-23 01:19:17 +08:00
|
|
|
|
|
|
|
/* the URL to query. */
|
2023-01-27 02:58:24 +08:00
|
|
|
static const char grep_base_url[] =
|
2007-06-04 09:57:16 +08:00
|
|
|
"http://cygwin.com/cgi-bin2/package-grep.cgi?text=1&grep=";
|
2005-11-23 01:19:17 +08:00
|
|
|
|
2016-10-23 21:57:40 +08:00
|
|
|
#ifdef __x86_64__
|
|
|
|
#define ARCH_STR "&arch=x86_64"
|
|
|
|
#else
|
2022-10-28 17:37:02 +08:00
|
|
|
#error unimplemented for this target
|
2016-10-23 21:57:40 +08:00
|
|
|
#endif
|
|
|
|
static const char *ARCH_str = ARCH_STR;
|
|
|
|
|
2005-11-23 01:19:17 +08:00
|
|
|
static int
|
2023-01-27 02:58:24 +08:00
|
|
|
fetch_url (const char *url, FILE *outstream)
|
2005-11-23 01:19:17 +08:00
|
|
|
{
|
2023-01-27 02:58:24 +08:00
|
|
|
DWORD rc = 0, rc_s = sizeof (DWORD);
|
|
|
|
HINTERNET hi = NULL, hurl = NULL;
|
|
|
|
char buf[4096];
|
|
|
|
DWORD numread;
|
2023-01-30 03:35:45 +08:00
|
|
|
int ret;
|
2005-11-23 01:19:17 +08:00
|
|
|
|
|
|
|
/* Connect to the net and open the URL. */
|
2013-11-19 19:14:36 +08:00
|
|
|
if (InternetAttemptConnect (0) != ERROR_SUCCESS)
|
2005-11-23 01:19:17 +08:00
|
|
|
{
|
|
|
|
fputs ("An internet connection is required for this function.\n", stderr);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize WinInet and attempt to fetch our URL. */
|
2016-10-23 21:57:40 +08:00
|
|
|
if (!(hi = InternetOpenA ("cygcheck", INTERNET_OPEN_TYPE_PRECONFIG,
|
|
|
|
NULL, NULL, 0)))
|
2005-11-23 01:19:17 +08:00
|
|
|
return display_internet_error ("InternetOpen() failed", NULL);
|
|
|
|
|
2013-11-19 19:14:36 +08:00
|
|
|
if (!(hurl = InternetOpenUrlA (hi, url, NULL, 0, 0, 0)))
|
2023-01-30 03:35:45 +08:00
|
|
|
{
|
|
|
|
ret = display_internet_error ("unable to contact cygwin.com site, "
|
|
|
|
"InternetOpenUrl() failed", hi, NULL);
|
|
|
|
goto out_open;
|
|
|
|
}
|
2005-11-23 01:19:17 +08:00
|
|
|
|
|
|
|
/* Check the HTTP response code. */
|
2013-11-19 19:14:36 +08:00
|
|
|
if (!HttpQueryInfoA (hurl, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
|
2007-06-04 09:57:16 +08:00
|
|
|
(void *) &rc, &rc_s, NULL))
|
2023-01-30 03:35:45 +08:00
|
|
|
{
|
|
|
|
ret = display_internet_error ("HttpQueryInfo() failed", hurl, hi, NULL);
|
|
|
|
goto out_open_url;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc != HTTP_STATUS_OK)
|
|
|
|
{
|
|
|
|
sprintf (buf, "error retrieving results from cygwin.com site, "
|
|
|
|
"HTTP status code %lu", rc);
|
|
|
|
ret = display_internet_error (buf, hurl, hi, NULL);
|
|
|
|
goto out_open_url;
|
|
|
|
}
|
2005-11-23 01:19:17 +08:00
|
|
|
|
2023-01-27 02:58:24 +08:00
|
|
|
/* Fetch result and print to outstream. */
|
2005-11-23 01:19:17 +08:00
|
|
|
do
|
|
|
|
{
|
2013-11-19 19:14:36 +08:00
|
|
|
if (!InternetReadFile (hurl, (void *) buf, sizeof (buf), &numread))
|
2023-01-30 03:35:45 +08:00
|
|
|
{
|
|
|
|
ret = display_internet_error ("InternetReadFile failed", hurl, hi,
|
|
|
|
NULL);
|
|
|
|
goto out_open_url;
|
|
|
|
}
|
2005-11-23 01:19:17 +08:00
|
|
|
if (numread)
|
2023-01-27 02:58:24 +08:00
|
|
|
fwrite ((void *) buf, (size_t) numread, 1, outstream);
|
2005-11-23 01:19:17 +08:00
|
|
|
}
|
|
|
|
while (numread);
|
|
|
|
|
2023-01-30 03:35:45 +08:00
|
|
|
ret = 0;
|
2023-01-27 02:58:24 +08:00
|
|
|
|
2023-01-30 03:35:45 +08:00
|
|
|
out_open_url:
|
2013-11-19 19:14:36 +08:00
|
|
|
InternetCloseHandle (hurl);
|
2023-01-30 03:35:45 +08:00
|
|
|
out_open:
|
2013-11-19 19:14:36 +08:00
|
|
|
InternetCloseHandle (hi);
|
2023-01-30 03:35:45 +08:00
|
|
|
return ret;
|
2005-11-23 01:19:17 +08:00
|
|
|
}
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
struct passwd {
|
|
|
|
char *pw_name; /* user name */
|
|
|
|
char *pw_passwd; /* encrypted password */
|
|
|
|
uint32_t pw_uid; /* user uid */
|
|
|
|
uint32_t pw_gid; /* user gid */
|
|
|
|
char *pw_comment; /* comment */
|
|
|
|
char *pw_gecos; /* Honeywell login info */
|
|
|
|
char *pw_dir; /* home directory */
|
|
|
|
char *pw_shell; /* default shell */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Downloads setup.ini from cygwin.com, if it hasn't been downloaded
|
|
|
|
already or is older than 24h. */
|
|
|
|
static FILE *
|
|
|
|
maybe_download_setup_ini ()
|
|
|
|
{
|
2023-01-30 04:32:25 +08:00
|
|
|
time_t t3h_before;
|
2023-01-28 21:59:39 +08:00
|
|
|
char *path;
|
|
|
|
struct stat st;
|
|
|
|
FILE *fp;
|
|
|
|
|
2023-01-30 04:32:25 +08:00
|
|
|
t3h_before = time (NULL) - 3 * 60 * 60;
|
2023-01-28 21:59:39 +08:00
|
|
|
for (int i = 0; i < 2; ++i)
|
|
|
|
{
|
|
|
|
/* Check for the system-wide setup.ini file first. If that's too
|
|
|
|
old and not writable, check for ~/.setup.ini. */
|
|
|
|
if (i == 0)
|
|
|
|
path = cygpath ("/etc/setup/setup.ini", NULL);
|
|
|
|
else
|
|
|
|
{
|
2023-01-29 21:13:25 +08:00
|
|
|
char *localappdata = getenv ("LOCALAPPDATA");
|
|
|
|
char *cp;
|
2023-01-28 21:59:39 +08:00
|
|
|
|
2023-01-29 21:13:25 +08:00
|
|
|
if (!localappdata)
|
2023-01-28 21:59:39 +08:00
|
|
|
return NULL;
|
2023-01-29 21:13:25 +08:00
|
|
|
path = (char *) malloc (strlen (localappdata)
|
|
|
|
+ strlen ("\\.setup.ini") + 1);
|
|
|
|
cp = stpcpy (path, localappdata);
|
|
|
|
stpcpy (cp, "\\.setup.ini");
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
2023-01-30 04:32:25 +08:00
|
|
|
/* If file exists, and has been downloaded less than 3h ago,
|
2023-01-28 21:59:39 +08:00
|
|
|
and if we can open it for reading, just use it. */
|
|
|
|
if (stat (path, &st) == 0
|
2023-01-30 04:32:25 +08:00
|
|
|
&& st.st_mtime > t3h_before
|
2023-01-28 21:59:39 +08:00
|
|
|
&& (fp = fopen (path, "rt")) != NULL)
|
|
|
|
return fp;
|
|
|
|
/* Otherwise, try to open it for writing and fetch from cygwin.com. */
|
|
|
|
if ((fp = fopen (path, "w+")) != NULL)
|
|
|
|
{
|
2023-01-30 00:51:42 +08:00
|
|
|
fputs ("Fetching setup.ini from cygwin.com...\n", stderr);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (!fetch_url ("https://cygwin.com/ftp/cygwin/x86_64/setup.ini", fp))
|
|
|
|
{
|
|
|
|
fclose (fp);
|
|
|
|
fp = fopen (path, "rt");
|
2023-01-29 21:13:25 +08:00
|
|
|
fputs ("\n", stderr);
|
2023-01-28 21:59:39 +08:00
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
fclose (fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct vers_info
|
|
|
|
{
|
|
|
|
char *version;
|
|
|
|
char *install;
|
|
|
|
char *source;
|
|
|
|
char *depends2;
|
2023-02-08 05:49:38 +08:00
|
|
|
char *build_depends;
|
2023-01-29 21:13:25 +08:00
|
|
|
time_t install_date;
|
|
|
|
bool matches;
|
|
|
|
bool installed;
|
2023-01-28 21:59:39 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ini_package_info
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
char *sdesc;
|
|
|
|
char *ldesc;
|
|
|
|
char *category;
|
|
|
|
char *url;
|
|
|
|
char *license;
|
|
|
|
vers_info curr;
|
|
|
|
size_t prev_count;
|
|
|
|
vers_info *prev;
|
|
|
|
size_t test_count;
|
|
|
|
vers_info *test;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
free_pkg_info (ini_package_info *pi)
|
|
|
|
{
|
|
|
|
free (pi->name);
|
|
|
|
free (pi->sdesc);
|
|
|
|
free (pi->ldesc);
|
|
|
|
free (pi->category);
|
|
|
|
free (pi->url);
|
|
|
|
free (pi->license);
|
|
|
|
free (pi->curr.version);
|
|
|
|
free (pi->curr.install);
|
|
|
|
free (pi->curr.source);
|
|
|
|
free (pi->curr.depends2);
|
2023-02-08 05:49:38 +08:00
|
|
|
free (pi->curr.build_depends);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (pi->prev)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < pi->prev_count; ++i)
|
|
|
|
{
|
|
|
|
free (pi->prev[i].version);
|
|
|
|
free (pi->prev[i].install);
|
|
|
|
free (pi->prev[i].source);
|
|
|
|
free (pi->prev[i].depends2);
|
2023-02-08 05:49:38 +08:00
|
|
|
free (pi->prev[i].build_depends);
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
free (pi->prev);
|
|
|
|
}
|
|
|
|
if (pi->test)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < pi->test_count; ++i)
|
|
|
|
{
|
|
|
|
free (pi->test[i].version);
|
|
|
|
free (pi->test[i].install);
|
|
|
|
free (pi->test[i].source);
|
|
|
|
free (pi->test[i].depends2);
|
2023-02-08 05:49:38 +08:00
|
|
|
free (pi->test[i].build_depends);
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
free (pi->test);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
collect_quoted_string (char *&tgt, FILE *fp, char *buf, size_t size, size_t offset)
|
|
|
|
{
|
|
|
|
bool found = false;
|
|
|
|
char *cp, *s;
|
|
|
|
|
|
|
|
cp = buf + offset;
|
|
|
|
if (*cp != '"') /* just 'til end of line */
|
|
|
|
{
|
|
|
|
if ((s = strchr (cp, '\n')))
|
|
|
|
*s = '\0';
|
|
|
|
tgt = strdup (cp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* text starts with a quote, collect 'til the closing quote */
|
|
|
|
++cp;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if ((s = strrchr (cp, '"')) && (s == cp || s[-1] != '\\'))
|
|
|
|
{
|
|
|
|
*s = '\0';
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
if (!tgt)
|
|
|
|
s = (char *) calloc (strlen (cp) + 1, sizeof *s);
|
|
|
|
else
|
|
|
|
s = (char *) realloc (tgt, strlen (tgt) + strlen (cp) + 1);
|
|
|
|
if (s)
|
|
|
|
{
|
|
|
|
tgt = s;
|
|
|
|
strcat (tgt, cp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (!found && (cp = fgets (buf, size, fp)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ini_package_info *
|
2023-02-09 04:05:18 +08:00
|
|
|
collect_pkg_info (FILE *fp, ini_package_info *pi, bool search)
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
|
|
|
vers_info *vinfo = &pi->curr;
|
|
|
|
char buf[4096];
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
memset (pi, 0, sizeof *pi);
|
|
|
|
/* Search next line starting with "@ ". */
|
|
|
|
while ((s = fgets (buf, sizeof buf, fp)))
|
|
|
|
{
|
|
|
|
if (s[0] == '@' && s[1] == ' ')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!s)
|
|
|
|
goto error;
|
|
|
|
/* Extract package name */
|
|
|
|
if ((s = strchr (buf, '\n')))
|
|
|
|
*s = '\0';
|
|
|
|
pi->name = strdup (buf + 2);
|
|
|
|
/* collect all of this package block. */
|
|
|
|
while ((s = fgets (buf, sizeof buf, fp)))
|
|
|
|
{
|
|
|
|
/* empty line? EOR. */
|
|
|
|
if (s[0] == '\n')
|
|
|
|
break;
|
|
|
|
/* prev or test version? */
|
|
|
|
if (buf[0] == '[')
|
|
|
|
{
|
|
|
|
vers_info **vers_p = NULL;
|
|
|
|
size_t *vers_cnt_p = NULL;
|
|
|
|
|
|
|
|
if (!strncmp (buf, "[prev]", strlen ("[prev]")))
|
|
|
|
{
|
|
|
|
vers_p = &pi->prev;
|
|
|
|
vers_cnt_p = &pi->prev_count;
|
|
|
|
}
|
|
|
|
else if (!strncmp (buf, "[test]", strlen ("[test]")))
|
|
|
|
{
|
|
|
|
vers_p = &pi->test;
|
|
|
|
vers_cnt_p = &pi->test_count;
|
|
|
|
}
|
|
|
|
if (vers_p)
|
|
|
|
{
|
|
|
|
vers_info *v;
|
|
|
|
|
|
|
|
v = (vers_info *) realloc (*vers_p, (*vers_cnt_p + 1)
|
|
|
|
* sizeof (vers_info));
|
|
|
|
if (!v)
|
|
|
|
goto error;
|
|
|
|
*vers_p = v;
|
|
|
|
vinfo = *vers_p + *vers_cnt_p;
|
|
|
|
memset (vinfo, 0, sizeof *vinfo);
|
|
|
|
++(*vers_cnt_p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strncmp (buf, "sdesc: ", strlen ("sdesc: ")))
|
|
|
|
collect_quoted_string (pi->sdesc, fp, buf, sizeof buf,
|
|
|
|
strlen ("sdesc: "));
|
|
|
|
else if (!strncmp (buf, "ldesc: ", strlen ("ldesc: ")))
|
|
|
|
collect_quoted_string (pi->ldesc, fp, buf, sizeof buf,
|
|
|
|
strlen ("ldesc: "));
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((s = strchr (buf, '\n')))
|
|
|
|
*s = '\0';
|
|
|
|
if (!strncmp (buf, "category: ", strlen ("category: ")))
|
|
|
|
pi->category = strdup (buf + strlen ("category: "));
|
|
|
|
else if (!strncmp (buf, "url: ", strlen ("url: ")))
|
|
|
|
pi->url = strdup (buf + strlen ("url: "));
|
|
|
|
else if (!strncmp (buf, "license: ", strlen ("license: ")))
|
|
|
|
pi->license = strdup (buf + strlen ("license: "));
|
|
|
|
else if (!strncmp (buf, "version: ", strlen ("version: ")))
|
|
|
|
vinfo->version = strdup (buf + strlen ("version: "));
|
|
|
|
else if (!strncmp (buf, "install: ", strlen ("install: ")))
|
|
|
|
vinfo->install = strdup (buf + strlen ("install: "));
|
|
|
|
else if (!strncmp (buf, "source: ", strlen ("source: ")))
|
|
|
|
vinfo->source = strdup (buf + strlen ("source: "));
|
|
|
|
else if (!strncmp (buf, "depends2: ", strlen ("depends2: ")))
|
2023-02-09 04:05:18 +08:00
|
|
|
{
|
|
|
|
if (!search)
|
|
|
|
vinfo->depends2 = strdup (buf + strlen ("depends2: "));
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* For pattern matching we need a standarized format.
|
2023-02-11 19:53:34 +08:00
|
|
|
Make sure all deps are prepended and trailed by a comma.
|
|
|
|
Note the missing space after the colon, that's deliberate
|
|
|
|
to keep it in the stored string. Originally we kept the
|
|
|
|
spaces in, but spaces are filtered out by PathMatchSpecA,
|
|
|
|
so we now replace all space by comma here. */
|
2023-02-09 04:05:18 +08:00
|
|
|
char *start = buf + strlen ("depends2:");
|
|
|
|
size_t len = strlen (start);
|
|
|
|
|
|
|
|
vinfo->depends2 = (char *) calloc (len + 2, 1);
|
|
|
|
if (vinfo->depends2)
|
2023-02-11 19:53:34 +08:00
|
|
|
{
|
|
|
|
*stpcpy (vinfo->depends2, start) = ',';
|
|
|
|
char *cp = vinfo->depends2;
|
|
|
|
while ((cp = strchr (cp, ' ')))
|
|
|
|
*cp = ',';
|
|
|
|
}
|
2023-02-09 04:05:18 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strncmp (buf, "build-depends: ",
|
|
|
|
strlen ("build-depends: ")))
|
|
|
|
{
|
|
|
|
if (!search)
|
|
|
|
vinfo->build_depends = strdup (buf
|
|
|
|
+ strlen ("build-depends: "));
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Ditto */
|
|
|
|
char *start = buf + strlen ("build-depends:");
|
|
|
|
size_t len = strlen (start);
|
|
|
|
|
|
|
|
vinfo->build_depends = (char *) calloc (len + 2, 1);
|
|
|
|
if (vinfo->build_depends)
|
2023-02-11 19:53:34 +08:00
|
|
|
{
|
|
|
|
*stpcpy (vinfo->build_depends, start) = ',';
|
|
|
|
char *cp = vinfo->build_depends;
|
|
|
|
while ((cp = strchr (cp, ' ')))
|
|
|
|
*cp++ = ',';
|
|
|
|
}
|
2023-02-09 04:05:18 +08:00
|
|
|
}
|
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return pi;
|
|
|
|
error:
|
|
|
|
free_pkg_info (pi);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2023-01-30 00:21:28 +08:00
|
|
|
static const char *
|
|
|
|
human_readable (char *buf, size_t bytes)
|
|
|
|
{
|
|
|
|
const char *siz[] = { "B", "K", "M", "G", NULL };
|
|
|
|
double db = bytes;
|
|
|
|
int idx = 0;
|
|
|
|
int prec;
|
|
|
|
|
|
|
|
while (bytes > 1023 && siz[idx + 1])
|
|
|
|
{
|
|
|
|
bytes >>= 10;
|
|
|
|
db /= 1024.0;
|
|
|
|
++idx;
|
|
|
|
}
|
|
|
|
prec = log10 (db) + 1;
|
|
|
|
if (prec < 2)
|
|
|
|
prec = 2;
|
|
|
|
sprintf (buf, "%.*g %s", prec, db, siz[idx]);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
static void
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (ini_package_info *pi, vers_info *vers, int selector)
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
|
|
|
char buf[4096];
|
|
|
|
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Name : %s\n", pi->name);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (vers->version)
|
|
|
|
{
|
|
|
|
char *version = strcpy (buf, vers->version);
|
|
|
|
char *release = NULL;
|
|
|
|
|
|
|
|
release = strrchr (version, '-');
|
|
|
|
if (release)
|
|
|
|
*release++ = '\0';
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Version : %s\n", version);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (release)
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Release : %s\n", release);
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
if (vers->install)
|
|
|
|
{
|
|
|
|
char *arch = strcpy (buf, vers->install);
|
2023-01-30 00:21:28 +08:00
|
|
|
char *sizep;
|
|
|
|
size_t size = 0;
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
char *cp;
|
|
|
|
|
|
|
|
cp = strchr (arch, '/');
|
|
|
|
if (cp)
|
|
|
|
{
|
|
|
|
*cp++ = '\0';
|
|
|
|
cp = strchr (cp, ' ');
|
|
|
|
if (cp)
|
|
|
|
{
|
2023-01-30 00:21:28 +08:00
|
|
|
sizep = ++cp;
|
2023-01-28 21:59:39 +08:00
|
|
|
cp = strchr (cp, ' ');
|
|
|
|
if (cp)
|
2023-01-30 00:21:28 +08:00
|
|
|
{
|
|
|
|
*cp = '\0';
|
|
|
|
size = strtoull (sizep, NULL, 10);
|
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (cp)
|
|
|
|
{
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Architecture: %s\n", arch);
|
|
|
|
if (vers->install_date)
|
|
|
|
printf ("Install Date: %s", ctime (&vers->install_date));
|
2023-01-30 00:21:28 +08:00
|
|
|
|
|
|
|
printf ("Size : %llu (%s)\n", size,
|
|
|
|
human_readable (buf, size));
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
}
|
2023-02-09 03:43:15 +08:00
|
|
|
if (pi->category)
|
|
|
|
printf ("Categories : %s\n", pi->category);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (vers->source)
|
|
|
|
{
|
|
|
|
char *source = strcpy (buf, vers->source);
|
|
|
|
char *cp = strchr (source, ' ');
|
|
|
|
if (cp)
|
|
|
|
{
|
|
|
|
*cp = '\0';
|
|
|
|
cp = strrchr (source, '/');
|
|
|
|
if (cp)
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Source : %s\n", cp + 1);
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
}
|
2023-02-09 04:05:18 +08:00
|
|
|
if ((selector & INFO_DEPS) && vers->depends2)
|
2023-02-08 05:49:38 +08:00
|
|
|
printf ("Dependencies: %s\n", vers->depends2);
|
2023-02-09 04:05:18 +08:00
|
|
|
if ((selector & INFO_BLDDEPS) && vers->build_depends)
|
2023-02-08 05:49:38 +08:00
|
|
|
printf ("Build Deps : %s\n", vers->build_depends);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (pi->sdesc)
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Summary : %s\n", pi->sdesc);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (pi->url)
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Url : %s\n", pi->url);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (pi->license)
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("License : %s\n", pi->license);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (pi->ldesc)
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Description :\n%s\n", pi->ldesc);
|
|
|
|
puts ("");
|
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
|
2023-01-29 21:13:25 +08:00
|
|
|
static void
|
|
|
|
package_info_check (ini_package_info *pi, vers_info *vi, pkgver *pv,
|
|
|
|
bool &am, bool &ai)
|
|
|
|
{
|
|
|
|
vi->matches = true;
|
|
|
|
if (pv && !strcmp (vi->version, pv->ver))
|
|
|
|
vi->installed = true;
|
|
|
|
am |= vi->matches;
|
|
|
|
ai |= vi->installed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
check_name_version (char *pkg_name, char *pkg_version, char *search)
|
|
|
|
{
|
|
|
|
char nv_buf[4096];
|
|
|
|
char *nvp, *cp;
|
|
|
|
|
|
|
|
nvp = stpcpy (nv_buf, pkg_name);
|
|
|
|
*nvp++ = '-';
|
|
|
|
stpcpy (nvp, pkg_version);
|
|
|
|
if (PathMatchSpecA (nv_buf, search))
|
|
|
|
return true;
|
|
|
|
if ((cp = strrchr (nvp, '-'))) /* try w/o release */
|
|
|
|
{
|
|
|
|
*cp = '\0';
|
|
|
|
if (PathMatchSpecA (nv_buf, search))
|
|
|
|
return true;
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
2023-01-29 21:13:25 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
package_info_vers_check (ini_package_info *pi, vers_info *vi, char *search,
|
|
|
|
pkgver *pv, bool &am, bool &ai)
|
|
|
|
{
|
|
|
|
vi->matches = check_name_version (pi->name, vi->version, search);
|
|
|
|
if (pv && !strcmp (vi->version, pv->ver))
|
|
|
|
vi->installed = true;
|
|
|
|
am |= vi->matches;
|
|
|
|
ai |= vi->installed;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
pkg_comp (const void *a, const void *b)
|
|
|
|
{
|
|
|
|
pkgver *pa = (pkgver *) a;
|
|
|
|
pkgver *pb = (pkgver *) b;
|
|
|
|
|
|
|
|
return strcmp (pa->name, pb->name);
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Print full info for the package matching the search string in terms of
|
|
|
|
name/version. */
|
|
|
|
static int
|
2023-01-29 21:13:25 +08:00
|
|
|
package_info (char **search, int selector)
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
|
|
|
FILE *fp = maybe_download_setup_ini ();
|
|
|
|
ini_package_info pi_buf, *pi;
|
2023-01-29 21:13:25 +08:00
|
|
|
size_t inst_pkg_count;
|
|
|
|
pkgver *inst_pkgs;
|
2023-01-28 21:59:39 +08:00
|
|
|
|
|
|
|
if (!fp)
|
|
|
|
return 1;
|
|
|
|
|
2023-02-09 04:05:18 +08:00
|
|
|
if ((selector & INFO_ALL) == 0)
|
2023-02-11 19:58:13 +08:00
|
|
|
selector |= INFO_ALL;
|
2023-01-29 21:13:25 +08:00
|
|
|
|
|
|
|
inst_pkgs = get_installed_packages (NULL, &inst_pkg_count);
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
while (search && *search)
|
|
|
|
{
|
|
|
|
rewind (fp);
|
2023-02-09 04:05:18 +08:00
|
|
|
while ((pi = collect_pkg_info (fp, &pi_buf, false)))
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
2023-01-29 21:13:25 +08:00
|
|
|
pkgver pv = { pi->name, NULL }, *inst_pkg = NULL;
|
|
|
|
bool avail_installed = false;
|
|
|
|
bool avail_matches = false;
|
|
|
|
bool inst_matches = false;
|
|
|
|
|
|
|
|
if (selector & INFO_INST)
|
|
|
|
{
|
|
|
|
inst_pkg = (pkgver *) bsearch (&pv, inst_pkgs, inst_pkg_count,
|
|
|
|
sizeof *inst_pkgs, pkg_comp);
|
|
|
|
if (inst_pkg)
|
|
|
|
{
|
|
|
|
if (PathMatchSpecA (inst_pkg->name, *search))
|
|
|
|
inst_matches = true;
|
|
|
|
else
|
|
|
|
inst_matches = check_name_version (inst_pkg->name,
|
|
|
|
inst_pkg->ver,
|
|
|
|
*search);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
/* Name matches? Print all versions */
|
|
|
|
if (PathMatchSpecA (pi->name, *search))
|
|
|
|
{
|
|
|
|
if (pi->curr.version)
|
2023-01-29 21:13:25 +08:00
|
|
|
package_info_check (pi, &pi->curr, inst_pkg,
|
|
|
|
avail_matches, avail_installed);
|
2023-01-28 21:59:39 +08:00
|
|
|
for (size_t i = 0; i < pi->prev_count; ++i)
|
2023-01-29 21:13:25 +08:00
|
|
|
package_info_check (pi, pi->prev + i, inst_pkg,
|
|
|
|
avail_matches, avail_installed);
|
2023-01-28 21:59:39 +08:00
|
|
|
for (size_t i = 0; i < pi->test_count; ++i)
|
2023-01-29 21:13:25 +08:00
|
|
|
package_info_check (pi, pi->test + i, inst_pkg,
|
|
|
|
avail_matches, avail_installed);
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Check if search matches name-version string */
|
2023-01-29 21:13:25 +08:00
|
|
|
if (pi->curr.version)
|
|
|
|
package_info_vers_check (pi, &pi->curr, *search, inst_pkg,
|
|
|
|
avail_matches, avail_installed);
|
|
|
|
for (size_t i = 0; i < pi->prev_count; ++i)
|
|
|
|
package_info_vers_check (pi, pi->prev + i, *search, inst_pkg,
|
|
|
|
avail_matches, avail_installed);
|
|
|
|
for (size_t i = 0; i < pi->test_count; ++i)
|
|
|
|
package_info_vers_check (pi, pi->test + i, *search, inst_pkg,
|
|
|
|
avail_matches, avail_installed);
|
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
|
2023-01-29 21:13:25 +08:00
|
|
|
/* First print installed package(s) */
|
|
|
|
if (inst_pkg && inst_matches)
|
|
|
|
{
|
|
|
|
time_t install_ts = 0;
|
|
|
|
struct stat st;
|
|
|
|
char *path;
|
2023-01-28 21:59:39 +08:00
|
|
|
|
2023-01-29 21:13:25 +08:00
|
|
|
printf ("Installed package:\n"
|
|
|
|
"------------------\n\n");
|
|
|
|
/* fetch timestamp of last install. */
|
|
|
|
|
|
|
|
path = cygpath ("/etc/setup/", inst_pkg->name, ".lst.gz", NULL);
|
|
|
|
if (path)
|
|
|
|
{
|
|
|
|
if (stat (path, &st) == 0)
|
|
|
|
install_ts = st.st_mtime;
|
|
|
|
free (path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fake min info if installed package is not available anymore */
|
|
|
|
if (!avail_installed)
|
|
|
|
{
|
|
|
|
ini_package_info inst_pi = { 0 };
|
|
|
|
|
|
|
|
inst_pi.name = inst_pkg->name;
|
|
|
|
inst_pi.sdesc = pi->sdesc;
|
|
|
|
inst_pi.ldesc = pi->ldesc;
|
|
|
|
inst_pi.url = pi->url;
|
|
|
|
inst_pi.license = pi->license;
|
|
|
|
inst_pi.curr.version = inst_pkg->ver;
|
|
|
|
inst_pi.curr.install_date = install_ts;
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (&inst_pi, &pi->curr, selector);
|
2023-01-29 21:13:25 +08:00
|
|
|
}
|
|
|
|
else
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
2023-01-29 21:13:25 +08:00
|
|
|
if (pi->curr.installed)
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
2023-01-29 21:13:25 +08:00
|
|
|
pi->curr.install_date = install_ts;
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (pi, &pi->curr, selector);
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
2023-01-29 21:13:25 +08:00
|
|
|
for (size_t i = 0; i < pi->prev_count; ++i)
|
|
|
|
if (pi->prev[i].installed)
|
|
|
|
{
|
|
|
|
pi->prev[i].install_date = install_ts;
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (pi, pi->prev + i, selector);
|
2023-01-29 21:13:25 +08:00
|
|
|
}
|
|
|
|
for (size_t i = 0; i < pi->test_count; ++i)
|
|
|
|
if (pi->test[i].installed)
|
|
|
|
{
|
|
|
|
pi->test[i].install_date = install_ts;
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (pi, pi->test + i, selector);
|
2023-01-29 21:13:25 +08:00
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
2023-01-29 21:13:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Next print available, matching packages */
|
|
|
|
if (avail_matches)
|
|
|
|
{
|
|
|
|
if ((selector & INFO_CURR) && pi->curr.matches)
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
2023-01-29 21:13:25 +08:00
|
|
|
puts ("Latest available package:\n"
|
|
|
|
"-------------------------\n");
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (pi, &pi->curr, selector);
|
2023-01-29 21:13:25 +08:00
|
|
|
}
|
|
|
|
if (selector & INFO_PREV)
|
|
|
|
{
|
|
|
|
uint32_t header_printed = 0;
|
|
|
|
|
|
|
|
for (size_t i = 0; i < pi->prev_count; ++i)
|
|
|
|
if (pi->prev[i].matches)
|
|
|
|
{
|
|
|
|
printf ("%s", header_printed++
|
|
|
|
? ""
|
|
|
|
: "Older available packages:\n"
|
|
|
|
"-------------------------\n\n");
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (pi, pi->prev + i, selector);
|
2023-01-29 21:13:25 +08:00
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
2023-01-29 21:13:25 +08:00
|
|
|
if (selector & INFO_TEST)
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
2023-01-29 21:13:25 +08:00
|
|
|
uint32_t header_printed = 0;
|
|
|
|
|
|
|
|
for (size_t i = 0; i < pi->test_count; ++i)
|
|
|
|
if (pi->test[i].matches)
|
|
|
|
{
|
|
|
|
printf ("%s", header_printed++
|
|
|
|
? ""
|
|
|
|
: "Available test packages:\n"
|
|
|
|
"------------------------\n\n");
|
2023-02-09 04:05:18 +08:00
|
|
|
package_info_print (pi, pi->test + i, selector);
|
2023-01-29 21:13:25 +08:00
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
}
|
|
|
|
}
|
2023-01-29 21:13:25 +08:00
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
free_pkg_info (&pi_buf);
|
|
|
|
}
|
|
|
|
++search;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-02-09 04:05:18 +08:00
|
|
|
/* Search for the search string in name and sdesc of available packages.
|
|
|
|
The selector is used to search for dependencies. */
|
2023-01-28 21:59:39 +08:00
|
|
|
static int
|
2023-02-09 04:05:18 +08:00
|
|
|
package_search (char **search, int selector)
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
|
|
|
FILE *fp = maybe_download_setup_ini ();
|
|
|
|
ini_package_info pi_buf, *pi;
|
|
|
|
char *ext_search, *ep;
|
|
|
|
|
|
|
|
if (!fp)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
while (search && *search)
|
|
|
|
{
|
2023-02-09 04:05:18 +08:00
|
|
|
rewind (fp);
|
|
|
|
|
|
|
|
ext_search = (char *) malloc (strlen (*search) + 5);
|
2023-01-28 21:59:39 +08:00
|
|
|
ep = ext_search;
|
2023-02-09 04:05:18 +08:00
|
|
|
if (selector)
|
|
|
|
{
|
2023-02-11 19:53:34 +08:00
|
|
|
ep = stpcpy (ep, "*,");
|
2023-02-09 04:05:18 +08:00
|
|
|
ep = stpcpy (ep, *search);
|
|
|
|
ep = stpcpy (ep, ",*");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (*(search)[0] != '*')
|
|
|
|
*ep++ = '*';
|
|
|
|
ep = stpcpy (ep, *search);
|
|
|
|
if (ep[-1] != '*')
|
|
|
|
stpcpy (ep, "*");
|
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
|
2023-02-09 04:05:18 +08:00
|
|
|
while ((pi = collect_pkg_info (fp, &pi_buf, true)))
|
2023-01-28 21:59:39 +08:00
|
|
|
{
|
2023-02-09 04:05:18 +08:00
|
|
|
/* Skip debuginfo packages */
|
|
|
|
if (PathMatchSpecA (pi->name, "*-debuginfo"))
|
|
|
|
continue;
|
|
|
|
if (selector)
|
|
|
|
{
|
|
|
|
/* search only curr version info for the dependency */
|
|
|
|
if (((selector & SRCH_REQS) && pi->curr.depends2
|
|
|
|
&& PathMatchSpecA (pi->curr.depends2, ext_search))
|
|
|
|
|| ((selector & SRCH_BLDREQS) && pi->curr.build_depends
|
|
|
|
&& PathMatchSpecA (pi->curr.build_depends, ext_search)))
|
|
|
|
printf ("%s : %s\n", pi->name, pi->sdesc);
|
|
|
|
}
|
|
|
|
else if (PathMatchSpecA (pi->name, ext_search)
|
2023-01-28 21:59:39 +08:00
|
|
|
|| (pi->sdesc && PathMatchSpecA (pi->sdesc, ext_search)))
|
|
|
|
printf ("%s : %s\n", pi->name, pi->sdesc);
|
|
|
|
free_pkg_info (&pi_buf);
|
|
|
|
}
|
|
|
|
free (ext_search);
|
|
|
|
++search;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-01-27 02:58:24 +08:00
|
|
|
/* Queries Cygwin web site for packages containing files matching a regexp.
|
|
|
|
Return value is 1 if there was a problem, otherwise 0. */
|
|
|
|
static int
|
2023-01-28 21:59:39 +08:00
|
|
|
package_grep (const char *search)
|
2023-01-27 02:58:24 +08:00
|
|
|
{
|
|
|
|
/* construct the actual URL by escaping */
|
|
|
|
char *url = (char *) alloca (sizeof (grep_base_url) + strlen (ARCH_str)
|
|
|
|
+ strlen (search) * 3);
|
|
|
|
strcpy (url, grep_base_url);
|
|
|
|
|
|
|
|
char *dest;
|
|
|
|
for (dest = &url[sizeof (grep_base_url) - 1]; *search; search++)
|
|
|
|
{
|
|
|
|
if (isalnum (*search)
|
|
|
|
|| memchr (safe_chars, *search, sizeof (safe_chars) - 1))
|
|
|
|
{
|
|
|
|
*dest++ = *search;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*dest++ = '%';
|
|
|
|
sprintf (dest, "%02x", (unsigned char) *search);
|
|
|
|
dest += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strcpy (dest, ARCH_str);
|
|
|
|
|
|
|
|
return fetch_url (url, stdout);
|
|
|
|
}
|
|
|
|
|
2020-08-07 19:29:43 +08:00
|
|
|
static void __attribute__ ((__noreturn__))
|
2002-03-07 11:13:17 +08:00
|
|
|
usage (FILE * stream, int status)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2002-02-28 00:10:17 +08:00
|
|
|
fprintf (stream, "\
|
2009-05-04 18:15:48 +08:00
|
|
|
Usage: cygcheck [-v] [-h] PROGRAM\n\
|
|
|
|
cygcheck -c [-d] [PACKAGE]\n\
|
|
|
|
cygcheck -s [-r] [-v] [-h]\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
cygcheck -k\n\
|
2009-05-04 18:15:48 +08:00
|
|
|
cygcheck -f FILE [FILE]...\n\
|
|
|
|
cygcheck -l [PACKAGE]...\n\
|
2023-01-30 00:52:13 +08:00
|
|
|
cygcheck -i [--inst] [--curr] [--prev] [--test] [PATTERN]...\n\
|
2023-01-28 21:59:39 +08:00
|
|
|
cygcheck -e [PATTERN]...\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
cygcheck -p REGEXP\n\
|
2009-10-31 21:26:37 +08:00
|
|
|
cygcheck --delete-orphaned-installation-keys\n\
|
2009-05-04 18:15:48 +08:00
|
|
|
cygcheck -h\n\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
List system information, check installed packages, or query package database.\n\
|
|
|
|
\n\
|
|
|
|
At least one command option or a PROGRAM is required, as shown above.\n\
|
|
|
|
\n\
|
|
|
|
PROGRAM list library (DLL) dependencies of PROGRAM\n\
|
|
|
|
-c, --check-setup show installed version of PACKAGE and verify integrity\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
(or for all installed packages if none specified)\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
-d, --dump-only just list packages, do not verify (with -c)\n\
|
2011-01-10 20:51:02 +08:00
|
|
|
-s, --sysinfo produce diagnostic system information (implies -c)\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
-r, --registry also scan registry for Cygwin settings (with -s)\n\
|
|
|
|
-k, --keycheck perform a keyboard check session (must be run from a\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
plain console only, not from a pty/rxvt/xterm)\n\
|
2023-01-29 21:13:25 +08:00
|
|
|
-e, --search-package list all available packages matching PATTERN\n\
|
|
|
|
PATTERN is a glob pattern with * and ? as wildcard chars\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
search selection specifiers (multiple allowed):\n\
|
|
|
|
--requires list packages depending on packages matching PATTERN\n\
|
|
|
|
--build-reqs list packages depending on packages matching PATTERN\n\
|
|
|
|
when building these packages\n\
|
|
|
|
only the most recent available releases are checked\n\
|
|
|
|
to collect requirements info\n\
|
2023-01-29 21:13:25 +08:00
|
|
|
-i, --info-package print full info on packages matching PATTERN, installed\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
and available releases\n\
|
2023-01-29 21:13:25 +08:00
|
|
|
PATTERN is a glob pattern with * and ? as wildcard chars\n\
|
2023-01-30 00:52:13 +08:00
|
|
|
info selection specifiers (multiple allowed):\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
--inst only print info on installed package release\n\
|
|
|
|
--curr only print info on most recent available release\n\
|
|
|
|
--prev only print info on older, still available releases\n\
|
|
|
|
--test only print info on test releases\n\
|
|
|
|
--deps additionally print package dependencies\n\
|
|
|
|
--build-deps additionally print package build dependencies\n\
|
2023-01-28 21:59:39 +08:00
|
|
|
-f, --find-package find the installed package to which FILE belongs\n\
|
|
|
|
-l, --list-package list contents of the installed PACKAGE (or all\n\
|
|
|
|
installed packages if none given)\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
-p, --package-query search for REGEXP in the entire cygwin.com package\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
repository (requires internet connectivity)\n\
|
2009-10-31 21:26:37 +08:00
|
|
|
--delete-orphaned-installation-keys\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
Delete installation keys of old, now unused\n\
|
|
|
|
installations from the registry. Requires the right\n\
|
|
|
|
to change the registry.\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
-v, --verbose produce more verbose output\n\
|
|
|
|
-h, --help annotate output with explanatory comments when given\n\
|
2023-02-09 04:05:18 +08:00
|
|
|
with another command, otherwise print this help\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
-V, --version print the version of cygcheck and exit\n\
|
2003-04-27 05:52:03 +08:00
|
|
|
\n\
|
2023-01-29 21:13:25 +08:00
|
|
|
Notes:\n\
|
2023-01-30 00:52:13 +08:00
|
|
|
-c, -f, and -l only report on packages that are currently installed.\n\
|
|
|
|
-i and -e report on available packages, too. To search for files within\n\
|
|
|
|
uninstalled Cygwin packages, use -p. The -p REGEXP matches package names,\n\
|
|
|
|
descriptions, and names of files/paths within all packages.\n\
|
2005-11-23 01:19:17 +08:00
|
|
|
\n");
|
2002-02-28 00:10:17 +08:00
|
|
|
exit (status);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2000-09-29 19:20:53 +08:00
|
|
|
struct option longopts[] = {
|
2001-11-11 14:07:36 +08:00
|
|
|
{"check-setup", no_argument, NULL, 'c'},
|
2003-09-12 00:24:26 +08:00
|
|
|
{"dump-only", no_argument, NULL, 'd'},
|
2000-10-28 13:00:00 +08:00
|
|
|
{"sysinfo", no_argument, NULL, 's'},
|
|
|
|
{"registry", no_argument, NULL, 'r'},
|
|
|
|
{"verbose", no_argument, NULL, 'v'},
|
|
|
|
{"keycheck", no_argument, NULL, 'k'},
|
2003-08-16 04:26:11 +08:00
|
|
|
{"find-package", no_argument, NULL, 'f'},
|
|
|
|
{"list-package", no_argument, NULL, 'l'},
|
2023-01-28 21:59:39 +08:00
|
|
|
{"info-packages", no_argument, NULL, 'i'},
|
2023-01-29 21:13:25 +08:00
|
|
|
{"inst", no_argument, NULL, 0x1001},
|
|
|
|
{"curr", no_argument, NULL, 0x1002},
|
|
|
|
{"prev", no_argument, NULL, 0x1004},
|
|
|
|
{"test", no_argument, NULL, 0x1008},
|
2023-02-09 04:05:18 +08:00
|
|
|
{"deps", no_argument, NULL, 0x1010},
|
|
|
|
{"build-deps", no_argument, NULL, 0x1020},
|
|
|
|
{"requires", no_argument, NULL, 0x1040},
|
|
|
|
{"build-reqs", no_argument, NULL, 0x1080},
|
2023-01-28 21:59:39 +08:00
|
|
|
{"search-packages", no_argument, NULL, 'e'},
|
2005-11-23 01:19:17 +08:00
|
|
|
{"package-query", no_argument, NULL, 'p'},
|
2009-10-31 21:26:37 +08:00
|
|
|
{"delete-orphaned-installation-keys", no_argument, NULL, CO_DELETE_KEYS},
|
2000-10-28 13:00:00 +08:00
|
|
|
{"help", no_argument, NULL, 'h'},
|
2002-03-07 11:06:28 +08:00
|
|
|
{"version", no_argument, 0, 'V'},
|
2000-10-28 13:00:00 +08:00
|
|
|
{0, no_argument, NULL, 0}
|
2000-09-29 19:20:53 +08:00
|
|
|
};
|
2000-10-28 13:39:38 +08:00
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
static char opts[] = "cdsrvkfliephV";
|
2002-02-28 00:10:17 +08:00
|
|
|
|
|
|
|
static void
|
|
|
|
print_version ()
|
|
|
|
{
|
2011-10-10 22:57:48 +08:00
|
|
|
printf ("cygcheck (cygwin) %d.%d.%d\n"
|
|
|
|
"System Checker for Cygwin\n"
|
2016-05-24 17:16:39 +08:00
|
|
|
"Copyright (C) 1998 - %s Cygwin Authors\n"
|
2016-10-23 21:57:40 +08:00
|
|
|
"This is free software; see the source for copying conditions. "
|
|
|
|
"There is NO\n"
|
|
|
|
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR "
|
|
|
|
"PURPOSE.\n",
|
2011-10-10 22:57:48 +08:00
|
|
|
CYGWIN_VERSION_DLL_MAJOR / 1000,
|
|
|
|
CYGWIN_VERSION_DLL_MAJOR % 1000,
|
|
|
|
CYGWIN_VERSION_DLL_MINOR,
|
|
|
|
strrchr (__DATE__, ' ') + 1);
|
2002-02-28 00:10:17 +08:00
|
|
|
}
|
2000-09-29 19:20:53 +08:00
|
|
|
|
2005-05-09 09:56:34 +08:00
|
|
|
void
|
|
|
|
nuke (char *ev)
|
|
|
|
{
|
2005-05-21 00:38:42 +08:00
|
|
|
int n = 1 + strchr (ev, '=') - ev;
|
2008-08-28 04:11:11 +08:00
|
|
|
char *s = (char *) malloc (n + 1);
|
2005-05-09 09:56:34 +08:00
|
|
|
memcpy (s, ev, n);
|
|
|
|
s[n] = '\0';
|
|
|
|
putenv (s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
load_cygwin (int& argc, char **&argv)
|
|
|
|
{
|
|
|
|
HMODULE h;
|
|
|
|
|
|
|
|
if (!(h = LoadLibrary ("cygwin1.dll")))
|
|
|
|
return;
|
2009-11-05 01:00:45 +08:00
|
|
|
GetModuleFileNameW (h, cygwin_dll_path, 32768);
|
2023-01-28 21:59:39 +08:00
|
|
|
if ((cygwin_internal = (uintptr_t (*) (cygwin_getinfo_types, ...))
|
|
|
|
GetProcAddress (h, "cygwin_internal")))
|
2008-07-27 22:53:42 +08:00
|
|
|
{
|
|
|
|
char **av = (char **) cygwin_internal (CW_ARGV);
|
2013-04-23 17:44:36 +08:00
|
|
|
if (av && ((uintptr_t) av != (uintptr_t) -1))
|
2008-08-04 23:30:06 +08:00
|
|
|
{
|
2015-08-31 03:35:23 +08:00
|
|
|
/* Copy cygwin's idea of the argument list into this Window
|
|
|
|
application. */
|
2008-08-04 23:30:06 +08:00
|
|
|
for (argc = 0; av[argc]; argc++)
|
|
|
|
continue;
|
|
|
|
argv = (char **) calloc (argc + 1, sizeof (char *));
|
|
|
|
for (char **argvp = argv; *av; av++)
|
|
|
|
*argvp++ = strdup (*av);
|
|
|
|
}
|
|
|
|
|
2005-05-09 09:56:34 +08:00
|
|
|
|
2008-07-27 22:53:42 +08:00
|
|
|
char **envp = (char **) cygwin_internal (CW_ENVP);
|
2013-04-23 17:44:36 +08:00
|
|
|
if (envp && ((uintptr_t) envp != (uintptr_t) -1))
|
2005-05-15 20:29:47 +08:00
|
|
|
{
|
2015-08-31 03:35:23 +08:00
|
|
|
/* Store path and revert to this value, otherwise path gets
|
|
|
|
overwritten by the POSIXy Cygwin variation, which breaks cygcheck.
|
2008-07-27 22:53:42 +08:00
|
|
|
Another approach would be to use the Cygwin PATH and convert it to
|
|
|
|
Win32 again. */
|
|
|
|
char *path = NULL;
|
|
|
|
char **env;
|
|
|
|
while (*(env = _environ))
|
|
|
|
{
|
|
|
|
if (strncmp (*env, "PATH=", 5) == 0)
|
|
|
|
path = strdup (*env);
|
|
|
|
nuke (*env);
|
|
|
|
}
|
|
|
|
for (char **ev = envp; *ev; ev++)
|
|
|
|
if (strncmp (*ev, "PATH=", 5) != 0)
|
2008-08-28 04:11:11 +08:00
|
|
|
putenv (strdup (*ev));
|
2008-07-27 22:53:42 +08:00
|
|
|
if (path)
|
|
|
|
putenv (path);
|
2005-05-27 23:45:53 +08:00
|
|
|
}
|
2005-05-09 09:56:34 +08:00
|
|
|
}
|
2023-01-28 21:59:39 +08:00
|
|
|
|
2015-08-31 03:35:23 +08:00
|
|
|
/* GDB chokes when the DLL got unloaded and, for some reason, fails to set
|
|
|
|
any breakpoint after the fact. */
|
|
|
|
if (!IsDebuggerPresent ())
|
|
|
|
FreeLibrary (h);
|
2005-05-09 09:56:34 +08:00
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
int
|
|
|
|
main (int argc, char **argv)
|
|
|
|
{
|
|
|
|
int i;
|
2005-07-06 05:41:37 +08:00
|
|
|
bool ok = true;
|
2005-05-09 09:56:34 +08:00
|
|
|
load_cygwin (argc, argv);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2017-02-25 03:55:14 +08:00
|
|
|
_setmode (1, _O_BINARY);
|
|
|
|
_setmode (2, _O_BINARY);
|
|
|
|
|
2006-09-13 23:32:04 +08:00
|
|
|
/* Need POSIX sorting while parsing args, but don't forget the
|
|
|
|
user's original environment. */
|
|
|
|
char *posixly = getenv ("POSIXLY_CORRECT");
|
|
|
|
if (posixly == NULL)
|
2009-10-31 21:26:37 +08:00
|
|
|
(void) putenv ("POSIXLY_CORRECT=1");
|
2000-09-29 19:20:53 +08:00
|
|
|
while ((i = getopt_long (argc, argv, opts, longopts, NULL)) != EOF)
|
|
|
|
switch (i)
|
|
|
|
{
|
|
|
|
case 's':
|
2000-10-28 13:00:00 +08:00
|
|
|
sysinfo = 1;
|
|
|
|
break;
|
2001-11-11 14:07:36 +08:00
|
|
|
case 'c':
|
|
|
|
check_setup = 1;
|
|
|
|
break;
|
2003-09-12 00:24:26 +08:00
|
|
|
case 'd':
|
|
|
|
dump_only = 1;
|
|
|
|
break;
|
2000-09-29 19:20:53 +08:00
|
|
|
case 'r':
|
2000-10-28 13:00:00 +08:00
|
|
|
registry = 1;
|
|
|
|
break;
|
2000-09-29 19:20:53 +08:00
|
|
|
case 'v':
|
2000-10-28 13:00:00 +08:00
|
|
|
verbose = 1;
|
|
|
|
break;
|
2000-09-29 19:20:53 +08:00
|
|
|
case 'k':
|
2000-10-28 13:00:00 +08:00
|
|
|
keycheck = 1;
|
|
|
|
break;
|
2003-08-16 04:26:11 +08:00
|
|
|
case 'f':
|
|
|
|
find_package = 1;
|
|
|
|
break;
|
|
|
|
case 'l':
|
|
|
|
list_package = 1;
|
|
|
|
break;
|
2023-01-28 21:59:39 +08:00
|
|
|
case 'i':
|
|
|
|
info_packages = 1;
|
|
|
|
break;
|
2023-01-29 21:13:25 +08:00
|
|
|
case 0x1001:
|
|
|
|
case 0x1002:
|
|
|
|
case 0x1004:
|
|
|
|
case 0x1008:
|
2023-02-09 04:05:18 +08:00
|
|
|
case 0x1010:
|
|
|
|
case 0x1020:
|
|
|
|
info_selector |= (i & 0x3f);
|
2023-01-29 21:13:25 +08:00
|
|
|
break;
|
2023-01-28 21:59:39 +08:00
|
|
|
case 'e':
|
|
|
|
search_packages = 1;
|
|
|
|
break;
|
2023-02-09 04:05:18 +08:00
|
|
|
case 0x1040:
|
|
|
|
case 0x1080:
|
|
|
|
search_selector |= (i & 0xc0);
|
|
|
|
break;
|
2005-11-23 01:19:17 +08:00
|
|
|
case 'p':
|
2007-06-04 09:57:16 +08:00
|
|
|
grep_packages = 1;
|
|
|
|
break;
|
2000-09-29 19:20:53 +08:00
|
|
|
case 'h':
|
2000-10-28 13:00:00 +08:00
|
|
|
givehelp = 1;
|
|
|
|
break;
|
2009-10-31 21:26:37 +08:00
|
|
|
case CO_DELETE_KEYS:
|
2011-12-18 07:39:47 +08:00
|
|
|
del_orphaned_reg = 1;
|
2009-10-31 21:26:37 +08:00
|
|
|
break;
|
2002-02-28 00:10:17 +08:00
|
|
|
case 'V':
|
|
|
|
print_version ();
|
2002-03-07 11:13:17 +08:00
|
|
|
exit (0);
|
2000-09-29 19:20:53 +08:00
|
|
|
default:
|
2011-10-10 22:57:48 +08:00
|
|
|
fprintf (stderr, "Try `cygcheck --help' for more information.\n");
|
|
|
|
exit (1);
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2000-09-29 19:20:53 +08:00
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
2006-09-13 23:32:04 +08:00
|
|
|
if (posixly == NULL)
|
|
|
|
putenv ("POSIXLY_CORRECT=");
|
2000-09-29 19:20:53 +08:00
|
|
|
|
2009-10-31 21:26:37 +08:00
|
|
|
if ((argc == 0) && !sysinfo && !keycheck && !check_setup && !list_package
|
2023-01-28 21:59:39 +08:00
|
|
|
&& !del_orphaned_reg && !info_packages && !search_packages)
|
2008-09-13 06:43:10 +08:00
|
|
|
{
|
|
|
|
if (givehelp)
|
|
|
|
usage (stdout, 0);
|
|
|
|
else
|
|
|
|
usage (stderr, 1);
|
|
|
|
}
|
2000-09-29 19:20:53 +08:00
|
|
|
|
2009-10-31 21:26:37 +08:00
|
|
|
if ((check_setup || sysinfo || find_package || list_package || grep_packages
|
2023-01-28 21:59:39 +08:00
|
|
|
|| del_orphaned_reg || info_packages || search_packages)
|
2005-11-23 01:19:17 +08:00
|
|
|
&& keycheck)
|
2003-08-16 04:26:11 +08:00
|
|
|
usage (stderr, 1);
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
if ((find_package || list_package || grep_packages
|
|
|
|
|| info_packages || search_packages)
|
2009-10-31 21:26:37 +08:00
|
|
|
&& (check_setup || del_orphaned_reg))
|
|
|
|
usage (stderr, 1);
|
|
|
|
|
2011-01-10 20:51:02 +08:00
|
|
|
if (dump_only && !check_setup && !sysinfo)
|
2003-09-12 00:24:26 +08:00
|
|
|
usage (stderr, 1);
|
|
|
|
|
2023-01-28 21:59:39 +08:00
|
|
|
if (find_package + list_package + grep_packages
|
|
|
|
+ info_packages + search_packages > 1)
|
2002-02-28 00:10:17 +08:00
|
|
|
usage (stderr, 1);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2023-02-09 04:05:18 +08:00
|
|
|
if (!info_packages && info_selector)
|
|
|
|
usage (stderr, 1);
|
|
|
|
|
|
|
|
if (!search_packages && search_selector)
|
|
|
|
usage (stderr, 1);
|
|
|
|
|
2000-09-29 19:20:53 +08:00
|
|
|
if (keycheck)
|
2000-10-28 13:00:00 +08:00
|
|
|
return check_keys ();
|
2009-10-31 21:26:37 +08:00
|
|
|
if (del_orphaned_reg)
|
|
|
|
del_orphaned_reg_installations ();
|
2005-11-23 01:19:17 +08:00
|
|
|
if (grep_packages)
|
|
|
|
return package_grep (*argv);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (info_packages)
|
2023-01-29 21:13:25 +08:00
|
|
|
return package_info (argv, info_selector);
|
2023-01-28 21:59:39 +08:00
|
|
|
if (search_packages)
|
2023-02-09 04:05:18 +08:00
|
|
|
return package_search (argv, search_selector);
|
2000-09-29 19:20:53 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
init_paths ();
|
|
|
|
|
2003-08-16 04:26:11 +08:00
|
|
|
/* FIXME: Add help for check_setup and {list,find}_package */
|
|
|
|
if (argc >= 1 && givehelp && !check_setup && !find_package && !list_package)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2003-08-16 04:26:11 +08:00
|
|
|
printf("Here is where the OS will find your program%s, and which dlls\n",
|
|
|
|
argc > 1 ? "s" : "");
|
|
|
|
printf ("will be used for it. Use -v to see DLL version info\n");
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
if (!sysinfo)
|
|
|
|
printf ("\n");
|
|
|
|
}
|
|
|
|
|
2001-11-11 14:07:36 +08:00
|
|
|
if (check_setup)
|
2004-11-11 09:52:33 +08:00
|
|
|
dump_setup (verbose, argv, !dump_only);
|
2003-08-16 04:26:11 +08:00
|
|
|
else if (find_package)
|
2004-11-11 09:52:33 +08:00
|
|
|
package_find (verbose, argv);
|
2003-08-16 04:26:11 +08:00
|
|
|
else if (list_package)
|
2004-11-11 09:52:33 +08:00
|
|
|
package_list (verbose, argv);
|
2001-11-11 14:07:36 +08:00
|
|
|
else
|
|
|
|
for (i = 0; i < argc; i++)
|
|
|
|
{
|
2003-08-16 04:26:11 +08:00
|
|
|
if (i)
|
|
|
|
puts ("");
|
2005-07-06 05:41:37 +08:00
|
|
|
ok &= cygcheck (argv[i]);
|
2001-11-11 14:07:36 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
if (sysinfo)
|
2001-11-11 14:16:18 +08:00
|
|
|
{
|
|
|
|
dump_sysinfo ();
|
|
|
|
if (!check_setup)
|
|
|
|
{
|
2001-11-13 05:28:32 +08:00
|
|
|
puts ("");
|
2011-01-10 20:51:02 +08:00
|
|
|
dump_setup (verbose, NULL, !dump_only);
|
2001-11-11 14:16:18 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2003-08-16 04:26:11 +08:00
|
|
|
if (!givehelp)
|
|
|
|
puts ("Use -h to see help about each section");
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-07-06 05:41:37 +08:00
|
|
|
return ok ? EXIT_SUCCESS : EXIT_FAILURE;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|