if confget("RPM::Upgrade-Virtual/b", "false") == "false" then

    return

end

knames = { "hugemem", "bigmem", "enterprise", "smp", "BOOT" }

-- get kernel package name for running kernel (kernel-smp, kernel, etc)

function get_kerneltype()

	for i, ktype in ipairs(knames) do

		if string.find(posix.uname("%r"), ktype) then

			return ktype

		end

	end

	-- it's either unknown type or normal UP system

	return ""

end

-- get package name

function get_kernelname()

	suffix = get_kerneltype()

	if suffix == "" then

		return "kernel"

	else

		return "kernel-"..suffix

	end

end

-- if grubby is available set default kernel to version

function set_default(version)

	if not posix.access('/sbin/grubby', 'x') then

		return

	end

	grubby = io.popen("LANG=C /sbin/grubby --default-kernel")

	for line in grubby.lines(grubby) do

		-- don't touch the default if it's not a linux system

		if string.find(line, "vmlinuz") then

			ktype = get_kerneltype()

			vmlinuz = '/boot/vmlinuz-'..version..ktype

			if posix.access(vmlinuz, 'f') then

				print(_("Setting "..vmlinuz.." as new default kernel."))

				os.execute('/sbin/grubby --set-default='..vmlinuz)

			else

				aptwarning(_("Unable to set new default kernel "..vmlinuz))

			end

		end

	end

end

-- find + mark for install any packages where uname -r is part of pkg name

-- eg external kernel modules

function upgrade_kernel_modules(new_version)

    modprefix = confgetlist("Kernel::Module-Prefix")

	if not new_version or not modprefix then

		return

	end

	seenpkgs = {}

	pkgs = pkglist()

	for i, pkg in ipairs(pkgs) do

		-- oh fun.. loop through all installed packages and see there are

		-- any which provide module-prefix, try to install version matching

		-- our new kernel

    	if not pkgisvirtual(pkg) and pkgvercur(pkg) then

        	ver = pkgvercur(pkg)

        	for j, prov in ipairs(verprovlist(ver)) do

				for x, prefix in ipairs(modprefix) do

            		if string.sub(prov.name, 1, string.len(prefix)) == prefix then

						inst = pkgfind(prov.name.."-"..new_version)

						if inst then

							markinstall(inst)

						elseif not seenpkgs[prov.name] == true then

							print(_("WARNING: "..prov.name.." not available for kernel "..new_version.."!"))

                    	end                                         

						seenpkgs[prov.name] = true

					end

            	end

        	end

    	end

	end

end

-- find all virtualized packages, their versions and if they're installed

function find_instonly_pkgs()

	pkgs = {}

	for i, pkg in ipairs(pkglist()) do

		idx = string.find(pkgname(pkg), "#")

		ver = pkgvercur(pkg)

		if idx and not pkgisvirtual(pkg) then

			name = string.sub(pkgname(pkg), 1, idx-1)

			if not ver then

				ver = pkgvercand(pkg)

			end

			-- new entry

			if not pkgs[name] then

				tmp = {}

				tmp.pkg = pkg

				tmp.ver = ver

				tmp.inst = false

				pkgs[name] = tmp

			end

			if pkgvercur(pkg) then

				pkgs[name].inst = true

			end

			-- mark it as latest if newer than what already known

			if ver and verstrcmp(verstr(ver), verstr(pkgs[name].ver)) > 0 then

				pkgs[name].ver = ver

				pkgs[name].pkg = pkg

			end

		end

	end

	return pkgs

end

-- mark installed virtualized packages for "upgrade"

function mark_upgrade(name, pkg)

	kname = get_kernelname()

	if pkg.inst and not pkgvercur(pkg.pkg) then

		markinstall(pkg.pkg)

		if name == kname and not pkgvercur(pkg.pkg) then

			confset('Kernel::New-Version', verstr(pkg.ver))

		end

	end

end

-- find the latest version of given virtual pkg for installation

function mark_install(virtualpkg)

	kname = get_kernelname()

	pkgs = find_instonly_pkgs()

	for name in pkgs do

		if name == virtualpkg then

			selected = pkgs[name].pkg

		end

	end

	if virtualpkg == kname and not pkgvercur(pkgs[virtualpkg].pkg) then

		confset('Kernel::New-Version', verstr(pkgs[virtualpkg].ver))

	end

end

-- normal install operation

if script_slot == 'Scripts::AptGet::Install::SelectPackage' then

	modprefix = confgetlist('Kernel::Module-Prefix')

	for i, prefix in ipairs(modprefix) do

		if string.find(virtualname, prefix, 1, true) then

			moduname = virtualname.."-"..posix.uname("%r")

			modpkg = pkgfind(moduname)

			if modpkg then

				selected = modpkg

			else

				apterror(_("Couldn't find package "..moduname))

				return

			end

		end

	end

	mark_install(virtualname)

	return

elseif script_slot == 'Scripts::AptGet::Install::PreResolve' then

	kname = get_kernelname()

	if not confexists('Kernel::New-Version') then

		for i, pkg in ipairs(pkglist()) do

			idx = string.find(pkgname(pkg), "#")

			if statinstall(pkg) and idx then

				name = string.sub(pkgname(pkg), 1, idx-1)

				if kname == name and not pkgvercur(pkg) then

					confset('Kernel::New-Version', verstr(pkgvercand(pkg)))

				end

			end

		end	

	end

	if confexists('Kernel::New-Version') then

		upgrade_kernel_modules(confget('Kernel::New-Version'))

	end

-- if there's no virtual provide without the version in the name

-- we need to match it here instead of selectpackage

elseif script_slot == 'Scripts::AptGet::Install::TranslateArg' then

    modprefix = confgetlist('Kernel::Module-Prefix')

    for i, prefix in ipairs(modprefix) do

		if string.find(argument, prefix, 1, true) then

			translated = argument.."-"..posix.uname("%r")

		end

	end

	return

elseif script_slot == 'Scripts::AptGet::Upgrade' or 

   script_slot == 'Scripts::AptGet::DistUpgrade' then

	pkgs = find_instonly_pkgs()

	table.foreach(pkgs, mark_upgrade)

	if confexists('Kernel::New-Version') then

		upgrade_kernel_modules(confget('Kernel::New-Version'))

	end

elseif script_slot == 'Scripts::PM::Post' then

	if confget('Kernel::Set-Default/b', "false") == "true" and 

       confexists('Kernel::New-Version') then

		set_default(confget('Kernel::New-Version'))

	end

end

-- vim:ts=4:sw=4