src/climain.cpp

   1 /*
   2  * climain.cpp
   3  *
   4  * $Id$
   5  *
   6  * Written by Keith Marshall <keithmarshall@users.sourceforge.net>
   7  * Copyright (C) 2009, 2010, 2011, MinGW Project
   8  *
   9  *
  10  * Implementation of the main program function, which is invoked by
  11  * the command line start-up stub when arguments are supplied; this
  12  * causes the application to continue running as a CLI process.
  13  *
  14  *
  15  * This is free software.  Permission is granted to copy, modify and
  16  * redistribute this software, under the provisions of the GNU General
  17  * Public License, Version 3, (or, at your option, any later version),
  18  * as published by the Free Software Foundation; see the file COPYING
  19  * for licensing details.
  20  *
  21  * Note, in particular, that this software is provided "as is", in the
  22  * hope that it may prove useful, but WITHOUT WARRANTY OF ANY KIND; not
  23  * even an implied WARRANTY OF MERCHANTABILITY, nor of FITNESS FOR ANY
  24  * PARTICULAR PURPOSE.  Under no circumstances will the author, or the
  25  * MinGW Project, accept liability for any damages, however caused,
  26  * arising from the use of this software.
  27  *
  28  */
  29 #include <stdio.h>
  30 #include <libgen.h>
  31 #include <string.h>
  32 #include <fcntl.h>
  33
  34 #include "dmh.h"
  35 #include "mkpath.h"
  36
  37 #include "pkgbase.h"
  38 #include "pkgkeys.h"
  39 #include "pkgopts.h"
  40 #include "pkgtask.h"
  41
  42 EXTERN_C void cli_setopts( struct pkgopts *opts )
  43 {
  44   /* Start-up hook used to make the table of command line options,
  45    * as parsed by the CLI start-up module, available within the DLL.
  46    */
  47   (void) pkgOptions( OPTION_TABLE_ASSIGN, opts );
  48 }
  49
  50 EXTERN_C pkgOpts *pkgOptions( int action, struct pkgopts *ref )
  51 {
  52   /* Global accessor for the program options data table.
  53    */
  54   static pkgOpts *table = NULL;
  55   if( action == OPTION_TABLE_ASSIGN )
  56     /*
  57      * This is a request to initialise the data table reference;
  58      * it is typically called at program start-up, to record the
  59      * location of the data table into which the CLI start-up
  60      * module stores the result of its CLI options parse.
  61      */
  62     table = (pkgOpts *)(ref);
  63
  64   /* In all cases, we return the assigned data table location.
  65    */
  66   return table;
  67 }
  68
  69 class pkgArchiveNameList
  70 {
  71   /* A locally implemented class, managing a LIFO stack of
  72    * package names; this is used when processing the source
  73    * and licence requests, to track the packages processed,
  74    * so that we may avoid inadvertent duplicate processing.
  75    */
  76   private:
  77     const char          *name;  // name of package tracked
  78     pkgArchiveNameList  *next;  // pointer to next stack entry
  79
  80   public:
  81     inline bool NotRecorded( const char *candidate )
  82     {
  83       /* Walk the stack of tracked package names, to determine
  84        * if an entry matching "candidate" is already present;
  85        * returns false if such an entry exists, otherwise true
  86        * to indicate that it may be added as a unique entry.
  87        */
  88       pkgArchiveNameList *check = this;
  89       while( check != NULL )
  90       {
  91         /* We haven't walked off the bottom of the stack yet...
  92          */
  93         if( strcmp( check->name, candidate ) == 0 )
  94         {
  95           /* ...and the current entry matches the candidate;
  96            * thus the candidate will not be stacked, so we
  97            * may discard it from the heap.
  98            */
  99           free( (void *)(candidate) );
 100
 101           /* We've found a match, so there is no point in
 102            * continuing the search; simply return false to
 103            * signal rejection of the candidate.
 104            */
 105           return false;
 106         }
 107         /* No matching entry found yet; walk down to the next
 108          * stack entry, if any, to continue the search.
 109          */
 110         check = check->next;
 111       }
 112       /* We walked off the bottom of the stack, without finding
 113        * any match; return true to accept the candidate.
 114        */
 115       return true;
 116     }
 117     inline pkgArchiveNameList *Record( const char *candidate )
 118     {
 119       /* Add a new entry at the top of the stack, to record
 120        * the processing of an archive named by "candidate";
 121        * on entry "this" is the current stack pointer, and
 122        * we return the new stack pointer, referring to the
 123        * added entry which becomes the new top of stack.
 124        */
 125       pkgArchiveNameList *retptr = new pkgArchiveNameList();
 126       retptr->name = candidate; retptr->next = this;
 127       return retptr;
 128     }
 129     inline ~pkgArchiveNameList()
 130     {
 131       /* Completely clear the stack, releasing the heap memory
 132        * allocated to record the stacked package names.
 133        */
 134       free( (void *)(name) );
 135       delete next;
 136     }
 137 };
 138
 139 static pkgArchiveNameList *pkgProcessedArchives; // stack pointer
 140
 141 EXTERN_C int climain( int argc, char **argv )
 142 {
 143   try
 144   { /* Set up the diagnostic message handler, using the console's
 145      * `stderr' stream for notifications, and tagging messages with
 146      * the program basename derived from argv[0]...
 147      */
 148     char *dmh_progname;
 149     char progname[ 1 + strlen( dmh_progname = strdup( basename( *argv++ ))) ];
 150     dmh_init( DMH_SUBSYSTEM_TTY, strcpy( progname, dmh_progname ) );
 151     free( dmh_progname );
 152
 153     /* Interpret the `action keyword', specifying the action to be
 154      * performed on this invocation...
 155      */
 156     int action = action_code( *argv );
 157     if( action < 0 )
 158       /*
 159        * The specified action keyword was invalid;
 160        * force an abort through a DMH_FATAL notification...
 161        */
 162       dmh_notify( DMH_FATAL, "%s: unknown action keyword\n", *argv );
 163
 164     /* If we get to here, then the specified action identifies a
 165      * valid operation; load the package database, according to the
 166      * local `profile' configuration, and invoke the operation.
 167      */
 168     const char *dfile;
 169     if( access( dfile = xmlfile( profile_key ), R_OK ) != 0 )
 170     {
 171       /* The user hasn't provided a custom configuration profile...
 172        */
 173       dmh_notify( DMH_WARNING, "%s: user configuration file missing\n", dfile );
 174
 175       /* ...release the memory allocated by xmlfile(), to store its path name,
 176        * then try the mingw-get distribution default profile instead.
 177        */
 178       free( (void *)(dfile) );
 179       dmh_notify( DMH_INFO, "%s: trying system default configuration\n",
 180           dfile = xmlfile( defaults_key ) );
 181     }
 182
 183     pkgXmlDocument dbase( dfile );
 184     if( dbase.IsOk() )
 185     {
 186       /* We successfully loaded the basic settings...
 187        * The configuration file name was pushed on to the heap,
 188        * by xmlfile(); we don't need that any more, (because it
 189        * is reproduced within the database image itself), so
 190        * free the heap copy, to avoid memory leaks.
 191        */
 192       free( (void *)(dfile) );
 193
 194       /* Merge all package lists, as specified in the "repository"
 195        * section of the "profile", into the XML database tree...
 196        */
 197       if( dbase.BindRepositories( action == ACTION_UPDATE ) == NULL )
 198         /*
 199          * ...bailing out, on an invalid profile specification...
 200          */
 201         dmh_notify( DMH_FATAL, "%s: invalid application profile\n", dbase.Value() );
 202
 203       /* If the requested action was "update", then we've already done it,
 204        * as a side effect of binding the cached repository catalogues...
 205        */
 206       if( action != ACTION_UPDATE )
 207       {
 208         /* ...otherwise, we need to load the system map...
 209          */
 210         dbase.LoadSystemMap();
 211
 212         /* ...and invoke the appropriate action handler.
 213          */
 214         switch( action )
 215         {
 216           case ACTION_LIST:
 217           case ACTION_SHOW:
 218             /*
 219              * "list" and "show" actions are synonymous;
 220              * invoke the info-display handler.
 221              */
 222             dbase.DisplayPackageInfo( argc, argv );
 223             break;
 224
 225           case ACTION_SOURCE:
 226           case ACTION_LICENCE:
 227             /*
 228              * Process the "source" or "licence" request for one
 229              * or more packages; begin with an empty stack of names,
 230              * for tracking packages as processed.
 231              */
 232             pkgProcessedArchives = NULL;
 233             if( pkgOptions()->Test( OPTION_ALL_DEPS ) == OPTION_ALL_DEPS )
 234             {
 235               /* The "--all-related" option is in effect; for each
 236                * package identified on the command line...
 237                */
 238               while( --argc )
 239                 /*
 240                  * ...schedule a request to install the package,
 241                  * together with all of its runtime dependencies...
 242                  */
 243                 dbase.Schedule( ACTION_INSTALL, *++argv );
 244
 245               /* ...but DON'T proceed with installation; rather
 246                * process the "source" or "licence" request for
 247                * each scheduled package.
 248                */
 249               dbase.GetScheduledSourceArchives( (unsigned long)(action) );
 250             }
 251             else while( --argc )
 252               /*
 253                * The "--all-related" option is NOT in effect; simply
 254                * process the "source" or "licence" request exclusively
 255                * in respect of each package named on the command line.
 256                */
 257               dbase.GetSourceArchive( *++argv, (unsigned long)(action) );
 258
 259             /* Finally, clear the stack of processed package names.
 260              */
 261             delete pkgProcessedArchives;
 262             break;
 263
 264           default:
 265             /* ...schedule the specified action for each additional command line
 266              * argument, (each of which is assumed to represent a package name)...
 267              */
 268             while( --argc )
 269               dbase.Schedule( (unsigned long)(action), *++argv );
 270
 271             /* ...finally, execute all scheduled actions, and update the
 272              * system map accordingly.
 273              */
 274             dbase.ExecuteActions();
 275             dbase.UpdateSystemMap();
 276         }
 277       }
 278
 279       /* If we get this far, then all actions completed successfully;
 280        * we are done.
 281        */
 282       return EXIT_SUCCESS;
 283     }
 284
 285     /* If we get to here, then the package database load failed;
 286      * once more, we force an abort through a DMH_FATAL notification...
 287      *
 288      * Note: although dmh_notify does not return, in the DMH_FATAL case,
 289      * GCC cannot know this, so we pretend that it gives us a return value,
 290      * to avoid a possible warning about reaching the end of a non-void
 291      * function without a return value assignment...
 292      */
 293     return dmh_notify( DMH_FATAL, "%s: cannot load configuration\n", dfile );
 294   }
 295
 296   catch( dmh_exception &e )
 297   {
 298     /* An error occurred; it should already have been diagnosed,
 299      * so simply bail out.
 300      */
 301     return EXIT_FAILURE;
 302   }
 303 }
 304
 305 #include "pkgproc.h"
 306
 307 void pkgActionItem::GetSourceArchive( pkgXmlNode *package, unsigned long category )
 308 {
 309   /* Handle a 'mingw-get source ...' or a 'mingw-get licence ...' request
 310    * in respect of the source code or licence archive for a single package.
 311    */
 312   const char *src = package->SourceArchiveName( category );
 313   if( (src != NULL) && pkgProcessedArchives->NotRecorded( src ) )
 314   {
 315     if( pkgOptions()->Test( OPTION_PRINT_URIS ) == OPTION_PRINT_URIS )
 316     {
 317       /* The --print-uris option is in effect; this is all
 318        * that we are expected to do.
 319        */
 320       PrintURI( src );
 321     }
 322
 323     else
 324     { /* The --print-uris option is not in effect; we must at
 325        * least check that the source package is available in the
 326        * source archive cache, and if not, download it...
 327        */
 328       const char *path_template;
 329       DownloadSingleArchive( src, path_template = (category == ACTION_SOURCE)
 330           ? pkgSourceArchivePath() : pkgArchivePath()
 331         );
 332
 333       /* ...then, unless the --download-only option is in effect...
 334        */
 335       if( pkgOptions()->Test( OPTION_DOWNLOAD_ONLY ) != OPTION_DOWNLOAD_ONLY )
 336       {
 337         /* ...we establish the current working directory as the
 338          * destination where it should be unpacked...
 339          */
 340         char source_archive[mkpath( NULL, path_template, src, NULL )];
 341         mkpath( source_archive, path_template, src, NULL );
 342
 343         /* ...and extract the content from the source archive.
 344          */
 345         pkgTarArchiveExtractor unpack( source_archive, "." );
 346       }
 347       /* The path_template was allocated on the heap; we are
 348        * done with it, so release the memory allocation...
 349        */
 350       free( (void *)(path_template) );
 351     }
 352
 353     /* Record the current archive name as "processed", so we may
 354      * avoid any inadvertent duplicate processing.
 355      */
 356     pkgProcessedArchives = pkgProcessedArchives->Record( src );
 357   }
 358 }
 359
 360 void pkgActionItem::GetScheduledSourceArchives( unsigned long category )
 361 {
 362   /* Process "source" or "licence" requests in respect of a list of
 363    * packages, (scheduled as if for installation); this is the handler
 364    * for the case when the "--all-related" option is in effect for a
 365    * "source" or "licence" request.
 366    */
 367   if( this != NULL )
 368   {
 369     /* The package list is NOT empty; ensure that we begin with
 370      * a reference to its first entry.
 371      */
 372     pkgActionItem *scheduled = this;
 373     while( scheduled->prev != NULL ) scheduled = scheduled->prev;
 374
 375     /* For each scheduled list entry...
 376      */
 377     while( scheduled != NULL )
 378     {
 379       /* ...process the "source" or "licence" request, as appropriate,
 380        * in respect of the associated package...
 381        */
 382       scheduled->GetSourceArchive( scheduled->Selection(), category );
 383       /*
 384        * ...then move on to the next entry, if any.
 385        */
 386       scheduled = scheduled->next;
 387     }
 388   }
 389 }
 390
 391 void pkgXmlDocument::GetSourceArchive( const char *name, unsigned long category )
 392 {
 393   /* Look up a named package reference in the XML catalogue,
 394    * then forward it as a pkgActionItem, for processing of an
 395    * associated "source" or "licence" request.
 396    */
 397   pkgXmlNode *pkg = FindPackageByName( name );
 398   if( pkg->IsElementOfType( package_key ) )
 399   {
 400     /* We found a top-level specification for the required package...
 401      */
 402     pkgXmlNode *component = pkg->FindFirstAssociate( component_key );
 403     if( component != NULL )
 404       /*
 405        * When this package is subdivided into components,
 406        * then we derive the source reference from the first
 407        * component defined.
 408        */
 409       pkg = component;
 410   }
 411
 412   /* Now inspect the "release" specifications within the
 413    * selected package/component definition...
 414    */
 415   if( (pkg = pkg->FindFirstAssociate( release_key )) != NULL )
 416   {
 417     /* ...creating a pkgActionItem...
 418      */
 419     pkgActionItem latest;
 420     pkgXmlNode *selected = pkg;
 421
 422     /* ...and examining each release in turn...
 423      */
 424     while( pkg != NULL )
 425     {
 426       /* ...select the most recent release, and assign it
 427        * to the pkgActionItem reference...
 428        */
 429       if( latest.SelectIfMostRecentFit( pkg ) == pkg )
 430         latest.SelectPackage( selected = pkg );
 431
 432       /* ...continuing until we have examined all available
 433        * release specifications.
 434        */
 435       pkg = pkg->FindNextAssociate( release_key );
 436     }
 437
 438     /* Finally, hand off the "source" or "licence" processing
 439      * request, based on the most recent release selection, to
 440      * the pkgActionItem we've just instantiated.
 441      */
 442     latest.GetSourceArchive( selected, category );
 443   }
 444 }
 445
 446 /* $RCSfile$: end of file */