slapt_transaction_t *slapt_init_transaction(void)
{
slapt_transaction_t *tran = slapt_malloc(sizeof *tran);
tran->install_pkgs = slapt_init_pkg_list();
tran->install_pkgs->free_pkgs = SLAPT_TRUE;
tran->remove_pkgs = slapt_init_pkg_list();
tran->remove_pkgs->free_pkgs = SLAPT_TRUE;
tran->exclude_pkgs = slapt_init_pkg_list();
tran->exclude_pkgs->free_pkgs = SLAPT_TRUE;
tran->upgrade_pkgs = slapt_malloc(sizeof *tran->upgrade_pkgs);
tran->upgrade_pkgs->pkgs = slapt_malloc(sizeof *tran->upgrade_pkgs->pkgs);
tran->upgrade_pkgs->pkg_count = 0;
tran->upgrade_pkgs->reinstall_count = 0;
tran->suggests = slapt_init_list();
tran->queue = slapt_queue_init();
tran->conflict_err = slapt_init_pkg_err_list();
tran->missing_err = slapt_init_pkg_err_list();
return tran;
}
slapt_source_list_t *slapt_init_source_list(void)
{
slapt_source_list_t *list = slapt_malloc(sizeof *list);
list->src = slapt_malloc(sizeof *list->src);
list->count = 0;
return list;
}
static slapt_queue_t *slapt_queue_init(void)
{
slapt_queue_t *t = NULL;
t = slapt_malloc(sizeof *t);
t->pkgs = slapt_malloc(sizeof *t->pkgs);
t->count = 0;
return t;
}
static void _slapt_add_upgrade_to_transaction(slapt_transaction_t *tran,
slapt_pkg_info_t *installed_pkg,
slapt_pkg_info_t *slapt_upgrade_pkg,
SLAPT_BOOL_T reinstall
)
{
slapt_pkg_upgrade_t **tmp_list;
/* don't add if already present in the transaction */
if (slapt_search_transaction_by_pkg(tran,slapt_upgrade_pkg) == 1)
return;
tmp_list = realloc(
tran->upgrade_pkgs->pkgs,
sizeof *tran->upgrade_pkgs->pkgs * (tran->upgrade_pkgs->pkg_count + 1)
);
if (tmp_list != NULL) {
tran->upgrade_pkgs->pkgs = tmp_list;
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count] = slapt_malloc(
sizeof *tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]);
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->installed =
slapt_malloc(
sizeof *tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->installed
);
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->upgrade =
slapt_malloc(
sizeof *tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->upgrade
);
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->installed = slapt_copy_pkg(
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->installed,
installed_pkg);
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->upgrade = slapt_copy_pkg(
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->upgrade,
slapt_upgrade_pkg);
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]->reinstall = reinstall;
queue_add_upgrade(tran->queue,
tran->upgrade_pkgs->pkgs[tran->upgrade_pkgs->pkg_count]);
++tran->upgrade_pkgs->pkg_count;
if (reinstall == SLAPT_TRUE)
++tran->upgrade_pkgs->reinstall_count;
}
}
static void clean (slapt_src_config *config)
{
struct dirent *file = NULL;
DIR *builddir = opendir (config->builddir);
if ( builddir != NULL ) {
while ((file = readdir (builddir)) != NULL) {
struct stat stat_buf;
if (strcmp (file->d_name, "..") == 0 || strcmp (file->d_name, ".") == 0)
continue;
if (lstat (file->d_name, &stat_buf) == -1)
continue;
if ( S_ISDIR (stat_buf.st_mode)) {
int r = 0, command_len = strlen (file->d_name)+8;
char *command = slapt_malloc (sizeof *command * command_len);
r = snprintf (command, command_len, "rm -rf %s", file->d_name);
if (r+1 == command_len) {
int sys_r = system (command);
if (sys_r != 0)
exit (EXIT_FAILURE);
}
}
}
}
closedir (builddir);
}
slapt_rc_config *slapt_init_config(void)
{
slapt_rc_config *global_config = slapt_malloc( sizeof *global_config );
global_config->download_only = SLAPT_FALSE;
global_config->simulate = SLAPT_FALSE;
global_config->ignore_excludes = SLAPT_FALSE;
global_config->no_md5_check = SLAPT_FALSE;
global_config->dist_upgrade = SLAPT_FALSE;
global_config->ignore_dep = SLAPT_FALSE;
global_config->disable_dep_check = SLAPT_FALSE;
global_config->print_uris = SLAPT_FALSE;
global_config->dl_stats = SLAPT_FALSE;
global_config->no_prompt = SLAPT_FALSE;
global_config->prompt = SLAPT_FALSE;
global_config->re_install = SLAPT_FALSE;
global_config->remove_obsolete = SLAPT_FALSE;
global_config->no_upgrade = SLAPT_FALSE;
global_config->use_priority = SLAPT_FALSE;
global_config->working_dir[0] = '\0';
global_config->progress_cb = NULL;
global_config->gpgme_allow_unauth = SLAPT_FALSE; /* even without GPGME */
global_config->sources = slapt_init_source_list();
global_config->exclude_list = slapt_init_list();
global_config->retry = 1;
return global_config;
}
void slapt_add_exclude_to_transaction(slapt_transaction_t *tran,
slapt_pkg_info_t *pkg)
{
slapt_pkg_info_t **tmp_list;
/* don't add if already present in the transaction */
if (slapt_search_transaction_by_pkg(tran,pkg) == 1)
return;
tmp_list = realloc(
tran->exclude_pkgs->pkgs,
sizeof *tran->exclude_pkgs->pkgs * (tran->exclude_pkgs->pkg_count + 1)
);
if (tmp_list != NULL) {
tran->exclude_pkgs->pkgs = tmp_list;
tran->exclude_pkgs->pkgs[tran->exclude_pkgs->pkg_count] = slapt_malloc(
sizeof *tran->exclude_pkgs->pkgs[tran->exclude_pkgs->pkg_count]
);
tran->exclude_pkgs->pkgs[tran->exclude_pkgs->pkg_count] = slapt_copy_pkg(
tran->exclude_pkgs->pkgs[tran->exclude_pkgs->pkg_count],
pkg
);
++tran->exclude_pkgs->pkg_count;
}
}
static void queue_add_upgrade(slapt_queue_t *t, slapt_pkg_upgrade_t *p)
{
slapt_queue_i **tmp;
tmp = realloc(t->pkgs, sizeof *t->pkgs * (t->count + 1));
if (!tmp)
return;
t->pkgs = tmp;
t->pkgs[t->count] = slapt_malloc(sizeof *t->pkgs[t->count]);
t->pkgs[t->count]->pkg.u = p;
t->pkgs[t->count]->type = UPGRADE;
++t->count;
}
static void queue_add_install(slapt_queue_t *t, slapt_pkg_info_t *p)
{
slapt_queue_i **tmp;
tmp = realloc(t->pkgs, sizeof *t->pkgs * (t->count + 1));
if (!tmp)
return;
t->pkgs = tmp;
t->pkgs[t->count] = slapt_malloc(sizeof *t->pkgs[t->count]);
t->pkgs[t->count]->pkg.i = p;
t->pkgs[t->count]->type = INSTALL;
++t->count;
}
static int show_summary (slapt_src_slackbuild_list *sbs, slapt_list_t *names, int action, SLAPT_BOOL_T prompt)
{
int i, line_len = 0;
printf (gettext ("The following packages will be %s:\n"),
action == INSTALL_OPT ? gettext ("installed")
: action == BUILD_OPT ? gettext ("built")
: gettext ("fetched")
);
for (i = 0; i < names->count; i++) {
slapt_list_t *parts = slapt_parse_delimited_list (names->items[i], ':');
const char *name = parts->items[0];
int name_len = strlen (name);
if (line_len == 0) {
printf (" %s ", name);
line_len += name_len + 1;
} else if (line_len < 80 - name_len) {
printf ("%s ", name);
line_len += name_len + 1;
} else {
printf ("\n %s ", name);
line_len = name_len + 2;
}
slapt_free_list (parts);
}
printf ("\n");
if (names->count < sbs->count) {
line_len = 0;
printf (gettext ("The following dependent slackbuilds will be built and installed:\n"));
for (i = 0; i < sbs->count; i++) {
const char *name = sbs->slackbuilds[i]->name;
const char *version = sbs->slackbuilds[i]->version;
char *namever = slapt_malloc (sizeof *namever * (strlen (name) + strlen (version) + 2));
sprintf (namever, "%s:%s", name, version);
if (slapt_search_list (names, name) == NULL && slapt_search_list (names, namever) == NULL) {
int name_len = strlen (name);
if (line_len == 0) {
printf (" %s ", name);
line_len += name_len + 2;
} else if (line_len < 80 - name_len) {
printf ("%s ", name);
line_len += name_len + 1;
} else {
printf ("\n %s ", name);
line_len = name_len + 2;
}
}
free (namever);
}
printf ("\n");
}
if (prompt == SLAPT_TRUE) {
if (slapt_ask_yes_no (gettext ("Do you want to continue? [y/N] ")) != 1) {
printf (gettext ("Abort.\n"));
return 0;
}
}
return action;
}
int main (int argc, char *argv[])
{
int c = -1, option_index = 0, action = 0, i = 0, rval = 0;
slapt_list_t *names = slapt_init_list ();
slapt_src_config *config = NULL;
slapt_src_slackbuild_list *sbs = NULL;
slapt_src_slackbuild_list *remote_sbs = NULL;
slapt_pkg_list_t *installed = NULL;
SLAPT_BOOL_T prompt = SLAPT_TRUE, do_dep = SLAPT_TRUE, simulate = SLAPT_FALSE;
char *config_file = NULL, *postcmd = NULL;
static struct option long_options[] = {
{"version", no_argument, 0, VERSION_OPT},
{"help", no_argument, 0, HELP_OPT},
{"update", no_argument, 0, UPDATE_OPT},
{"list", no_argument, 0, LIST_OPT},
{"clean", no_argument, 0, CLEAN_OPT},
{"e", no_argument, 0, CLEAN_OPT},
{"search", required_argument, 0, SEARCH_OPT},
{"s", required_argument, 0, SEARCH_OPT},
{"show", required_argument, 0, SHOW_OPT},
{"w", required_argument, 0, SHOW_OPT},
{"fetch", required_argument, 0, FETCH_OPT},
{"build", required_argument, 0, BUILD_OPT},
{"install", required_argument, 0, INSTALL_OPT},
{"yes", no_argument, 0, YES_OPT},
{"simulate", no_argument, 0, SIMULATE_OPT},
{"t", no_argument, 0, SIMULATE_OPT},
{"no-dep", no_argument, 0, NODEP_OPT},
{"config", required_argument, 0, CONFIG_OPT},
{"c", required_argument, 0, CONFIG_OPT},
{"postprocess", required_argument, 0, POSTCMD_OPT},
{0, 0, 0, 0}
};
/* initialization */
setbuf (stdout, NULL);
#ifdef ENABLE_NLS
setlocale (LC_ALL,"");
textdomain (GETTEXT_PACKAGE);
#endif
#ifdef SLAPT_HAS_GPGME
gpgme_check_version (NULL);
#ifdef ENABLE_NLS
gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
#endif
#endif
curl_global_init (CURL_GLOBAL_ALL);
uname (&uname_v);
/* stop early */
if (argc < 2) {
help ();
exit (EXIT_SUCCESS);
}
while ( (c = getopt_long_only (argc, argv, "", long_options, &option_index)) != -1) {
switch (c) {
case HELP_OPT: help (); break;
case VERSION_OPT: version (); break;
case UPDATE_OPT: action = UPDATE_OPT; break;
case LIST_OPT: action = LIST_OPT; break;
case CLEAN_OPT: action = CLEAN_OPT; break;
case FETCH_OPT: action = FETCH_OPT; slapt_add_list_item (names, optarg); break;
case SEARCH_OPT: action = SEARCH_OPT; slapt_add_list_item (names, optarg); break;
case SHOW_OPT: action = SHOW_OPT; slapt_add_list_item (names, optarg); break;
case BUILD_OPT: action = BUILD_OPT; slapt_add_list_item (names, optarg); break;
case INSTALL_OPT: action = INSTALL_OPT; slapt_add_list_item (names, optarg); break;
case YES_OPT: prompt = SLAPT_FALSE; break;
case SIMULATE_OPT: simulate = SLAPT_TRUE; break;
case NODEP_OPT: do_dep = SLAPT_FALSE; break;
case CONFIG_OPT: config_file = strdup (optarg); break;
case POSTCMD_OPT: postcmd = strdup (optarg); break;
default: help (); exit (EXIT_FAILURE);
}
}
/* add extra arguments */
while (optind < argc) {
slapt_add_list_item (names, argv[optind]);
++optind;
}
if (config_file != NULL)
config = slapt_src_read_config (config_file);
else
config = slapt_src_read_config (SLAPT_SRC_RC);
if (config == NULL) {
fprintf (stderr, gettext ("Failed to read %s\n"), SLAPT_SRC_RC);
exit (EXIT_FAILURE);
}
/* honor command line option */
config->do_dep = do_dep;
config->postcmd = postcmd; /* to be freed in slapt_src_config_free */
init_builddir (config);
if ( (chdir (config->builddir)) != 0) {
perror (gettext ("Failed to chdir to build directory"));
exit (EXIT_FAILURE);
}
/* setup, fetch, and other preperation steps */
switch (action) {
case LIST_OPT:
case SEARCH_OPT:
case SHOW_OPT:
remote_sbs = slapt_src_get_available_slackbuilds ();
break;
case FETCH_OPT:
case BUILD_OPT:
case INSTALL_OPT:
remote_sbs = slapt_src_get_available_slackbuilds ();
installed = slapt_get_installed_pkgs ();
/* convert all names to slackbuilds */
if (names->count > 0) {
sbs = slapt_src_names_to_slackbuilds (config, remote_sbs, names, installed);
if (sbs == NULL || sbs->count == 0) {
printf (gettext ("Unable to find all specified slackbuilds.\n"));
exit (EXIT_FAILURE);
}
}
/* provide summary */
if (!simulate)
action = show_summary (sbs, names, action, prompt);
break;
}
/* now, actually do what was requested */
switch (action) {
case UPDATE_OPT:
rval = slapt_src_update_slackbuild_cache (config);
break;
case FETCH_OPT:
for (i = 0; i < sbs->count; i++) {
if (simulate) {
printf (gettext ("FETCH: %s\n"), sbs->slackbuilds[i]->name);
continue;
} else
slapt_src_fetch_slackbuild (config, sbs->slackbuilds[i]);
}
break;
case BUILD_OPT:
for (i = 0; i < sbs->count; i++) {
slapt_src_slackbuild *sb = sbs->slackbuilds[i];
int r = 0, nv_len = strlen (sb->name) + strlen (sb->version) + 2;
char *namever = slapt_malloc (sizeof *namever * nv_len);
r = snprintf (namever, nv_len, "%s:%s", sb->name, sb->version);
if (r+1 != nv_len)
exit (EXIT_FAILURE);
if (simulate) {
printf (gettext ("BUILD: %s\n"), sb->name);
free (namever);
continue;
}
slapt_src_fetch_slackbuild (config, sb);
slapt_src_build_slackbuild (config, sb);
/* XXX we assume if we didn't request the slackbuild, then
it is a dependency, and needs to be installed */
if (slapt_search_list (names, sb->name) == NULL && slapt_search_list (names, namever) == NULL)
slapt_src_install_slackbuild (config, sbs->slackbuilds[i]);
free (namever);
}
break;
case INSTALL_OPT:
for (i = 0; i < sbs->count; i++) {
slapt_src_slackbuild *sb = sbs->slackbuilds[i];
if (simulate) {
printf (gettext ("INSTALL: %s\n"), sb->name);
continue;
}
slapt_src_fetch_slackbuild (config, sb);
slapt_src_build_slackbuild (config, sb);
slapt_src_install_slackbuild (config, sb);
}
break;
case SEARCH_OPT:
{
slapt_src_slackbuild_list *search = slapt_src_search_slackbuild_cache (remote_sbs, names);
for (i = 0; i < search->count; i++) {
slapt_src_slackbuild *sb = search->slackbuilds[i];
printf ("%s:%s - %s\n",
sb->name,
sb->version,
sb->short_desc != NULL ? sb->short_desc : ""
);
}
slapt_src_slackbuild_list_free (search);
}
break;
case LIST_OPT:
for (i = 0; i < remote_sbs->count; i++) {
slapt_src_slackbuild *sb = remote_sbs->slackbuilds[i];
printf ("%s:%s - %s\n",
sb->name,
sb->version,
sb->short_desc != NULL ? sb->short_desc : ""
);
}
break;
case SHOW_OPT:
{
int c;
for (i = 0; i < names->count; i++) {
slapt_src_slackbuild *sb = NULL;
slapt_list_t *parts = slapt_parse_delimited_list (names->items[i], ':');
const char *name = parts->items[0];
const char *ver = NULL;
if (parts->count > 1)
ver = parts->items[1];
sb = slapt_src_get_slackbuild (remote_sbs, name, ver);
if (sb != NULL) {
printf (gettext ("SlackBuild Name: %s\n"), sb->name);
printf (gettext ("SlackBuild Version: %s\n"), sb->version);
printf (gettext ("SlackBuild Category: %s\n"), sb->location);
printf (gettext ("SlackBuild Description: %s\n"), sb->short_desc != NULL ? sb->short_desc : "");
printf (gettext ("SlackBuild Files:\n"));
for (c = 0; c < sb->files->count; c++) {
printf (" %s\n", sb->files->items[c]);
}
if (sb->requires != NULL)
printf (gettext ("SlackBuild Requires: %s\n"), sb->requires);
if (i+1 != names->count)
printf ("\n");
/* slapt_src_slackbuild_free (sb); NO FREE */
}
slapt_free_list (parts);
}
}
break;
case CLEAN_OPT:
clean (config);
break;
}
if (names != NULL)
slapt_free_list (names);
if (sbs != NULL)
slapt_src_slackbuild_list_free (sbs);
if (remote_sbs != NULL)
slapt_src_slackbuild_list_free (remote_sbs);
if (installed != NULL)
slapt_free_pkg_list (installed);
if (config_file != NULL)
free (config_file);
slapt_src_config_free (config);
return rval;
}
slapt_source_t *slapt_init_source(const char *s)
{
slapt_source_t *src;
unsigned int source_len = 0;
unsigned int attribute_len = 0;
slapt_regex_t *attribute_regex = NULL;
char *source_string = NULL;
char *attribute_string = NULL;
if (s == NULL)
return NULL;
src = slapt_malloc(sizeof *src);
src->priority = SLAPT_PRIORITY_DEFAULT;
src->disabled = SLAPT_FALSE;
source_string = slapt_strip_whitespace (s);
source_len = strlen (source_string);
/* parse for :[attr] in the source url */
if ((attribute_regex = slapt_init_regex(SLAPT_SOURCE_ATTRIBUTE_REGEX)) == NULL) {
exit(EXIT_FAILURE);
}
slapt_execute_regex(attribute_regex,source_string);
if (attribute_regex->reg_return == 0) {
/* if we find an attribute string, extract it */
attribute_string = slapt_regex_extract_match(attribute_regex, source_string, 1);
attribute_len = strlen(attribute_string);
source_len -= attribute_len;
}
slapt_free_regex(attribute_regex);
/* now add a trailing / if not already there */
if ( source_string[source_len - 1] == '/' ) {
src->url = strndup(source_string, source_len);
} else {
src->url = slapt_malloc(sizeof *src->url * (source_len + 2));
src->url[0] = '\0';
src->url = strncat(
src->url,
source_string,
source_len
);
if (isblank(src->url[source_len - 1]) == 0) {
src->url = strncat(src->url, "/", 1);
} else {
if (src->url[source_len - 2] == '/') {
src->url[source_len - 2] = '/';
src->url[source_len - 1] = '\0';
} else {
src->url[source_len - 1] = '/';
}
}
src->url[source_len + 1] = '\0';
}
free(source_string);
/* now parse the attribute string */
if (attribute_string != NULL) {
slapt_source_parse_attributes(src, attribute_string + 1);
free(attribute_string);
}
return src;
}
slapt_transaction_t *slapt_remove_from_transaction(slapt_transaction_t *tran,
slapt_pkg_info_t *pkg)
{
unsigned int i;
slapt_transaction_t *new_tran = NULL;
if (slapt_search_transaction_by_pkg(tran,pkg) == 0)
return tran;
/* since this is a pointer, slapt_malloc before calling init */
new_tran = slapt_malloc(sizeof *new_tran);
new_tran->install_pkgs = slapt_malloc(sizeof *new_tran->install_pkgs);
new_tran->remove_pkgs = slapt_malloc(sizeof *new_tran->remove_pkgs);
new_tran->upgrade_pkgs = slapt_malloc(sizeof *new_tran->upgrade_pkgs);
new_tran->exclude_pkgs = slapt_malloc(sizeof *new_tran->exclude_pkgs);
new_tran = slapt_init_transaction();
for (i = 0;i < tran->install_pkgs->pkg_count; ++i) {
slapt_pkg_info_t *p = tran->install_pkgs->pkgs[i];
if (
strcmp(pkg->name,p->name) == 0 &&
strcmp(pkg->version,p->version) == 0 &&
strcmp(pkg->location,p->location) == 0
) {
continue;
}
slapt_add_install_to_transaction(new_tran,p);
}
for (i = 0;i < tran->remove_pkgs->pkg_count; ++i) {
slapt_pkg_info_t *p = tran->remove_pkgs->pkgs[i];
if (
strcmp(pkg->name,p->name) == 0 &&
strcmp(pkg->version,p->version) == 0 &&
strcmp(pkg->location,p->location) == 0
) {
continue;
}
slapt_add_remove_to_transaction(new_tran,tran->remove_pkgs->pkgs[i]);
}
for (i = 0;i < tran->upgrade_pkgs->pkg_count; ++i) {
slapt_pkg_info_t *u = tran->upgrade_pkgs->pkgs[i]->upgrade;
slapt_pkg_info_t *p = tran->upgrade_pkgs->pkgs[i]->installed;
if (
strcmp(pkg->name,u->name) == 0 &&
strcmp(pkg->version,u->version) == 0 &&
strcmp(pkg->location,u->location) == 0
) {
continue;
}
slapt_add_upgrade_to_transaction(new_tran, p, u);
}
for (i = 0; i < tran->exclude_pkgs->pkg_count; ++i) {
slapt_pkg_info_t *p = tran->exclude_pkgs->pkgs[i];
if (
strcmp(pkg->name,p->name) == 0 &&
strcmp(pkg->version,p->version) == 0 &&
strcmp(pkg->location,p->location) == 0
) {
continue;
}
slapt_add_exclude_to_transaction(new_tran,p);
}
return new_tran;
}
