langupdate.cc File Reference

---

Detailed Description

Parse the cache output.

Author:

Neil Williams <codehelp@debian.org>

Definition in file langupdate.cc.

#include "config.h"
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <locale.h>
#include <glib.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#include <apt-pkg/configuration.h>
#include "langupdate.h"
#include "aptcache.h"

Go to the source code of this file.

#define	GNU_WARRANTY
#define	DPKG_II   "^Package: (.*)$"
#define	GREX_EMPTY   GRegexMatchFlags(0)
#define	LOCALEGEN   "/etc/locale.gen"
#define	STATUS_CHK   "Status"
#define	APTARCHSTR   " -o APT::Architecture="
	debug handling
#define	APTCONFIGSTR
	Configuration string for apt.
static guint	c = 0
static const gchar *	sourceslist = "/var/lib/"PACKAGE"/sources.list"
static GList *	installed = NULL
static GList *	targets = NULL
static GHashTable *	choices = NULL
static GList *	not_ours = NULL
	List of packages that are not from Emdebian.
static GHashTable *	orphans = NULL
static gchar *	suite_codename = NULL
static gchar *	user_suite = NULL
static gchar *	mirror = NULL
static gint	verbose = 0
static gboolean	dry_run = false
static gboolean	show_version = false
static gboolean	purge_mode = false
static gchar *	purge_names = NULL
static GOptionEntry	entries []
gchar *	lu_get_aptstring (void)
	Collate the various apt options into a string.
static void	output (gpointer key, gpointer data)
static gchar *	parse_installed (const gchar *pkg, const gchar *locale)
	Parses list of all installed packages.
static gboolean	append_sourceslist (const gchar *lang)
	write the sources list
static void	lu_check_supported_suites (gchar *user_suite)
	checks the user specified suite against the supported list
static void	remove_cache (const gchar *file, const gchar *user_suite)
static void	run_apt_clean (const gchar *user_suite)
static void	remove_lists (gchar *suite)
static gboolean	lu_strip_components (gchar *line, gchar **code, gchar **root)
	strip extra components from a language variable
static void	lu_purge_orphans (gpointer key, gpointer value, gpointer data)
static gboolean	lu_skip_not_ours (gpointer key, gpointer value, gpointer data)
gint	main (gint argc, gchar *argv[])
	Read the apt-cache to know what is available. then compare dpkg_list with apt_list.

---

Define Documentation

#define APTARCHSTR   " -o APT::Architecture="

debug handling

Bug:

TDebs are not architecture-independent anymore.

In theory, apt should not care about the architecture because the translations are Architecture: all. In practice, it appears that apt is not expecting an entire repository of architecture-independent packages. The langupdate cache needs to force apt to look for architecture-dependent packages or the langupdate cache is likely to be empty.

Definition at line 113 of file langupdate.cc.

#define APTCONFIGSTR

Value:

"-o APT::Get::List-Cleanup=off " \
 "-o Apt::Install-Recommends=false " \
 "-o Dir=/var/lib/"PACKAGE" " \
 "-o Dir::Etc=/var/lib/"PACKAGE" " \
 "-o Dir::Etc::SourceList=sources.list " \
 "-o Dir::State::Status=/var/lib/"PACKAGE"/status "

Configuration string for apt.

Provides the main mechanism to separate the tdeb cache from the apt cache.

Note:

options that specify the suite are deliberately omitted.

Definition at line 122 of file langupdate.cc.

#define GNU_WARRANTY

Value:

"Copyright (C) 2006-2009 Neil Williams <codehelp@debian.org>\n" \
"This is free software; see the source for copying conditions.  There is NO\n" \
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"

Definition at line 40 of file langupdate.cc.

---

Function Documentation

static void lu_check_supported_suites

(

gchar *

user_suite

)

[static]

checks the user specified suite against the supported list

Sets the user specified suite if supported, otherwise sets the Emdebian default (unstable). If the user also specifies a particular mirror, allow whatever value the user specifies for the suite.

Definition at line 320 of file langupdate.cc.

{
    gchar * allowed, * match;

    /* if user specifies a mirror, all bets are off. */
    if (mirror)
        return;
    match = NULL;
    /* Translators: used with the --suite option to confirm
    the suite codename entered by the user. */
    g_print ("%s: %s %s\n", PACKAGE, _("checking Emdebian support for: "), user_suite);
    allowed = g_strdup("unstable sid testing lenny stable squeeze experimental");
    match = g_strrstr_len (allowed, strlen(allowed), user_suite);
    if (match)
        suite_codename = g_strdup(user_suite);
    else
    {
        /* Translators - the %s strings are the same value. */
        g_warning (_("Suite '%s' is not supported by Emdebian.\n"
            "Use the mirror option to specify a repository that can\n"
            "provide the '%s', suite"), user_suite, user_suite);
        g_print ("\n%s: %s", PACKAGE, _("Using the default Emdebian suite: unstable.\n"));
        suite_codename = g_strdup("unstable");
    }
    g_free (user_suite);
    g_free (allowed);
}

gchar* lu_get_aptstring

(

void

)

Collate the various apt options into a string.

Depending on various settings, the apt configuration list needs to be adjusted so it cannot be completely defined as a macro. This function adds the customisations, creates a newly allocated string and returns it. The caller is responsible for freeing the string.

Also sets the langupdate cache data to the same configuration if this has not been done already.

Returns:

newly allocated string of apt options or NULL on error.

Definition at line 130 of file langupdate.cc.

{
    return g_strconcat (APTARCHSTR, HOST_CPU, " ", APTCONFIGSTR, "-o Dir::State=",
        suite_codename, " -o Dir::Cache=", suite_codename, NULL);
}

gint main	(	gint	argc,
		gchar *	argv[]
	)

Read the apt-cache to know what is available. then compare dpkg_list with apt_list.

Todo:

put the variables into a context struct for easier initialisation.

Definition at line 494 of file langupdate.cc.

{
    GError * em_gerr;
    gchar * dpkg, *code, *lgen, * log, * root, * name, *src;
    const gchar * const * locale_v;
    GList * dpkg_list, * p, *locales;
    GHashTable * tbl;
    gchar ** status_list, ** gen_list;
    guint mcount, c, l;
    gboolean pkg_changed;
    GOptionContext *context;

    code = root = NULL;
    em_gerr = NULL;
    locales = dpkg_list = NULL;
    orphans = g_hash_table_new (g_str_hash, g_str_equal);
    tbl = g_hash_table_new (g_str_hash, g_str_equal);
    choices = g_hash_table_new (g_str_hash, g_str_equal);
    l = mcount = 0;
#ifdef ENABLE_NLS
    setlocale (LC_ALL, "");
    bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR);
    bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
    textdomain (GETTEXT_PACKAGE);
#endif
    context = g_option_context_new (_("- updates language support for emdebian"));
    g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
    g_option_context_set_summary (context,
        _("Apt frontend to match the Emdebian TDeb support with the installed\n"
        "packages and supported locales."));
    g_option_context_set_description (context, 
        /* Translators: the line endings need to be in roughly the same place in
        your own language, counting by characters and allowing for all breaks to
        be between words. */
        _("Emdebian TDebs provide a method for splitting all translation files out of\n"
        "packages and into separate TDeb packages, organised by the locale root and\n"
        "source package. This allows individual users to only install translations\n"
        "files for the locales supported on their own machine and only for the\n"
        "packages installed at the time.\n\n"
        "Note that this functionality is not available for Debian TDebs.\n"));
    g_option_context_parse (context, &argc, &argv, &em_gerr);
    if (show_version)
    {
        g_print ("%s (%s)\n", PACKAGE, VERSION);
        g_print ("%s", GNU_WARRANTY);
        return (0);
    }
    if (!user_suite)
        suite_codename = g_strdup("unstable");
    else
        lu_check_supported_suites(user_suite);
    if (dry_run && !purge_mode)
        g_print ("%s: %s\n", PACKAGE,
            _("Dry run, just showing cache data for installable packages."));
    locale_v = g_get_language_names ();
    if (0 == strcmp (locale_v[l], "C"))
        return 0;
    while (strcmp (locale_v[l], "C") != 0)
    {
        gchar * line;

        line = g_strdup (locale_v[l]);
        if (!lu_strip_components (line, &code, &root))
            continue;
        if (!code || !root)
            continue;
        g_free (line);
        locales = g_list_append (locales, code);
        if (!g_hash_table_lookup(tbl, root))
        {
            if (verbose >= 1)
                g_print ("%s: %s %s\n", PACKAGE, 
                    _("Environment needs support for:"), code);
            if (!append_sourceslist (root)) 
                return -1;
            if (verbose >= 1)
                g_print ("%s: %s %s\n", PACKAGE, 
                    _("Adding support for:"), root);
            g_hash_table_insert (tbl, root, code);
        }
        else
        {
            g_free (code);
            g_free (root);
            code = NULL;
            root = NULL;
        }
        l++;
    }
    // parse /etc/locale.gen here
    if (!g_file_get_contents (LOCALEGEN, &lgen, NULL, &em_gerr))
    {
        g_critical (em_gerr->message);
        g_message (_("Unable to open the locale.gen configuration file."));
        g_clear_error (&em_gerr);
        return -1;
    }
    gen_list = g_strsplit (lgen, "\n", -1);
    for (mcount = 0; mcount <= g_strv_length(gen_list); mcount++)
    {
        gchar * line;

        if (!gen_list[mcount])
            continue;
        if (g_str_has_prefix (gen_list[mcount], "#"))
            continue;
        if (!g_strcmp0 ("", gen_list[mcount]))
            continue;
        line = g_strdup (gen_list[mcount]);
        if (!lu_strip_components (line, &code, &root))
            continue;
        if (!code || !root)
            continue;
        g_free (line);
        if (!g_hash_table_lookup(tbl, root))
        {
            locales = g_list_append (locales, root);
            if (verbose >= 1)
                g_print ("%s: %s %s\n", PACKAGE, 
                    _("/etc/locale.gen requires adding support for:"), code);
            if (!append_sourceslist (root)) 
                return -1;
            g_hash_table_insert (tbl, root, code);
            if (verbose >= 1)
                g_print ("%s: %s %s\n", PACKAGE, 
                    _("Adding support for:"), root);
        }
        g_free (code);
    }
    g_strfreev (gen_list);
    
    g_return_val_if_fail (apt_init (sourceslist, suite_codename, verbose), -1);
    if (!g_file_get_contents (DPKG_FILE, &dpkg, NULL, &em_gerr))
    {
        g_critical (em_gerr->message);
        g_message (_("Unable to open the dpkg status file."));
        g_clear_error (&em_gerr);
        return -1;
    }
    status_list = g_strsplit (dpkg, "\n", -1);
    name = NULL;
    for (mcount = 0; mcount <= g_strv_length(status_list); mcount++)
    {
        gchar * pkg;

        if (!status_list[mcount])
            continue;
        if (!g_strcmp0 (status_list[mcount], ""))
        {
            pkg_changed = TRUE;
            if (name)
            {
                g_free (name);
                name = NULL;
            }
        }
        else
            pkg_changed = FALSE;
        if (status_list[mcount+1] && g_str_has_prefix (status_list[mcount+1], STATUS_CHK))
        {
            gchar ** pos;

            pos = g_strsplit (status_list[mcount], ": ", -1);
            if (g_str_has_suffix (status_list[mcount+1], "not-installed"))
            {
                g_strfreev (pos);
                continue;
            }
            g_strfreev (pos);
        }
        if ((!pkg_changed) && (g_str_has_prefix (status_list[mcount], "Version: ")))
        {
            gchar * em_chunk;

            /* -1 to allow for em1, em2, em3 etc. */
            em_chunk = g_strndup (status_list[mcount], strlen (status_list[mcount]) -1);
            if (!g_str_has_suffix (em_chunk, "em"))
            {
                gchar ** pkg_name;

                // need to add to a list that can be subtracted later.
                // but existing TDebs also show up here due to problems in
                // the repository.
                pkg_name = g_strsplit (name, ":", -1);
                if (g_strv_length(pkg_name) == 2)
                {
                    gchar * chunk;

                    chunk = g_strdup (pkg_name[1]);
                    chunk = g_strstrip (chunk);
                    if (verbose >= 2)
                    {
                        g_print ("%s: %s: %s (%s)\n", PACKAGE,
                        _("Not an Emdebian package"), chunk, status_list[mcount]);
                    }
                    /* swap the binary package name for the source */
                    {
                        src = lu_get_sourcepkg(chunk);
                        if (src)
                            not_ours = g_list_prepend (not_ours, g_strdup(src));
                    }
                    not_ours = g_list_prepend (not_ours, g_strdup(chunk));
                    g_free (chunk);
                }
                g_strfreev (pkg_name);
                g_free (em_chunk);
                continue;
            }
        }
        if (g_str_has_prefix (status_list[mcount], PACKAGE_CHK))
        {
            if (!name)
                name = g_strdup (status_list[mcount]);
            name = g_strstrip (name);
            for (p = locales; p != NULL; p = p->next)
            {
                gchar * chunk;

                chunk = g_strdup ((gchar*)p->data);
                chunk = g_strstrip (chunk);
                /* pkg is the binary package name */
                src = lu_get_sourcepkg (chunk);
                if (src)
                    pkg = parse_installed (status_list[mcount], src);
                else
                    pkg = parse_installed (status_list[mcount], chunk);
                if (pkg)
                {
                    dpkg_list = g_list_prepend (dpkg_list, pkg);
                }
                g_free (src);
                src = NULL;
            }
        }
    }
    g_strfreev (status_list);
    for (p = dpkg_list; p != NULL; p = p->next)
    {
        gboolean exists;
        gchar * pkg = g_strdup((gchar*)p->data);
        pkg = g_strstrip (pkg);
        src = lu_get_sourcepkg (pkg);
        if (src)
            exists= aptcache_lookup (src);
        else
            exists = aptcache_lookup (pkg);
        if (exists)
        {
            GList  * done = NULL;
            done = g_list_find_custom (installed, pkg, check_pkg_name);
            if (done)
            {
                if ((verbose >= 1) && (!purge_mode))
                    g_print ("%s: %s - %s\n", PACKAGE, pkg, 
                        _("TDeb is already installed."));
                continue;
            }
            /* this looks strange - adding and then removing
             but removing is done by prefix so all possible matches
             need to exist first. */
            g_printerr ("DEBUG: adding %s\n", pkg);
            if (src)
                g_printerr ("DEBUG: from %s\n", src);
            g_hash_table_insert (choices, pkg, pkg);
        }
    }
    for (p = not_ours; p != NULL; p = p->next)
    {
        g_hash_table_foreach_remove (choices, lu_skip_not_ours, p->data);
    }
    c = g_hash_table_size (choices);
    if (!purge_mode)
    {
        GList * sorted = NULL;

        if (c == 0)
            g_print ("%s: %s\n", PACKAGE, _("Nothing to do."));
        else
        {
            g_print ("%s: ", PACKAGE);
            g_print (ngettext("%d package to be installed\n",
                "%d packages to be installed\n", c), c);
            sorted = g_list_sort (g_hash_table_get_keys (choices), check_pkg_name);
            g_list_foreach (sorted, output, NULL);
        }
    }
    g_hash_table_destroy (tbl);
    g_hash_table_destroy (choices);
    run_apt_clean (suite_codename);
    remove_cache ("lists/lock", suite_codename);
    remove_cache ("lock", suite_codename);
    remove_cache ("srcpkgcache.bin", suite_codename);
    remove_cache ("pkgcache.bin", suite_codename);
    remove_lists (suite_codename);
    log = g_strconcat ("/var/lib/"PACKAGE"/var/log/apt/term.log", NULL);
    g_unlink (log);
    g_free (log);
    g_list_free (locales);
    g_unlink (sourceslist);
    if (purge_mode)
    {
        gchar * command;

        /* to convert to a "remove all TDebs" option, whether the
         package is installed or not, switch these
         from g_hash_table_remove to g_hash_table_insert */
        for (p = targets; p != NULL; p = p->next)
        {
            g_hash_table_remove (orphans, (gchar*)p->data);
        }
        for (p = installed; p != NULL; p = p->next)
        {
            g_hash_table_remove (orphans, (gchar*)p->data);
        }
        purge_names = g_strdup("");
        g_hash_table_foreach (orphans, lu_purge_orphans, NULL);
        if (g_strcmp0(purge_names, ""))
        {
            command = g_strconcat ("apt-get -y --purge remove ", purge_names, NULL);
            if (dry_run)
                g_print ("%s: %s '%s'\n", PACKAGE, _("Dry-run only."), command);
            else
                g_spawn_command_line_sync (command, NULL, NULL, NULL, &em_gerr);
            if (em_gerr)
            {
                g_critical (em_gerr->message);
                g_message (_("Unable to execute command: %s."), command);
                g_clear_error (&em_gerr);
            }
            g_free (command);
        }
        else
            g_print ("%s: %s\n", PACKAGE, _("No TDeb packages to remove."));
    }
    g_print ("\n");
    g_free (suite_codename);
    lu_clear_caches ();
    return 0;
}

static void output	(	gpointer	key,
		gpointer	data
	)			[static]

install each available package name

Todo:

run all install operations in one call.

Todo:

rationalise error output.

Definition at line 141 of file langupdate.cc.

{
    gchar * name, * hdl, * hdl_err, * config_str, * cmd, * func;
    gint err_status = 0;
    GError * gerr = NULL;

    c++;
    g_print ("%s: %s %s\n", PACKAGE, _("installing:"), (gchar*)key);
    name = NULL;
    config_str = lu_get_aptstring();
    if (dry_run)
    {
        cmd = g_strdup("apt-cache");
        func = g_strdup("show");
    }
    else
    {
        cmd = g_strdup ("apt-get");
        func = g_strdup("install -y");
    }
    if ((key) && (strcmp ((gchar*)key, "")))
        name = g_strdup_printf ( "%s %s %s %s", cmd, config_str, func, (gchar*)key);
    g_free (config_str);
    if (verbose >= 4)
        g_print ("%s: %s %s\n", PACKAGE, _("running apt command: "), name);
    g_spawn_command_line_sync (name, &hdl, &hdl_err, &err_status, &gerr);
    g_free (name);
    g_free (cmd);
    g_free (func);
    if (gerr) 
    {
        fprintf (stdout, _("apt returned an error:%s\n"), hdl_err);
        fprintf (stdout, _("status code:%d\n"), err_status);
        fprintf (stdout, "%s\n", gerr->message);
        fprintf (stdout, "%s\n", hdl);
        g_clear_error (&gerr);
        g_free (hdl_err);
        return;
    }
    if (dry_run)
    {
        fprintf (stdout, "%s\n", hdl);
        g_free (hdl);
    }
}

static gchar* parse_installed	(	const gchar *	pkg,
		const gchar *	locale
	)			[static]

Parses list of all installed packages.

Store a list of existing target packages by skipping those already installed.

Bug:

called once per locale - needs to use a GHashTable instead of a GList to avoid repetition.

Definition at line 198 of file langupdate.cc.

{
    GList * match;
    gchar ** pos;
    gchar * r, *target, * lang, *src;

    pos = g_strsplit (pkg, ": ", -1);
    if (!pos[0])
        return NULL;
    r = NULL;
    match = NULL;
    lang = g_strconcat ("-", LOCALE_SUFFIX, "-", locale, NULL);
    if (g_str_has_prefix(PACKAGE_CHK, pos[0]))
    {
        if (verbose >= 4)
            g_print ("Parsing %s\n", pos[1]);
        r = g_strdup (pos[1]);
        if (g_str_has_suffix (r, lang))
        {
            if (verbose >= 2)
                g_print ("Skipping %s\n", r);
            installed = g_list_prepend (installed, r);
            /* in case the target occurs later in the list */
            targets = g_list_remove (targets, r);
            return NULL;
        }
        else
        {
            gchar * orphaned, * l;

            orphaned = l = NULL;
            l = g_strconcat ("-", LOCALE_SUFFIX, "-", NULL);
            orphaned = g_strrstr_len (r, strlen(r), l);
            if (orphaned)
                g_hash_table_insert (orphans, g_strdup(r), g_strdup(""));
            orphaned = NULL;
            g_free (l);
        }
        /* generate a target name. */
        src = lu_get_sourcepkg (r);
        if (src)
            target = g_strconcat (src, lang, NULL);
        else
            target = g_strconcat (r, lang, NULL);
        match = g_list_find_custom (installed, target, check_pkg_name);
        if (g_list_length (match) != 0)
            targets = g_list_prepend (targets, target);
        g_strfreev (pos);
        g_free (r);
        return target;
    }
    g_free (lang);
    g_strfreev (pos);
    return NULL;
}

static void run_apt_clean

(

const gchar *

user_suite

)

[static]

Todo:

rationalise error output.

Definition at line 361 of file langupdate.cc.

{
    gchar * config_str, * hdl, * hdl_err, * name;
    GError * gerr = NULL;
    gint err_status = 0;

    g_return_if_fail (user_suite);
    config_str = lu_get_aptstring();
    name = g_strdup_printf ( "%s %s %s", "apt-get", config_str, "clean");
    g_spawn_command_line_sync (name, &hdl, &hdl_err, &err_status, &gerr);
    if (gerr) 
    {
        g_printerr (_("apt returned an error:%s\n"), hdl_err);
        g_printerr (_("status code:%d\n"), err_status);
        g_printerr ("%s\n", gerr->message);
        g_clear_error (&gerr);
        g_free (hdl_err);
        return;
    }
}

---

Variable Documentation

guint c = 0 [static]

Todo:

put the static variables into a context struct?

Definition at line 49 of file langupdate.cc.

GOptionEntry entries[] [static]

Initial value:

 
{
    { "dry-run", 'n', 0, G_OPTION_ARG_NONE, &dry_run, 
        _("Only show the cache data, do not install"), 0 },
    { "mirror", 'm', 0, G_OPTION_ARG_STRING, &mirror,
        _("Use the specified TDeb mirror instead of the Emdebian default."), 
        _("mirror_name")},
    { "autoremove", 'r', 0, G_OPTION_ARG_NONE, &purge_mode,
        _("Remove TDebs for unsupported locales."), 0},
    { "verbose", 'v', 0, G_OPTION_ARG_INT, &verbose, _("Specify verbose level [0-4]"),
        _("integer") },
    { "suite", 0, 0, G_OPTION_ARG_STRING, &user_suite, 
        _("Specify the apt suite name [default unstable]"), _("codename") },
    { "version", 0, 0, G_OPTION_ARG_NONE, &show_version, _("Show version information "
        "and exit."), 0},
    { NULL }
}

Definition at line 83 of file langupdate.cc.

GList* not_ours = NULL [static]

List of packages that are not from Emdebian.

In order for langupdate to be safe in use in Debian, langupdate must not attempt to install an Emdebian TDeb when the package installed is from Debian as a file conflict will occur. (Emdebian TDebs do not have "Replaces:" for the corresponding binary packages.)

Even though the sysadmin can manually delete files from /usr/share/locale, it is not safe to assume that this has happened for the specific files in the TDeb. Calculating the conflict would require looking up the Source: package in the installed package check.

Currently, langupdate takes the safer option that if the relevant binary package is not from Emdebian (with an Emdebian version string), then the TDeb should not be considered.

The list of packages that fall into this category is held in not_ours.

Definition at line 73 of file langupdate.cc.