/**********************************************************************
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, disable_chrefs = 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" );
fprintf( stdout, " --disable-chrefs Do not manage references to the package.\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
#define DISABLE_CHREFS 873
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 },
{ "disable-chrefs", no_argument, NULL, DISABLE_CHREFS },
#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 DISABLE_CHREFS:
{
disable_chrefs = 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( !disable_chrefs )
{
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( !disable_chrefs )
{
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
3 Commits
0 Branches
2 Tags