RPM-LUA(7)

NAMN

rpm-lua — RPM-inbäddad Lua-tolk

SYNOPSIS

%scriptlet -p <lua>

%{lua:…}

BESKRIVNING
Lua är ett generellt programmeringsspråk specifikt designat för att bäddas in i andra program, och RPM inkluderar en inbäddad Lua-tolk som kan användas i avancerade rpm-macros(7) och transaktionsskript.

Den inbäddade Lua-tolken gör diverse saker möjligt som är svåra eller omöjliga med vanliga makron eller externa skalskript, såsom hjälp att eliminera beroendeslingor från paketskript.

MAKRON

  Komma åt makron
Rpm-utökningen har diverse funktioner för att arbeta med makron, men det bekvämaste sättet att komma åt rpm-macroproc(7) från RPM-Lua-miljön är via den globala macros-tabellen.

Lua gör ingen skillnad mellan tabellindex och fältnamnssyntax så macros.apa och macros['apa'] är likvärdiga, använd vad som passar bäst för ändamålet.

Som i en verklig Lua-tabell returneras poster som inte finns som nil, och tilldelning kan användas för att definiera eller avdefiniera makron.

Exempel:
    if not macros.ditt then
        macros.mitt = 'mitt makro'
    end

    local v = { '_libdir', '_bindir', '_xbindir' }
    for _, v in ipairs(v) do
        if not macros[v] then
            macros[v] = 'default'
        end
    end

Alla makron delar samma globala Lua-körmiljö.

  Anrop av parametriserade makron
Parametriserade makron (inklusive alla inbyggda makron) kan anropas på ett normalt Lua-sätt via tabellen macros, med antingen syntaxen macros.namn() eller macros[namn]().

Argument skickas via ett enda argument, som är antingen
•   en enda sträng, i vilket fall den expanderas och delas med vanliga makroregler
•   en tabell, i vilket fall tabellinnehållet används som bokstavliga argument som inte expanderas på något sätt

Exempel 1:
    macros.med(apa')

Exempel 2:
    macros.jobba({'ett', 'två', 'tre'})

  Returnera data
Per definition kommer allt som print():as i Lua hamna i makroexpansionen. Lua-makron kan även göra return på sin utdata, vilket gör att programmering av hjälpmakron ser mer naturliga ut.

Exempel:
    %sum() %{lua:
       local v = 0
       for _, a in ipairs(arg) do
           v = v + tonumber(a)
       end
       return v
    }

  Flaggor och argument
Parametriserade Lua-makron får sina flaggor och argument som två lokala tabeller opt och arg, där opt innehåller bearbetade flaggvärden med flaggbokstaven som nyckel, och arg innehåller argument med numeriska index.

Dessa tabeller finns alltid oavsett huruvida flaggor eller argument faktiskt skickades för att förenkla användningen.

Exempel:
    %apa(a:b) %{lua:
    if opt.b then
       print('gör b')
    else
       print('eller inte')
    end
    if opt.a == 's' then
       print('gör s')
    end
    if #arg == 0 then
       print('inga arument :(')
    else
       for i = 1, #arg do
          print(arg[i])
       end
    end
    }

SKRIPT
Den interna Lua:n kan användas som tolk av RPM i transaktionsskript, inklusive utlösare och filutlösare:

Exempel:
    %pre -p <lua>
    print('Hej från Lua')

Medan den ärevördiga /bin/sh vanligen är mer bekväm för paketrelaterade skriptaktiviteter har den inbäddadde Lua-tolken några unika fördelar för transaktionsskript: de lägger inte till några extra beroenden till paketet och kan på så sätt hjälpa till att eliminera beroendeslingor. Detta kan vara en avgörande skillnad i den tidiga uppsättningen ”uppstartspaket” i den initiala installationen.

Speciellt är ett inbäddat Lua-skript den enda allmänt användbara möjligheten i %pretrans-skript under den initiala installationen av ett system.

Inbäddad Lua är också mycket snabbare än att köra en potentiellt tungviktig tolk bara för att köra ett par rader i ett skalskript.

Observera: skript som använder den interna Lua:n skall inte göra antaganden om att dela körmiljö med andra skript.

  Argument
Skriptargument är tillgängliga från en global tabell arg.

Observera: i Lua startar index normalt på 1 (ett) istället för 0 (noll), och på gott och ont följer RPM-implementationen denna praktik. Skriptens argumentindex skiljer alltså ett steg från de vanliga förväntningarna baserade på traditionella skriptargument. Argumentet som innehåller antalet installerade paketinstanser är arg[2] och det liknande argumentet till utlösarmål är arg[3], till skillnad mot det vanliga $1 och $2 i skalskript.

Exempel:
    %postun -p <lua>
    if arg[2] == 0  then
        print("raderar")
    end

  Omlokaliserbara paket
Skript i omlokaliserbara paket får dessutom en global tabell RPM_INSTALL_PREFIX som innehåller alla möjliga prefix i paketet.

Tillagt i: 4.18.0

  Slutstatus
Även om skript normalt inte skall tillåtas att misslyckas kan man signalera felstatus från skript genom att använda Lua:s funktion error(medd, [nivå]) om man behöver det.

SPEC-FILER
I sammanhanget av en rpm-spec(5)-filtolkning med rpmbuild(1) eller rpmspec(1) innehåller RPM-Lua-miljön följande spec-specifika globala tabeller:

patches
    Filnamnen på patcharna i spec:en, i den ordning de förekom i spec:en.

patch_nums
    Numren på patcharna i spec:en, i den ordning de förekom i spec:en.

sources
    Filnamnen på källkoden i spec:en, i den ordning de förekom i spec:en.

source_nums
    Filnamnen på källkoden i spec:en, i den ordning de förekom i spec:en.

Exempel:
    for i, p in ipairs(patches) do
        print(string.format("echo %d: %sn", patch_nums[i], patches[i]))
    end

UTÖKNINGAR
Utöver Lua:s standardbibliotek (med förbehåll för Lua-versionen RPM är länkad med) är följande utökningar tillgängliga i alla sammanhang där den interna Lua:n kan användas.

  rpm-utökningar

Följande RPM-specifika funktioner är tillgängliga:

b64decode(arg)
    Utför base64-avkodning av argumentet. Se även b64encode().

    Exempel:
        blob = 'binärdata'
        print(blob)
        e = rpm.b64encode(blob)
        print(e)
        d = rpm.b64decode(e)
        print(d)

b64encode(arg [, radlängd])
    Utför base64-kodning av argumentet. Radlängden får specificeras via ett andra argument. Se även b64decode().

define("namn kropp")
    Definiera ett globalt makro namn till kropp. Se även MAKRON.

    Exempel:
        rpm.define('apa 1')

execute(sökväg [, arg1 [,…])
    Kör ett externt kommando. Detta är praktiskt för att köra externa hjälpkommandon utan att vara beroende av skalet. sökväg är kommandot att köra, följt av ett valfritt antal argument att skicka till kommandot.

    För bättre styrning av processkörningen och utdata, se rpm.spawn().±&

    Tillagt i: 4.15.0

    Exempel:
        rpm.execute('ls', '-l', '/')
expand(arg)
    Utför RPM-makroexpansion av strängen arg. Se även MAKRON.

    Exempel:
        rpm.expand('%{_libdir}/minkat')

glob(mönster, [flaggor])
    Returnera en tabell med sökvägar som matchar mönster. Om flaggor innehåller c, returnera mönster ifall inget matchar.

    Exempel:
        for i, p in ipairs(rpm.glob('*')) do
            print(p)
        end

interactive()
    Starta en interaktiv session för testning och felsökning. Använd rpmlua(1) istället.

    Exempel:
        rpm --eval "%{lua: rpm.interactive()}"

isdefined(namn)
    Testa huruvida makrot namn är definierat och huruvida det är parametriskt, returnerar två booleaner. Se även MAKRON. (Tillagt i 4.17.0)

    Exempel:
        if rpm.isdefined('_libdir') then
            …
        end

load(sökväg)
    Ladda en makrofil från den givna sökvägen. Samma som det inbyggda makrot %{load:…}.

    Exempel:
        rpm.load('mina.makron')

open(sökväg, [läge[.flaggor]])
    Öppna en filström med RPM:s IO-funktioner, med stöd för transparent komprimering och dekomprimering.

    sökväg är filnamnssträngen, eventuellt följd av en sträng läge som anger specifikt öppningsbeteende:
    •   a: öppna för tillägg på slutet
    •   w: öppna för skrivning, hugg av
    •   r: öppna för läsning (standard)
    •   +: öppna för läsning och skrivning
    •   x: misslyckas om filen redan finns

    och eventuellt följd av rpm-payloadflags(7) för komprimering och dekomprimering.

    Tillagt i: 4.17.0

    Exempel:
        f = rpm.open('någon.txt.gz', 'r.gzdio')
        print(f:read())

    Det returnerade rpm.fd-objektet har följande metoder:

    fd:close()

    Stäng filströmmen.

    Exempel:
        f = rpm.open('fil')
        f:close()

    fd:flush()

    Töm filströmmen.

    Exempel:
        f = rpm.open('fil', 'w')
        f:write('apa')
        f:flush()
        f:close()

    fd:read([längd])

    Läs data från filströmmen upp till längd byte eller om det inte angetts, hela filen.

    Exempel:
        f = rpm.open('/någon/fil')
        print(f:read())

    fd:seek(läge, avstånd)

    Positionera om filavståndet i strömmen. läge är en av set, cur och end, och avståndet är relativt läget: absolut, relativt aktuellt eller relativt slutet. Inte alla strömmar stödjer att söka.

    Returnerar filavståndet efter åtgärden.

    Se även lseek(3).

    Exempel:
        f = rpm.open('nyfil', 'w')
        f:seek('set', 555)
        f:close()

    fd:write(buf [, längd])

    Skriv data i buf till filströmmen, antingen i sin helhet eller upp till längd byte om angett.

    Exempel:
        f = rpm.open('nyfil', 'w')
        f:write('data data')
        f:close()

    fd:reopen(läge)

    Öppna om en ström i ett nytt läge (se rpm.open()).

    Exempel:
        rpm.open(någon.txt.gz')
        f = f:reopen('r.gzdio')
        print(f:read())}

redirect2null(fdnr) (FÖRÅLDRAT)
    Omdirigera filbeskrivare fdnr till /dev/null (före 4.16 var detta känt som posix.redirect2null())

    Denna funktion är föråldrad och bara tillgänglig för RPM v4-paket för bakåtkompatibilitet. använd ”rpm.spawn()” eller ”rpm.execute()” istället.

        pid = posix.fork()
        if pid == 0 then
            posix.redirect2null(2)
            assert(posix.exec('/bin/awk'))
        elseif pid > 0 then
            posix.wait(pid)
        end

spawn({kommando} [, {åtgärder}])
    Yngla av, även känt som kör, ett externt program.

    {kommando} är en tabell som består av kommandot och dess argument. En frivillig andra tabell kan användas för att skicka diverse åtgärder relaterade till kommandokörningen, för närvarande stödjs:

        | Åtgärd  | Argument | Beskrivning
        |---------|-------------------
        | *stdin* | sökväg   | Omdirigera standard in till sökväg
        | *stdout*| sökväg   | Omdirigera standard ut till sökväg
        | *stderr*| sökväg   | Omdirigera standard fel till sökväg

    Returnerar kommandots slutstatus: noll om det gick bra, eller en tupel av (nil, meddelande, kod) om det misslyckades.

    Tillagt i: 4.20

    Exempel:
        rpm.spawn({'systemctl', 'restart', 'httpd'}, {stderr='/dev/null'})

undefine(namn)
    Avdefiniera ett makro. Se även MACRON.

    Observera att detta endast plockar bort den senaste makrodefinitionen av det givna namnet från stacken, d.v.s. det kan fortfarande finnas makrodefinitioner med samma namn efter åtgärden undefine.

    Exempel:
        rpm.undefine('zzz')

vercmp(v1, v2)
    Utför jämförelse av RPM-versioner på argumentsträngar. Returnerar -1, 0 eller 1 om v1 är mindre än, lika med eller större än v2. Se rpm-version(7).

    Observera: i RPM < 4.16 arbetade detta endast på versionssegment, vilket inte producerar korrekta resultat på fullständiga EVR-strängar.

    Exempel:
        rpm.vercmp('1.2-1', '2.0-1')

ver(evr), ver(e, v, r)
    Skapa RPM-versionsojbekt. Detta tar antingen en evr-sträng som tolkas till dess komponenter, eller epok, version och utgåva i separata argument (vilka kan vara antingen strängar eller tal). Objektet har tre attribut: e för epok, v för version och r for utgåva, kan skrivas i sin EVR-form och stödjer inbyggd jämförelse i Lua.

    Tillagt i: 4.17.0

    Exempel:
        v1 = rpm.ver('5:1.0-2)
        v2 = rpm.ver(3, '5a', 1)
        if v1 < v2 then
           …
        end

        if v1.e then
           …
        end

  posix-utvidgningar

Lua:s standardibliotek erbjuder en ganska begränsad uppsättning io-åtgärder. Utvidgningen posix utökar kraftigt vad som kan göras från Lua.

Följande funktioner är tillgängliga i namnrymden posix, d.v.s för att anropa dem använd posix.funktion(). Denna dokumentation koncentrerar sig på Lua:s API-konventioner, för ytterligare information om motsvarande systemanrop referera systemmanualen, t.ex. access(3) för posix.access().

access(sökväg [, läge])
    Testa åtkomligheten för filen/katalogen sökväg. Se access(3). Om läge utelämnas testas existensen, annars är det en kombination av följande tester:
    •   r: läsbar
    •   w: skrivbar
    •   x: körbar
    •   f: finns

    Exempel:
        if posix.access('/bin/rpm', 'x') then
            …
        end

chdir(sökväg)
    Ändra aktuell arbetskatalog till sökväg. Se chdir(1).

    Exempel:
        posix.chdir('/tmp')

chmod(sökväg, läge)
    Ändra filens/katalogens rättigheter. Läge kan antingen vara ett oktalt tal som till systemanropet chmod(2), eller en strängpresentation liknande chmod(1).

    Exempel:
        posix.chmod('aa', 600)
        posix.chmod('bb', 'rw-')
        posix.chmod('cc', 'u+x')

chown(sökväg, användare, grupp)
    Ändra filen/katalogen sökvägs ägare/grupp. Argumenten användare och grupp kan antingen vara numeriska id-värden eller användar-/gruppnamn. Se chown(2) och chown(1).

    Observera: detta är en privilegierad åtgärd.

    Exempel:
        posix.chown('aa', 0, 0)
        posix.chown('bb', 'nobody', 'nobody')

ctermid()
    Hämta den styrande terminalens namn. Se ctermid(3).

    Exempel:
        print(posix.ctermid())

dir([sökväg])
    Hämta katalogens innehåll — som readdir(3). Om sökväg utelämnas används den aktuella katalogen.

    Exempel:
        for i,p in pairs(posix.dir('/')) do
            print(p..'n')
        end

errno()
    Hämta strerror(3)-meddelandet och motsvarande nummer för det aktuella errno(3).

    Exempel:
        f = '/zzz'
        if not posix.chmod(f, 100) then
            s, n = posix.errno()
            print(f, s)
        end

exec(sökväg [, arg…]) (FÖRÅLDRAT)
    Kör ett program. Detta får bara utföras efter posix.fork().

    Denna funktion är föråldrad och endast tillgänglig för bakåtkompatibilitet med RPM v4-paket. Använd rpm.spawn() eller rpm.execute() istället.

files([sökväg])
    Iterera över kataloginnehåll. Om sökväg utelämnas används den aktuella katalogen.

    Exempel:
        for f in posix.files('/') do
            print(f..'n')
        end

fork() (FÖRÅLDRAT)
    Grena av en ny process. Se fork(2).

    Denna funktion är föråldrad och endast tillgänglig för bakåtkompatibilitet med RPM v4-paket. Använd rpm.spawn() eller rpm.execute() istället.

    Exempel:
        pid = posix.fork()
        if pid == 0 then
            posix.exec('/apa/bepa')
        elseif pid > 0 then
            posix.wait(pid)
        end

getcwd()
    Hämta den aktuella katalogen. Se getcwd(3).

    Exempel:
        if posix.getcwd() ~= '/' then
            …
        endif

getenv(namn)
    Hämta en miljövariabel. Se getenv(3).

    Exempel:
        if posix.getenv('HOME') ~= posix.getcwd() then
            print('inte hemma')
        end

getgroup(grupp)
    Hämta group(5)-information om en grupp. grupp kan antingen vara ett numeriskt id eller ett gruppnamn. Om utelämnat används den aktuella gruppen. Returnerar en tabell med fälten name och gid satta till gruppnamnet respektive dess id, och index från 1 och framåt specificerar gruppmedlemmar.

    Exempel:
        print(posix.getgroup('wheel').gid)

getlogin()
    Hämta inloggningsnamnet. Se getlogin(3).

    Exempel:
        n = posix.getlogin()

getpasswd([användare [, väljare]])
    Hämta passwd(5)-information för ett användarkonto. användare kan antingen vara ett numeriskt id eller användarnamn. Om utelämnat används den aktuella användaren. Det frivilliga argumentet väljare kan vara ett av:
    •   name
    •   uid
    •   gid
    •   dir
    •   shell
    •   gecos
    •   passwd

    Om det utelämnas returneras en tabell med alla dessa fält.

    Exempel:
        pw = posix.getpasswd(posix.getlogin(), 'shell')|

getprocessid([väljare])
    Hämta information om den aktuella processen. Det frivilliga argumentet väljare kan vara ett av
    •   egid: effektivt grupp-id
    •   euid: effektivt användar-id
    •   gid: grupp-id
    •   uid: användar-id
    •   pgrp: förälderns grupp-id
    •   pid: processens id
    •   ppid: förälderns pid

    Om det utelämnas returneras en tabell med alla dessa fält.

    Exempel:
        if posix.getprocessid('pid') == 1 then
            …
        end

kill(pid [, signal])
    Skicka en signal(7) till en process. signal måste vara ett numeriskt värde, t.ex. 9 för SIGKILL. Om det utelämnas används SIGTERM. Se även kill(2).

    Exempel:
        posix.kill(posix.getprocessid('pid'))

link(gammalsökväg, nysökväg)
    Skapa ett nytt namn på newpath för en fil på oldpath, även känt som hårdlänk. Se även link(2).

    Exempel:
        f = rpm.open('aaa', 'w')
        posix.link('aaa', 'bbb')

mkdir(sökväg)
    Skapa en ny katalog på path. Se även mkdir(2).

    Exempel:
        posix.mkdir('/tmp')

mkfifo(sökväg)
    Skapa en FIFO även känt som namngivet rör på sökväg. Se även mkfifo(2).

    Exempel:
        posix.mkfifo('/tmp/dumplats')

pathconf(sökväg [, väljare])
    Hämta pathconf(3)-information för sökväg. Den frivilliga väljaren kan vara en av
    •   link_max
    •   max_canon
    •   max_input
    •   name_max
    •   path_max
    •   pipe_buf
    •   chown_restricted
    •   no_trunc
    •   vdisable.

    Om det utelämnas returneras en tabell med alla dessa fält.

    Exempel:
        posix.pathconf('/', 'path_max')

putenv(sträng)
    Ändra eller lägg till en miljövariabel. Se även putenv(3).

    Exempel:
        posix.putenv('HOME=/mig')

readlink(sökväg)
    Läs värdet av den symboliska länken på sökväg. Se även readlink(2).

    Exempel:
        posix.mkdir('aaa')
        posix.symlink('aaa', 'bbb')
        print(posix.readlink('bbb'))

rmdir(sökväg)
    Ta bort katalogen sökväg. Se även rmdir(2).

    Exempel:
        posix.rmdir('/tmp')

setgid(grupp)
    Sätt gruppidentitet. grupp kan anges antingen som ett numeriskt id eller gruppnamn. Se även setgid(2).

    Observera: detta är en privilegierad åtgärd.

setuid(användare)
    Sätt användaridentitet. användare kan anges antingen som ett numeriskt id eller användarnamn. Se även setuid(2).

    Observera: detta är en privilegierad åtgärd.

    Exempel:
        posix.setuid('nobody')

sleep(sekunder)
    Sov under sekunder. Se även sleep(3).

    Exempel:
        posix.sleep(5)

stat(sökväg [, väljare])
    Hämta fil-stat(3)-information om en fil på sökväg. Den frivilliga väljare kan vara en av
    •   mode
    •   ino
    •   dev
    •   nlink
    •   uid
    •   gid
    •   size
    •   atime
    •   mtime
    •   ctime
    •   type.

    Om det utelämnas returneras en tabell med alla dessa fält.

    Exempel:
        print(posix.stat('/tmp', 'mode'))|

        s1 = posix.stat('f1')
        s2 = posix.stat('f2')
        if s1.ino == s2.ino and s1.dev == s2.dev then
            …
        end

symlink(gammalsökväg, nysökväg)
    Skapa en symbolisk länk på nysökväg till gammalsökväg. Se även symlink(2).

    Exempel:
        posix.mkdir('aaa')
        posix.symlink('aaa', 'bbb')

sysconf([väljare])
    Hämta sysconf(3)-information. Det frivilliga argumentet väljare kan vara en av:
    •   arg_max
    •   child_max
    •   clk_tck
    •   ngroups_max
    •   stream_max
    •   tzname_max
    •   open_max
    •   job_control
    •   saved_ids
    •   version.

    Om det utelämnas returneras en tabell med alla dessa fält.

    Exempel:
        posix.sysconf('open_max')|

times([väljare])
    Hämta processens och inväntade barnprocessers times(2). Det frivilliga argumentet väljare kan vara ett av
    •   utime
    •   stime
    •   cutime
    •   cstime
    •   elapsed

    Om det utelämnas returneras en tabell med alla dessa fält.

    Exempel:
        t = posix.times()
        print(t.utime, t.stime)

ttyname([fb])
    Hämta namnet på en terminal som är associerad med filbeskrivaren fb. Om fb utelämnas används 0 (även känt som standard in). Se ttyname(3).

    Exempel:
        if not posix.ttyname() then
            …
        endif

umask([läge])
    Hämta eller sätt processens umask(2). läge kan anges som ett oktalt tal eller en rättighetssträng liknande posix.chmod().

    Exempel:
        print(posix.umask())
        posix.umask(222)
        posix.umask('ug-w')
        posix.umask('rw-rw-r--')

uname(format)
    Hämta uname(2)-information om det aktuella systemet. Följande formatdirektiv stödjs:

    •   %m: Namnet på hårdvarutypen
    •   %n: Namnet på denna nod
    •   %r: Aktuell utgåvenivå för denna implementation
    •   %s: Namnet på detta operativsystem
    •   %v: Aktuell versionsnivå på denna implementation

    Exempel:
        print(posix.uname('%s %r'))

utime(sökväg [, mtid [, ctid]])
    Ändra senaste åtkomst- och ändringstider. mtid och ctid uttrycks i sekunder sedan epoken. Se utime(2).

    Om mtid eller ctid utelämnas används aktuell tid, i likhet med touch(1).

    Exempel:
        posix.mkdir('aaa')
        posix.utime('aaa', 0, 0)

wait([pid]) (FÖRÅLDRAT)
    Vänta på en barnprocess. Om pid anges, vänta på just det barnet. Se även wait(2).

    Denna funktion är föråldrad och endast tillgänglig för bakåtkompatibilitet med RPM v4-paket. Använd rpm.spawn() eller rpm.execute() istället.

    Exempel:
        pid = posix.fork()
        if pid == 0 then
            posix.exec('/bin/ls'))
        elseif pid > 0 then
            posix.wait(pid)
        end

setenv(namn, värde [, ersätt])
    Ändra eller lägg till miljövariabeln namn. Det frivilliga ersätt är en boolean vilken avgör beteendet när en variabel med samma namn redan finns. Se även setenv(3).

    Exempel:
        posix.setenv('HOME', '/mig', true)

unsetenv(namn)
    Ta bort variabeln namn från miljön. Se även unsetenv(3).

    Exempel:
        posix.unsetenv('HOME')

UTVIDGNING OCH ANPASSNING
Vid initieringen kör RPM ett global Lua-initiieringsskript init.lua från katalogen som %getconfdir expanderar till, normalt /usr/lib/rpm/init.lua. Detta kan användas för att anpassa rpm-Lua-miljön utan att kompilera om RPM.

För den inbäddade Lua-tolken söks moduler laddade med require primärt från %{getconfdir}/lua/. %_rpmluadir är en kortform för denna sökväg.

SE ÄVEN
rpm-macros(7) rpm-payloadflags(7) rpmlua(1) rpm-version(7)

https://www.lua.org/

ÖVERSÄTTNING
Den svenska översättningen av denna manualsida skapades av Göran Uddeborg <goeran@uddeborg.se>

Denna översättning är fri dokumentation; läs GNU General Public License Version 3 (https://www.gnu.org/licenses/gpl-3.0.html) eller senare för upphovsrättsvillkor. Vi tar INGET ANSVAR.

Om du hittar fel i översättningen av denna manualsida, skicka ett mail till Tp-sv@listor.tp-sv.se.