Index: update-package.c
===================================================================
--- update-package.c (nonexistent)
+++ update-package.c (revision 5)
@@ -0,0 +1,3425 @@
+
+/**********************************************************************
+
+ Copyright 2019 Andrey V.Kosteltsev
+
+ Licensed under the Radix.pro License, Version 1.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ https://radix.pro/licenses/LICENSE-1.0-en_US.txt
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied.
+
+ **********************************************************************/
+
+#include <config.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/sysinfo.h>
+#include <sys/types.h>
+#include <stdint.h>
+#include <dirent.h>
+#include <sys/stat.h> /* chmod(2) */
+#include <sys/file.h> /* flock(2) */
+#include <fcntl.h>
+#include <linux/limits.h>
+#include <alloca.h> /* alloca(3) */
+#include <string.h> /* strdup(3) */
+#include <strings.h> /* index(3) */
+#include <libgen.h> /* basename(3) */
+#include <ctype.h> /* tolower(3) */
+#include <errno.h>
+#include <time.h>
+#include <sys/time.h>
+#include <pwd.h>
+#include <grp.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+#include <math.h>
+
+#include <sys/wait.h>
+
+#include <sys/resource.h>
+
+#include <signal.h>
+#if !defined SIGCHLD && defined SIGCLD
+# define SIGCHLD SIGCLD
+#endif
+
+#define _GNU_SOURCE
+#include <getopt.h>
+
+#include <config.h>
+
+#include <msglog.h>
+#include <wrapper.h>
+#include <system.h>
+
+#include <cmpvers.h>
+#include <dlist.h>
+
+#if defined( HAVE_DIALOG )
+#include <dialog-ui.h>
+#endif
+
+#define PROGRAM_NAME "update-package"
+
+#include <defs.h>
+
+
+char *program = PROGRAM_NAME;
+char *root = NULL, *pkgs_path = NULL, *rempkgs_path = NULL, *remlog_fname = NULL,
+ *pkg_fname = NULL, *asc_fname = NULL, *pkglog_fname = NULL, *pkglist_fname = NULL,
+ *tmpdir = NULL, *rtmpdir = NULL, *curdir = NULL, *log_fname = NULL;
+
+int ask = 0, rqck = 0, gpgck = 0, reinstall = 0, ignore_chrefs_errors = 0;
+char *description = NULL;
+
+int exit_status = EXIT_SUCCESS; /* errors counter */
+char *selfdir = NULL;
+
+static char *pkgname = NULL,
+ *pkgver = NULL,
+ *arch = NULL,
+ *distroname = NULL,
+ *distrover = NULL,
+ *group = NULL,
+ *short_description = NULL,
+ *url = NULL,
+ *license = NULL,
+ *uncompressed_size = NULL,
+ *compressed_size = NULL,
+ *total_files = NULL;
+
+static char *installed_version = NULL;
+static char *installed_group = NULL;
+
+enum _update_mode {
+ CONSOLE = 0,
+ INFODIALOG,
+ MENUDIALOG
+} update_mode = CONSOLE;
+
+enum _priority {
+ REQUIRED = 0, /* synonims: REQUIRED | required | REQ | req */
+ RECOMMENDED, /* synonims: RECOMMENDED | recommended | REC | rec */
+ OPTIONAL, /* synonims: OPTIONAL | optional | OPT | opt */
+ SKIP /* synonims: SKIP | skip | SKP | skp */
+} priority = REQUIRED;
+
+enum _procedure
+{
+ INSTALL = 0, /* 'install' */
+ UPDATE /* 'update' */
+} procedure = UPDATE;
+
+enum _input_type {
+ IFMT_PKG = 0,
+ IFMT_LOG,
+
+ IFMT_UNKNOWN
+} input_format = IFMT_PKG;
+
+char uncompress = '\0';
+
+static struct dlist *rdirs = NULL;
+static struct dlist *rfiles = NULL;
+static struct dlist *rlinks = NULL;
+
+static struct dlist *dirs = NULL;
+static struct dlist *files = NULL;
+static struct dlist *links = NULL;
+
+static void free_list( struct dlist *list );
+
+
+#define FREE_PKGINFO_VARIABLES() \
+ if( pkgname ) { free( pkgname ); } pkgname = NULL; \
+ if( pkgver ) { free( pkgver ); } pkgver = NULL; \
+ if( arch ) { free( arch ); } arch = NULL; \
+ if( distroname ) { free( distroname ); } distroname = NULL; \
+ if( distrover ) { free( distrover ); } distrover = NULL; \
+ if( group ) { free( group ); } group = NULL; \
+ if( short_description ) { free( short_description ); } short_description = NULL; \
+ if( description ) { free( description ); } description = NULL; \
+ if( url ) { free( url ); } url = NULL; \
+ if( license ) { free( license ); } license = NULL; \
+ if( uncompressed_size ) { free( uncompressed_size ); } uncompressed_size = NULL; \
+ if( compressed_size ) { free( compressed_size ); } compressed_size = NULL; \
+ if( total_files ) { free( total_files ); } total_files = NULL; \
+ if( installed_version ) { free( installed_version ); } installed_version = NULL; \
+ if( installed_group ) { free( installed_group ); } installed_group = NULL
+
+void free_resources()
+{
+ if( root ) { free( root ); root = NULL; }
+ if( pkgs_path ) { free( pkgs_path ); pkgs_path = NULL; }
+ if( rempkgs_path ) { free( rempkgs_path ); rempkgs_path = NULL; }
+ if( pkg_fname ) { free( pkg_fname ); pkg_fname = NULL; }
+ if( asc_fname ) { free( asc_fname ); asc_fname = NULL; }
+ if( pkglog_fname ) { free( pkglog_fname ); pkglog_fname = NULL; }
+ if( remlog_fname ) { free( remlog_fname ); remlog_fname = NULL; }
+
+ if( pkglist_fname ) { free( pkglist_fname ); pkglist_fname = NULL; }
+
+ if( rdirs ) { free_list( rdirs ); rdirs = NULL; }
+ if( rfiles ) { free_list( rfiles ); rfiles = NULL; }
+ if( rlinks ) { free_list( rlinks ); rlinks = NULL; }
+
+ if( dirs ) { free_list( dirs ); dirs = NULL; }
+ if( files ) { free_list( files ); files = NULL; }
+ if( links ) { free_list( links ); links = NULL; }
+
+ if( rtmpdir ) { free( rtmpdir ); rtmpdir = NULL; }
+ if( curdir ) { free( curdir ); curdir = NULL; }
+ if( log_fname ) { free( log_fname ); log_fname = NULL; }
+
+ if( selfdir ) { free( selfdir ); selfdir = NULL; }
+
+ FREE_PKGINFO_VARIABLES();
+}
+
+void usage()
+{
+ free_resources();
+
+ fprintf( stdout, "\n" );
+ fprintf( stdout, "Usage: %s [options] <package>\n", program );
+ fprintf( stdout, "\n" );
+ fprintf( stdout, "Update package.\n" );
+ fprintf( stdout, "\n" );
+ fprintf( stdout, "Options:\n" );
+ fprintf( stdout, " -h,--help Display this information.\n" );
+ fprintf( stdout, " -v,--version Display the version of %s utility.\n", program );
+ fprintf( stdout, " -a,--always-ask Used with menudialog mode: always ask\n" );
+ fprintf( stdout, " if a package should be updated regardless\n" );
+ fprintf( stdout, " of what the package priority is. Without\n" );
+ fprintf( stdout, " this option, if the priority is equal to\n" );
+ fprintf( stdout, " REQUIRED, the package is updateded without\n" );
+ fprintf( stdout, " asking for confirmation the update.\n" );
+ fprintf( stdout, " -c,--check-requires Check package requires before update.\n" );
+#if defined( HAVE_GPG2 )
+ fprintf( stdout, " -g,--gpg-verify Verify GPG2 signature. The signature must be\n" );
+ fprintf( stdout, " saved in a file whose name is the same as the\n" );
+ fprintf( stdout, " package file name, but with the extension '.asc'\n" );
+ fprintf( stdout, " and located in the same directory as the package.\n" );
+#endif
+ fprintf( stdout, " --ignore-chrefs-errors Ignore change references errors (code: 48).\n" );
+#if defined( HAVE_DIALOG )
+ fprintf( stdout, " -i,--info-dialog Show package description during update\n" );
+ fprintf( stdout, " process using ncurses dialog.\n" );
+ fprintf( stdout, " -m,--menu-dialog Ask for confirmation the update,\n" );
+ fprintf( stdout, " unless the priority is REQUIRED.\n" );
+#endif
+ fprintf( stdout, " -l,--pkglist=<FILENAME> Specify a different package list file\n" );
+ fprintf( stdout, " to use for read package priority and type\n" );
+ fprintf( stdout, " of install procedure. By default used the\n" );
+ fprintf( stdout, " '.pkglist' file found in the directory\n" );
+ fprintf( stdout, " where source package is placed.\n" );
+ fprintf( stdout, " -p,--priority=<required|recommended|optional|skip>\n" );
+ fprintf( stdout, " Provides a priority of package instead of\n" );
+ fprintf( stdout, " the priority defined in the .pkglist file.\n" );
+ fprintf( stdout, " --reinstall Reinstall even if the package is already\n" );
+ fprintf( stdout, " installed correctly.\n" );
+ fprintf( stdout, " Without this option, the already installed package\n" );
+ fprintf( stdout, " will not be updated. The update procedure will be\n" );
+ fprintf( stdout, " stopped with success return code.\n" );
+ fprintf( stdout, " -r,--root=<DIR> Target rootfs path.\n" );
+ fprintf( stdout, "\n" );
+ fprintf( stdout, "Parameter:\n" );
+ fprintf( stdout, " <package> The PACKAGE tarball.\n" );
+ fprintf( stdout, "\n" );
+ fprintf( stdout, "Return codes:\n" );
+ fprintf( stdout, " ------+-------------------------------------------------------\n" );
+ fprintf( stdout, " code | status\n" );
+ fprintf( stdout, " ------+-------------------------------------------------------\n" );
+ fprintf( stdout, " 30 | package is not installed\n" );
+ fprintf( stdout, " ----+----\n" );
+ fprintf( stdout, " 41 | update is aborted due to priority=SKIP\n" );
+ fprintf( stdout, " 42 | .pkglist appointed the 'install' procedure instead\n" );
+ fprintf( stdout, " 43 | pre-update script returned error status\n" );
+ fprintf( stdout, " 44 | uncompress process returned error status\n" );
+ fprintf( stdout, " 45 | restore-links script returned error status\n" );
+ fprintf( stdout, " 46 | post-update script returned error status\n" );
+ fprintf( stdout, " 47 | PKGLOG cannot be stored in the Setup Database\n" );
+ fprintf( stdout, " 48 | references cannot be updated in Setup Database\n" );
+ fprintf( stdout, " 49 | requires cannot be updated in Setup Database\n" );
+#if defined( HAVE_GPG2 )
+ fprintf( stdout, " ----+----\n" );
+ fprintf( stdout, " 51 | signature verification returned error status\n" );
+#endif
+ fprintf( stdout, " ------+-------------------------------------------------------\n" );
+ fprintf( stdout, "\n" );
+ fprintf( stdout, "Upon successful completion zero is returned. Other non-zero return\n" );
+ fprintf( stdout, "codes imply incorrect completion of the update procedure.\n" );
+ fprintf( stdout, "\n" );
+
+ exit( EXIT_FAILURE );
+}
+
+void to_lowercase( char *s )
+{
+ char *p = s;
+ while( p && *p ) { int c = *p; *p = tolower( c ); ++p; }
+}
+
+void to_uppercase( char *s )
+{
+ char *p = s;
+ while( p && *p ) { int c = *p; *p = toupper( c ); ++p; }
+}
+
+void version()
+{
+ char *upper = NULL;
+
+ upper = (char *)alloca( strlen( program ) + 1 );
+
+ strcpy( (char *)upper, (const char *)program );
+ to_uppercase( upper );
+
+ fprintf( stdout, "%s (%s) %s\n", program, upper, PROGRAM_VERSION );
+
+ fprintf( stdout, "Copyright (C) 2019 Andrey V.Kosteltsev.\n" );
+ fprintf( stdout, "This is free software. There is NO warranty; not even\n" );
+ fprintf( stdout, "for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" );
+ fprintf( stdout, "\n" );
+
+ free_resources();
+ exit( EXIT_SUCCESS );
+}
+
+
+static void remove_trailing_slash( char *dir )
+{
+ char *s;
+
+ if( !dir || dir[0] == '\0' ) return;
+
+ s = dir + strlen( dir ) - 1;
+ while( *s == '/' )
+ {
+ *s = '\0'; --s;
+ }
+}
+
+
+static void bind_asc_extention( char *name )
+{
+ char *p = NULL, *q = NULL;
+
+ if( (p = rindex( name, '.' )) && (strlen(p) < 5) )
+ {
+ if( !strncmp( p, ".gz", 3 ) ||
+ !strncmp( p, ".bz2", 4 ) ||
+ !strncmp( p, ".xz", 3 ) )
+ {
+ *p = '\0';
+ q = rindex( name, '.' );
+ if( q && (strlen(q) < 5) && !strncmp( q, ".tar", 4 ) )
+ {
+ *q = '\0';
+ }
+ }
+ else if( !strncmp( p, ".tar", 4 ) ||
+ !strncmp( p, ".tbz", 4 ) ||
+ !strncmp( p, ".tgz", 4 ) ||
+ !strncmp( p, ".txz", 4 ) )
+ {
+ *p = '\0';
+ }
+ }
+
+ (void)strcat( name, ".asc" );
+}
+
+////////////////////////////////////////////////////
+//static char *strmode( enum _update_mode mode )
+//{
+// char *p = NULL;
+//
+// switch( mode )
+// {
+// case CONSOLE:
+// p = "CONSOLE";
+// break;
+// case INFODIALOG:
+// p = "INFODIALOG";
+// break;
+// case MENUDIALOG:
+// p = "MENUDIALOG";
+// break;
+// }
+// return p;
+//}
+////////////////////////////////////////////////////
+
+static char *strprio( enum _priority priority, int short_name )
+{
+ char *p = NULL;
+
+ switch( priority )
+ {
+ case REQUIRED:
+ p = ( short_name ) ? "REQ" : "required";
+ break;
+ case RECOMMENDED:
+ p = ( short_name ) ? "REC" : "recommended";
+ break;
+ case OPTIONAL:
+ p = ( short_name ) ? "OPT" : "optional";
+ break;
+ case SKIP:
+ p = ( short_name ) ? "SKP" : "skip";
+ break;
+ }
+ return p;
+}
+
+static char *strproc( enum _procedure procedure )
+{
+ char *p = NULL;
+
+ switch( procedure )
+ {
+ case INSTALL:
+ p = "install";
+ break;
+ case UPDATE:
+ p = "update";
+ break;
+ }
+ return p;
+}
+
+
+static int _mkdir_p( const char *dir, const mode_t mode )
+{
+ char *buf;
+ char *p = NULL;
+ struct stat sb;
+
+ if( !dir ) return -1;
+
+ buf = (char *)alloca( strlen( dir ) + 1 );
+ strcpy( buf, dir );
+
+ remove_trailing_slash( buf );
+
+ /* check if path exists and is a directory */
+ if( stat( buf, &sb ) == 0 )
+ {
+ if( S_ISDIR(sb.st_mode) )
+ {
+ return 0;
+ }
+ }
+
+ /* mkdir -p */
+ for( p = buf + 1; *p; ++p )
+ {
+ if( *p == '/' )
+ {
+ *p = 0;
+ /* test path */
+ if( stat( buf, &sb ) != 0 )
+ {
+ /* path does not exist - create directory */
+ if( mkdir( buf, mode ) < 0 )
+ {
+ return -1;
+ }
+ } else if( !S_ISDIR(sb.st_mode) )
+ {
+ /* not a directory */
+ return -1;
+ }
+ *p = '/';
+ }
+ }
+
+ /* test path */
+ if( stat( buf, &sb ) != 0 )
+ {
+ /* path does not exist - create directory */
+ if( mkdir( buf, mode ) < 0 )
+ {
+ return -1;
+ }
+ } else if( !S_ISDIR(sb.st_mode) )
+ {
+ /* not a directory */
+ return -1;
+ }
+
+ return 0;
+}
+
+static void _rm_tmpdir( const char *dirpath )
+{
+ DIR *dir;
+ char *path;
+ size_t len;
+
+ struct stat path_sb, entry_sb;
+ struct dirent *entry;
+
+ if( stat( dirpath, &path_sb ) == -1 )
+ {
+ return; /* stat returns error code; errno is set */
+ }
+
+ if( S_ISDIR(path_sb.st_mode) == 0 )
+ {
+ return; /* dirpath is not a directory */
+ }
+
+ if( (dir = opendir(dirpath) ) == NULL )
+ {
+ return; /* Cannot open direcroty; errno is set */
+ }
+
+ len = strlen( dirpath );
+
+ while( (entry = readdir( dir )) != NULL)
+ {
+
+ /* skip entries '.' and '..' */
+ if( ! strcmp( entry->d_name, "." ) || ! strcmp( entry->d_name, ".." ) ) continue;
+
+ /* determinate a full name of an entry */
+ path = alloca( len + strlen( entry->d_name ) + 2 );
+ strcpy( path, dirpath );
+ strcat( path, "/" );
+ strcat( path, entry->d_name );
+
+ if( stat( path, &entry_sb ) == 0 )
+ {
+ if( S_ISDIR(entry_sb.st_mode) )
+ {
+ /* recursively remove a nested directory */
+ _rm_tmpdir( path );
+ }
+ else
+ {
+ /* remove a file object */
+ (void)unlink( path );
+ }
+ }
+ /* else { stat() returns error code; errno is set; and we have to continue the loop } */
+
+ }
+
+ /* remove the devastated directory and close the object of this directory */
+ (void)rmdir( dirpath );
+
+ closedir( dir );
+}
+
+static char *_mk_tmpdir( void )
+{
+ char *buf = NULL, *p, *tmp = "/tmp";
+ size_t len = 0, size = 0;
+
+ (void)umask( S_IWGRP | S_IWOTH ); /* octal 022 */
+
+ /* Get preferred directory for tmp files */
+ if( (p = getenv( "TMP" )) != NULL ) {
+ tmp = p;
+ }
+ else if( (p = getenv( "TEMP" )) != NULL ) {
+ tmp = p;
+ }
+
+ size = strlen( tmp ) + strlen( DISTRO_NAME ) + strlen( program ) + 12;
+
+ buf = (char *)malloc( size );
+ if( !buf ) return NULL;
+
+ len = snprintf( buf, size, (const char *)"%s/%s/%s-%.7u", tmp, DISTRO_NAME, program, getpid() );
+ if( len == 0 || len == size - 1 )
+ {
+ free( buf ); return NULL;
+ }
+
+ _rm_tmpdir( (const char *)&buf[0] );
+
+ if( _mkdir_p( buf, S_IRWXU | S_IRWXG | S_IRWXO ) == 0 )
+ {
+ return buf;
+ }
+
+ free( buf ); return NULL;
+}
+
+
+void fatal_error_actions( void )
+{
+ logmsg( errlog, MSG_NOTICE, "Free resources on FATAL error..." );
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+}
+
+void sigint( int signum )
+{
+ (void)signum;
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+}
+
+static void set_signal_handlers()
+{
+ struct sigaction sa;
+ sigset_t set;
+
+ memset( &sa, 0, sizeof( sa ) );
+ sa.sa_handler = sigint; /* TERM, INT */
+ sa.sa_flags = SA_RESTART;
+ sigemptyset( &set );
+ sigaddset( &set, SIGTERM );
+ sigaddset( &set, SIGINT );
+ sa.sa_mask = set;
+ sigaction( SIGTERM, &sa, NULL );
+ sigaction( SIGINT, &sa, NULL );
+
+ memset( &sa, 0, sizeof( sa ) ); /* ignore SIGPIPE */
+ sa.sa_handler = SIG_IGN;
+ sa.sa_flags = 0;
+ sigaction( SIGPIPE, &sa, NULL );
+
+ /* System V fork+wait does not work if SIGCHLD is ignored */
+ signal( SIGCHLD, SIG_DFL );
+}
+
+
+static enum _input_type check_input_file( char *uncompress, const char *fname )
+{
+ struct stat st;
+ size_t pkglog_size = 0;
+ unsigned char buf[8];
+ int rc, fd;
+
+ /* SIGNATURES: https://www.garykessler.net/library/file_sigs.html */
+
+ if( uncompress )
+ {
+ *uncompress = '\0';
+ }
+
+ if( stat( fname, &st ) == -1 )
+ {
+ FATAL_ERROR( "Cannot access %s file: %s", basename( (char *)fname ), strerror( errno ) );
+ }
+
+ pkglog_size = st.st_size;
+
+ if( (fd = open( fname, O_RDONLY )) == -1 )
+ {
+ FATAL_ERROR( "Cannot open %s file: %s", basename( (char *)fname ), strerror( errno ) );
+ }
+
+ rc = (int)read( fd, (void *)&buf[0], 7 );
+ if( rc != 7 )
+ {
+ close( fd ); return IFMT_UNKNOWN;
+ }
+ buf[7] = '\0';
+
+ /* TEXT */
+ if( !strncmp( (const char *)&buf[0], "PACKAGE", 7 ) )
+ {
+ close( fd ); return IFMT_LOG;
+ }
+
+ /* GZ */
+ if( buf[0] == 0x1F && buf[1] == 0x8B && buf[2] == 0x08 )
+ {
+ if( uncompress ) { *uncompress = 'x'; }
+ close( fd ); return IFMT_PKG;
+ }
+
+ /* BZ2 */
+ if( buf[0] == 0x42 && buf[1] == 0x5A && buf[2] == 0x68 )
+ {
+ if( uncompress ) { *uncompress = 'j'; }
+ close( fd ); return IFMT_PKG;
+ }
+
+ /* XZ */
+ if( buf[0] == 0xFD && buf[1] == 0x37 && buf[2] == 0x7A &&
+ buf[3] == 0x58 && buf[4] == 0x5A && buf[5] == 0x00 )
+ {
+ if( uncompress ) { *uncompress = 'J'; }
+ close( fd ); return IFMT_PKG;
+ }
+
+ if( pkglog_size > 262 )
+ {
+ if( lseek( fd, 257, SEEK_SET ) == -1 )
+ {
+ FATAL_ERROR( "Cannot check signature of %s file: %s", basename( (char *)fname ), strerror( errno ) );
+ }
+ rc = (int)read( fd, &buf[0], 5 );
+ if( rc != 5 )
+ {
+ FATAL_ERROR( "Cannot read signature of %s file", basename( (char *)fname ) );
+ }
+ /* TAR */
+ if( buf[0] == 0x75 && buf[1] == 0x73 && buf[2] == 0x74 && buf[3] == 0x61 && buf[4] == 0x72 )
+ {
+ close( fd ); return IFMT_PKG;
+ }
+ }
+
+ close( fd ); return IFMT_UNKNOWN;
+}
+
+
+void get_args( int argc, char *argv[] )
+{
+#if defined( HAVE_GPG2 )
+#if defined( HAVE_DIALOG )
+ const char* short_options = "hvacgiml:p:r:";
+#else
+ const char* short_options = "hvacgl:p:r:";
+#endif
+#else
+#if defined( HAVE_DIALOG )
+ const char* short_options = "hvaciml:p:r:";
+#else
+ const char* short_options = "hvacl:p:r:";
+#endif
+#endif
+
+#define REINSTALL 812
+#define IGNORE_CHREFS_ERRORS 872
+
+ const struct option long_options[] =
+ {
+ { "help", no_argument, NULL, 'h' },
+ { "version", no_argument, NULL, 'v' },
+ { "always-ask", no_argument, NULL, 'a' },
+ { "check-requires", no_argument, NULL, 'c' },
+#if defined( HAVE_GPG2 )
+ { "gpg-verify", no_argument, NULL, 'g' },
+#endif
+ { "ignore-chrefs-errors", no_argument, NULL, IGNORE_CHREFS_ERRORS },
+#if defined( HAVE_DIALOG )
+ { "info-dialog", no_argument, NULL, 'i' },
+ { "menu-dialog", no_argument, NULL, 'm' },
+#endif
+ { "pkglist", required_argument, NULL, 'l' },
+ { "priority", required_argument, NULL, 'p' },
+ { "reinstall", no_argument, NULL, REINSTALL },
+ { "root", required_argument, NULL, 'r' },
+ { NULL, 0, NULL, 0 }
+ };
+
+ int ret;
+ int option_index = 0;
+
+ while( (ret = getopt_long( argc, argv, short_options, long_options, &option_index )) != -1 )
+ {
+ switch( ret )
+ {
+ case 'h':
+ {
+ usage();
+ break;
+ }
+ case 'v':
+ {
+ version();
+ break;
+ }
+ case 'a':
+ {
+ ask = 1;
+ break;
+ }
+ case 'c':
+ {
+ rqck = 1;
+ break;
+ }
+#if defined( HAVE_GPG2 )
+ case 'g':
+ {
+ gpgck = 1;
+ break;
+ }
+#endif
+
+#if defined( HAVE_DIALOG )
+ case 'i':
+ {
+ update_mode = INFODIALOG;
+ break;
+ }
+ case 'm':
+ {
+ update_mode = MENUDIALOG;
+ break;
+ }
+#endif
+
+ case REINSTALL:
+ {
+ reinstall = 1;
+ break;
+ }
+ case IGNORE_CHREFS_ERRORS:
+ {
+ ignore_chrefs_errors = 1;
+ break;
+ }
+
+ case 'p':
+ {
+ if( optarg != NULL )
+ {
+ char *match = NULL;
+
+ if( strlen( (const char *)optarg ) > 2 )
+ {
+ to_lowercase( optarg );
+ if( (match = strstr( optarg, "req" )) && match == optarg ) {
+ priority = REQUIRED;
+ }
+ else if( (match = strstr( optarg, "rec" )) && match == optarg ) {
+ priority = RECOMMENDED;
+ }
+
+ else if( (match = strstr( optarg, "opt" )) && match == optarg ) {
+ priority = OPTIONAL;
+ }
+ else if( (match = strstr( optarg, "sk" )) && match == optarg ) {
+ priority = SKIP;
+ }
+ else {
+ FATAL_ERROR( "Unknown --priority '%s' value", optarg );
+ }
+ }
+ else
+ {
+ FATAL_ERROR( "Unknown --priority '%s' value", optarg );
+ }
+ }
+ else
+ /* option is present but without value */
+ usage();
+ break;
+ }
+
+ case 'l':
+ {
+ if( optarg != NULL )
+ {
+ pkglist_fname = xstrdup( (const char *)optarg );
+ }
+ else
+ /* option is present but without value */
+ usage();
+ break;
+ }
+
+ case 'r':
+ {
+ if( optarg != NULL )
+ {
+ char cwd[PATH_MAX];
+
+ bzero( (void *)cwd, PATH_MAX );
+ if( optarg[0] != '/' && curdir )
+ {
+ /* skip current directory definition './' at start of argument: */
+ if( !strncmp( optarg, "./", 2 ) && strncmp( optarg, "..", 2 ) )
+ (void)sprintf( cwd, "%s/%s", curdir, optarg + 2 );
+ else if( (strlen( optarg ) == 1) && !strncmp( optarg, ".", 1 ) )
+ (void)sprintf( cwd, "%s", curdir );
+ else
+ (void)sprintf( cwd, "%s/%s", curdir, optarg );
+ root = xstrdup( (const char *)cwd );
+ }
+ else
+ {
+ root = xstrdup( (const char *)optarg );
+ }
+ remove_trailing_slash( root );
+ }
+ else
+ /* option is present but without value */
+ usage();
+ break;
+ }
+
+ case '?': default:
+ {
+ usage();
+ break;
+ }
+ }
+ }
+
+
+ if( optind < argc )
+ {
+ struct stat st;
+ char *buf = NULL;
+
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ buf = (char *)malloc( (size_t)PATH_MAX );
+ if( !buf ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)buf, PATH_MAX );
+
+ /* absolute path to input package: */
+ if( argv[optind][0] != '/' && curdir )
+ (void)sprintf( buf, "%s/%s", curdir, (const char *)argv[optind] );
+ else
+ (void)strcpy( buf, (const char *)argv[optind] );
+
+ if( stat( (const char *)&buf[0], &st ) == -1 )
+ {
+ FATAL_ERROR( "Cannot access '%s' file: %s", buf, strerror( errno ) );
+ }
+
+ if( S_ISREG(st.st_mode) )
+ {
+ pkg_fname = xstrdup( (const char *)&buf[0] );
+ bind_asc_extention( buf );
+ asc_fname = xstrdup( (const char *)&buf[0] );
+ free( buf );
+ }
+ else
+ {
+ FATAL_ERROR( "Input package '%s' is not a regular file", (const char *)argv[optind] );
+ }
+ }
+ else
+ {
+ usage();
+ }
+
+
+ if( !pkgs_path )
+ {
+ struct stat st;
+ char *buf = NULL;
+ int len;
+
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ buf = (char *)malloc( (size_t)PATH_MAX );
+ if( !buf ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)buf, PATH_MAX );
+
+ if( !root )
+ {
+ buf[0] = '/'; buf[1] = '\0';
+ root = xstrdup( (const char *)buf );
+ }
+ else
+ {
+ len = strlen( root );
+
+ (void)strcpy( buf, (const char *)root );
+ if( buf[ len - 1 ] != '/' )
+ {
+ buf[len] = '/'; buf[len+1] = '\0';
+ free( root ); root = xstrdup( (const char *)buf );
+ }
+ }
+
+ if( stat( (const char *)&buf[0], &st ) == -1 )
+ {
+ FATAL_ERROR( "Cannot access '%s' file or directory: %s", buf, strerror( errno ) );
+ }
+ if( !S_ISDIR(st.st_mode) )
+ {
+ FATAL_ERROR( "Defined --root '%s' is not a directory", buf );
+ }
+
+ len = strlen( (const char *)buf );
+
+ (void)strcat( buf, PACKAGES_PATH );
+ if( _mkdir_p( buf, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot access '/%s' directory", PACKAGES_PATH );
+ }
+ pkgs_path = xstrdup( (const char *)&buf[0] );
+
+ /*********************************************
+ Create other directories of Setup Database:
+ */
+ buf[len] = '\0';
+ (void)strcat( buf, REMOVED_PKGS_PATH );
+ if( _mkdir_p( buf, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot access '/%s' directory", REMOVED_PKGS_PATH );
+ }
+ rempkgs_path = xstrdup( (const char *)&buf[0] );
+
+ buf[len] = '\0';
+ (void)strcat( buf, SETUP_PATH );
+ if( _mkdir_p( buf, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot access '/%s' directory", SETUP_PATH );
+ }
+
+ /*********************************************
+ Allocate memory for Setup LOG File name:
+ */
+ buf[len] = '\0';
+ (void)strcat( buf, LOG_PATH );
+ (void)strcat( buf, SETUP_LOG_FILE );
+ log_fname = xstrdup( (const char *)&buf[0] );
+
+ free( buf );
+
+ } /* End if( !pkgs_path ) */
+}
+
+static void setup_log( char *format, ... )
+{
+ FILE *fp = NULL;
+
+ time_t t = time( NULL );
+ struct tm tm = *localtime(&t);
+
+ va_list argp;
+
+ if( ! format ) return;
+
+ fp = fopen( (const char *)log_fname, "a" );
+ if( !fp )
+ {
+ FATAL_ERROR( "Cannot open /%s%s file", LOG_PATH, SETUP_LOG_FILE );
+ }
+
+ fprintf( fp, "[%04d-%02d-%02d %02d:%02d:%02d]: ",
+ tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+ tm.tm_hour, tm.tm_min, tm.tm_sec );
+
+ va_start( argp, format );
+ vfprintf( fp, format, argp );
+ fprintf( fp, "\n" );
+
+ fflush( fp );
+ fclose( fp );
+}
+
+/***********************************************************
+ Remove leading spaces and take non-space characters only:
+ (Especialy for pkginfo lines)
+ */
+static char *skip_spaces( char *s )
+{
+ char *q, *p = (char *)0;
+
+ if( !s || *s == '\0' ) return p;
+
+ p = s;
+
+ while( (*p == ' ' || *p == '\t') && *p != '\0' ) { ++p; } q = p;
+ while( *q != ' ' && *q != '\t' && *q != '\0' ) { ++q; } *q = '\0';
+
+ if( *p == '\0' ) return (char *)0;
+
+ return( xstrdup( (const char *)p ) );
+}
+
+
+/*******************************
+ remove spaces at end of line:
+ */
+static void skip_eol_spaces( char *s )
+{
+ char *p = (char *)0;
+
+ if( !s || *s == '\0' ) return;
+
+ p = s + strlen( s ) - 1;
+ while( isspace( *p ) ) { *p-- = '\0'; }
+}
+
+
+static char *trim( char *s )
+{
+ char *p = (char *)0;
+
+ if( !s || *s == '\0' ) return p;
+
+ p = s + strlen( s ) - 1;
+ while( isspace( *p ) ) { *p-- = '\0'; }
+ p = s; while( isspace( *p ) ) { ++p; }
+
+ return( p );
+}
+
+
+static char *size_to_string( size_t pkgsize )
+{
+ int nd;
+ double sz = (double)pkgsize / (double)1024;
+
+ char *ret = NULL;
+ char *tmp = NULL;
+
+ tmp = (char *)malloc( PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ if( sz > (double)1048576 )
+ {
+ sz = sz / (double)1048576;
+ /*
+ NOTE:
+ ----
+ Операция округления до одного знака после десятичной точки: sz = round(sz*10.0)/10.0;
+ здесь не нужна; можно обойтись вычислением количества цифр, выводимых на печать с помощью
+ формата '%.*g':
+
+ Количество десятичных цифр, необходимое для предстваления целой части числа + 1(одна)
+ десятичная цифра после десятичной точки. Формат %.*g не будет выводить дробную часть
+ числа, если после округления, до одного знака после десятичной точки, дробная часть
+ равна нулю:
+ */
+ nd = (int)ceil(log10(floor(sz) + 1.0)) + 1;
+ (void)sprintf( (char *)&tmp[0], "%.*gG", nd, sz );
+ }
+ else if( sz > (double)1024 )
+ {
+ sz = sz / (double)1024;
+ nd = (int)ceil(log10(floor(sz) + 1.0)) + 1;
+ (void)sprintf( (char *)&tmp[0], "%.*gM", nd, sz );
+ }
+ else
+ {
+ nd = (int)ceil(log10(floor(sz) + 1.0)) + 1;
+ (void)sprintf( (char *)&tmp[0], "%.*gK", nd, sz );
+ }
+
+ ret = xstrdup( (const char *)&tmp[0] );
+ free( tmp );
+
+ return ret;
+}
+
+static void read_pkginfo( const char *pkginfo_fname )
+{
+ char *ln = NULL;
+ char *line = NULL;
+
+ FILE *pkginfo = NULL;
+
+ if( pkginfo_fname != NULL )
+ {
+ pkginfo = fopen( (const char *)pkginfo_fname, "r" );
+ if( !pkginfo )
+ {
+ FATAL_ERROR( "Cannot open %s file", pkginfo_fname );
+ }
+ }
+
+ line = (char *)malloc( (size_t)PATH_MAX );
+ if( !line )
+ {
+ FATAL_ERROR( "Cannot allocate memory" );
+ }
+
+ while( (ln = fgets( line, PATH_MAX, pkginfo )) )
+ {
+ char *match = NULL;
+
+ ln[strlen(ln) - 1] = '\0'; /* replace new-line symbol */
+ skip_eol_spaces( ln ); /* remove spaces at end-of-line */
+
+ if( (match = strstr( ln, "pkgname" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( pkgname ) { free( pkgname ); }
+ pkgname = skip_spaces( p );
+ }
+ }
+ if( (match = strstr( ln, "pkgver" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( pkgver ) { free( pkgver ); }
+ pkgver = skip_spaces( p );
+ }
+ }
+ if( (match = strstr( ln, "arch" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( arch ) { free( arch ); }
+ arch = skip_spaces( p );
+ }
+ }
+ if( (match = strstr( ln, "distroname" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( distroname ) { free( distroname ); }
+ distroname = skip_spaces( p );
+ }
+ }
+ if( (match = strstr( ln, "distrover" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( distrover ) { free( distrover ); }
+ distrover = skip_spaces( p );
+ }
+ }
+
+ if( (match = strstr( ln, "group" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( group ) { free( group ); }
+ group = skip_spaces( p );
+ }
+ }
+
+ if( (match = strstr( ln, "short_description" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ char *b = index( p, '"'),
+ *e = rindex( p, '"');
+ if( b && e && ( b != e ) )
+ {
+ p = ++b; *e = '\0';
+ if( short_description ) { free( short_description ); }
+ short_description = xstrdup( (const char *)p );
+ }
+ }
+ }
+ if( (match = strstr( ln, "url" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( url ) { free( url ); }
+ url = skip_spaces( p );
+ }
+ }
+ if( (match = strstr( ln, "license" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( license ) { free( license ); }
+ license = skip_spaces( p );
+ }
+ }
+
+ if( (match = strstr( ln, "uncompressed_size" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( uncompressed_size ) { free( uncompressed_size ); }
+ uncompressed_size = skip_spaces( p );
+ }
+ }
+ if( (match = strstr( ln, "total_files" )) && match == ln ) {
+ char *p = index( match, '=' ) + 1;
+ if( p != NULL )
+ {
+ if( total_files ) { free( total_files ); }
+ total_files = skip_spaces( p );
+ }
+ }
+ }
+
+ free( line );
+
+ if( !pkgname || !pkgver || !arch || !distroname || !distrover )
+ {
+ FATAL_ERROR( "Invalid input .PKGINFO file" );
+ }
+
+ fclose( pkginfo );
+}
+
+
+/***********************************************************
+ Find functions:
+ */
+static void _search_pkglog( const char *dirpath, const char *grp )
+{
+ DIR *dir;
+ char *path;
+ size_t len;
+
+ struct stat path_sb, entry_sb;
+ struct dirent *entry;
+
+ char *pname = (char *)dirpath + strlen( root ); /* do not remove leading '/' */
+
+ if( stat( dirpath, &path_sb ) == -1 )
+ {
+ FATAL_ERROR( "%s: Cannot stat Setup Database or group directory", pname );
+ }
+
+ if( S_ISDIR(path_sb.st_mode) == 0 )
+ {
+ FATAL_ERROR( "%s: Setup Database or group is not a directory", pname );
+ }
+
+ if( (dir = opendir(dirpath) ) == NULL )
+ {
+ FATAL_ERROR( "Canot access %s directory: %s", pname, strerror( errno ) );
+ }
+
+ len = strlen( dirpath );
+
+ while( (entry = readdir( dir )) != NULL)
+ {
+ /* skip entries '.' and '..' */
+ if( ! strcmp( entry->d_name, "." ) || ! strcmp( entry->d_name, ".." ) ) continue;
+
+ /* determinate a full name of an entry */
+ path = alloca( len + strlen( entry->d_name ) + 2 );
+
+ strcpy( path, dirpath );
+ strcat( path, "/" );
+ strcat( path, entry->d_name );
+
+ if( stat( path, &entry_sb ) == 0 )
+ {
+ if( S_ISREG(entry_sb.st_mode) )
+ {
+ char *match = NULL, *name = basename( path );
+
+ if( (match = strstr( name, pkgname )) && match == name )
+ {
+ /****************************************************************
+ Здесь мы еще должны проверить, что найденный пакет не имеет
+ более длинное имя, которое начинается с имени искомого пакета.
+ Полагаясь на факт, что версия может начинаться только с цифры,
+ мы пропускаем символ '-', разделяющий имя и версию пакета,
+ а затем проверяем начальный символ версии:
+ */
+ if( *(name + strlen( pkgname )) == '-' && isdigit( *(name + strlen( pkgname ) + 1) ) )
+ {
+ remlog_fname = xstrdup( (const char *)path );
+ closedir( dir );
+ return;
+ }
+ }
+ }
+ if( S_ISDIR(entry_sb.st_mode) && grp == NULL )
+ {
+ /**************************************************************************
+ NOTE:
+ In the Setup Database can be only one package with the same pkgname
+ but in different groups. For example, the package named 'cairo'
+ has two instance: libs/cairo-1.14.6 and xlibs/cairo-1.14.6. During
+ system installation the package libs/cairo-1.14.6 installed first
+ and then updated by xlibs/cairo-1.14.6 and PKGLOG of libs/cairo-1.14.6
+ moved from /var/log/radix/packages to /var/log/radix/removed-packages.
+
+ So here we have to look for the PKGLOG in all group directories:
+ */
+ _search_pkglog( (const char *)path, (const char *)entry->d_name );
+ }
+ }
+ /* else { stat() returns error code; errno is set; and we have to continue the loop } */
+ }
+
+ closedir( dir );
+}
+
+static char *find_package( void )
+{
+ char *ret = NULL;
+
+ _search_pkglog( (const char *)pkgs_path, NULL );
+ if( remlog_fname )
+ {
+ ret = remlog_fname;
+ }
+
+ return ret;
+}
+/*
+ Enf of Find functions.
+ ***********************************************************/
+
+/***********************************************************
+ check_installed_package():
+ ---------------------
+
+ Возвращает:
+ -1 если пакет установлен, но его версия меньше
+ запрашиваемого,
+ 0 если версия установленного и запрашиваемого равны,
+ 1 если пакет установлен, но его версия больше
+ запрашиваемого.
+
+ В случае возврата -1 или 1, устанавливается переменная
+ instaled_version, равная версии существующего пакета.
+
+ Если пакет не установлен, осуществляется выход со статусом 30.
+ */
+static int check_installed_package( void )
+{
+ struct stat st;
+ char *fname = pkg_fname;
+
+ enum _input_type type = IFMT_UNKNOWN;
+ char uncompress = '\0';
+
+ char *requested_version = NULL;
+ char *requested_group = NULL;
+
+ int ret = 0;
+
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ if( stat( (const char *)fname, &st ) == -1 )
+ {
+ FATAL_ERROR( "Cannot access input '%s' file: %s", fname, strerror( errno ) );
+ }
+
+ type = check_input_file( &uncompress, fname );
+ if( type != IFMT_PKG )
+ {
+ FATAL_ERROR( "Unknown format of input '%s' file", fname );
+ }
+
+ if( S_ISREG(st.st_mode) )
+ {
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *tmp= NULL, *cmd = NULL;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ (void)sprintf( &tmp[0], "%s", tmpdir );
+ if( _mkdir_p( tmp, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from '%s' file", basename( (char *)fname ) );
+ }
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/pkginfo -d %s -o pkginfo %s > /dev/null 2>&1",
+ selfdir, tmp, fname );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from %s file", basename( (char *)fname ) );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+ if( rc != 0 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from '%s' file", basename( (char *)fname ) );
+ }
+
+ (void)strcat( tmp, "/.PKGINFO" );
+ read_pkginfo( (const char *)&tmp[0] );
+ (void)unlink( (const char *)&tmp[0] ); /* :remove unnecessary .PKGINFO file */
+ *(strstr( tmp, "/.PKGINFO" )) = '\0'; /* :restore 'tmpdir' in tmp[] buffer */
+
+ requested_version = xstrdup( (const char *)pkgver );
+ requested_group = ( group ) ? xstrdup( (const char *)group ) : NULL;
+
+ fname = NULL;
+ fname = find_package();
+ if( !fname )
+ {
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", basename( pkg_fname ), NULL, NULL,
+ "\nPackage is not installed.\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nPackage '%s' is not installed.\n\n", basename( pkg_fname ) );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "Specified package '%s' is not installed.\n\n", basename( pkg_fname ) );
+ }
+
+ exit_status = 30; /* Package is not installed: install */
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+
+ exit( exit_status );
+ }
+
+ free( cmd );
+ free( tmp );
+ }
+ else
+ {
+ FATAL_ERROR( "Input %s file is not a regular file", basename( (char *)fname ) );
+ }
+
+
+ /* Now fname is a name of installed PKGLOG file; check fname again: */
+ if( stat( (const char *)fname, &st ) == -1 )
+ {
+ FATAL_ERROR( "Cannot access input '%s' file: %s", fname, strerror( errno ) );
+ }
+
+ type = check_input_file( &uncompress, fname );
+ if( type != IFMT_LOG )
+ {
+ FATAL_ERROR( "Unknown format of input '%s' file", fname );
+ }
+
+ if( S_ISREG(st.st_mode) )
+ {
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *tmp= NULL, *cmd = NULL;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ (void)sprintf( &tmp[0], "%s/to-remove", tmpdir );
+ if( _mkdir_p( tmp, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from '%s' file", basename( (char *)fname ) );
+ }
+ rtmpdir = xstrdup( (const char *)&tmp[0] );
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/pkginfo -d %s -o pkginfo,description,restore-links,filelist %s > /dev/null 2>&1",
+ selfdir, tmp, fname );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from %s file", basename( (char *)fname ) );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+ if( rc != 0 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from '%s' file", basename( (char *)fname ) );
+ }
+
+ (void)strcat( tmp, "/.PKGINFO" );
+ read_pkginfo( (const char *)&tmp[0] );
+ *(strstr( tmp, "/.PKGINFO" )) = '\0'; /* :restore tmpdir in tmp[] buffer */
+
+ installed_version = xstrdup( (const char *)pkgver );
+ installed_group = ( group ) ? xstrdup( (const char *)group ) : NULL;
+
+ free( cmd );
+ free( tmp );
+
+ if( requested_group && installed_group )
+ {
+ if( !(ret = strcmp( (const char *)installed_group, (const char *)requested_group )) )
+ {
+ ret = cmp_version( (const char *)installed_version, (const char *)requested_version );
+ }
+ }
+ else if( !requested_group && !installed_group )
+ {
+ ret = cmp_version( (const char *)installed_version, (const char *)requested_version );
+ }
+ else if( requested_group )
+ {
+ ret = -1;
+ }
+ else
+ {
+ ret = 1;
+ }
+
+ if( requested_version ) { free( requested_version ); }
+ if( requested_group ) { free( requested_group ); }
+ }
+ else
+ {
+ FATAL_ERROR( "Input %s file is not a regular file", basename( (char *)fname ) );
+ }
+
+ return ret;
+}
+
+static int check_installed_pkg_integrity( void )
+{
+ struct stat st;
+ FILE *fp = NULL;
+
+ char *ln = NULL;
+ char *line = NULL;
+
+ char *buf = NULL, *tmp = NULL;
+
+ int restore_links = 0;
+ int ret = 1;
+
+ buf = (char *)malloc( (size_t)PATH_MAX );
+ if( !buf ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)buf, PATH_MAX );
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ /* Check if .RESTORELINKS is present */
+ (void)sprintf( &tmp[0], "%s/.RESTORELINKS", rtmpdir );
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( (stat( (const char *)&tmp[0], &st ) == 0) && (st.st_size > 8) )
+ {
+ restore_links = 1;
+ }
+
+ (void)sprintf( &tmp[0], "%s/.FILELIST", rtmpdir );
+ fp = fopen( (const char *)&tmp[0], "r" );
+ if( !fp )
+ {
+ FATAL_ERROR( "Cannot open .FILELIST file" );
+ }
+
+ line = (char *)malloc( (size_t)PATH_MAX );
+ if( !line ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)line, PATH_MAX );
+
+ while( (ln = fgets( line, PATH_MAX, fp )) )
+ {
+ int dir = 0;
+
+ ln[strlen(ln) - 1] = '\0'; /* replace new-line symbol */
+ skip_eol_spaces( ln ); /* remove spaces at end-of-line */
+
+ if( *(ln + strlen(ln) - 1) == '/' ) { dir = 1; *(ln + strlen(ln) - 1) = '\0'; }
+ else { dir = 0; }
+
+ if( !dir )
+ {
+ char *p = rindex( ln, '.' );
+ if( p && !strncmp( (const char *)p, ".new", 4 ) )
+ {
+ /**************************
+ Do not check .new files:
+ */
+ *p = '\0';
+ }
+ }
+
+ (void)sprintf( &buf[0], "%s%s", root, ln );
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ if( lstat( (const char *)&buf[0], &st ) == -1 )
+ {
+ /* cannot access file list entry */
+ ret = 0; continue;
+ }
+
+ if( dir )
+ {
+ if( S_ISDIR(st.st_mode) == 0 )
+ {
+ /* not a directory */
+ ret = 0; continue;
+ }
+ }
+ else
+ {
+ if( S_ISREG(st.st_mode) == 0 )
+ {
+ /* not a regular file */
+ ret = 0; continue;
+ }
+ if( !restore_links )
+ {
+ if( S_ISLNK(st.st_mode) == 0 )
+ {
+ /* not a symbolic link */
+ ret = 0; continue;
+ }
+ }
+ }
+ } /* End of while( file list entry ) */
+ fclose( fp );
+
+
+ (void)sprintf( &tmp[0], "%s/.RESTORELINKS", rtmpdir );
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ if( stat( (const char *)&tmp[0], &st ) == 0 )
+ {
+ fp = fopen( (const char *)&tmp[0], "r" );
+ if( !fp )
+ {
+ FATAL_ERROR( "Cannot open .RESTORELINKS file" );
+ }
+
+ while( (ln = fgets( line, PATH_MAX, fp )) )
+ {
+ char *match = NULL;
+
+ ln[strlen(ln) - 1] = '\0'; /* replace new-line symbol */
+ skip_eol_spaces( ln ); /* remove spaces at end-of-line */
+
+ if( (match = strstr( ln, "; rm -rf " )) )
+ {
+ char *q = NULL;
+ char *p = strstr( ln, "cd" ) + 2;
+ char *f = strstr( ln, "; rm -rf" ) + 8;
+
+ if( !p || !f ) continue;
+
+ while( (*p == ' ' || *p == '\t') && *p != '\0' ) ++p;
+ while( (*f == ' ' || *f == '\t') && *f != '\0' ) ++f;
+
+ q = p; while( *q != ' ' && *q != '\t' && *q != ';' && *q != '\0' ) ++q; *q = '\0';
+ q = f; while( *q != ' ' && *q != '\t' && *q != ';' && *q != '\0' ) ++q; *q = '\0';
+
+ if( p && f )
+ {
+ (void)sprintf( &buf[0], "%s/%s/%s", root, p, f );
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ if( lstat( (const char *)&buf[0], &st ) == -1 )
+ {
+ /* cannot access restore links entry */
+ ret = 0; continue;
+ }
+
+ if( S_ISLNK(st.st_mode) == 0 )
+ {
+ /* not a symbolic link */
+ ret = 0; continue;
+ }
+ }
+ }
+ } /* End of while( restore links entry ) */
+ fclose( fp );
+ }
+
+ free( line );
+ free( tmp );
+ free( buf );
+
+ return ret;
+}
+
+
+static void read_service_files( void )
+{
+ struct stat st;
+ char *fname = pkg_fname;
+
+ enum _input_type type = IFMT_UNKNOWN;
+
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ if( stat( (const char *)fname, &st ) == -1 )
+ {
+ FATAL_ERROR( "Cannot access input '%s' file: %s", fname, strerror( errno ) );
+ }
+
+ type = check_input_file( &uncompress, fname );
+ if( type != IFMT_PKG )
+ {
+ FATAL_ERROR( "Unknown format of input '%s' file", fname );
+ }
+
+ if( S_ISREG(st.st_mode) )
+ {
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *tmp= NULL, *cmd = NULL;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ (void)sprintf( &tmp[0], "%s", tmpdir );
+ if( _mkdir_p( tmp, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from '%s' file", basename( (char *)fname ) );
+ }
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/pkginfo -d %s"
+ " -o pkginfo,description,requires,restore-links,install-script,filelist"
+ " %s > /dev/null 2>&1",
+ selfdir, tmp, fname );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from %s file", basename( (char *)fname ) );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+ if( rc != 0 )
+ {
+ FATAL_ERROR( "Cannot get PKGINFO from '%s' file", basename( (char *)fname ) );
+ }
+
+ (void)strcat( tmp, "/.PKGINFO" );
+ read_pkginfo( (const char *)&tmp[0] );
+ *(strstr( tmp, "/.PKGINFO" )) = '\0'; /* :restore tmpdir in tmp[] buffer */
+
+ compressed_size = size_to_string( st.st_size );
+
+ /******************
+ Get PKGLOG file:
+ */
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/pkglog -m -d %s %s > /dev/null 2>&1",
+ selfdir, tmp, tmp );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot get PKGLOG from %s file", basename( (char *)fname ) );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+ if( rc != 0 )
+ {
+ FATAL_ERROR( "Cannot get PKGLOG from '%s' file", basename( (char *)fname ) );
+ }
+
+ if( group )
+ (void)sprintf( cmd, "%s/%s/%s-%s-%s-%s-%s", tmp, group, pkgname, pkgver, arch, distroname, distrover );
+ else
+ (void)sprintf( cmd, "%s/%s-%s-%s-%s-%s", tmp, pkgname, pkgver, arch, distroname, distrover );
+
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( stat( (const char *)cmd, &st ) == -1 )
+ {
+ FATAL_ERROR( "Cannot get PKGLOG from '%s' file: %s", basename( (char *)fname ), strerror( errno ) );
+ }
+
+ pkglog_fname = xstrdup( (const char *)cmd );
+
+ /*************************************
+ Attempt to read packages list file:
+ */
+ {
+ if( !pkglist_fname )
+ {
+ /*****************************************
+ Get source packages path if applicable:
+ */
+ (void)strcpy( cmd, (const char *)fname );
+ (void)strcpy( tmp, dirname( cmd ) );
+
+ if( group && !strcmp( group, basename( tmp ) ) )
+ (void)strcpy( cmd, (const char *)dirname( tmp ) );
+ else
+ (void)strcpy( cmd, (const char *)tmp );
+
+ /*****************************************
+ Save default packages list file name:
+ */
+ (void)strcat( cmd, "/.pkglist" );
+ pkglist_fname = xstrdup( (const char *)cmd );
+ }
+
+ /**************************
+ read .pkglist if exists:
+ */
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( (stat( (const char *)pkglist_fname, &st ) == 0) && S_ISREG(st.st_mode) )
+ {
+ char *ln = NULL;
+ char *line = NULL;
+
+ FILE *pkglist = NULL;
+
+ pkglist = fopen( (const char *)pkglist_fname, "r" );
+ if( !pkglist )
+ {
+ FATAL_ERROR( "Cannot open %s file", pkglist_fname );
+ }
+
+ line = (char *)malloc( (size_t)PATH_MAX );
+ if( !line )
+ {
+ FATAL_ERROR( "Cannot allocate memory" );
+ }
+
+ while( (ln = fgets( line, PATH_MAX, pkglist )) )
+ {
+ char *match = NULL;
+
+ ln[strlen(ln) - 1] = '\0'; /* replace new-line symbol */
+ skip_eol_spaces( ln ); /* remove spaces at end-of-line */
+
+ if( (match = strstr( ln, pkgname )) && match == ln )
+ {
+ char *p = NULL;
+ char *name = NULL, *vers = NULL, *desc = NULL, *ball = NULL, *proc = NULL, *prio = NULL;
+
+ name = ln;
+ if( (p = index( (const char *)name, ':' )) ) { *p = '\0'; vers = ++p; name = trim( name ); } else continue;
+ if( (p = index( (const char *)vers, ':' )) ) { *p = '\0'; desc = ++p; vers = trim( vers ); } else continue;
+ if( (p = index( (const char *)desc, ':' )) ) { *p = '\0'; ball = ++p; desc = trim( desc ); } else continue;
+ if( (p = index( (const char *)ball, ':' )) ) { *p = '\0'; proc = ++p; ball = trim( ball ); } else continue;
+ if( (p = index( (const char *)proc, ':' )) ) { *p = '\0'; prio = ++p; proc = trim( proc ); } else continue;
+ prio = trim( prio );
+
+ if( name && vers && desc && ball && proc && prio )
+ {
+ char *grp = index( (const char *)ball, '/' );
+ if( grp )
+ {
+ *grp = '\0'; grp = ball; grp = trim( grp );
+ if( strcmp( group, grp ) ) continue;
+ }
+
+ /* read priority: */
+ if( strlen( (const char*)prio ) > 2 )
+ {
+ char *m = NULL;
+
+ to_lowercase( prio );
+ if( (m = strstr( prio, "req" )) && m == prio ) {
+ priority = REQUIRED;
+ }
+ else if( (m = strstr( prio, "rec" )) && m == prio ) {
+ priority = RECOMMENDED;
+ }
+ else if( (m = strstr( prio, "opt" )) && m == prio ) {
+ priority = OPTIONAL;
+ }
+ else if( (m = strstr( prio, "sk" )) && m == prio ) {
+ priority = SKIP;
+ }
+ else {
+ priority = REQUIRED;
+ }
+ }
+ else
+ {
+ priority = REQUIRED;
+ }
+
+ /* read procedure: */
+ if( strlen( (const char*)proc ) > 5 )
+ {
+ char *m = NULL;
+
+ to_lowercase( proc );
+ if( (m = strstr( proc, "install" )) && m == proc ) {
+ procedure = INSTALL;
+ }
+ else if( (m = strstr( proc, "update" )) && m == proc ) {
+ procedure = UPDATE;
+ }
+ else {
+ procedure = UPDATE;
+ }
+ }
+ else
+ {
+ procedure = UPDATE;
+ }
+ }
+
+ } /* End if( match ) */
+
+ } /* End of while( ln = fgets() ) */
+
+ free( line );
+ fclose( pkglist );
+
+ } /* End of reading .pkglist */
+
+ } /* End of attemption of reading .pkflist file */
+
+ free( cmd );
+ free( tmp );
+
+ if( priority == SKIP )
+ {
+ exit_status = 41;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ char *tmp = NULL;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ (void)sprintf( &tmp[0],
+ "\nUpdate procedure is skipped due to specified '%s' priority.\n",
+ strprio( priority, 0 ) );
+
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ (const char *)&tmp[0], 5, 0, 0 );
+
+ free( tmp );
+#else
+ fprintf( stdout,
+ "\nUpdate procedure of package '%s-%s' is skipped due to specified '%s' priority.\n\n",
+ pkgname, pkgver, strprio( priority, 0 ) );
+#endif
+ }
+ else
+ {
+ fprintf( stdout,
+ "\nUpdate procedure of package '%s-%s' is skipped due to specified '%s' priority.\n\n",
+ pkgname, pkgver, strprio( priority, 0 ) );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+
+ exit( exit_status );
+ }
+
+ if( procedure != UPDATE )
+ {
+ exit_status = 42;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ char *tmp = NULL;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ (void)sprintf( &tmp[0],
+ "\nUpdate is skipped because the '%s' procedure is specified.\n",
+ strproc( procedure ) );
+
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ (const char *)&tmp[0], 6, 0, 0 );
+
+ free( tmp );
+#else
+ fprintf( stdout,
+ "\nUpdate procedure of package '%s-%s' is skipped because the '%s' procedure is specified.\n\n",
+ pkgname, pkgver, strproc( procedure ) );
+#endif
+ }
+ else
+ {
+ fprintf( stdout,
+ "\nUpdate procedure of package '%s-%s' is skipped because the '%s' procedure is specified.\n\n",
+ pkgname, pkgver, strproc( procedure ) );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+
+ exit( exit_status );
+ }
+
+ }
+ else
+ {
+ FATAL_ERROR( "Input %s file is not a regular file", basename( (char *)fname ) );
+ }
+}
+
+
+static void check_requires( void )
+{
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL;
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/check-requires --root=%s %s > /dev/null 2>&1",
+ selfdir, root, pkglog_fname );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot check required packages for '%s-%s' package", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( rc != 0 )
+ {
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\nPackage requires other packages to be installed.\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nPackage '%s-%s' requires other packages to be installed.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nPackage '%s-%s' requires other packages to be installed.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( rc );
+ }
+}
+
+/********************************************************
+ Read .FILELIST and .RESTORELINKS functions used for
+ roolback/remove in case post-update errors:
+ */
+static int __cmp_list_items( const void *a, const void *b )
+{
+ if( a && b )
+ return strcmp( (const char *)a, (const char *)b );
+ else if( a )
+ return 1;
+ else
+ return -1;
+}
+
+static void __free_list( void *data, void *user_data )
+{
+ if( data ) { free( data ); }
+}
+
+static void free_list( struct dlist *list )
+{
+ if( list ) { dlist_free( list, __free_list ); }
+}
+
+////////////////////////////////////////////////////
+//static void __print_list( void *data, void *user_data )
+//{
+// int *counter = (int *)user_data;
+//
+// if( counter ) { fprintf( stdout, "item[%.5d]: %s\n", *counter, (char *)data ); ++(*counter); }
+// else { fprintf( stdout, "item: %s\n", (char *)data ); }
+//}
+//
+//static void print_list( struct dlist *list )
+//{
+// int cnt = 0;
+// if( list ) { dlist_foreach( list, __print_list, (void *)&cnt ); }
+//}
+////////////////////////////////////////////////////
+
+static void read_filelist( void **d, void **f, const char *path )
+{
+ struct stat st;
+ FILE *fp = NULL;
+
+ char *ln = NULL;
+ char *line = NULL, *tmp = NULL;
+
+ struct dlist *dirs = (struct dlist *)(*d);
+ struct dlist *files = (struct dlist *)(*f);
+
+ if( !dirs || !files || !path ) return;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ (void)sprintf( &tmp[0], "%s/.FILELIST", path );
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( (stat( (const char *)&tmp[0], &st ) == -1) )
+ {
+ FATAL_ERROR( "Cannot get .FILELIST from '%s' file", basename( (char *)pkglog_fname ) );
+ }
+
+ fp = fopen( (const char *)&tmp[0], "r" );
+ if( !fp )
+ {
+ FATAL_ERROR( "Cannot open .FILELIST file" );
+ }
+
+ line = (char *)malloc( (size_t)PATH_MAX );
+ if( !line ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)line, PATH_MAX );
+
+ while( (ln = fgets( line, PATH_MAX, fp )) )
+ {
+ ln[strlen(ln) - 1] = '\0'; /* replace new-line symbol */
+ skip_eol_spaces( ln ); /* remove spaces at end-of-line */
+
+ if( *(ln + strlen(ln) - 1) == '/' )
+ {
+ *(ln + strlen(ln) - 1) = '\0';
+ (void)sprintf( &tmp[0], "%s%s", (const char *)root, (const char *)ln );
+ dirs = dlist_append( dirs, xstrdup( (const char *)&tmp[0] ) );
+ }
+ else
+ {
+ (void)sprintf( &tmp[0], "%s%s", (const char *)root, (const char *)ln );
+ files = dlist_append( files, xstrdup( (const char *)&tmp[0] ) );
+ }
+
+ } /* End of while( file list entry ) */
+
+ fclose( fp );
+
+ free( line );
+ free( tmp );
+}
+
+static void read_restorelinks( void **l, const char *path )
+{
+ struct stat st;
+ FILE *fp = NULL;
+
+ char *ln = NULL;
+ char *line = NULL, *tmp = NULL;
+
+ struct dlist *links = (struct dlist *)(*l);
+
+ if( !links || !path ) return;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ (void)sprintf( &tmp[0], "%s/.RESTORELINKS", path );
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( (stat( (const char *)&tmp[0], &st ) == -1) || (st.st_size < 8) )
+ {
+ free( tmp );
+ return;
+ }
+
+ fp = fopen( (const char *)&tmp[0], "r" );
+ if( !fp )
+ {
+ FATAL_ERROR( "Cannot open .RESTORELINKS file" );
+ }
+
+ line = (char *)malloc( (size_t)PATH_MAX );
+ if( !line ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)line, PATH_MAX );
+
+ while( (ln = fgets( line, PATH_MAX, fp )) )
+ {
+ char *match = NULL;
+
+ ln[strlen(ln) - 1] = '\0'; /* replace new-line symbol */
+ skip_eol_spaces( ln ); /* remove spaces at end-of-line */
+
+ if( (match = strstr( ln, "; rm -rf " )) )
+ {
+ char *q = NULL;
+ char *p = strstr( ln, "cd" ) + 2;
+ char *f = strstr( ln, "; rm -rf" ) + 8;
+
+ if( !p || !f ) continue;
+
+ while( (*p == ' ' || *p == '\t') && *p != '\0' ) ++p;
+ while( (*f == ' ' || *f == '\t') && *f != '\0' ) ++f;
+
+ q = p; while( *q != ' ' && *q != '\t' && *q != ';' && *q != '\0' ) ++q; *q = '\0';
+ q = f; while( *q != ' ' && *q != '\t' && *q != ';' && *q != '\0' ) ++q; *q = '\0';
+
+ if( p && f )
+ {
+ (void)sprintf( &tmp[0], "%s%s/%s", (const char *)root, p, f );
+ links = dlist_append( links, xstrdup( (const char *)&tmp[0] ) );
+ }
+ }
+ } /* End of while( restore links entry ) */
+
+ fclose( fp );
+
+ free( line );
+ free( tmp );
+}
+/*
+ End of read .FILELIST and .RESTORELINKS functions.
+ ********************************************************/
+
+/********************************************************
+ Rollback/Remove functions:
+ */
+static void __remove_link( void *data, void *user_data )
+{
+ const char *fname = (const char *)data;
+
+ if( fname )
+ {
+ (void)unlink( fname );
+ }
+}
+
+static void __remove_file( void *data, void *user_data )
+{
+ const char *fname = (const char *)data;
+
+ if( fname )
+ {
+ char *p = rindex( fname, '.' );
+ /*
+ Если .new файл остался с тем же именем, это значит что до инсталляции
+ в системе существовал такой же файл но без расширения .new и при этом
+ он отличался от нового. В данном случае надо удалять только файл .new.
+
+ Если же файл .new не существует, то надо удалять такой же файл но без
+ расширения .new .
+ */
+ if( p && !strncmp( (const char *)p, ".new", 4 ) )
+ {
+ struct stat st;
+
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( (stat( fname, &st ) == -1) ) *p = '\0';
+ }
+
+ (void)unlink( fname );
+ }
+}
+
+static int is_dir_empty( const char *dirpath )
+{
+ int ret = 0;
+
+ DIR *dir;
+ char *path;
+ size_t len;
+
+ struct stat path_sb, entry_sb;
+ struct dirent *entry;
+
+ if( stat( dirpath, &path_sb ) == -1 ) return ret; /* stat returns error code; errno is set */
+ if( S_ISDIR(path_sb.st_mode) == 0 ) return ret; /* dirpath is not a directory */
+ if( (dir = opendir(dirpath) ) == NULL ) return ret; /* Cannot open direcroty; errno is set */
+
+ ret = 1;
+
+ len = strlen( dirpath );
+ while( (entry = readdir( dir )) != NULL)
+ {
+ /* skip entries '.' and '..' */
+ if( ! strcmp( entry->d_name, "." ) || ! strcmp( entry->d_name, ".." ) ) continue;
+
+ /* determinate a full name of an entry */
+ path = alloca( len + strlen( entry->d_name ) + 2 );
+ strcpy( path, dirpath );
+ strcat( path, "/" );
+ strcat( path, entry->d_name );
+
+ if( stat( path, &entry_sb ) == 0 )
+ {
+ ret = 0;
+ break;
+ }
+ /* else { stat() returns error code; errno is set; and we have to continue the loop } */
+ }
+ closedir( dir );
+
+ return ret;
+}
+
+static void __remove_dir( void *data, void *user_data )
+{
+ const char *dname = (const char *)data;
+
+ if( dname && is_dir_empty( (const char *)dname ) )
+ {
+ (void)rmdir( dname );
+ }
+}
+
+static void rollback( void )
+{
+ /* Try to change CWD to the ROOT directory: */
+ (void)chdir( (const char *)root );
+
+ if( links ) { dlist_foreach( links, __remove_link, NULL ); }
+
+ if( files ) { dlist_foreach( files, __remove_file, NULL ); }
+
+ if( dirs )
+ {
+ dirs = dlist_sort( dirs, __cmp_list_items );
+ dirs = dlist_reverse( dirs );
+ dlist_foreach( dirs, __remove_dir, NULL );
+ }
+
+ /* Try to remove PKGLOG file */
+ {
+ char *tmp = NULL;
+
+ tmp = (char *)malloc( PATH_MAX );
+ if( tmp )
+ {
+ const char *fname = basename( (char *)pkglog_fname );
+
+ bzero( (void *)tmp, PATH_MAX );
+
+ if( group )
+ (void)sprintf( &tmp[0], "%s/%s/%s", pkgs_path, group, fname );
+ else
+ (void)sprintf( &tmp[0], "%s/%s", pkgs_path, fname );
+
+ (void)unlink( (const char *)&tmp[0] );
+
+ if( group )
+ {
+ const char *dir = (const char *)dirname( (char *)&tmp[0] );
+ if( is_dir_empty( dir ) )
+ {
+ (void)rmdir( dir );
+ }
+ }
+ free( tmp );
+ }
+ }
+
+ /* Try to change CWD to the CURRENT directory: */
+ (void)chdir( (const char *)curdir );
+}
+
+static void remove_package( void )
+{
+ /* Try to change CWD to the ROOT directory: */
+ (void)chdir( (const char *)root );
+
+ if( rlinks ) { dlist_foreach( rlinks, __remove_link, NULL ); }
+
+ if( rfiles ) { dlist_foreach( rfiles, __remove_file, NULL ); }
+
+ if( rdirs )
+ {
+ rdirs = dlist_sort( rdirs, __cmp_list_items );
+ rdirs = dlist_reverse( rdirs );
+ dlist_foreach( rdirs, __remove_dir, NULL );
+ }
+
+ /* Try to change CWD to the CURRENT directory: */
+ (void)chdir( (const char *)curdir );
+}
+
+static void finalize_removal( void )
+{
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL, *tmp = NULL;
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ /*********************************************
+ Decrement references in the Setup Database:
+ */
+ if( installed_group )
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/chrefs --operation=dec --destination=%s %s/%s > /dev/null 2>&1",
+ selfdir, pkgs_path, installed_group, basename( (char *)remlog_fname ) );
+ else
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/chrefs --operation=dec --destination=%s %s > /dev/null 2>&1",
+ selfdir, pkgs_path, basename( (char *)remlog_fname ) );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot decrement '%s-%s' package references", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+ if( (rc != 0) && !ignore_chrefs_errors )
+ {
+ free( cmd );
+ free( tmp );
+
+ exit_status = 48;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, NULL,
+ "\n\\Z1Cannot decrement package references in Setup Database.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nCannot decrement '%s-%s' package references in Setup Database.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nCannot decrement '%s-%s' package references in Setup Database.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+
+ /*****************************************************
+ Backup PKGLOG file into removed-packages directory:
+ */
+ bzero( (void *)tmp, PATH_MAX );
+
+ if( installed_group )
+ (void)sprintf( &tmp[0], "%s/%s/", rempkgs_path, installed_group );
+ else
+ (void)sprintf( &tmp[0], "%s/", rempkgs_path );
+
+ if( _mkdir_p( tmp, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot access '/%s' directory", REMOVED_PKGS_PATH );
+ }
+
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "mv %s %s > /dev/null 2>&1",
+ remlog_fname, (const char *)&tmp[0] );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot backup '%s' pkglog file", basename( (char *)remlog_fname ) );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( rc != 0 )
+ {
+ free( tmp );
+
+ exit_status = 47;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, NULL,
+ "\n\\Z1Cannot backup PKGLOG file.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nCannot backup '%s' pkglog file.\n\n", basename( (char *)remlog_fname ) );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nCannot backup '%s' pkglog file.\n\n", basename( (char *)remlog_fname ) );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+
+ /****************************************
+ Remove group directory if it is empty:
+ */
+ bzero( (void *)tmp, PATH_MAX );
+
+ if( installed_group )
+ {
+ (void)sprintf( &tmp[0], "%s/%s/", pkgs_path, installed_group );
+
+ const char *dir = (const char *)&tmp[0];
+ if( is_dir_empty( dir ) )
+ {
+ (void)rmdir( dir );
+ }
+ }
+
+ free( tmp );
+}
+
+/*
+ End of rollback/remove functions.
+ ********************************************************/
+
+static void read_description( const char *path, int show_compressed_size )
+{
+ struct stat st;
+ FILE *fp = NULL;
+
+ char *buf = NULL, *tmp = NULL;
+ char *lp = NULL;
+ int n = 0;
+
+ char *ln = NULL;
+ char *line = NULL;
+
+ if( !path ) return;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ buf = (char *)malloc( (size_t)PATH_MAX );
+ if( !buf ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)buf, PATH_MAX );
+
+ (void)sprintf( &tmp[0], "%s/.DESCRIPTION", path );
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( (stat( (const char *)&tmp[0], &st ) == -1) || (st.st_size < 8) )
+ {
+ free( tmp );
+ return;
+ }
+
+ fp = fopen( (const char *)&tmp[0], "r" );
+ if( !fp )
+ {
+ FATAL_ERROR( "Cannot open .DESCRIPTION file" );
+ }
+
+ (void)sprintf( (char *)&buf[0], "%s:", pkgname );
+
+ line = (char *)malloc( (size_t)PATH_MAX );
+ if( !line ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)line, PATH_MAX );
+
+ lp = (char *)&tmp[0];
+ bzero( (void *)tmp, PATH_MAX );
+ (void)sprintf( (char *)&tmp[0], "\n" );
+ ++lp;
+
+ while( (ln = fgets( line, PATH_MAX, fp )) && n < DESCRIPTION_NUMBER_OF_LINES )
+ {
+ char *match = NULL;
+
+ ln[strlen(ln) - 1] = '\0'; /* replace new-line symbol */
+
+ if( (match = strstr( (const char *)ln, (const char *)buf )) && match == ln ) /* at start of line only */
+ {
+ int mlen = strlen( match ), plen = strlen( buf );
+ int length = ( mlen > plen ) ? (mlen - plen - 1) : 0 ;
+
+ if( length > DESCRIPTION_LENGTH_OF_LINE )
+ {
+ /* WARNING( "Package DESCRIPTION contains lines with length greater than %d characters", DESCRIPTION_LENGTH_OF_LINE ); */
+ match[plen + 1 + DESCRIPTION_LENGTH_OF_LINE] = '\0'; /* truncating description line */
+ skip_eol_spaces( match ); /* remove spaces at end-of-line */
+ }
+
+ match += plen + 1;
+ if( match[0] != '\0' ) { (void)sprintf( lp, " %s\n", match ); lp += strlen( match ) + 2; }
+ else { (void)sprintf( lp, "\n" ); ++lp; }
+ ++n;
+ }
+ } /* End of while( ln = fgets() ) */
+
+ fclose( fp );
+
+ (void)sprintf( lp, " Uncompressed Size: %s\n", uncompressed_size );
+ lp += strlen( uncompressed_size ) + 21;
+ if( show_compressed_size )
+ {
+ (void)sprintf( lp, " Compressed Size: %s\n", compressed_size );
+ lp += strlen( compressed_size ) + 21;
+ }
+
+ if( description ) { free( description ); description = NULL; }
+ description = xstrdup( (const char *)&tmp[0] );
+
+ free( buf );
+ free( line );
+ free( tmp );
+}
+
+static int ask_for_update( void )
+{
+ int ret = 0; /* continue update */
+#if defined( HAVE_DIALOG )
+ /******************************************************
+ Ask for update dialog shown only in MENUDIALOG mode
+ when priority != REQUIRED or --always-ask=yes:
+ */
+ if( (update_mode == MENUDIALOG) && (((priority == REQUIRED) && ask) || (priority != REQUIRED)) )
+ {
+ ret = ask_update_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ description, 18, 0, 0 );
+ }
+
+ if( ret )
+ {
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\nUpdate terminated by user.\n", 5, 0, 0 );
+ }
+#endif
+ return ret;
+}
+
+static int ask_for_reinstall( void )
+{
+ int ret = 0; /* continue update */
+#if defined( HAVE_DIALOG )
+ /***************************************************************
+ Ask for remove dialog shown only in INFO or MENU DIALOG mode:
+ */
+ if( update_mode == MENUDIALOG )
+ {
+ char *msg = NULL;
+
+ msg = (char *)malloc( (size_t)PATH_MAX );
+ if( !msg ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)msg, PATH_MAX );
+
+ (void)sprintf( &msg[0], "\nThe same version of requested package installed and correct.\n"
+ "\n\\Z1Re-install this vesion?\\Zn\n" );
+
+ if( (ret = ask_reinstall_box( "Update:", pkgname, installed_version, (const char *)&msg[0], 9, 0, 0 )) )
+ {
+ info_pkg_box( "Update:", pkgname, installed_version, NULL,
+ "\nPackage update terminated by user.\n", 5, 0, 0 );
+ }
+
+ free( msg );
+ }
+ else if( update_mode == INFODIALOG )
+ {
+ if( !reinstall )
+ {
+ info_pkg_box( "Update:", pkgname, installed_version, NULL,
+ "\nThe same version of requested package installed and correct.\n", 5, 0, 0 );
+ ret = 1;
+ }
+ }
+ else
+ {
+ if( !reinstall )
+ {
+ fprintf( stdout, "\nThe same version of '%s-%s' package is installed and correct.\n\n", pkgname, installed_version );
+ ret = 1;
+ }
+ }
+#else
+ {
+ if( !reinstall )
+ {
+ fprintf( stdout, "\nThe same version of '%s-%s' package is installed and correct.\n\n", pkgname, installed_version );
+ ret = 1;
+ }
+ }
+#endif
+ return ret;
+}
+
+
+static void show_update_progress( void )
+{
+ fprintf( stdout, "\033[2J" ); /* clear screen */
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ description, 16, 0, 0 );
+#else
+ fprintf( stdout, "\n Update: %s-%s [%s]...\n", pkgname, pkgver, strprio( priority, 0 ));
+ /*************************************************
+ Ruler: 68 characters + 2 spaces left and right:
+
+ | ----handy-ruler----------------------------------------------------- | */
+ fprintf( stdout, "|======================================================================|\n" );
+ fprintf( stdout, "%s\n", description );
+ fprintf( stdout, "|======================================================================|\n\n" );
+ fprintf( stdout, "\n\n\n" ); /* 3 lines up for final message */
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\n Update: %s-%s [%s]...\n", pkgname, pkgver, strprio( priority, 0 ));
+ /*************************************************
+ Ruler: 68 characters + 2 spaces left and right:
+
+ | ----handy-ruler----------------------------------------------------- | */
+ fprintf( stdout, "|======================================================================|\n" );
+ fprintf( stdout, "%s\n", description );
+ fprintf( stdout, "|======================================================================|\n\n" );
+ fprintf( stdout, "\n\n\n" ); /* 3 lines up for final message */
+ }
+}
+
+
+static void pre_update_routine( void )
+{
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL;
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "cd %s && %s/.INSTALL pre_update %s %s > /dev/null 2>&1",
+ root, tmpdir, pkgver, installed_version );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot run pre-update script for '%s-%s' package", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( rc != 0 )
+ {
+ exit_status = 43;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\n\\Z1Pre-update script returned error status.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nPre-update script of '%s-%s' returned error status.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nPre-update script of '%s-%s' returned error status.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+}
+
+static const char *fill_decompressor( char *buffer, char compressor )
+{
+ switch( compressor )
+ {
+ case 'J':
+ (void)sprintf( buffer, "xz --threads=%d -dc", get_nprocs() );
+ break;
+ case 'j':
+ (void)sprintf( buffer, "bzip2 -dc" );
+ break;
+ case 'z':
+ (void)sprintf( buffer, "gzip -dc" );
+ break;
+ default:
+ (void)sprintf( buffer, "cat -" );
+ break;
+ }
+ return (const char *)buffer;
+}
+
+static void uncompress_package( void )
+{
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL;
+
+ char decompressor[64];
+
+ (void)fill_decompressor( (char *)&decompressor[0], uncompress );
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "cat %s | %s | tar -C %s "
+ "--exclude='.DESCRIPTION' "
+ "--exclude='.FILELIST' "
+ "--exclude='.INSTALL' "
+ "--exclude='.PKGINFO' "
+ "--exclude='.REQUIRES' "
+ "--exclude='.RESTORELINKS' "
+ "-xf - > /dev/null 2>&1",
+ pkg_fname, decompressor, root );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot uncompress '%s-%s' package", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( rc != 0 )
+ {
+ exit_status = 44;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\n\\Z1Cannot uncompress package.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nCannot uncompress '%s-%s' package.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nCannot uncompress '%s-%s' package.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+}
+
+static void restore_links( void )
+{
+ struct stat st;
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL;
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ (void)sprintf( &cmd[0], "%s/.RESTORELINKS", tmpdir );
+ bzero( (void *)&st, sizeof( struct stat ) );
+ if( (stat( (const char *)&cmd[0], &st ) == -1) || (st.st_size < 8) )
+ {
+ free( cmd );
+ return;
+ }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "cd %s && sh %s/.RESTORELINKS > /dev/null 2>&1",
+ root, tmpdir );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot restore links for '%s-%s' package", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( rc != 0 )
+ {
+ rollback();
+
+ exit_status = 45;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\n\\Z1Restore-links script returned error status.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nRestore-links script of '%s-%s' returned error status.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nRestore-links script of '%s-%s' returned error status.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+}
+
+static void post_update_routine( void )
+{
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL;
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "cd %s && %s/.INSTALL post_update %s %s > /dev/null 2>&1",
+ root, tmpdir, pkgver, installed_version );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot run post-update script for '%s-%s' package", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( rc != 0 )
+ {
+ rollback();
+
+ exit_status = 46;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\n\\Z1Post-update script returned error status.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nPost-update script of '%s-%s' returned error status.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nPost-update script of '%s-%s' returned error status.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+}
+
+static void finalize_update( void )
+{
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL, *tmp = NULL;
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ if( group )
+ (void)sprintf( &tmp[0], "%s/%s/", pkgs_path, group );
+ else
+ (void)sprintf( &tmp[0], "%s/", pkgs_path );
+
+ if( _mkdir_p( tmp, S_IRWXU | S_IRWXG | S_IRWXO ) != 0 )
+ {
+ FATAL_ERROR( "Cannot access '/%s' directory", PACKAGES_PATH );
+ }
+
+ /****************************************
+ Store PKGLOG file into Setup Database:
+ */
+ len = snprintf( &cmd[0], PATH_MAX,
+ "cp %s %s > /dev/null 2>&1",
+ pkglog_fname, (const char *)&tmp[0] );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot store '%s' pkglog file", basename( (char *)pkglog_fname ) );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+ if( rc != 0 )
+ {
+ rollback();
+
+ free( cmd );
+ free( tmp );
+
+ exit_status = 47;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\n\\Z1Cannot store PKGLOG file into Setup Database.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nCannot store '%s' pkglog file into Setup Database.\n\n", basename( (char *)pkglog_fname ) );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nCannot store '%s' pkglog file into Setup Database.\n\n", basename( (char *)pkglog_fname ) );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+
+ /*********************************************
+ Increment references in the Setup Database:
+ */
+ if( group )
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/chrefs --operation=inc --destination=%s %s/%s > /dev/null 2>&1",
+ selfdir, pkgs_path, group, basename( (char *)pkglog_fname ) );
+ else
+ len = snprintf( &cmd[0], PATH_MAX,
+ "%s/chrefs --operation=inc --destination=%s %s > /dev/null 2>&1",
+ selfdir, pkgs_path, basename( (char *)pkglog_fname ) );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot increment '%s-%s' package references", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( (rc != 0) && !ignore_chrefs_errors )
+ {
+ free( tmp );
+
+ rollback();
+
+ exit_status = 48;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\n\\Z1Cannot increment package references in Setup Database.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nCannot increment '%s-%s' package references in Setup Database.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nCannot increment '%s-%s' package references in Setup Database.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+
+ /*************************************************
+ Remove backup PKGLOG file from removed-packages
+ directory if exists:
+ */
+ bzero( (void *)tmp, PATH_MAX );
+ {
+ const char *fname = basename( (char *)pkglog_fname );
+
+ if( group )
+ (void)sprintf( &tmp[0], "%s/%s/%s", rempkgs_path, group, fname );
+ else
+ (void)sprintf( &tmp[0], "%s/%s", rempkgs_path, fname );
+
+ (void)unlink( (const char *)&tmp[0] );
+
+ if( group )
+ {
+ const char *dir = (const char *)dirname( (char *)&tmp[0] );
+ if( is_dir_empty( dir ) )
+ {
+ (void)rmdir( dir );
+ }
+ }
+ }
+
+ free( tmp );
+}
+
+#if defined( HAVE_GPG2 )
+static void verify_gpg_signature( void )
+{
+ struct stat st;
+ pid_t p = (pid_t) -1;
+ int rc;
+
+ int len = 0;
+ char *cmd = NULL;
+
+ bzero( (void *)&st, sizeof( struct stat ) );
+
+ /******************************************************************
+ Do not try to verify signature if '.asc' file is not accessible:
+ */
+ if( stat( (const char *)asc_fname, &st ) == -1 ) return;
+
+ cmd = (char *)malloc( (size_t)PATH_MAX );
+ if( !cmd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cmd, PATH_MAX );
+
+ len = snprintf( &cmd[0], PATH_MAX,
+ "gpg2 --verify %s %s > /dev/null 2>&1",
+ asc_fname, pkg_fname );
+ if( len == 0 || len == PATH_MAX - 1 )
+ {
+ FATAL_ERROR( "Cannot verify GPG2 signature of '%s-%s' package", pkgname, pkgver );
+ }
+ p = sys_exec_command( cmd );
+ rc = sys_wait_command( p, (char *)NULL, PATH_MAX );
+
+ free( cmd );
+
+ if( rc != 0 )
+ {
+ exit_status = 51;
+
+ if( update_mode != CONSOLE )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\n\\Z1Cannot verify GPG2 signature of the package.\\Zn\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nGPG2 signature verification of '%s-%s' package returned error status.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ fprintf( stdout, "\nGPG2 signature verification of '%s-%s' package returned error status.\n\n", pkgname, pkgver );
+ }
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+}
+#endif
+
+
+static void dialogrc( void )
+{
+ struct stat st;
+ char *tmp = NULL;
+
+ tmp = (char *)malloc( (size_t)PATH_MAX );
+ if( !tmp ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)tmp, PATH_MAX );
+
+ /* imagine that the utility is in /sbin directory: */
+ (void)sprintf( &tmp[0], "%s/../usr/share/%s/.dialogrc", selfdir, PACKAGE_NAME );
+ if( stat( (const char *)&tmp[0], &st ) == -1 )
+ {
+ /* finaly assume that /usr/sbin is a sbindir: */
+ (void)sprintf( &tmp[0], "%s/../../usr/share/%s/.dialogrc", selfdir, PACKAGE_NAME );
+ }
+
+ setenv( "DIALOGRC", (const char *)&tmp[0], 1 );
+
+ free( tmp );
+}
+
+static char *get_curdir( void )
+{
+ char *cwd = NULL;
+
+ cwd = (char *)malloc( PATH_MAX );
+ if( !cwd ) { FATAL_ERROR( "Cannot allocate memory" ); }
+ bzero( (void *)cwd, PATH_MAX );
+
+ if( getcwd( cwd, (size_t)PATH_MAX ) != NULL )
+ {
+ char *p = NULL;
+ remove_trailing_slash( cwd );
+ p = xstrdup( (const char *)cwd );
+ free( cwd );
+ return p;
+ }
+ else
+ {
+ FATAL_ERROR( "Cannot get absolute path to current directory" );
+ }
+
+ return (char *)NULL;
+}
+
+
+/*********************************************
+ Get directory where this program is placed:
+ */
+char *get_selfdir( void )
+{
+ char *buf = NULL;
+ ssize_t len;
+
+ buf = (char *)malloc( PATH_MAX );
+ if( !buf )
+ {
+ FATAL_ERROR( "Cannot allocate memory" );
+ }
+
+ bzero( (void *)buf, PATH_MAX );
+ len = readlink( "/proc/self/exe", buf, (size_t)PATH_MAX );
+ if( len > 0 && len < PATH_MAX )
+ {
+ char *p = xstrdup( (const char *)dirname( buf ) );
+ free( buf );
+ return p;
+ }
+ FATAL_ERROR( "Cannot determine self directory. Please mount /proc filesystem" );
+}
+
+void set_stack_size( void )
+{
+ const rlim_t stack_size = 16 * 1024 * 1024; /* min stack size = 16 MB */
+ struct rlimit rl;
+ int ret;
+
+ ret = getrlimit( RLIMIT_STACK, &rl );
+ if( ret == 0 )
+ {
+ if( rl.rlim_cur < stack_size )
+ {
+ rl.rlim_cur = stack_size;
+ ret = setrlimit( RLIMIT_STACK, &rl );
+ if( ret != 0 )
+ {
+ fprintf(stderr, "setrlimit returned result = %d\n", ret);
+ FATAL_ERROR( "Cannot set stack size" );
+ }
+ }
+ }
+}
+
+
+int main( int argc, char *argv[] )
+{
+ gid_t gid;
+
+ set_signal_handlers();
+
+ gid = getgid();
+ setgroups( 1, &gid );
+
+ fatal_error_hook = fatal_error_actions;
+
+ selfdir = get_selfdir();
+ curdir = get_curdir();
+ dialogrc();
+
+ errlog = stderr;
+
+ program = basename( argv[0] );
+ get_args( argc, argv );
+
+ /* set_stack_size(); */
+
+ tmpdir = _mk_tmpdir();
+ if( !tmpdir )
+ {
+ FATAL_ERROR( "Cannot create temporary directory" );
+ }
+
+
+ {
+ int status = 0;
+
+ /**********************************************************
+ Fill pkginfo data and put or replace pkglog into tmpdir:
+ */
+ status = check_installed_package();
+
+ read_filelist( (void *)&rdirs, (void *)&rfiles, (const char *)rtmpdir );
+ read_restorelinks( (void *)&rlinks, (const char *)rtmpdir );
+ read_description( (const char *)rtmpdir, 0 );
+ if( status == 0 )
+ {
+ int integrity = check_installed_pkg_integrity();
+ if( integrity ) /* not depends on --always-ask option */
+ {
+ /* same version of requested package is already installed and correct: */
+ if( ask_for_reinstall() )
+ {
+ /* Terminate update procedure with success return code: */
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+ }
+ }
+ }
+
+ /************************************************************
+ Getting Service Files, reading pkginfo, preserving pkglog:
+ */
+ read_service_files();
+
+ if( rqck ) check_requires();
+#if defined( HAVE_GPG2 )
+ if( gpgck ) verify_gpg_signature();
+#endif
+
+ read_filelist( (void *)&dirs, (void *)&files, (const char *)tmpdir );
+ read_restorelinks( (void *)&links, (const char *)tmpdir );
+
+ read_description( (const char *)tmpdir, 1 );
+
+ if( ask_for_update() )
+ {
+ /* Terminate update: */
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+ exit( exit_status );
+ }
+
+ /************
+ DO REMOVE:
+ */
+ remove_package();
+ finalize_removal();
+
+ show_update_progress();
+
+ /************
+ DO UPDATE:
+ */
+ pre_update_routine();
+ uncompress_package();
+ restore_links();
+ post_update_routine();
+ finalize_update();
+
+ fprintf( stdout, "\033[3A" ); /* move cursor up 3 lines */
+
+ if( (update_mode != CONSOLE) && (update_mode == MENUDIALOG) )
+ {
+#if defined( HAVE_DIALOG )
+ info_pkg_box( "Update:", pkgname, pkgver, strprio( priority, 0 ),
+ "\nPackage has been updated.\n", 5, 0, 0 );
+#else
+ fprintf( stdout, "\nPackage '%s-%s' has been updated.\n\n", pkgname, pkgver );
+#endif
+ }
+ else
+ {
+ if( (update_mode != INFODIALOG) )
+ {
+ fprintf( stdout, "\nPackage '%s-%s' has been updated.\n\n", pkgname, pkgver );
+ }
+ }
+
+ setup_log( "Package '%s-%s' has been updated", pkgname, pkgver );
+
+ if( tmpdir ) { _rm_tmpdir( (const char *)tmpdir ); free( tmpdir ); }
+ free_resources();
+
+ exit( exit_status );
+}
Radix cross Linux Package Tools
Package Tools – is a set of utilities to create, install, and update RcL packages
8 Commits
0 Branches
2 Tags