path: root/cups-genppdupdate.py.in

#!/usr/bin/python3
# $Id$
# Update CUPS PPDs for Gutenprint queues.
# Copyright (C) 2002-2003 Roger Leigh (rleigh@debian.org)
# Copyright (C) 2009, 2011, 2014 Red Hat, Inc.
#
# 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, 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
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

import getopt
import glob
import io
import os
import re
import stat
import subprocess
import sys
from functools import reduce

global optargs
global debug
global verbose
global interactive
global quiet
global no_action
global reset_defaults
global version
global micro_version
global use_static_ppd
global file_version

global ppd_dir
global ppd_root_dir
global ppd_base_dir
global ppd_out_dir
global gzext
global updated_ppd_count
global skipped_ppd_count
global failed_ppd_count
global exit_after_parse_args
global languages

global serverdir
global driver_bin
global driver_version
global server_multicat
global server_multicat_initialized

global ppd_files
global languagemappings

def help():
    print ("""
Usage: %s [OPTION]... [PPD_FILE]...
Update CUPS+Gutenprint PPD files.

  -d flags    Enable debugging
  -h          Display this help text
  -n          No-action.  Don't overwrite any PPD files.
  -q          Quiet mode.  No messages except errors.
  -s ppd_dir  Use ppd_dir as the source PPD directory.
  -p ppd_dir  Update PPD files in ppd_dir.
  -P driver   Use the specified driver binary to generate PPD files.
  -v          Verbose messages.
  -N          Reset options to defaults.
  -o out_dir  Output PPD files to out_dir.
  -r version  Use PPD files for Gutenprint major.minor version.
  -f          Ignore new PPD file safety checks.
  -i          Prompt (interactively) for each PPD file.
  -l language Language choice (Gutenprint 5.1 or below).
              Choices: %s
              Or -loriginal to preserve original language
                 with Gutenprint 5.2 or above
""" % (sys.argv[0],
       reduce (lambda x,y: "%s %s" % (x,y), languages)))
    sys.exit (0)

def die_if_not_directory (dir):
    try:
        st = os.stat (dir)
        if not stat.S_ISDIR (st.st_mode):
            os.chdir (dir)
    except OSError as err:
        (e, s) = err.args
        print ("%s: invalid directory: %s" % (dir, s))
        sys.exit (1)

def get_driver_version():
    global server_multicat
    global driver_version

    def run_with_arg (arg):
        try:
            p = subprocess.Popen ([driver_bin, arg],
                                  stdin=subprocess.DEVNULL,
                                  stdout=subprocess.PIPE,
                                  stderr=subprocess.DEVNULL,
                                  shell=False)
            (stdout, stderr) = p.communicate ()
        except OSError:
            return None

        if stdout != None:
            stdout = stdout.decode ()

        return stdout

    stdout = run_with_arg ("org.gutenprint.extensions")
    if stdout == None:
        return
    for line in stdout.split ("\n"):
        if line == "org.gutenprint.multicat":
            server_multicat = 1
            break

    stdout = run_with_arg ("VERSION")
    if stdout == None:
        return

    driver_version = stdout.strip ()

def parse_options():
    try:
        opts, args = getopt.getopt (sys.argv[1:], "d:hnqs:vNo:p:P:r:ifl:")
    except getopt.GetoptError:
        help ()

    global optargs
    global debug
    global verbose
    global interactive
    global quiet
    global no_action
    global reset_defaults
    global version
    global micro_version
    global use_static_ppd
    global file_version
    global ppd_dir
    global ppd_out_dir
    global ppd_base_dir
    global ppd_root_dir
    global serverdir
    global driver_bin
    global driver_version
    global server_multicat
    global languages
    optargs = dict()
    for opt, optarg in opts:
        optargs[opt[1]] = optarg

    if 'n' in optargs:
        no_action = 1

    if 'd' in optargs:
        try:
            debug = int (optargs['d'])
        except ValueError:
            d = 0

    if 'v' in optargs:
        verbose = 1
        quiet = 0

    if 'q' in optargs:
        verbose = 0
        quiet = 1

    if 'N' in optargs:
        reset_defaults = 1

    if 'o' in optargs:
        opt_o = optargs['o']
        die_if_not_directory (opt_o)
        ppd_out_dir = opt_o

    if 'r' in optargs:
        opt_r = optargs['r']
        if version != opt_r:
            version = opt_r
            if 's' in optargs:
                opt_s = optargs['s']
                die_if_not_directory (opt_s)
                ppd_base_dir = opt_s
                driver_bin = ""
                server_multicat = 0
                use_static_ppd = "yes"
            else:
                ppd_base_dir = ppd_root_dir + "/gutenprint/" + version
                driver_bin = serverdir + "/driver/gutenprint." + version

            driver_version = ""
            # If user specifies version, we're not going to be able to check
            # for an exact match.
            file_version = '"' + version
            if os.access (driver_bin, os.X_OK):
                get_driver_version ()
                use_static_ppd = "no"
                file_version = "\"%s\"$" % driver_version
            else:
                print ("Gutenprint %s does not appear to be installed!" %
                       version)
                sys.exit (1)

    if 's' in optargs:
        opt_s = optargs['s']
        die_if_not_directory (opt_s)
        ppd_base_dir = opt_s
        driver_bin = ""
        server_multicat = 0
        driver_version = ""
        use_static_ppd = "yes"

    if 'p' in optargs:
        opt_p = optargs['p']
        die_if_not_directory (opt_p)
        ppd_dir = opt_p

    if 'P' in optargs:
        opt_P = optargs['P']
        if os.access (opt_P, os.X_OK):
            driver_bin = opt_P
            get_driver_version ()
            use_static_ppd = "no"
        else:
            print ("%s: invalid executable" % opt_P)

    if 'h' in optargs:
        help ()

    if ('l' in optargs and
        optargs['l'].lower () != "original" and
        optargs['l'].lower () not in languages):
        print ("Unknown language '%s'" % optargs['l'], file=sys.stderr)

    if 'i' in optargs:
        interactive = 1

    if exit_after_parse_args:
        sys.exit (0)

    if verbose and driver_version != "":
        print ("Updating PPD files from Gutenprint %s" % driver_version)

    return args

def check_encoding(filename):
    import charset_normalizer

    with open(filename, 'rb') as f:
         charenc = charset_normalizer.detect(f.read())['encoding']

    if debug & 1:
        print("File encoding: {}".format(charenc))

    if charenc in ['ascii', 'utf-8']:
        return 'utf-8'
    else:
        if debug & 1:
            print("Trying to use latin1 for decoding {}".format(charenc))

        return 'latin1'

def update_ppd (ppd_source_filename):
    global ppd_dest_filename
    global ppd_out_dir
    global optargs
    global languagemappings
    global interactive
    global server_multicat
    global no_action
    global quiet, verbose
    global reset_defaults

    ppd_dest_filename = ppd_source_filename
    if ppd_out_dir:
        ppd_dest_filename = "%s/%s" % (ppd_out_dir,
                                       os.path.basename (ppd_dest_filename))

    fenc = check_encoding(ppd_source_filename)
    orig = open(ppd_source_filename, encoding=fenc)
    orig_metadata = os.fstat (orig.fileno ())
    if debug & 1:
        print ("Source Filename: %s" % ppd_source_filename)

    filename = ""
    driver = ""
    gutenprintdriver = ""
    locale = ""
    lingo = ""
    region = ""
    valid = 0
    orig_locale = ""

    try:
        orig_lines = orig.readlines()
    except UnicodeDecodeError:
        if debug & 1:
            print('PPD {} has an unexpected enconding, '
                  'skipping.'.format(ppd_source_filename))

        return -1

    for line in orig_lines:
        line.rstrip ()
        if line.find ("*StpLocale:") != -1:
            match = re.search (r'\*StpLocale:\s*"(.*)"$', line)
            if match:
                groups = match.groups ()
                if len (groups) >= 1:
                    locale = groups[0]
                    orig_locale = locale
                    valid = 1
        elif line.startswith ("*LanguageVersion"):
            match = re.search (r'^\*LanguageVersion:\s*(.*)$', line)
            if match:
                groups = match.groups ()
                if len (groups) >= 1:
                    lingo = groups[0]
        elif line.startswith ("*StpDriverName:"):
            match = re.search (r'^\*StpDriverName:\s*"(.*)"$', line)
            if match:
                groups = match.groups ()
                if len (groups) >= 1:
                    driver = groups[0]
                    valid = 1
        elif line.find ("*%End of ") != -1 and driver == "":
            match = re.search (r'^\*%End of\s*(.*).ppd$', line)
            if match:
                groups = match.groups ()
                if len (groups) >= 1:
                    driver = groups[0]
        elif line.startswith ("*StpPPDLocation:"):
            match = re.search (r'^\*StpPPDLocation:\s*"(.*)"$', line)
            if match:
                groups = match.groups ()
                if len (groups) >= 1:
                    filename = groups[0]
                    valid = 1
        elif line.startswith ("*%Gutenprint Filename:"):
            valid = 1

        if filename and driver and lingo and locale:
            break

        if not valid and line.startswith ("*OpenUI"):
            break

    if not valid:
        #print (("Skipping %s: not a Gutenprint PPD file" %
        #        ppd_source_filename), file=sys.stderr)
        return -1

    if ('l' in optargs and
        optargs['l'] != "" and
        optargs['l'].lower () != "original"):
        locale = optargs['l']
        orig_locale = locale

    if debug & 2:
        print ("Gutenprint Filename: %s" % filename)
        if 'l' in optargs:
            print ("Locale: %s (from -l)" % locale)
        else:
            print ("Locale: %s" % locale)

        print ("Language: %s" % lingo)
        print ("Driver: %s" % driver)

    if locale:
        # Split into the language and territory.
        s = locale.split ("_", 1)
        locale = s[0]
        try:
            region = s[1]
        except IndexError:
            region = ""
    else:
        # Split into the language and territory.
        s = lingo.split ("_", 1)
        locale = s[0]
        try:
            region = s[1]
        except IndexError:
            region = ""

        # Convert language into language code.
        locale = languagemappings.get (lingo.lower (), "C")

    if debug & 2:
        print ("Base Locale: %s" % locale)
        print ("Region: %s" % region)

    # Read in the new PPD, decompressing it if needed...
    (new_ppd_filename, source_fd) = get_ppd_fh (ppd_source_filename,
                                                filename,
                                                driver,
                                                locale,
                                                region)
    if source_fd == None:
        print ("Unable to retrieve PPD file!")
        return 0

    if interactive:
        inp = input ("Update PPD %s from %s [nyq]? " % ppd_source_filename)
        inp = inp.lower ()
        if inp.startswith ("q"):
            if server_multicat:
                source_fd.detach ()
            else:
                source_fd.close ()

            print ("Skipping all...")
            return -2
        elif not inp.startswith ("y"):
            if server_multicat:
                source_fd.detach ()
            else:
                source_fd.close ()

            print ("Skipping...")
            return -1

    # Extract the default values from the original PPD...

    orig.seek (0)
    (odt, oopt, ores, odef, unused) = get_ppd_data (orig, 1, 0, 1, 1, 0)
    (ndt, nopt, nres, ndef, source_data) = get_ppd_data (source_fd,
                                                         1, 1, 1, 1, 1)
    
    # Close original and temporary files...

    orig.close ()
    if server_multicat:
        source_fd.detach ()
    else:
        source_fd.close ()

    orig_default_types = odt
    new_default_types = ndt
    defaults = odef
    new_defaults = ndef
    options = nopt
    resolution_map = nres
    old_resolution_map = dict()
    for key, value in resolution_map.items ():
        old_resolution_map[value] = key

    # Store previous language in the PPD file so that -l original works
    # correctly.

    if orig_locale != "":
        lines = source_data.rstrip ().split ("\n")
        source_data = ""
        for line in lines:
            m = re.search (r'(\*StpLocale:\s*")(.*)(")', line)
            if m:
                groups = m.groups ()
                line = groups[0] + orig_locale + groups[2]

            source_data += line + "\n"

    if debug & 4:
        print ("Options (Old->New Default Type):")
        keys = list(options.keys ())
        keys.sort ()
        for t in keys:
            old_type = orig_default_types.get (t, "(New)")
            new_type = new_default_types.get (t)
            if old_type != new_type:
                out = "  %s (%s -> %s) :  " % (t, old_type, new_type)
            else:
                out = "  %s (%s) :  " % (t, new_type)

            dft = defaults.get ("Default%s" % t)
            for opt in options.get (t, []):
                if dft != None and dft == opt:
                    out += "*"

                out += "%s " % opt

            print (out)

        if len (list(resolution_map.keys ())) > 0:
            print ("Resolution Map:")
            keys = list(resolution_map.keys ())
            keys.sort ()
            for key in keys:
                print ("   %s: %s" % (key, resolution_map[key]))

        if len (list(old_resolution_map.keys ())) > 0:
            print ("Old Resolution Map:")
            keys = list(old_resolution_map.keys ())
            keys.sort ()
            for key in keys:
                print ("   %s: %s" % (key, old_resolution_map[key]))

        print ("Non-UI Defaults:")
        keys = list(defaults.keys ())
        keys.sort ()
        for key in keys:
            xkey = key
            if xkey.startswith ("Default"):
                xkey = xkey[7:]
            if xkey not in options:
                print ("  %s: %s" % (key, defaults[key]))

        print ("Default Types of dropped options:")
        keys = list(orig_default_types.keys ())
        keys.sort ()
        for t in keys:
            if t not in options:
                print ("  %s: %s" % (t, orig_default_types[t]))

    if no_action:
        if not quiet or verbose:
            if ppd_dest_filename == ppd_source_filename:
                print ("Would update %s using %s" % (ppd_source_filename,
                                                     new_ppd_filename))
            else:
                print ("Would update %s to %s using %s" % (ppd_source_filename,
                                                           ppd_dest_filename,
                                                           new_ppd_filename))

        return 0

    if not reset_defaults:
        # Update source buffer with old defaults...

        # Loop through each default in turn.
        keys = list(defaults.keys ())
        keys.sort ()
        for default_option in keys:
            default_option_value = defaults[default_option]
            option = default_option
            if option.startswith ("Default"):
                # Strip off `Default'
                option = option[7:]

            # Check method is valid
            orig_method = orig_default_types.get (option)
            new_method = new_default_types.get (option)
            new_default = new_defaults.get (default_option)
            if (orig_method == None or new_method == None or
                orig_method != new_method):
                continue

            if (new_default != None and
                default_option_value == new_default):
                if verbose:
                    print ("%s: Preserve *%s (%s)" % (ppd_source_filename,
                                                      default_option,
                                                      default_option_value))

                continue

            if new_method == "PickOne":
                next_default = False

                # Check the old setting is valid
                for opt in options.get (option, []):
                    def_option = default_option_value
                    odef_option = def_option
                    if (option == "Resolution" and
                        def_option in old_resolution_map):
                        if debug & 4:
                            print (("Intermapping old resolution %s to %s" %
                                    def_option, old_resolution_map[def_option]))

                        def_option = old_resolution_map[def_option]

                    dopts = [def_option]
                    if def_option != odef_option:
                        dopts.append (odef_option)

                    for dopt in dopts:
                        valid = False
                        if dopt == opt:
                            valid = True
                        elif (option == "Resolution" and
                              dopt in resolution_map):
                            dopt = resolution_map[dopt]
                            if dopt == opt:
                                valid = True

                        if valid:
                            # Valid option

                            # Set the option in the new PPD
                            lines = source_data.rstrip ().split ("\n")
                            source_data = ""
                            attr = "*%s" % default_option
                            for line in lines:
                                if line.startswith (attr):
                                    line = "%s:%s" % (attr, dopt)

                                source_data += line + "\n"

                            if verbose:
                                print ("%s: Set *%s to %s" %
                                       (ppd_source_filename,
                                        default_option,
                                        dopt))

                            next_default = True
                            break
                    if next_default:
                        break

                if next_default:
                    continue

                print (("Warning: %s: Invalid option: *%s: %s.  Using default "
                        "setting %s." % (ppd_source_filename, default_option,
                                         defaults[default_option],
                                         new_defaults[default_option])))
                continue

            print (("Warning: %s: PPD OpenUI method %s not understood." %
                    (ppd_source_filename, new_default_types[default_option])))

    # Write new PPD...
    tmpnew = "%s.new" % ppd_dest_filename
    try:
        newppd = open (tmpnew, "w")
    except IOError as err:
        (e, s) = err.args
        print ("Can't create %s: %s" % (tmpnew, s))
        return 0

    newppd.writelines (source_data)
    try:
        newppd.close ()
    except IOError as err:
        (e, s) = err.args
        print ("Can't write to %s: %s" % (tmpnew, s))
        return 0

    chcon = subprocess.Popen (["chcon", "--reference=%s" % ppd_dest_filename,
                               tmpnew], shell=False,
                              stdin=subprocess.DEVNULL,
                              stdout=subprocess.DEVNULL,
                              stderr=subprocess.STDOUT)
    chcon.communicate ()

    try:
        os.rename (tmpnew, ppd_dest_filename)
    except OSError as err:
        (e, s) = err.args
        print ("Can't rename %s to %s: %s" % (tmpnew, ppd_dest_filename, s))
        try:
            os.unlink (tmpnew)
        except OSError:
            pass

        return 0

    try:
        os.chown (ppd_dest_filename,
                  orig_metadata.st_uid,
                  orig_metadata.st_gid)
    except OSError:
        pass

    try:
        os.chmod (ppd_dest_filename,
                  orig_metadata.st_mode & 0o777)
    except OSError:
        pass

    if not quiet or verbose:
        if ppd_dest_filename == ppd_source_filename:
            print ("Updated %s using %s" % (ppd_source_filename,
                                            new_ppd_filename))
        else:
            print ("Updated %s to %s using %s" % (ppd_source_filename,
                                                  ppd_dest_filename,
                                                  new_ppd_filename))

    # All done!
    return 1

def get_ppd_data (fh, types, opts, resolutions, defaults, data):
    options_map = dict()
    defaults_map = dict()
    resolution_map = dict()
    default_types = dict()
    cur_opt = ""
    optionlist = []
    source_data = ""

    if reset_defaults:
        types = 0
        opts = 0
        resolutions = 0
        defaults = 0

    if resolutions or types or opts or defaults or data:
        while True:
            line = fh.readline ()
            if line == '':
                break
            if line == "*%*%EOFEOF\n":
                break
            source_data += line
            line = line.strip ()

            if (types or opts) and line.startswith ("*OpenUI"):
                m = re.search (r'^\*OpenUI\s\*(\w+).*:\s(\w+)',
                               line)
                if m:
                    groups = m.groups ()
                    key = groups[0]
                    value = groups[1]
                    default_types[key] = value
                    cur_opt = key
            elif opts and line.startswith ("*CloseUI"):
                if cur_opt != "":
                    options_map[cur_opt] = optionlist
                    cur_opt = ""

                optionlist = []
            elif opts and line.startswith ("*%s" % cur_opt):
                m = re.search (r'^\*%s\s*(\w+)[\/:]' % cur_opt, line)
                if m:
                    groups = m.groups()
                    if len (groups) >= 1:
                        value = m.groups ()[0]
                        optionlist.append (value)
            elif resolutions and line.startswith ("*StpResolutionMap:"):
                s = line.split (None, 3)
                if len (s) == 3:
                    new = s[1]
                    old = s[2]
                    resolution_map[old] = new
            elif defaults and line.startswith ("*Default"):
                m = re.search (r'^\*(\w+):\s*(\w+)', line)
                if m:
                    groups = m.groups ()
                    key = groups[0]
                    value = groups[1]
                    defaults_map[key] = value

    return (default_types, options_map, resolution_map,
            defaults_map, source_data)

def get_ppd_fh (ppd_source_filename, filename, driver, locale, region):
    global use_static_ppd
    global driver_version
    global optargs
    global driver_bin
    global debug
    global server_multicat, server_multicat_initialized
    global gzext

    if use_static_ppd == "no" and driver_version != "":
        if re.search (".*/([^/]*)(.sim)(.ppd)?(.gz)?$", filename):
            simplified = "simple"
        else:
            simplified = "expert"

        opt_r = optargs.get ('r')
        if opt_r:
            try:
                opt_r = float (opt_r)
            except ValueError:
                opt_r = None

        url_list = []
        if (((opt_r != None and opt_r < 5.2) or
             ('l' in optargs and optargs['l'] != "")) and
            locale != ""):
            if region:
                url_list.append ("gutenprint.%s://%s/%s/%s_%s" %
                                 version, driver, simplified, locale, region)
            url_list.append ("gutenprint.%s://%s/%s/%s" %
                             version, driver, simplified, locale)

        url_list.append ("gutenprint.%s://%s/%s" % (version, driver,
                                                    simplified))
        for url in url_list:
            new_ppd_filename = url
            if debug & 8:
                if server_multicat:
                    cat = ""
                else:
                    cat = "%s cat " % driver_bin

                print (("Trying %s%s for %s, %s, %s, %s" %
                        (cat, url, driver, simplified, locale, region)))

            if server_multicat:
                try:
                    if not server_multicat_initialized:
                        mc_proc = subprocess.Popen ([driver_bin,
                                                     "org.gutenprint.multicat"],
                                                    shell=False,
                                                    stdin=subprocess.PIPE,
                                                    stdout=subprocess.PIPE,
                                                    stderr=subprocess.DEVNULL)
                        server_multicat_initialized = mc_proc

                    mc_in = io.TextIOWrapper (server_multicat_initialized.stdin)
                    print ("%s" % url, file=mc_in)
                    mc_in.flush ()
                    mc_in.detach ()
                    return (new_ppd_filename,
                            io.TextIOWrapper (server_multicat_initialized.stdout))
                except OSError:
                    pass

            try:
                proc = subprocess.Popen ([driver_bin, "cat", url],
                                         shell=False,
                                         stdin=subprocess.DEVNULL,
                                         stdout=subprocess.PIPE,
                                         stderr=subprocess.DEVNULL)
                return (new_ppd_filename, io.TextIOWrapper (proc.stdout))
            except OSError:
                pass

        # Otherwise fall through and try to find a static PPD

    # Search for a PPD matching our criteria...

    new_ppd_filename = find_ppd (filename, driver, locale, region)
    if not new_ppd_filename:
        # There wasn't a valid source PPD file, so give up.
        print (("%s: no valid candidate for replacement.  Skipping" %
                ppd_source_filename), file=sys.stderr)
        print (("%s: please upgrade this PPD manually" %
                ppd_source_filename), file=sys.stderr)
        return ("", None)

    if debug & 1:
        print ("Candidate PPD: %s" % new_ppd_filename)

    suffix = "\\" + gzext # Add '\' so the regexp matches the '.'
    if new_ppd_filename.endswith (".gz"):
        # Decompress input buffer
        try:
            proc = subprocess.Popen (['gunzip', '-c', new_ppd_filename],
                                     shell=False,
                                     stdin=subprocess.DEVNULL,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.DEVNULL)
        except OSError as err:
            (e, s) = err.args
            print ("can't open for decompression: %s" % s)
            sys.exit (1)

        return (new_ppd_filename, io.TextIOWrapper (proc.stdout))
    else:
        return (new_ppd_filename, open (new_ppd_filename))

def find_ppd (gutenprintfilename, drivername, lang, region):
    global file_version
    global optargs
    global ppd_base_dir
    global ppd_root_dir
    global debug

    key = '^\\*FileVersion:[ 	]*' + file_version
    match = re.search (r'.*/([^/]+\.[0-9]+\.[0-9]+)(\.sim)?(\.ppd)?(\.gz)?$',
                       gutenprintfilename)
    if not match:
        return None

    stored_name = match.groups ()[0]
    if re.search (r'.*/([^/]*)(\.sim)(\.ppd)?(\.gz)?$', gutenprintfilename):
        simplified = ".sim"
    else:
        simplified = ""

    stored_dir = os.path.dirname (gutenprintfilename)

    current_best_file = ""
    current_best_time = 0
    if 's' in optargs:
        basedirs = [optargs['s']]
    else:
        basedirs = [ppd_base_dir, stored_dir, ppd_root_dir]

    lingos = []
    if region != "":
        lingos.append ("%s_%s/" % (lang, region))

    lingos.append ("%s/" % lang)
    if lang != "C":
        lingos.append ("C/")

    lingos.append ("en/")
    lingos.append ("")
    lingos.append ("Global/")
    bases = ["stp-%s.%s%s" % (drivername, version, simplified),
             "%s.%s%s" % (drivername, version, simplified)]
    if stored_name not in bases:
        bases.append (stored_name)

    bases.append (drivername)

    # All possible candidates, in order of usefulness and gzippedness
    for lingo in lingos:
        for suffix in (".ppd%s" % gzext,
                       ".ppd"):
            for base in bases:
                for basedir in basedirs:
                    if basedir == "" or base == "":
                        continue

                    fn = "%s/%s%s%s" % (basedir, lingo, base, suffix)
                    if debug & 8:
                        print (("Trying %s for %s, %s, %s" %
                                (fn, gutenprintfilename, lang, region)))

                    try:
                        st = os.stat (fn)
                    except OSError:
                        continue

                    if ('f' in optargs or
                        (stat.S_ISREG (st.st_mode) and
                         st.st_uid == 0)):
                        # Check that the file is a valid Gutenprint PPD file
                        # of the correct version.
                        if fn.endswith (".gz"):
                            cmdline = "gunzip -c '%s' | grep '%s'" % (fn, key)
                        else:
                            cmdline = "cat '%s' | grep '%s'" % (fn, key)

                        try:
                            p = subprocess.Popen (cmdline,
                                                  stdin=subprocess.DEVNULL,
                                                  stdout=subprocess.PIPE,
                                                  stderr=subprocess.DEVNULL)
                        except OSError:
                            new_file_version = ""
                        else:
                            (stdin, stderr) = p.communicate ()
                            new_file_version = stdin.decode ().rstrip ()

                        if new_file_version != "":
                            if debug & 8:
                                print (("   Format valid: time %s best %s "
                                        "prev %s cur %s!" %
                                        (st.st_mtime, current_best_time,
                                         current_best_file, fn)))

                            if st.st_mtime > current_best_time:
                                current_best_time = st.st_mtime
                                current_best_file = fn
                                if debug & 8:
                                    print (("***current_best_file "
                                            " is %s" % fn), file=sys.stderr)
                        elif debug & 8:
                            print ("   Format invalid")
                    else:
                        if (not stat.S_ISDIR (st.st_mode) and
                            not fn.endswith ("/")):
                            print (("%s: not a regular file, "
                                    "or insecure ownership and "
                                    "permissions.  Skipped" % fn),
                                   file=sys.stderr)

    if current_best_file:
        return current_best_file

    # Yikes!  Cannot find a valid PPD file!
    return None

debug=0
verbose=0
interactive=0
quiet=0
no_action=0
reset_defaults=0
version="@GUTENPRINT_MAJOR_VERSION@.@GUTENPRINT_MINOR_VERSION@"
micro_version="@GUTENPRINT_VERSION@"
use_static_ppd="@BUILD_CUPS_PPDS@"
file_version='"@VERSION@"$'

ppd_dir = "@cups_conf_serverroot@/ppd"
ppd_root_dir = "@cups_conf_datadir@/model";
ppd_base_dir = ppd_root_dir + "/gutenprint/" + version
ppd_out_dir = ""
gzext = ".gz"
updated_ppd_count = 0
skipped_ppd_count = 0
failed_ppd_count = 0
exit_after_parse_args = 0
languages=["Global", "C"] + "@ALL_LINGUAS@".split (' ')

serverdir = "@cups_conf_serverbin@"
driver_bin = serverdir + "/driver/gutenprint." + version
driver_version = ""
server_multicat = 0
server_multicat_initialized = 0

if os.access (driver_bin, os.X_OK):
    get_driver_version ()

ppd_files = []
languagemappings = { "chinese": "cn",
                     "danish": "da",
                     "dutch": "nl",
                     "english": "en",
                     "finnish": "fi",
                     "french": "fr",
                     "german": "de",
                     "greek": "el",
                     "hungarian": "hu",
                     "italian": "it",
                     "japanese": "jp",
                     "norwegian": "no",
                     "polish": "pl",
                     "portuguese": "pt",
                     "russian": "ru",
                     "slovak": "sk",
                     "spanish": "es",
                     "swedish": "sv",
                     "turkish": "tr" }

# Check command-line options...
args = parse_options()

# Set a secure umask...
os.umask (0o177)


# Find all in-use Gutenprint PPD files...
# For case-insensitive filesystems, use only one of .ppd and .PPD
# (bug 1929738)

for f in args:
    if (os.access (f, os.F_OK) and
        (f.lower ().endswith (".ppd") or
         f.find ("/") != -1)):
        ppd_files.append (f)
    elif os.access ("%s/%s" % (ppd_dir, f), os.F_OK):
        ppd_files.append ("%s/%s" % (ppd_dir, f))
    elif os.access ("%s/%s.ppd" % (ppd_dir, f), os.F_OK):
        ppd_files.append ("%s/%s.ppd" % (ppd_dir, f))
    elif os.access ("%s/%s.PPD" % (ppd_dir, f), os.F_OK):
        ppd_files.append ("%s/%s.PPD" % (ppd_dir, f))
    else:
        print (("Cannot find file %s/%s, %s/%s.ppd, or %s/%s.PPD" %
                ppd_dir, f, ppd_dir, f, ppd_dir, f), file=sys.stderr)

if len (args) == 0:
    ppdtmp = glob.glob ("%s/*.ppd" % ppd_dir)
    ppdtmp += glob.glob ("%s/*.PPD" % ppd_dir)
    ppd_map = dict()
    for each in ppdtmp:
        ppd_map[each] = 1

    for f in ppdtmp:
        if f.endswith (".PPD"):
            g = f[:-4] + ".ppd"
            if g not in ppd_map:
                ppd_files.append (f)
        else:
            ppd_files.append (f)

# Update each of the Gutenprint PPDs, where possible...

for ppd_file in ppd_files:
    status = update_ppd (ppd_file)
    if status == -2:
        break
    elif status == 0:
        failed_ppd_count += 1
    elif status == 1:
        updated_ppd_count += 1
    elif status == -1:
        skipped_ppd_count += 1

if (not quiet) or verbose:
    if len (ppd_files) == 0:
        print ("No Gutenprint PPD files to update.")
    elif updated_ppd_count > 0:
        plural = ""
        if updated_ppd_count != 1:
            plural = "s"

        print ("Updated %d PPD file%s" % (updated_ppd_count, plural))
        if (('o' not in optargs) or
            optargs['o'] != ""):
            print ("Restart cupsd for the changes to take effect.")
    else:
        if failed_ppd_count > 0:
            print ("Failed to update any PPD files")
        else:
            print ("Did not update any PPD files")

sys.exit (failed_ppd_count > 0)