void slapt_free_transaction(slapt_transaction_t *tran)
{
unsigned int i;
if (tran->install_pkgs->free_pkgs == SLAPT_TRUE) {
for (i = 0;i < tran->install_pkgs->pkg_count; ++i) {
slapt_free_pkg(tran->install_pkgs->pkgs[i]);
}
}
free(tran->install_pkgs->pkgs);
free(tran->install_pkgs);
if (tran->remove_pkgs->free_pkgs == SLAPT_TRUE) {
for (i = 0;i < tran->remove_pkgs->pkg_count; ++i) {
slapt_free_pkg(tran->remove_pkgs->pkgs[i]);
}
}
free(tran->remove_pkgs->pkgs);
free(tran->remove_pkgs);
for (i = 0;i < tran->upgrade_pkgs->pkg_count; ++i) {
slapt_free_pkg(tran->upgrade_pkgs->pkgs[i]->upgrade);
slapt_free_pkg(tran->upgrade_pkgs->pkgs[i]->installed);
free(tran->upgrade_pkgs->pkgs[i]);
}
free(tran->upgrade_pkgs->pkgs);
free(tran->upgrade_pkgs);
if (tran->exclude_pkgs->free_pkgs == SLAPT_TRUE) {
for (i = 0; i < tran->exclude_pkgs->pkg_count; ++i) {
slapt_free_pkg(tran->exclude_pkgs->pkgs[i]);
}
}
free(tran->exclude_pkgs->pkgs);
free(tran->exclude_pkgs);
slapt_free_list(tran->suggests);
queue_free(tran->queue);
slapt_free_pkg_err_list(tran->conflict_err);
slapt_free_pkg_err_list(tran->missing_err);
free(tran);
}
static void add_suggestion(slapt_transaction_t *tran, slapt_pkg_info_t *pkg)
{
slapt_list_t *suggests = NULL;
unsigned int i = 0;
if (pkg->suggests == NULL || strlen(pkg->suggests) == 0) {
return;
}
suggests = slapt_parse_delimited_list(pkg->suggests, ',');
for (i = 0; i < suggests->count; i++) {
/* no need to add it if we already have it */
if (slapt_search_transaction(tran,suggests->items[i]) == 1)
continue;
slapt_add_list_item(tran->suggests, suggests->items[i]);
}
slapt_free_list(suggests);
}
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_rc_config *slapt_read_rc_config(const char *file_name)
{
FILE *rc = NULL;
char *getline_buffer = NULL;
size_t gb_length = 0;
ssize_t g_size;
slapt_rc_config *global_config = NULL;
rc = slapt_open_file(file_name,"r");
if ( rc == NULL )
return NULL;
global_config = slapt_init_config();
while ( (g_size = getline(&getline_buffer,&gb_length,rc) ) != EOF ) {
char *token_ptr = NULL;
getline_buffer[g_size - 1] = '\0';
/* check to see if it has our key and value separated by our token */
/* and extract them */
if ( (strchr(getline_buffer,'#') != NULL) && (strstr(getline_buffer, SLAPT_DISABLED_SOURCE_TOKEN) == NULL) )
continue;
if ( (token_ptr = strstr(getline_buffer,SLAPT_SOURCE_TOKEN)) != NULL ) {
/* SOURCE URL */
if ( strlen(token_ptr) > strlen(SLAPT_SOURCE_TOKEN) ) {
slapt_source_t *s = slapt_init_source(token_ptr + strlen(SLAPT_SOURCE_TOKEN));
if (s != NULL) {
slapt_add_source(global_config->sources,s);
if (s->priority != SLAPT_PRIORITY_DEFAULT) {
global_config->use_priority = SLAPT_TRUE;
}
}
}
} else if ( (token_ptr = strstr(getline_buffer,SLAPT_DISABLED_SOURCE_TOKEN)) != NULL ) {
/* DISABLED SOURCE */
if (strlen(token_ptr) > strlen(SLAPT_DISABLED_SOURCE_TOKEN) ) {
slapt_source_t *s = slapt_init_source(token_ptr + strlen(SLAPT_DISABLED_SOURCE_TOKEN));
if (s != NULL) {
s->disabled = SLAPT_TRUE;
slapt_add_source(global_config->sources,s);
}
}
} else if ( (token_ptr = strstr(getline_buffer,SLAPT_WORKINGDIR_TOKEN)) != NULL ) {
/* WORKING DIR */
if ( strlen(token_ptr) > strlen(SLAPT_WORKINGDIR_TOKEN) ) {
strncpy(
global_config->working_dir,
token_ptr + strlen(SLAPT_WORKINGDIR_TOKEN),
(strlen(token_ptr) - strlen(SLAPT_WORKINGDIR_TOKEN))
);
global_config->working_dir[
(strlen(token_ptr) - strlen(SLAPT_WORKINGDIR_TOKEN))
] = '\0';
}
} else if ( (token_ptr = strstr(getline_buffer,SLAPT_EXCLUDE_TOKEN)) != NULL ) {
/* exclude list */
slapt_free_list(global_config->exclude_list);
global_config->exclude_list = parse_exclude(token_ptr);
}
}
fclose(rc);
if ( getline_buffer )
free(getline_buffer);
if ( strcmp(global_config->working_dir,"") == 0 ) {
fprintf(stderr,gettext("WORKINGDIR directive not set within %s.\n"),
file_name);
return NULL;
}
if ( global_config->sources->count == 0 ) {
fprintf(stderr,gettext("SOURCE directive not set within %s.\n"),file_name);
return NULL;
}
return global_config;
}
void slapt_free_rc_config(slapt_rc_config *global_config)
{
slapt_free_list(global_config->exclude_list);
slapt_free_source_list(global_config->sources);
free(global_config);
}
