fromcwd.cc

   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 DJ Delorie <dj@cygnus.com>
  13  *
  14  */
  15
  16 /* The purpose of this file is to handle the case where we're
  17    installing from files that already exist in the current directory.
  18    If a setup.ini file is present, we set the mirror site to "." and
  19    pretend we're installing from the `internet' ;-) else we have to
  20    find all the .tar.gz files, deduce their versions, and try to
  21    compare versions in the case where the current directory contains
  22    multiple versions of any given package.  We do *not* try to compare
  23    versions with already installed packages; we always choose a
  24    package in the current directory over one that's already installed
  25    (otherwise, why would you have asked to install it?).  Note
  26    that we search recursively. */
  27
  28 #if 0
  29 static const char *cvsid =
  30   "\n%%% $Id$\n";
  31 #endif
  32
  33 #include "win32.h"
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <io.h>
  38 #include <unistd.h>
  39 #include <ctype.h>
  40
  41 #include "ini.h"
  42 #include "resource.h"
  43 #include "state.h"
  44 #include "dialog.h"
  45 #include "msg.h"
  46 #include "find.h"
  47 #include "filemanip.h"
  48 #include "version.h"
  49 #include "site.h"
  50 #include "rfc1738.h"
  51
  52 #include "port.h"
  53
  54 #include "package_db.h"
  55 #include "package_meta.h"
  56 #include "package_version.h"
  57 #include "cygpackage.h"
  58 # if 0
  59 static int
  60 is_test_version (char *v)
  61 {
  62   int i;
  63   for (i = 0; v[i] && isdigit (v[i]); i++);
  64   return (i >= 6) ? 1 : 0;
  65 }
  66 #endif
  67
  68 static void
  69 found_file (char *path, unsigned int fsize)
  70 {
  71   fileparse f;
  72
  73   if (!parse_filename (path, f))
  74     return;
  75
  76   if (f.what.size() != 0)
  77     return;
  78
  79   packagedb db;
  80   packagemeta &p = db.packages.registerbykey (f.pkg);
  81   packageversion *pv = new cygpackage (f.pkg);
  82   ((cygpackage *)pv)->set_canonical_version (f.ver);
  83   if (!f.what.size())
  84     pv->bin.set_cached (String ("file://") + path);
  85   else
  86     // patch or src, assume src until someone complains
  87     pv->src.set_cached (String ("file://") + path);
  88
  89   // check for a duplciate version FIXME make this a method or friend
  90
  91
  92   int merged = 0;
  93   for (size_t n = 1; !merged && n <= p.versions.number (); n++)
  94     if (!p.versions[n]->Canonical_version().casecompare (pv->Canonical_version()))
  95       {
  96         /* Copy the binary mirror across if this site claims to have an install */
  97         if (pv->bin.sites.number ())
  98           p.versions[n]->bin.sites.registerbykey (pv->bin.sites[1]->key);
  99         /* Ditto for src */
 100         if (pv->src.sites.number ())
 101           p.versions[n]->src.sites.registerbykey (pv->src.sites[1]->key);
 102         /* Copy the descriptions across */
 103         if (pv->SDesc ().size() && !p.versions[n]->SDesc ().size())
 104           p.versions[n]->set_sdesc (pv->SDesc ());
 105         if (pv->LDesc ().size() && !p.versions[n]->LDesc ().size())
 106           p.versions[n]->set_ldesc (pv->LDesc ());
 107         pv = p.versions[n];
 108         merged = 1;
 109       }
 110   if (!merged)
 111     p.add_version (*pv);
 112
 113 #if 0
 114   // This is handled by the scan2 - there is no need for duplication - or is there?
 115
 116   int trust = is_test_version (f.ver) ? TRUST_TEST : TRUST_CURR;
 117
 118   /* See if this version is older than what we have */
 119   if (p->info[trust].version)
 120     {
 121       char *ov = canonicalize_version (p->info[trust].version);
 122       char *nv = canonicalize_version (f.ver);
 123       if (strcmp (ov, nv) > 0)
 124         return;
 125     }
 126
 127   if (p->info[trust].version)
 128     free (p->info[trust].version);
 129   p->info[trust].version = _strdup (f.ver);
 130
 131   if (p->info[trust].install)
 132     free (p->info[trust].install);
 133   p->info[trust].install = _strdup (path);
 134
 135   p->info[trust].install_size = fsize;
 136 #endif
 137 }
 138
 139 static bool found_ini;
 140
 141 static void
 142 check_ini (char *path, unsigned int fsize)
 143 {
 144   if (fsize && strstr (path, "setup.ini"))
 145     found_ini = true;
 146 }
 147
 148 void
 149 do_fromcwd (HINSTANCE h, HWND owner)
 150 {
 151   // Assume we won't find the INI file.
 152   found_ini = false;
 153   find (".", check_ini);
 154   if (found_ini)
 155     {
 156       // Found INI, load it.
 157       next_dialog = IDD_S_LOAD_INI;
 158       return;
 159     }
 160
 161   next_dialog = IDD_CHOOSER;
 162
 163   find (".", found_file);
 164
 165 #if 0
 166   // Reinstate this FIXME: Replace obsolete structures first
 167   // Now see about source tarballs
 168   int i, t;
 169   packagemeta *p;
 170   char srcpath[_MAX_PATH];
 171   for (i = 0; i < npackages; i++)
 172     {
 173       p = package + i;
 174       /* For each version with a binary after running find */
 175       for (t = TRUST_PREV; t <= TRUST_TEST; t++)
 176         if (p->info[t].install)
 177           {
 178             /* Is there a -src file too? */
 179             int n = find_tar_ext (p->info[t].install);
 180             strcpy (srcpath, p->info[t].install);
 181             strcpy (srcpath + n, "-src.tar.gz");
 182             msg ("looking for %s", srcpath);
 183
 184             WIN32_FIND_DATA wfd;
 185             HANDLE h = FindFirstFile (srcpath, &wfd);
 186             if (h == INVALID_HANDLE_VALUE)
 187               {
 188                 strcpy (srcpath + n, "-src.tar.bz2");
 189                 h = FindFirstFile (srcpath, &wfd);
 190               }
 191             if (h != INVALID_HANDLE_VALUE)
 192               {
 193                 msg ("-- got it");
 194                 FindClose (h);
 195                 p->info[t].source = _strdup (srcpath);
 196                 p->info[t].source_size = wfd.nFileSizeLow;
 197               }
 198           }
 199     }
 200 #endif
 201   return;
 202 }