2005-03-14 20:51:43 -05:00
|
|
|
/*
|
|
|
|
* util.c
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2007-12-10 23:55:22 -05:00
|
|
|
* Copyright (c) 2002-2007 by Judd Vinet <jvinet@zeroflux.org>
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2005-03-14 20:51:43 -05:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2007-12-10 23:55:22 -05:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
2007-03-05 17:13:33 -05:00
|
|
|
#include "config.h"
|
|
|
|
|
2006-11-21 23:53:10 -05:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/ioctl.h>
|
2007-02-03 20:36:45 -05:00
|
|
|
#include <sys/time.h>
|
2007-10-23 00:33:47 -04:00
|
|
|
#include <sys/stat.h>
|
2006-11-21 23:53:10 -05:00
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2007-04-26 19:20:46 -04:00
|
|
|
#include <stdarg.h>
|
2005-03-14 20:51:43 -05:00
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <dirent.h>
|
2005-03-16 16:21:06 -05:00
|
|
|
#include <unistd.h>
|
2007-09-06 20:03:38 -04:00
|
|
|
#include <limits.h>
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2007-01-19 04:28:44 -05:00
|
|
|
#include <alpm.h>
|
|
|
|
#include <alpm_list.h>
|
2007-03-05 17:13:33 -05:00
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
/* pacman */
|
|
|
|
#include "util.h"
|
2005-12-20 18:58:27 -05:00
|
|
|
#include "conf.h"
|
2007-04-26 19:20:46 -04:00
|
|
|
|
2007-09-28 00:03:35 -04:00
|
|
|
int needs_transaction()
|
|
|
|
{
|
|
|
|
if(config->op != PM_OP_MAIN && config->op != PM_OP_QUERY && config->op != PM_OP_DEPTEST) {
|
|
|
|
if((config->op == PM_OP_SYNC && !config->op_s_sync &&
|
2007-10-04 19:13:09 -04:00
|
|
|
(config->op_s_search || config->group || config->op_q_list || config->op_q_info))
|
2007-10-03 22:02:36 -04:00
|
|
|
|| config->op == PM_OP_DEPTEST) {
|
2007-09-28 00:03:35 -04:00
|
|
|
/* special case: PM_OP_SYNC can be used w/ config->op_s_search by any user */
|
|
|
|
return(0);
|
|
|
|
} else {
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2006-11-20 04:10:23 -05:00
|
|
|
/* gets the current screen column width */
|
2007-03-13 12:15:38 -04:00
|
|
|
int getcols()
|
2006-11-20 04:10:23 -05:00
|
|
|
{
|
2006-12-28 12:20:41 -05:00
|
|
|
if(!isatty(1)) {
|
|
|
|
/* We will default to 80 columns if we're not a tty
|
|
|
|
* this seems a fairly standard file width.
|
|
|
|
*/
|
|
|
|
return 80;
|
2007-01-18 11:52:57 -05:00
|
|
|
} else {
|
2006-11-21 23:53:10 -05:00
|
|
|
#ifdef TIOCGSIZE
|
2007-01-18 11:52:57 -05:00
|
|
|
struct ttysize win;
|
|
|
|
if(ioctl(1, TIOCGSIZE, &win) == 0) {
|
|
|
|
return win.ts_cols;
|
|
|
|
}
|
2006-11-21 23:53:10 -05:00
|
|
|
#elif defined(TIOCGWINSZ)
|
2007-01-18 11:52:57 -05:00
|
|
|
struct winsize win;
|
|
|
|
if(ioctl(1, TIOCGWINSZ, &win) == 0) {
|
|
|
|
return win.ws_col;
|
|
|
|
}
|
2006-11-21 23:53:10 -05:00
|
|
|
#endif
|
2007-01-18 11:52:57 -05:00
|
|
|
/* If we can't figure anything out, we'll just assume 80 columns */
|
|
|
|
/* TODO any problems caused by this assumption? */
|
|
|
|
return 80;
|
2006-11-21 23:53:10 -05:00
|
|
|
}
|
|
|
|
/* Original envvar way - prone to display issues
|
2006-11-20 04:10:23 -05:00
|
|
|
const char *cenv = getenv("COLUMNS");
|
|
|
|
if(cenv != NULL) {
|
|
|
|
return atoi(cenv);
|
|
|
|
}
|
|
|
|
return -1;
|
2006-11-21 23:53:10 -05:00
|
|
|
*/
|
2006-11-20 04:10:23 -05:00
|
|
|
}
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
/* does the same thing as 'mkdir -p' */
|
2007-05-31 02:51:28 -04:00
|
|
|
int makepath(const char *path)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
char *orig, *str, *ptr;
|
2007-04-25 17:24:23 -04:00
|
|
|
char full[PATH_MAX+1] = "";
|
2005-03-14 20:51:43 -05:00
|
|
|
mode_t oldmask;
|
|
|
|
|
|
|
|
oldmask = umask(0000);
|
|
|
|
|
|
|
|
orig = strdup(path);
|
|
|
|
str = orig;
|
|
|
|
while((ptr = strsep(&str, "/"))) {
|
|
|
|
if(strlen(ptr)) {
|
|
|
|
struct stat buf;
|
|
|
|
|
2007-04-25 17:24:23 -04:00
|
|
|
/* TODO we should use strncat */
|
2005-03-14 20:51:43 -05:00
|
|
|
strcat(full, "/");
|
|
|
|
strcat(full, ptr);
|
|
|
|
if(stat(full, &buf)) {
|
2005-03-16 16:52:49 -05:00
|
|
|
if(mkdir(full, 0755)) {
|
2005-03-14 20:51:43 -05:00
|
|
|
free(orig);
|
|
|
|
umask(oldmask);
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(orig);
|
|
|
|
umask(oldmask);
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* does the same thing as 'rm -rf' */
|
2007-05-31 02:51:28 -04:00
|
|
|
int rmrf(const char *path)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
int errflag = 0;
|
|
|
|
struct dirent *dp;
|
|
|
|
DIR *dirp;
|
|
|
|
|
|
|
|
if(!unlink(path)) {
|
|
|
|
return(0);
|
|
|
|
} else {
|
|
|
|
if(errno == ENOENT) {
|
|
|
|
return(0);
|
|
|
|
} else if(errno == EPERM) {
|
|
|
|
/* fallthrough */
|
|
|
|
} else if(errno == EISDIR) {
|
|
|
|
/* fallthrough */
|
|
|
|
} else if(errno == ENOTDIR) {
|
|
|
|
return(1);
|
|
|
|
} else {
|
|
|
|
/* not a directory */
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if((dirp = opendir(path)) == (DIR *)-1) {
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
for(dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
|
|
|
|
if(dp->d_ino) {
|
2006-01-07 04:42:48 -05:00
|
|
|
char name[PATH_MAX];
|
2005-03-14 20:51:43 -05:00
|
|
|
sprintf(name, "%s/%s", path, dp->d_name);
|
|
|
|
if(strcmp(dp->d_name, "..") && strcmp(dp->d_name, ".")) {
|
|
|
|
errflag += rmrf(name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
closedir(dirp);
|
|
|
|
if(rmdir(path)) {
|
|
|
|
errflag++;
|
|
|
|
}
|
|
|
|
return(errflag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-25 17:13:30 -05:00
|
|
|
/** Parse the basename of a program from a path.
|
|
|
|
* Grabbed from the uClibc source.
|
|
|
|
* @param path path to parse basename from
|
|
|
|
*
|
|
|
|
* @return everything following the final '/'
|
|
|
|
*/
|
|
|
|
char *mbasename(const char *path)
|
|
|
|
{
|
|
|
|
const char *s;
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
p = s = path;
|
|
|
|
|
|
|
|
while (*s) {
|
|
|
|
if (*s++ == '/') {
|
|
|
|
p = s;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return (char *)p;
|
|
|
|
}
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
/* output a string, but wrap words properly with a specified indentation
|
|
|
|
*/
|
2007-03-13 12:15:38 -04:00
|
|
|
void indentprint(const char *str, int indent)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2006-11-20 04:10:23 -05:00
|
|
|
const char *p = str;
|
2007-03-13 12:15:38 -04:00
|
|
|
int cidx = indent;
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2008-01-11 01:01:58 -05:00
|
|
|
if(!p) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
while(*p) {
|
|
|
|
if(*p == ' ') {
|
2006-11-20 04:10:23 -05:00
|
|
|
const char *next = NULL;
|
2007-08-16 16:19:06 -04:00
|
|
|
int len;
|
2005-03-14 20:51:43 -05:00
|
|
|
p++;
|
|
|
|
if(p == NULL || *p == ' ') continue;
|
|
|
|
next = strchr(p, ' ');
|
|
|
|
if(next == NULL) {
|
2007-07-10 23:36:15 -04:00
|
|
|
next = p + mbstowcs(NULL, p, 0);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
len = next - p;
|
2007-03-13 12:15:38 -04:00
|
|
|
if(len > (getcols() - cidx - 1)) {
|
2005-03-14 20:51:43 -05:00
|
|
|
/* newline */
|
2007-03-13 12:15:38 -04:00
|
|
|
int i;
|
2005-03-14 20:51:43 -05:00
|
|
|
fprintf(stdout, "\n");
|
|
|
|
for(i = 0; i < indent; i++) {
|
|
|
|
fprintf(stdout, " ");
|
|
|
|
}
|
|
|
|
cidx = indent;
|
|
|
|
} else {
|
|
|
|
printf(" ");
|
|
|
|
cidx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fprintf(stdout, "%c", *p);
|
|
|
|
p++;
|
|
|
|
cidx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert a string to uppercase
|
|
|
|
*/
|
|
|
|
char *strtoupper(char *str)
|
|
|
|
{
|
|
|
|
char *ptr = str;
|
|
|
|
|
|
|
|
while(*ptr) {
|
|
|
|
(*ptr) = toupper(*ptr);
|
|
|
|
ptr++;
|
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Trim whitespace and newlines from a string
|
|
|
|
*/
|
|
|
|
char *strtrim(char *str)
|
|
|
|
{
|
|
|
|
char *pch = str;
|
2007-06-04 12:01:53 -04:00
|
|
|
|
2007-06-04 12:51:23 -04:00
|
|
|
if(str == NULL || *str == '\0') {
|
2007-06-04 12:01:53 -04:00
|
|
|
/* string is empty, so we're done. */
|
|
|
|
return(str);
|
|
|
|
}
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
while(isspace(*pch)) {
|
|
|
|
pch++;
|
|
|
|
}
|
|
|
|
if(pch != str) {
|
|
|
|
memmove(str, pch, (strlen(pch) + 1));
|
|
|
|
}
|
2007-11-16 21:18:45 -05:00
|
|
|
|
2007-06-04 12:01:53 -04:00
|
|
|
/* check if there wasn't anything but whitespace in the string. */
|
|
|
|
if(*str == '\0') {
|
|
|
|
return(str);
|
|
|
|
}
|
|
|
|
|
2007-05-14 03:16:55 -04:00
|
|
|
pch = (str + (strlen(str) - 1));
|
2005-03-14 20:51:43 -05:00
|
|
|
while(isspace(*pch)) {
|
|
|
|
pch--;
|
|
|
|
}
|
|
|
|
*++pch = '\0';
|
|
|
|
|
2007-06-04 12:01:53 -04:00
|
|
|
return(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Helper function for strreplace */
|
|
|
|
static void _strnadd(char **str, const char *append, unsigned int count)
|
|
|
|
{
|
|
|
|
if(*str) {
|
|
|
|
*str = realloc(*str, strlen(*str) + count + 1);
|
|
|
|
} else {
|
|
|
|
*str = calloc(sizeof(char), count + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
strncat(*str, append, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Replace all occurances of 'needle' with 'replace' in 'str', returning
|
|
|
|
* a new string (must be free'd) */
|
|
|
|
char *strreplace(const char *str, const char *needle, const char *replace)
|
|
|
|
{
|
|
|
|
const char *p, *q;
|
|
|
|
p = q = str;
|
|
|
|
|
|
|
|
char *newstr = NULL;
|
|
|
|
unsigned int needlesz = strlen(needle),
|
|
|
|
replacesz = strlen(replace);
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
q = strstr(p, needle);
|
|
|
|
if(!q) { /* not found */
|
|
|
|
if(*p) {
|
|
|
|
/* add the rest of 'p' */
|
|
|
|
_strnadd(&newstr, p, strlen(p));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
} else { /* found match */
|
|
|
|
if(q > p){
|
|
|
|
/* add chars between this occurance and last occurance, if any */
|
|
|
|
_strnadd(&newstr, p, q - p);
|
|
|
|
}
|
|
|
|
_strnadd(&newstr, replace, replacesz);
|
|
|
|
p = q + needlesz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return newstr;
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
2007-11-13 19:32:56 -05:00
|
|
|
/** Splits a string into a list of strings using the chosen character as
|
|
|
|
* a delimiter.
|
|
|
|
*
|
|
|
|
* @param str the string to split
|
|
|
|
* @param splitchar the character to split at
|
|
|
|
*
|
|
|
|
* @return a list containing the duplicated strings
|
|
|
|
*/
|
|
|
|
alpm_list_t *strsplit(const char *str, const char splitchar)
|
|
|
|
{
|
|
|
|
alpm_list_t *list = NULL;
|
|
|
|
const char *prev = str;
|
|
|
|
char *dup = NULL;
|
|
|
|
|
|
|
|
while((str = strchr(str, splitchar))) {
|
|
|
|
dup = strndup(prev, str - prev);
|
|
|
|
if(dup == NULL) {
|
|
|
|
return(NULL);
|
|
|
|
}
|
|
|
|
list = alpm_list_add(list, dup);
|
|
|
|
|
|
|
|
str++;
|
|
|
|
prev = str;
|
|
|
|
}
|
|
|
|
|
|
|
|
dup = strdup(prev);
|
|
|
|
if(dup == NULL) {
|
|
|
|
return(NULL);
|
|
|
|
}
|
|
|
|
list = alpm_list_add(list, strdup(prev));
|
|
|
|
|
|
|
|
return(list);
|
|
|
|
}
|
|
|
|
|
2007-11-23 16:32:40 -05:00
|
|
|
void string_display(const char *title, const char *string)
|
|
|
|
{
|
|
|
|
printf("%s ", title);
|
|
|
|
if(string == NULL || string[0] == '\0') {
|
|
|
|
printf(_("None\n"));
|
|
|
|
} else {
|
|
|
|
printf("%s\n", string);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-05 17:34:33 -04:00
|
|
|
void list_display(const char *title, const alpm_list_t *list)
|
2007-01-19 04:28:44 -05:00
|
|
|
{
|
2007-06-05 17:34:33 -04:00
|
|
|
const alpm_list_t *i;
|
2007-01-19 04:28:44 -05:00
|
|
|
int cols, len;
|
|
|
|
|
2007-07-10 23:36:15 -04:00
|
|
|
len = mbstowcs(NULL, title, 0);
|
2007-01-19 04:28:44 -05:00
|
|
|
printf("%s ", title);
|
|
|
|
|
|
|
|
if(list) {
|
|
|
|
for(i = list, cols = len; i; i = alpm_list_next(i)) {
|
|
|
|
char *str = alpm_list_getdata(i);
|
2007-07-10 23:36:15 -04:00
|
|
|
int s = mbstowcs(NULL, str, 0) + 2;
|
2007-03-13 12:15:38 -04:00
|
|
|
int maxcols = getcols();
|
2007-01-19 04:28:44 -05:00
|
|
|
if(s + cols >= maxcols) {
|
|
|
|
int i;
|
|
|
|
cols = len;
|
|
|
|
printf("\n");
|
2007-02-01 01:35:30 -05:00
|
|
|
for (i = 0; i <= len; ++i) {
|
2007-01-19 04:28:44 -05:00
|
|
|
printf(" ");
|
|
|
|
}
|
|
|
|
}
|
2007-02-01 01:35:30 -05:00
|
|
|
printf("%s ", str);
|
2007-01-19 04:28:44 -05:00
|
|
|
cols += s;
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
} else {
|
|
|
|
printf(_("None\n"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-03 20:36:45 -05:00
|
|
|
/* Display a list of transaction targets.
|
|
|
|
* `pkgs` should be a list of pmsyncpkg_t's,
|
|
|
|
* retrieved from a transaction object
|
|
|
|
*/
|
2007-04-26 15:28:54 -04:00
|
|
|
/* TODO move to output.c? or just combine util and output */
|
2007-10-19 13:17:54 -04:00
|
|
|
void display_targets(const alpm_list_t *syncpkgs, pmdb_t *db_local)
|
2007-02-03 20:36:45 -05:00
|
|
|
{
|
|
|
|
char *str;
|
2007-06-05 17:34:33 -04:00
|
|
|
const alpm_list_t *i, *j;
|
2007-02-03 20:36:45 -05:00
|
|
|
alpm_list_t *targets = NULL, *to_remove = NULL;
|
2007-02-08 15:44:47 -05:00
|
|
|
/* TODO these are some messy variable names */
|
2007-11-11 15:14:07 -05:00
|
|
|
unsigned long isize = 0, rsize = 0, dispsize = 0, dlsize = 0;
|
|
|
|
double mbisize = 0.0, mbrsize = 0.0, mbdispsize = 0.0, mbdlsize = 0.0;
|
2007-02-03 20:36:45 -05:00
|
|
|
|
2007-02-04 03:26:52 -05:00
|
|
|
for(i = syncpkgs; i; i = alpm_list_next(i)) {
|
2007-02-03 20:36:45 -05:00
|
|
|
pmsyncpkg_t *sync = alpm_list_getdata(i);
|
2007-02-26 03:43:02 -05:00
|
|
|
pmpkg_t *pkg = alpm_sync_get_pkg(sync);
|
2007-02-03 20:36:45 -05:00
|
|
|
|
|
|
|
/* If this sync record is a replacement, the data member contains
|
|
|
|
* a list of packages to be removed due to the package that is being
|
|
|
|
* installed. */
|
|
|
|
if(alpm_sync_get_type(sync) == PM_SYNC_TYPE_REPLACE) {
|
|
|
|
alpm_list_t *to_replace = alpm_sync_get_data(sync);
|
2007-11-16 21:18:45 -05:00
|
|
|
|
2007-02-03 20:36:45 -05:00
|
|
|
for(j = to_replace; j; j = alpm_list_next(j)) {
|
|
|
|
pmpkg_t *rp = alpm_list_getdata(j);
|
|
|
|
const char *name = alpm_pkg_get_name(rp);
|
|
|
|
|
|
|
|
if(!alpm_list_find_str(to_remove, name)) {
|
2007-02-08 15:44:47 -05:00
|
|
|
rsize += alpm_pkg_get_isize(rp);
|
2007-02-03 20:36:45 -05:00
|
|
|
to_remove = alpm_list_add(to_remove, strdup(name));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-14 01:21:42 -04:00
|
|
|
dispsize = alpm_pkg_get_size(pkg);
|
2007-10-19 13:17:54 -04:00
|
|
|
dlsize += alpm_pkg_download_size(pkg, db_local);
|
2007-02-08 15:44:47 -05:00
|
|
|
isize += alpm_pkg_get_isize(pkg);
|
2007-02-03 20:36:45 -05:00
|
|
|
|
2007-06-01 11:00:39 -04:00
|
|
|
/* print the package size with the output if ShowSize option set */
|
2007-06-04 12:51:23 -04:00
|
|
|
if(config->showsize) {
|
2007-05-14 01:21:42 -04:00
|
|
|
/* Convert byte size to MB */
|
|
|
|
mbdispsize = dispsize / (1024.0 * 1024.0);
|
|
|
|
|
2007-10-16 09:41:37 -04:00
|
|
|
asprintf(&str, "%s-%s [%.2f MB]", alpm_pkg_get_name(pkg),
|
|
|
|
alpm_pkg_get_version(pkg), mbdispsize);
|
2007-05-14 01:21:42 -04:00
|
|
|
} else {
|
|
|
|
asprintf(&str, "%s-%s", alpm_pkg_get_name(pkg),
|
|
|
|
alpm_pkg_get_version(pkg));
|
|
|
|
}
|
2007-02-03 20:36:45 -05:00
|
|
|
targets = alpm_list_add(targets, str);
|
|
|
|
}
|
|
|
|
|
2007-02-08 15:44:47 -05:00
|
|
|
/* Convert byte sizes to MB */
|
2007-05-14 01:21:42 -04:00
|
|
|
mbisize = isize / (1024.0 * 1024.0);
|
|
|
|
mbrsize = rsize / (1024.0 * 1024.0);
|
2007-10-19 13:17:54 -04:00
|
|
|
mbdlsize = dlsize / (1024.0 * 1024.0);
|
2007-02-08 15:44:47 -05:00
|
|
|
|
2007-04-26 15:28:54 -04:00
|
|
|
/* start displaying information */
|
|
|
|
printf("\n");
|
|
|
|
|
2007-02-03 20:36:45 -05:00
|
|
|
if(to_remove) {
|
|
|
|
list_display(_("Remove:"), to_remove);
|
2007-04-26 15:28:54 -04:00
|
|
|
printf("\n");
|
2007-02-03 20:36:45 -05:00
|
|
|
FREELIST(to_remove);
|
2007-11-16 21:18:45 -05:00
|
|
|
|
2007-04-26 15:28:54 -04:00
|
|
|
printf(_("Total Removed Size: %.2f MB\n"), mbrsize);
|
2007-11-11 10:28:35 -05:00
|
|
|
printf("\n");
|
2007-02-03 20:36:45 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
list_display(_("Targets:"), targets);
|
2007-04-26 15:28:54 -04:00
|
|
|
printf("\n");
|
2007-02-03 20:36:45 -05:00
|
|
|
|
2007-10-19 13:17:54 -04:00
|
|
|
printf(_("Total Download Size: %.2f MB\n"), mbdlsize);
|
2007-11-16 21:18:45 -05:00
|
|
|
|
2007-04-26 15:28:54 -04:00
|
|
|
/* TODO because all pkgs don't include isize, this is a crude hack */
|
2007-11-11 15:14:07 -05:00
|
|
|
if(mbisize > mbdlsize) {
|
2007-04-26 15:28:54 -04:00
|
|
|
printf(_("Total Installed Size: %.2f MB\n"), mbisize);
|
2007-02-03 20:36:45 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
FREELIST(targets);
|
|
|
|
}
|
|
|
|
|
2007-04-26 19:20:46 -04:00
|
|
|
/* presents a prompt and gets a Y/N answer */
|
|
|
|
/* TODO there must be a better way */
|
|
|
|
int yesno(char *fmt, ...)
|
|
|
|
{
|
|
|
|
char response[32];
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
if(config->noconfirm) {
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
/* Use stderr so questions are always displayed when redirecting output */
|
2007-06-07 15:42:26 -04:00
|
|
|
vfprintf(stderr, fmt, args);
|
|
|
|
va_end(args);
|
2007-04-26 19:20:46 -04:00
|
|
|
|
|
|
|
if(fgets(response, 32, stdin)) {
|
|
|
|
if(strlen(response) != 0) {
|
|
|
|
strtrim(response);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!strcasecmp(response, _("Y")) || !strcasecmp(response, _("YES")) || strlen(response) == 0) {
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2007-06-07 15:42:26 -04:00
|
|
|
int pm_printf(pmloglevel_t level, const char *format, ...)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
/* print the message using va_arg list */
|
|
|
|
va_start(args, format);
|
|
|
|
ret = pm_vfprintf(stdout, level, format, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
int pm_fprintf(FILE *stream, pmloglevel_t level, const char *format, ...)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
/* print the message using va_arg list */
|
|
|
|
va_start(args, format);
|
|
|
|
ret = pm_vfprintf(stream, level, format, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
2007-12-03 16:57:54 -05:00
|
|
|
int pm_vasprintf(char **string, pmloglevel_t level, const char *format, va_list args)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
char *msg = NULL;
|
|
|
|
|
|
|
|
/* if current logmask does not overlap with level, do not print msg */
|
|
|
|
if(!(config->logmask & level)) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* print the message using va_arg list */
|
|
|
|
ret = vasprintf(&msg, format, args);
|
|
|
|
|
|
|
|
/* print a prefix to the message */
|
|
|
|
switch(level) {
|
|
|
|
case PM_LOG_DEBUG:
|
2008-01-17 20:04:15 -05:00
|
|
|
asprintf(string, "debug: %s", msg);
|
2007-12-03 16:57:54 -05:00
|
|
|
break;
|
|
|
|
case PM_LOG_ERROR:
|
|
|
|
asprintf(string, _("error: %s"), msg);
|
|
|
|
break;
|
|
|
|
case PM_LOG_WARNING:
|
|
|
|
asprintf(string, _("warning: %s"), msg);
|
|
|
|
break;
|
|
|
|
case PM_LOG_FUNCTION:
|
|
|
|
asprintf(string, _("function: %s"), msg);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
free(msg);
|
|
|
|
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
2007-06-07 15:42:26 -04:00
|
|
|
int pm_vfprintf(FILE *stream, pmloglevel_t level, const char *format, va_list args)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* if current logmask does not overlap with level, do not print msg */
|
|
|
|
if(!(config->logmask & level)) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(PACMAN_DEBUG)
|
|
|
|
/* If debug is on, we'll timestamp the output */
|
|
|
|
if(config->logmask & PM_LOG_DEBUG) {
|
|
|
|
time_t t;
|
|
|
|
struct tm *tmp;
|
|
|
|
char timestr[10] = {0};
|
|
|
|
|
|
|
|
t = time(NULL);
|
|
|
|
tmp = localtime(&t);
|
|
|
|
strftime(timestr, 9, "%H:%M:%S", tmp);
|
|
|
|
timestr[8] = '\0';
|
|
|
|
|
|
|
|
printf("[%s] ", timestr);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* print a prefix to the message */
|
|
|
|
switch(level) {
|
|
|
|
case PM_LOG_DEBUG:
|
2008-01-17 20:04:15 -05:00
|
|
|
fprintf(stream, "debug: ");
|
2007-06-07 15:42:26 -04:00
|
|
|
break;
|
|
|
|
case PM_LOG_ERROR:
|
|
|
|
fprintf(stream, _("error: "));
|
|
|
|
break;
|
|
|
|
case PM_LOG_WARNING:
|
|
|
|
fprintf(stream, _("warning: "));
|
|
|
|
break;
|
|
|
|
case PM_LOG_FUNCTION:
|
|
|
|
/* TODO we should increase the indent level when this occurs so we can see
|
|
|
|
* program flow easier. It'll be fun */
|
|
|
|
fprintf(stream, _("function: "));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* print the message using va_arg list */
|
|
|
|
ret = vfprintf(stream, format, args);
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
2007-10-24 01:37:50 -04:00
|
|
|
#ifndef HAVE_STRNDUP
|
|
|
|
/* A quick and dirty implementation derived from glibc */
|
|
|
|
static size_t strnlen(const char *s, size_t max)
|
|
|
|
{
|
|
|
|
register const char *p;
|
|
|
|
for(p = s; *p && max--; ++p);
|
|
|
|
return(p - s);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *strndup(const char *s, size_t n)
|
|
|
|
{
|
|
|
|
size_t len = strnlen(s, n);
|
|
|
|
char *new = (char *) malloc(len + 1);
|
|
|
|
|
|
|
|
if (new == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
new[len] = '\0';
|
|
|
|
return (char *) memcpy(new, s, len);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
/* vim: set ts=2 sw=2 noet: */
|