[cygwin-apps/setup.git] / pkg.c

/*
 * Copyright (c) 2000, Red Hat, Inc.
 *
 *     This program is free software; you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation; either version 2 of the License, or
 *     (at your option) any later version.
 *
 *     A copy of the GNU General Public License can be found at
 *     http://www.gnu.org/
 *
 * Written by Christopher Faylor <cgf@redhat.com>
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <windows.h>
#include "setup.h"
#include <sys/stat.h>

#define CYGMAJOR "%%% Cygwin dll major: "
#define CYGMAJOR_LEN (sizeof (CYGMAJOR) - 1)
#define CYGMINOR "%%% Cygwin dll minor: "
#define CYGMINOR_LEN (sizeof (CYGMINOR) - 1)

pkg global_pkgstuff[1000];

void
normalize_version (const char *fn_in, char **prod, char **version)
{
  char *p;
  char *fn, *origfn;
  char *dot;
  static char buf1[1024];
  static char buf2[1024];

  origfn = buf1;
  strcpy (buf1, fn_in);
  fn = origfn = buf1;

  if ((p = strstr (fn, ".tar.gz")) != NULL)
    *p = '\0';
  else if ((p = strstr (fn, "_tar.gz")) != NULL)
    *p = '\0';

  while (isalpha (*fn))
    fn++;
  if (*fn)
    *fn++ = '\0';

  *prod = origfn;
  if (!*fn)
    {
      *version = strcpy (buf2, "0000");
      return;
    }

  dot = "";
  buf2[0] = '\0';
  while (*fn)
    {
      int n;
      fn += strspn (fn, "-_.+,");
      if (!*fn)
	break;
      n = strcspn (fn, "-_.+,");
      sprintf (strchr (buf2, '\0'), "%s%04.*s", dot, n, fn);
      fn += n;
      dot = ".";
    }

  *version = buf2;
  return;
}

static HKEY hkpkg;

static pkg default_pkgs[] =
{
  {"diff", "0000"},
  {"ash", "0000"},
  {"bash", "0000"},
  {"binutils", "19990818.0001"},
  {"bison", "0000"},
  {"byacc", "0000"},
  {"bzip", "0000"},
  {"clear", "0001.0000"},
  {"dejagnu", "0000"},
  {"expect", "0000"},
  {"fileutils", "0000"},
  {"findutils", "0000"},
  {"flex", "0000"},
  {"gawk", "0000"},
  {"gcc", "0002.0095.0002.0001"},
  {"gdb", "20000415"},
  {"gperf", "0000"},
  {"grep", "0000"},
  {"groff", "0001.011a.0001"},
  {"gzip", "0000"},
  {"less", "0000"},
  {"m", "0000"},
  {"make", "0000"},
  {"man", "0001.005g.0001"},
  {"patch", "0000"},
  {"sed", "0000"},
  {"shellutils", "0000"},
  {"tar", "0000"},
  {"tcltk", "0000"},
  {"termcap", "0000"},
  {"texinfo", "0000"},
  {"textutils", "0000"},
  {"time", "0000"},
  {NULL, NULL}
};

pkg *
use_default_pkgs (pkg *stuff)
{
  pkg *def, *stf;
  int sawend;
  def = default_pkgs;

  sawend = 0;
  for (stf = stuff, def = default_pkgs; def->name != NULL; stf++)
    {
      if (sawend || !stf->name)
	{
	  stf->name = xstrdup (def->name);
	  stf->version = xstrdup (def->version);
	  def++;
	  sawend = 1;
	}
      (void) write_pkg (NULL, stf->name, stf->version);
    }
  stf->name = NULL;
  stf->version = NULL;
  return stuff;
}

pkg *
find_pkg (pkg *stuff, char *name)
{
  int i;

  for (i = 0; stuff[i].name; i++)
    if (stricmp (stuff[i].name, name) == 0)
      return stuff + i;

  return NULL;
}

const char *
check_for_installed (const char *root, pkg *stuff)
{
  char *cygwin = pathcat (root, "bin\\cygwin1.dll");
  FILE *fp = fopen (cygwin, "rb");
  char *buf, *bufend;
  struct _stat st;
  char *major, *minor;
  pkg *pkg;
  static char buf1[256];

  xfree (cygwin);

  if (fp == NULL)
    return NULL;

  if (_fstat (fileno (fp), &st))
    goto err;

  buf = xmalloc (st.st_size);
  if (!buf)
    goto err;

  if (fread (buf, st.st_size, 1, fp) <= 0)
    goto err;

  fclose (fp);

  bufend = buf + st.st_size;
  major = minor = NULL;
  while (buf < bufend)
    if ((buf = memchr (buf, '%', bufend - buf)) == NULL)
	return 0;
    else if (strncmp (buf, CYGMAJOR, CYGMAJOR_LEN) == 0)
	major = buf += CYGMAJOR_LEN;
    else if (strncmp (buf, CYGMINOR, CYGMINOR_LEN) != 0)
	buf++;
    else
	{
	  minor = buf + CYGMINOR_LEN;
	  break;
	}

  if (!minor)
    return NULL;

  sprintf (buf1, "%04d.%04d.%04d", atoi (major) / 1000, atoi (major) % 1000, atoi (minor));

  pkg = find_pkg (stuff, "cygwin");
  if (pkg)
    xfree (pkg->version);
  else
    {
      pkg = stuff;
      stuff[1].name = stuff[1].version = NULL;
    }

  pkg->name = xstrdup ("cygwin");
  pkg->version = xstrdup (buf1);

  sprintf (buf1, "%d.%d.%d", atoi (major) / 1000, atoi (major) % 1000, atoi (minor));

  return buf1;

err:
  fclose (fp);
  return NULL;
}

#define REGWHERE "SOFTWARE\\Cygnus Solutions\\Cygwin\\Installed Components"

pkg *
init_pkgs (const char *root, int use_current_user)
{
  LONG res;
  DWORD what;
  char *p, empty[] = "";
  char buf[4096];
  DWORD ty, sz;
  DWORD nc = 0;

  sprintf (buf, "%s\\%s", REGWHERE, root);
  for (p = buf + sizeof (REGWHERE); (p = strchr (p, '\\')) != NULL; )
    *p = '/';
  
  res = RegCreateKeyEx (use_current_user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, buf,
			0, empty,  REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkpkg, &what);

  if (res != ERROR_SUCCESS)
    return NULL;

  for (nc = 0, sz = sizeof (buf);
       RegEnumValue (hkpkg, nc, buf, &sz, NULL, &ty, NULL, NULL) == ERROR_SUCCESS;
       nc++, sz = sizeof (buf))
    {
      DWORD sz = sizeof (buf);
      global_pkgstuff[nc].name = xstrdup (buf);

      if (RegQueryValueEx (hkpkg, global_pkgstuff[nc].name, NULL,
			 &ty, buf, &sz) == ERROR_SUCCESS)
	global_pkgstuff[nc].version = xstrdup (buf);
      else
	global_pkgstuff[nc].version = xstrdup ("");
    }

  global_pkgstuff[nc].version = global_pkgstuff[nc].name = NULL;
  return global_pkgstuff;
}

int
write_pkg (pkg *pkg, char *name, char *version)
{
  if (pkg != NULL && stricmp (pkg->version, version) >= 0)
    return 0;

  RegSetValueEx (hkpkg, name, 0, REG_SZ, version, strlen (version) + 1);
  return 1;
}

int
newer_pkg (pkg *pkg, char *version)
{
  if (pkg != NULL && stricmp (pkg->version, version) >= 0)
    return 0;
  return 1;
}

void
close_pkgs ()
{
  RegCloseKey (hkpkg);
}

#ifdef check
int
main (int argc, char **argv)
{
  pkg *stuff = init_pkgs ();

  while (*++argv)
    {
      char *stub, *ver;
      pkg *pkg;
      normalize_version (*argv, &stub, &ver);
      printf ("%s = %s, %s\n", *argv, stub, ver);
      if ((pkg = find_pkg (stuff, stub)) != NULL)
	printf ("found pkg %s = %s\n", pkg->name, pkg->version);
      printf ("write_pkg returns %d\n", write_pkg (pkg, stub, ver));
    }
  exit (0);
}
#endif
Commit	Line	Data
1304023e CF	1	/*
	2	* Copyright (c) 2000, Red Hat, Inc.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* A copy of the GNU General Public License can be found at
	10	* http://www.gnu.org/
	11	*
	12	* Written by Christopher Faylor <cgf@redhat.com>
	13	*
	14	*/
	15
	16	#include <stdio.h>
	17	#include <stdlib.h>
	18	#include <ctype.h>
	19	#include <windows.h>
	20	#include "setup.h"
	21	#include <sys/stat.h>
	22
	23	#define CYGMAJOR "%%% Cygwin dll major: "
	24	#define CYGMAJOR_LEN (sizeof (CYGMAJOR) - 1)
	25	#define CYGMINOR "%%% Cygwin dll minor: "
	26	#define CYGMINOR_LEN (sizeof (CYGMINOR) - 1)
	27
55650749 CF	28	pkg global_pkgstuff[1000];
55650749 CF	29
1304023e CF	30	void
	31	normalize_version (const char fn_in, char prod, char *version)
	32	{
	33	char *p;
	34	char fn, origfn;
	35	char *dot;
	36	static char buf1[1024];
	37	static char buf2[1024];
	38
	39	origfn = buf1;
	40	strcpy (buf1, fn_in);
	41	fn = origfn = buf1;
	42
	43	if ((p = strstr (fn, ".tar.gz")) != NULL)
	44	*p = '\0';
	45	else if ((p = strstr (fn, "_tar.gz")) != NULL)
	46	*p = '\0';
	47
	48	while (isalpha (*fn))
	49	fn++;
	50	if (*fn)
	51	*fn++ = '\0';
	52
	53	*prod = origfn;
	54	if (!*fn)
	55	{
	56	*version = strcpy (buf2, "0000");
	57	return;
	58	}
	59
	60	dot = "";
	61	buf2[0] = '\0';
	62	while (*fn)
	63	{
	64	int n;
	65	fn += strspn (fn, "-_.+,");
	66	if (!*fn)
	67	break;
	68	n = strcspn (fn, "-_.+,");
	69	sprintf (strchr (buf2, '\0'), "%s%04.*s", dot, n, fn);
	70	fn += n;
	71	dot = ".";
	72	}
	73
	74	*version = buf2;
	75	return;
	76	}
	77
	78	static HKEY hkpkg;
	79
	80	static pkg default_pkgs[] =
	81	{
	82	{"diff", "0000"},
	83	{"ash", "0000"},
	84	{"bash", "0000"},
	85	{"binutils", "19990818.0001"},
	86	{"bison", "0000"},
	87	{"byacc", "0000"},
	88	{"bzip", "0000"},
	89	{"clear", "0001.0000"},
	90	{"dejagnu", "0000"},
	91	{"expect", "0000"},
	92	{"fileutils", "0000"},
	93	{"findutils", "0000"},
94	{"flex", "0000"},
95	{"gawk", "0000"},
96	{"gcc", "0002.0095.0002.0001"},
97	{"gdb", "20000415"},
98	{"gperf", "0000"},
99	{"grep", "0000"},
100	{"groff", "0001.011a.0001"},
101	{"gzip", "0000"},
102	{"less", "0000"},
103	{"m", "0000"},
104	{"make", "0000"},
105	{"man", "0001.005g.0001"},
106	{"patch", "0000"},
107	{"sed", "0000"},
108	{"shellutils", "0000"},
109	{"tar", "0000"},
110	{"tcltk", "0000"},
aba5babb	111	{"termcap", "0000"},
1304023e CF	112	{"texinfo", "0000"},
	113	{"textutils", "0000"},
	114	{"time", "0000"},
	115	{NULL, NULL}
	116	};
	117
	118	pkg *
	119	use_default_pkgs (pkg *stuff)
	120	{
	121	pkg def, stf;
	122	int sawend;
	123	def = default_pkgs;
	124
	125	sawend = 0;
	126	for (stf = stuff, def = default_pkgs; def->name != NULL; stf++)
	127	{
	128	if (sawend \|\| !stf->name)
	129	{
	130	stf->name = xstrdup (def->name);
	131	stf->version = xstrdup (def->version);
	132	def++;
	133	sawend = 1;
	134	}
	135	(void) write_pkg (NULL, stf->name, stf->version);
	136	}
	137	stf->name = NULL;
	138	stf->version = NULL;
	139	return stuff;
	140	}
	141
	142	pkg *
	143	find_pkg (pkg stuff, char name)
	144	{
	145	int i;
	146
	147	for (i = 0; stuff[i].name; i++)
	148	if (stricmp (stuff[i].name, name) == 0)
	149	return stuff + i;
	150
	151	return NULL;
	152	}
	153
	154	const char *
	155	check_for_installed (const char root, pkg stuff)
	156	{
	157	char *cygwin = pathcat (root, "bin\\cygwin1.dll");
	158	FILE *fp = fopen (cygwin, "rb");
	159	char buf, bufend;
	160	struct _stat st;
	161	char major, minor;
	162	pkg *pkg;
	163	static char buf1[256];
	164
	165	xfree (cygwin);
	166
	167	if (fp == NULL)
	168	return NULL;
	169
	170	if (_fstat (fileno (fp), &st))
	171	goto err;
	172
	173	buf = xmalloc (st.st_size);
	174	if (!buf)
	175	goto err;
176
177	if (fread (buf, st.st_size, 1, fp) <= 0)
178	goto err;
179
180	fclose (fp);
181
182	bufend = buf + st.st_size;
183	major = minor = NULL;
184	while (buf < bufend)
185	if ((buf = memchr (buf, '%', bufend - buf)) == NULL)
186	return 0;
187	else if (strncmp (buf, CYGMAJOR, CYGMAJOR_LEN) == 0)
188	major = buf += CYGMAJOR_LEN;
189	else if (strncmp (buf, CYGMINOR, CYGMINOR_LEN) != 0)
190	buf++;
191	else
192	{
193	minor = buf + CYGMINOR_LEN;
194	break;
195	}
196
197	if (!minor)
198	return NULL;
199
200	sprintf (buf1, "%04d.%04d.%04d", atoi (major) / 1000, atoi (major) % 1000, atoi (minor));
201
202	pkg = find_pkg (stuff, "cygwin");
203	if (pkg)
204	xfree (pkg->version);
205	else
206	{
207	pkg = stuff;
208	stuff[1].name = stuff[1].version = NULL;
209	}
210
211	pkg->name = xstrdup ("cygwin");
212	pkg->version = xstrdup (buf1);
213
214	sprintf (buf1, "%d.%d.%d", atoi (major) / 1000, atoi (major) % 1000, atoi (minor));
215
216	return buf1;
217
218	err:
219	fclose (fp);
220	return NULL;
221	}
222
9e76799c CF	223	#define REGWHERE "SOFTWARE\\Cygnus Solutions\\Cygwin\\Installed Components"
9e76799c CF	224
1304023e	225	pkg *
9e76799c	226	init_pkgs (const char *root, int use_current_user)
1304023e CF	227	{
	228	LONG res;
	229	DWORD what;
9e76799c	230	char *p, empty[] = "";
1304023e CF	231	char buf[4096];
	232	DWORD ty, sz;
	233	DWORD nc = 0;
1304023e	234
9e76799c CF	235	sprintf (buf, "%s\\%s", REGWHERE, root);
	236	for (p = buf + sizeof (REGWHERE); (p = strchr (p, '\\')) != NULL; )
	237	*p = '/';
	238
	239	res = RegCreateKeyEx (use_current_user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, buf,
	240	0, empty, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkpkg, &what);
1304023e	241
2cf65e6e CF	242	if (res != ERROR_SUCCESS)
	243	return NULL;
	244
1304023e CF	245	for (nc = 0, sz = sizeof (buf);
	246	RegEnumValue (hkpkg, nc, buf, &sz, NULL, &ty, NULL, NULL) == ERROR_SUCCESS;
	247	nc++, sz = sizeof (buf))
	248	{
	249	DWORD sz = sizeof (buf);
55650749	250	global_pkgstuff[nc].name = xstrdup (buf);
1304023e	251
55650749	252	if (RegQueryValueEx (hkpkg, global_pkgstuff[nc].name, NULL,
1304023e	253	&ty, buf, &sz) == ERROR_SUCCESS)
55650749	254	global_pkgstuff[nc].version = xstrdup (buf);
1304023e	255	else
55650749	256	global_pkgstuff[nc].version = xstrdup ("");
1304023e CF	257	}
1304023e CF	258
55650749 CF	259	global_pkgstuff[nc].version = global_pkgstuff[nc].name = NULL;
55650749 CF	260	return global_pkgstuff;
1304023e CF	261	}
	262
	263	int
	264	write_pkg (pkg pkg, char name, char *version)
	265	{
	266	if (pkg != NULL && stricmp (pkg->version, version) >= 0)
	267	return 0;
	268
	269	RegSetValueEx (hkpkg, name, 0, REG_SZ, version, strlen (version) + 1);
	270	return 1;
	271	}
	272
	273	int
	274	newer_pkg (pkg pkg, char version)
	275	{
	276	if (pkg != NULL && stricmp (pkg->version, version) >= 0)
	277	return 0;
	278	return 1;
	279	}
	280
	281	void
	282	close_pkgs ()
	283	{
	284	RegCloseKey (hkpkg);
	285	}
	286
	287	#ifdef check
	288	int
	289	main (int argc, char **argv)
	290	{
	291	pkg *stuff = init_pkgs ();
	292
	293	while (*++argv)
	294	{
	295	char stub, ver;
	296	pkg *pkg;
	297	normalize_version (*argv, &stub, &ver);
	298	printf ("%s = %s, %s\n", *argv, stub, ver);
	299	if ((pkg = find_pkg (stuff, stub)) != NULL)
	300	printf ("found pkg %s = %s\n", pkg->name, pkg->version);
	301	printf ("write_pkg returns %d\n", write_pkg (pkg, stub, ver));
	302	}
	303	exit (0);
	304	}
	305	#endif