OSDN -- Develop and Download Open Source Software
  • R/O
  • SSH
  • HTTPS

svardos: Commit


Commit MetaInfo

Revision615 (tree)
Time2022-02-04 07:54:03
Authormateuszviste

Log Message

frozen ver 20220203 to tags

Change Summary

Incremental Difference

--- pkg/tags/20220203/nls_utf8/pkg_de.txt (nonexistent)
+++ pkg/tags/20220203/nls_utf8/pkg_de.txt (revision 615)
@@ -0,0 +1,74 @@
1+# Help Message
2+# FDNPKG language file
3+# Time-stamp: "2017-03-09 22:50:34 joerg"
4+#
5+# Language..: German
6+# Translator: Jörg Jenderek
7+# Version...: 0.99.4
8+
9+
10+#### Help ####
11+
12+1.0:Dies ist der Paketmanager für SvarDOS.
13+1.20:Gebrauch: pkg install package.zip
14+1.21: pkg update package.zip
15+1.22: pkg remove package
16+1.23: pkg listfiles package
17+1.24: pkg listlocal [filter]
18+1.27: pkg unzip datei.zip
19+1.25:PKG is published under the MIT license.
20+1.26:It is configured through %DOSDIR%\CFG\PKG.CFG
21+
22+### General stuff ####
23+
24+2.2:%DOSDIR% nicht gesetzt! Sie sollte auf das SvarDOS-Hauptverzeichnis verweisen.
25+2.3:Beispiel: SET DOSDIR=C:\SVARDOS
26+2.14:Kein Speicher mehr! (%s)
27+
28+#### Installing package ####
29+
30+3.8:FEHLER: Ungültiges Zip-Archiv! Paket nicht installiert.
31+3.9:FEHLER: Paket enthält eine Datei, die bereits lokal existiert:
32+3.10:FEHLER: %s konnte nicht erstellt werden!
33+3.12:FEHLER: Paket enthält nicht die Datei %s! Kein gültiges FreeDOS-Paket.
34+3.18:Paket %s ist bereits installiert! Sie sollten die 'update' Aktion verwenden.
35+3.19:Paket %s installiert: %d Dateien extrahiert, %d Fehler.
36+3.20:FEHLER: Paket enthält eine verschlüsselte Datei:
37+3.23:FEHLER: Paket enthält einen ungültigen Dateinamen:
38+3.24:FEHLER: package name too long
39+
40+#### Removing package ####
41+
42+4.0:Paket %s ist nicht installiert, daher nicht entfernt.
43+4.3:Kein Speicher mehr! Konnte das Verzeichnis %s nicht speichern!
44+4.4:entferne %s
45+4.5:Paket %s wurde entfernt.
46+
47+#### Searching package ####
48+
49+5.0:Kein Paket entspricht der Suche.
50+
51+#### Loading configuration ####
52+
53+7.0:FEHLER: Repository '%s' wird zweimal aufgeführt!
54+7.1:FEHLER: Konfigurationsdatei '%s' konnte nicht geöffnet werden!
55+7.4:Warnung: Token mit leerem Wert in Zeile #%d
56+7.8:Warnung: Unbekanntes Token '%s' in Zeile #%d
57+7.11:Warnung: Ungültige 'DIR'-Richtlinie in Zeile #%d
58+7.15:FEHLER: spezielles Verzeichnis '%s' ist kein gültiger absoluter Pfad!
59+7.16:FEHLER: spezielles Verzeichnis '%s' ist ein reservierter Name!
60+
61+#### Unziping package ####
62+
63+8.1:unbekannte ZIP-Signatur: 0x%08lx
64+8.2:FEHLER: Paket enthält eine Datei mit nicht unterstützter Komprimierung (%d):
65+8.3:FEHLER beim Extrahieren von '%s' zu '%s'!
66+
67+#### Handling the local list of installed packages ####
68+
69+9.0:FEHLER: konnte nicht auf das Verzeichnis %s zugreifen.
70+9.1:FEHLER: Lokales Paket %s nicht gefunden.
71+
72+# Local Variables:
73+# coding:cp850-dos
74+# End:
--- pkg/tags/20220203/nls_utf8/pkg_dk.txt (nonexistent)
+++ pkg/tags/20220203/nls_utf8/pkg_dk.txt (revision 615)
@@ -0,0 +1,68 @@
1+#
2+# FDNPKG language file
3+#
4+# Language..: Danish
5+# Translator: Henrik Schick-Hansen
6+#
7+
8+#### Help ####
9+
10+1.0:Pakke administrator til SvarDOS.
11+1.20:Anvendelse: pkg install package.zip
12+1.21: pkg update package.zip
13+1.22: pkg remove package
14+1.23: pkg listfiles package
15+1.24: pkg listlocal [filter]
16+1.27: pkg unzip file.zip
17+1.25:PKG is published under the MIT license.
18+1.26:It is configured through %DOSDIR%\CFG\PKG.CFG
19+
20+### General stuff ####
21+
22+2.2:%DOSDIR% ikke sat! DOSDIR skal pege på SvarDOS hoved biblioteket.
23+2.3:Eksempel: SET DOSDIR=C:\SVARDOS
24+2.14:Hukommelse opbrugt! (%s)
25+
26+#### Installing package ####
27+
28+3.8:Fejl: Ugyldigt zip arkiv! Pakken blev ikke installeret.
29+3.9:Fejl: Pakken indeholder en fil som findes lokalt allerede:
30+3.10:Fejl: Kan ikke oprette %s!
31+3.12:Fejl: Pakken indeholder ikke filen %s! Er ikke en gyldig FreeDOS pakke.
32+3.18:Pakke %s er installeret allerede! Benyt 'update' handlingen i stedet.
33+3.19:Pakke %s installeret: %d filer udpakket, %d fejl.
34+3.20:Fejl: Pakken indeholder en krypteret fil:
35+3.23:ERROR: Package contains an invalid filename:
36+3.24:ERROR: package name too long
37+
38+#### Removing package ####
39+
40+4.0:Pakken %s er ikke installeret, og kan derfor ikke slettes.
41+4.3:Hukommelse opbrugt! Kan ikke gemme biblioteket %s!
42+4.4:sletter %s
43+4.5:Pakken %s er slettet.
44+
45+#### Searching package ####
46+
47+5.0:Ingen pakke passer med søgningen.
48+
49+#### Loading configuration ####
50+
51+7.0:Fejl: opbevaringsstedet '%s' er oplistet to gange!
52+7.1:Fejl: Kan ikke åbne opsætningsfilen '%s'!
53+7.4:Advarsel: tomt udtryk i linje #%d
54+7.8:Advarsel: Ukendt udtryk '%s' i linje #%d
55+7.11:Advarsel: Ugyldigt 'DIR' direktiv fundet i linje #%d
56+7.15:Fejl: tilpasset bib '%s' er ikke en gyldig og fuldstændig sti!
57+7.16:Fejl: tilpasset bib '%s' er et reserveret navn!
58+
59+#### Unziping package ####
60+
61+8.1:ukendt zip signatur: 0x%08x
62+8.2:Fejl: Pakkeindhold komprimeret med en ikke understøttet metode (%d):
63+8.3:Fejl under udpakning af '%s' til '%s'!
64+
65+#### Handling the local list of installed packages ####
66+
67+9.0:Fejl: Kan ikke få adgang til %s biblioteket.
68+9.1:Fejl: Lokal pakke %s ikke fundet.
--- pkg/tags/20220203/nls_utf8/pkg_en.txt (nonexistent)
+++ pkg/tags/20220203/nls_utf8/pkg_en.txt (revision 615)
@@ -0,0 +1,76 @@
1+#
2+# PKG language file
3+#
4+# Language..: English
5+# Translator: Mateusz Viste
6+#
7+
8+#### Help ####
9+
10+1.0:PKG is the package installer for SvarDOS.
11+1.20:Usage: pkg install package.zip
12+1.21: pkg update package.zip
13+1.22: pkg remove package
14+1.23: pkg listfiles package
15+1.24: pkg listlocal [filter]
16+1.27: pkg unzip file.zip
17+1.25:PKG is published under the MIT license.
18+1.26:It is configured through %DOSDIR%\CFG\PKG.CFG
19+
20+### General stuff ####
21+
22+2.2:%DOSDIR% not set! You should make it point to the SvarDOS main directory.
23+2.3:Example: SET DOSDIR=C:\SVARDOS
24+2.14:Out of memory! (%s)
25+
26+#### Installing package ####
27+
28+3.8:ERROR: Invalid zip archive! Package not installed.
29+3.9:ERROR: Package contains a file that already exists locally:
30+3.10:ERROR: Could not create %s!
31+3.12:ERROR: Package does not contain the %s file! Not a valid SvarDOS package.
32+3.18:Package %s is already installed! You might want to use the 'update' action.
33+3.19:Package %s installed: %d files extracted, %d errors.
34+3.20:ERROR: Package contains an encrypted file:
35+3.23:ERROR: Package contains an invalid filename:
36+3.24:ERROR: package name too long
37+
38+#### Removing package ####
39+
40+4.0:Package %s is not installed, so not removed.
41+4.3:Out of memory! Could not store directory %s!
42+4.4:removing %s
43+4.5:Package %s has been removed.
44+
45+#### Searching package ####
46+
47+5.0:No package matched the search.
48+
49+#### Loading configuration ####
50+
51+7.0:ERROR: custom dir '%s' is listed twice!
52+7.1:ERROR: Could not open config file '%s'!
53+7.4:Warning: token with empty value on line #%d
54+7.8:Warning: Unknown token '%s' at line #%d
55+7.11:Warning: Invalid 'DIR' directive found at line #%d
56+7.15:ERROR: custom dir '%s' is not a valid absolute path!
57+7.16:ERROR: custom dir '%s' is a reserved name!
58+
59+#### Unziping package ####
60+
61+8.1:unknown zip sig: 0x%08lx
62+8.2:ERROR: Package contains a file compressed with an unsupported method (%d):
63+8.3:ERROR: failed extracting '%s' to '%s'!
64+
65+#### Handling the local list of installed packages ####
66+
67+9.0:ERROR: Could not access directory %s
68+9.1:ERROR: Local package '%s' not found
69+
70+#### unzip ####
71+
72+10.0:OK
73+10.1:ERROR: Failed to open the archive file
74+10.2:ERROR: Invalid ZIP archive
75+10.3:ERROR: File already exists
76+10.4:ERROR: unzip failure (%d)
--- pkg/tags/20220203/nls_utf8/pkg_fr.txt (nonexistent)
+++ pkg/tags/20220203/nls_utf8/pkg_fr.txt (revision 615)
@@ -0,0 +1,68 @@
1+#
2+# FDNPKG language file
3+#
4+# Language..: French
5+# Translator: anonymous
6+#
7+
8+#### Help ####
9+
10+1.0:PKG est le gestionnaire de paquets de SvarDOS.
11+1.20:Usage: pkg install package.zip
12+1.21: pkg update package.zip
13+1.22: pkg remove package
14+1.23: pkg listfiles package
15+1.24: pkg listlocal [filter]
16+1.27: pkg unzip fichier.zip
17+1.25:PKG est publié sous license MIT.
18+1.26:Cet outil est configurable via %DOSDIR%\CFG\PKG.CFG
19+
20+### General stuff ####
21+
22+2.2:%DOSDIR% non défini! Faites-le pointer vers le répertoire principal de SvarDOS.
23+2.3:Exemple : SET DOSDIR=C:\SVARDOS
24+2.14:Mémoire insuffisante! (%s)
25+
26+#### Installing package ####
27+
28+3.8:ERREUR: archive zip invalide! Le paquet n'a pas été installé.
29+3.9:ERREUR: le paquet contient un fichier qui existe déjà localement:
30+3.10:ERREUR: impossible de créer %s!
31+3.12:ERREUR: le paquet ne contient pas de fichier %s! Ce n'est pas un paquet SvarDOS valide.
32+3.18:Le paquet %s est déjà installé! Utilisez plutôt l'action "update".
33+3.19:Le paquet %s a été installé: %d fichiers extraits, %d erreurs.
34+3.20:ERREUR: le paquet contient un fichier crypté:
35+3.23:ERREUR: le paquet contient un nom de fichier invalide:
36+3.24:ERREUR: nom du paquet trop long
37+
38+#### Removing package ####
39+
40+4.0:Le paquet %s n'est pas installé, il n'a donc pas été supprimé.
41+4.3:Mémoire insuffisante! Impossible de mémoriser le répertoire %s!
42+4.4:effacement en cours: %s
43+4.5:Le paquet %s a été supprimé.
44+
45+#### Searching package ####
46+
47+5.0:Aucun paquet ne correspond à la recherche.
48+
49+#### Loading configuration ####
50+
51+7.0:ERREUR: le répertoire personalisé "%s" est listé deux fois!
52+7.1:ERREUR: échec de l'ouverture du fichier de configuration "%s"!
53+7.4:Attention: jeton avec une valeur vide sur la ligne #%d
54+7.8:Attention: jeton "%s" inconnu à la ligne #%d
55+7.11:Attention: directive "DIR" invalide trouvée à la ligne #%d
56+7.15:ERREUR: le répertoire personnalisé "%s" n'est pas un chemin absolu valide!
57+7.16:ERREUR: le répertoire personnalisé "%s" est un nom réservé!
58+
59+#### Unziping package ####
60+
61+8.1:signature zip inconnue: 0x%08lx
62+8.2:ERREUR: le paquet utilise une méthode de compression non supportée (%d):
63+8.3:ERREUR: échec lors de l'extraction de "%s" vers "%s"!
64+
65+#### Handling the local list of installed packages ####
66+
67+9.0:ERREUR: échec de l'accès au répertoire "%s"
68+9.1:ERREUR: le paquet local %s n'a pas été trouvé
--- pkg/tags/20220203/nls_utf8/pkg_pl.txt (nonexistent)
+++ pkg/tags/20220203/nls_utf8/pkg_pl.txt (revision 615)
@@ -0,0 +1,76 @@
1+#
2+# PKG language file
3+#
4+# Language..: Polish
5+# Translator: Mateusz Viste
6+#
7+
8+#### Help ####
9+
10+1.0:Menadżer pakietów dla SvarDOS.
11+1.20:Użycie: pkg install pakiet.zip
12+1.21: pkg update pakiet.zip
13+1.22: pkg remove pakiet
14+1.23: pkg listfiles pakiet
15+1.24: pkg listlocal [filtr]
16+1.27: pkg unzip plik.zip
17+1.25:PKG jest opublikowany na licencji MIT.
18+1.26:Konfiguracja znajduje się w pliku %DOSDIR%\CFG\PKG.CFG
19+
20+### General stuff ####
21+
22+2.2:%DOSDIR% nie ustawione! Ustaw by wskazywało na katalog instalacji SvarDOS.
23+2.3:Przykład: SET DOSDIR=C:\SVARDOS
24+2.14:Brak pamięci! (%s)
25+
26+#### Installing package ####
27+
28+3.8:BŁĄD: Nieprawidłowe archiwum zip! Pakiet nie został zainstalowany.
29+3.9:BŁĄD: Pakiet zawiera plik który już istnieje lokalnie:
30+3.10:BŁĄD: Nie udało się stworzyć %s!
31+3.12:BŁĄD: Pakiet nie zawiera pliku %s! Nieprawidłowy pakiet SvarDOS.
32+3.18:Pakiet %s jest już zainstalowany! Zobacz akcję 'update'.
33+3.19:Pakiet %s został zainstalowany: rozpakowano %d plików, %d błędów.
34+3.20:BŁĄD: Pakiet zawiera zaszyfrowany plik:
35+3.23:BŁĄD: Pakiet zawiera plik o nieprawidłowej nazwie:
36+3.24:BŁĄD: Zbyt długa nazwa pakietu
37+
38+#### Removing package ####
39+
40+4.0:Pakiet %s nie jest zainstalowany, więc nie wykasowany.
41+4.3:Brak pamięci! Nie zapamiętano katalogu %s!
42+4.4:usuwanie %s
43+4.5:Pakiet %s został usunięty.
44+
45+#### Searching package ####
46+
47+5.0:Żaden pakiet nie pasuje do wyszukiwania.
48+
49+#### Loading configuration ####
50+
51+7.0:BŁĄD: repozytorium '%s' jest skonfigurowane dwa razy!
52+7.1:BŁĄD: nie zdołano otworzyć pliku konfiguracyjnego '%s'!
53+7.4:Uwaga: token z pustą wartością w linii #%d
54+7.8:Uwaga: Nieznany token '%s' w linii #%d
55+7.11:Uwaga: Nieprawidłowe polecenie 'DIR' w linii #%d
56+7.15:BŁĄD: katalog specjalny '%s' nie jest prawidłową ścieżką!
57+7.16:BŁĄD: katalog specjalny '%s' jest zarezerwowaną nazwą!
58+
59+#### Unziping package ####
60+
61+8.1:nieznana sygnatura zip: 0x%08lx
62+8.2:BŁĄD: Pakiet zawiera plik skompresowany nieznaną metodę (%d):
63+8.3:BŁĄD: rozpakowanie '%s' do '%s' nie powiodło się!
64+
65+#### Handling the local list of installed packages ####
66+
67+9.0:BŁĄD: Dostęp do katalogu %s nie powiódł się.
68+9.1:BŁĄD: Nie znaleziono lokalnego pakietu %s.
69+
70+#### unzip ####
71+
72+10.0:OK
73+10.1:BŁĄD: Otwarcie pliku archiwum nie powiodło się
74+10.2:BŁĄD: Nieprawidłowe archiwum ZIP
75+10.3:BŁĄD: Plik już istnieje
76+10.4:BŁĄD: błąd unzip (%d)
--- pkg/tags/20220203/nls_utf8/pkg_si.txt (nonexistent)
+++ pkg/tags/20220203/nls_utf8/pkg_si.txt (revision 615)
@@ -0,0 +1,68 @@
1+#
2+# PKG language file
3+#
4+# Language..: Slovene
5+# Translator: Matej Horvat (http://matejhorvat.si/)
6+# Updated...: 2016-12-12
7+
8+#### Help ####
9+
10+1.0:To je upravitelj paketov za SvarDOS.
11+1.20:Usage: pkg install package.zip
12+1.21: pkg update package.zip
13+1.22: pkg remove package
14+1.23: pkg listfiles package
15+1.24: pkg listlocal [filter]
16+1.27: pkg unzip file.zip
17+1.25:PKG is published under the MIT license.
18+1.26:It is configured through %DOSDIR%\CFG\PKG.CFG
19+
20+### General stuff ####
21+
22+2.0:Spremenljivka TEMP ni nastavljena! Kaže naj na imenik, kamor se da pisati.
23+2.3:Primer: SET DOSDIR=C:\SVARDOS
24+2.14:Ni dovolj spomina! (%s)
25+
26+#### Installing package ####
27+
28+3.8:NAPAKA: Neveljavna ZIP datoteka! Paketa ni mogoče namestiti.
29+3.9:NAPAKA: Paket vsebuje datoteko, ki že obstaja na tem računalniku:
30+3.10:NAPAKA: Ni mogoče ustvariti %s.
31+3.12:NAPAKA: Paket ne vsebuje datoteke %s; to ni veljaven FreeDOS paket.
32+3.18:Paket %s je že nameščen! Morda želite uporabiti dejavnost UPDATE.
33+3.19:Paket %s nameščen: %d datotek razširjenih, %d napak.
34+3.20:NAPAKA: paket vsebuje šifrirano datoteko:
35+3.23:NAPAKA: paket vsebuje neveljavno ime datoteke:
36+3.24:NAPAKA: package name too long
37+
38+#### Removing package ####
39+
40+4.0:Paket %s ni nameščen, zato ga ni mogoče odstraniti.
41+4.3:Ni dovolj spomina. Ni mogoče shraniti imenika %s!
42+4.4:odstranjujem %s
43+4.5:Paket %s odstranjen.
44+
45+#### Searching package ####
46+
47+5.0:Noben paket ne ustreza iskalnim zahtevam.
48+
49+#### Loading configuration ####
50+
51+7.0:NAPAKA: Zbirka %s je našteta dvakrat!
52+7.1:NAPAKA: Ni mogoče odpreti nastavitvene datoteke %s.
53+7.4:Warning: token with empty value on line #%d
54+7.8:Opozorilo: neznan ukaz "%s" v vrstici %d
55+7.11:Opozorilo: Neveljaven ukaz DIR v vrstici %d.
56+7.15:NAPAKA: custom dir '%s' is not a valid absolute path!
57+7.16:NAPAKA: custom dir '%s' is a reserved name!
58+
59+#### Unziping package ####
60+
61+8.1:Neznana vrsta datoteke ZIP: 0x%08x
62+8.2:NAPAKA: Paket vsebuje datoteko, ki je stisnjena z nepodprto metodo (%d):
63+8.3:NAPAKA med razširjanjem %s v %s!
64+
65+#### Handling the local list of installed packages ####
66+
67+9.0:NAPAKA: Dostop do imenika %s ni mogoč
68+9.1:NAPAKA: Ni mogoče najti lokalnega paketa %s
--- pkg/tags/20220203/nls_utf8/pkg_tr.txt (nonexistent)
+++ pkg/tags/20220203/nls_utf8/pkg_tr.txt (revision 615)
@@ -0,0 +1,68 @@
1+#
2+# FDNPKG language file
3+#
4+# Language..: Turkish
5+# Translator: anonymous
6+#
7+
8+#### Help ####
9+
10+1.0:Bu, SvarDOS için ağ tabanlı bir paket yöneticisidir.
11+1.20:Usage: pkg install package.zip
12+1.21: pkg update package.zip
13+1.22: pkg remove package
14+1.23: pkg listfiles package
15+1.24: pkg listlocal [filter]
16+1.27: pkg unzip file.zip
17+1.25:PKG is published under the MIT license.
18+1.26:It is configured through %DOSDIR%\CFG\PKG.CFG
19+
20+### General stuff ####
21+
22+2.2:%DOSDIR% ayarlanmamış! Onun SvarDOS ana dizinine işaret etmesi gerekir.
23+2.3:Örnek: SET DOSDIR=C:\SVARDOS
24+2.14:Bellek yetersiz! (%s)
25+
26+#### Installing package ####
27+
28+3.8:HATA: Geçersiz zip arşivi! Paket kurulmadı.
29+3.9:HATA: Paket zaten yerel olarak mevcut olan bir dosya içeriyor:
30+3.10:HATA: %s oluşturulamadı %s!
31+3.12:HATA: Paket %s dosyasını içermiyor! Geçerli bir SvarDOS paketi değil.
32+3.18:%s paketi zaten kuruludur! Güncelleme eylemini yapabilirsiniz.
33+3.19:%s paketi kuruldu: %d dosya çıkarıldı, %d hata.
34+3.20:HATA: paket şifreli bir dosya içermektedir:
35+3.23:HATA: paket geçersiz bir dosya ismi içermektedir:
36+3.24:HATA: package name too long
37+
38+#### Removing package ####
39+
40+4.0:%s paketi kurulu değildir, dolayısıyla kaldırılmamıştır.
41+4.3:Yetersiz bellek! %s dizini kaydedilemedi!
42+4.4:%s kaldırılıyor
43+4.5:%s paketi kaldırıldı.
44+
45+#### Searching package ####
46+
47+5.0:Hiçbir paket aramayla eşleşmedi.
48+
49+#### Loading configuration ####
50+
51+7.0:HATA: '%s' deposu iki kez listelenmiş!
52+7.1:HATA: '%s' yapılandırma dosyası açılamadı!
53+7.4:İkaz: #%d satırında boş değerli bir belirteç
54+7.8:İkaz: #%d satırında bilinmeyen '%s' belirteci
55+7.11:İkaz: #%d satırında geçersiz 'DIR' yönergesi bulundu
56+7.15:HATA: özel dizin '%s' geçerli bir mutlak yol değildir!
57+7.16:HATA: özel dizin '%s' ayrılmış bir isimdir!
58+
59+#### Unziping package ####
60+
61+8.1:bilinmeyen zip imzası: 0x%08lx
62+8.2:HATA: Paket desteklenmeyen metotla sıkıştırılmış dosya içeriyor (%d):
63+8.3:'%s' unsurunun to '%s' konumuna çıkarılması sırasında hata!
64+
65+#### Handling the local list of installed packages ####
66+
67+9.0:Hata: %s dizinine erişilemedi.
68+9.1:Hata: %s yerel paketi bulunamadı.
--- pkg/tags/20220203/zlib/readme.txt (nonexistent)
+++ pkg/tags/20220203/zlib/readme.txt (revision 615)
@@ -0,0 +1,5 @@
1+This directory contains the zlib v1.2.8 library, precompiled with Open Watcom
2+ver 1.9, for compact and large models.
3+
4+Compiled with the -DNO_GZIP and -DNOBYFOUR definitions, to save a few
5+kilobytes of unnecessary bloat.
--- pkg/tags/20220203/zlib/zconf.h (nonexistent)
+++ pkg/tags/20220203/zlib/zconf.h (revision 615)
@@ -0,0 +1,511 @@
1+/* zconf.h -- configuration of the zlib compression library
2+ * Copyright (C) 1995-2013 Jean-loup Gailly.
3+ * For conditions of distribution and use, see copyright notice in zlib.h
4+ */
5+
6+/* @(#) $Id$ */
7+
8+#ifndef ZCONF_H
9+#define ZCONF_H
10+
11+/*
12+ * If you *really* need a unique prefix for all types and library functions,
13+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
14+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
15+ * this permanently in zconf.h using "./configure --zprefix".
16+ */
17+#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
18+# define Z_PREFIX_SET
19+
20+/* all linked symbols */
21+# define _dist_code z__dist_code
22+# define _length_code z__length_code
23+# define _tr_align z__tr_align
24+# define _tr_flush_bits z__tr_flush_bits
25+# define _tr_flush_block z__tr_flush_block
26+# define _tr_init z__tr_init
27+# define _tr_stored_block z__tr_stored_block
28+# define _tr_tally z__tr_tally
29+# define adler32 z_adler32
30+# define adler32_combine z_adler32_combine
31+# define adler32_combine64 z_adler32_combine64
32+# ifndef Z_SOLO
33+# define compress z_compress
34+# define compress2 z_compress2
35+# define compressBound z_compressBound
36+# endif
37+# define crc32 z_crc32
38+# define crc32_combine z_crc32_combine
39+# define crc32_combine64 z_crc32_combine64
40+# define deflate z_deflate
41+# define deflateBound z_deflateBound
42+# define deflateCopy z_deflateCopy
43+# define deflateEnd z_deflateEnd
44+# define deflateInit2_ z_deflateInit2_
45+# define deflateInit_ z_deflateInit_
46+# define deflateParams z_deflateParams
47+# define deflatePending z_deflatePending
48+# define deflatePrime z_deflatePrime
49+# define deflateReset z_deflateReset
50+# define deflateResetKeep z_deflateResetKeep
51+# define deflateSetDictionary z_deflateSetDictionary
52+# define deflateSetHeader z_deflateSetHeader
53+# define deflateTune z_deflateTune
54+# define deflate_copyright z_deflate_copyright
55+# define get_crc_table z_get_crc_table
56+# ifndef Z_SOLO
57+# define gz_error z_gz_error
58+# define gz_intmax z_gz_intmax
59+# define gz_strwinerror z_gz_strwinerror
60+# define gzbuffer z_gzbuffer
61+# define gzclearerr z_gzclearerr
62+# define gzclose z_gzclose
63+# define gzclose_r z_gzclose_r
64+# define gzclose_w z_gzclose_w
65+# define gzdirect z_gzdirect
66+# define gzdopen z_gzdopen
67+# define gzeof z_gzeof
68+# define gzerror z_gzerror
69+# define gzflush z_gzflush
70+# define gzgetc z_gzgetc
71+# define gzgetc_ z_gzgetc_
72+# define gzgets z_gzgets
73+# define gzoffset z_gzoffset
74+# define gzoffset64 z_gzoffset64
75+# define gzopen z_gzopen
76+# define gzopen64 z_gzopen64
77+# ifdef _WIN32
78+# define gzopen_w z_gzopen_w
79+# endif
80+# define gzprintf z_gzprintf
81+# define gzvprintf z_gzvprintf
82+# define gzputc z_gzputc
83+# define gzputs z_gzputs
84+# define gzread z_gzread
85+# define gzrewind z_gzrewind
86+# define gzseek z_gzseek
87+# define gzseek64 z_gzseek64
88+# define gzsetparams z_gzsetparams
89+# define gztell z_gztell
90+# define gztell64 z_gztell64
91+# define gzungetc z_gzungetc
92+# define gzwrite z_gzwrite
93+# endif
94+# define inflate z_inflate
95+# define inflateBack z_inflateBack
96+# define inflateBackEnd z_inflateBackEnd
97+# define inflateBackInit_ z_inflateBackInit_
98+# define inflateCopy z_inflateCopy
99+# define inflateEnd z_inflateEnd
100+# define inflateGetHeader z_inflateGetHeader
101+# define inflateInit2_ z_inflateInit2_
102+# define inflateInit_ z_inflateInit_
103+# define inflateMark z_inflateMark
104+# define inflatePrime z_inflatePrime
105+# define inflateReset z_inflateReset
106+# define inflateReset2 z_inflateReset2
107+# define inflateSetDictionary z_inflateSetDictionary
108+# define inflateGetDictionary z_inflateGetDictionary
109+# define inflateSync z_inflateSync
110+# define inflateSyncPoint z_inflateSyncPoint
111+# define inflateUndermine z_inflateUndermine
112+# define inflateResetKeep z_inflateResetKeep
113+# define inflate_copyright z_inflate_copyright
114+# define inflate_fast z_inflate_fast
115+# define inflate_table z_inflate_table
116+# ifndef Z_SOLO
117+# define uncompress z_uncompress
118+# endif
119+# define zError z_zError
120+# ifndef Z_SOLO
121+# define zcalloc z_zcalloc
122+# define zcfree z_zcfree
123+# endif
124+# define zlibCompileFlags z_zlibCompileFlags
125+# define zlibVersion z_zlibVersion
126+
127+/* all zlib typedefs in zlib.h and zconf.h */
128+# define Byte z_Byte
129+# define Bytef z_Bytef
130+# define alloc_func z_alloc_func
131+# define charf z_charf
132+# define free_func z_free_func
133+# ifndef Z_SOLO
134+# define gzFile z_gzFile
135+# endif
136+# define gz_header z_gz_header
137+# define gz_headerp z_gz_headerp
138+# define in_func z_in_func
139+# define intf z_intf
140+# define out_func z_out_func
141+# define uInt z_uInt
142+# define uIntf z_uIntf
143+# define uLong z_uLong
144+# define uLongf z_uLongf
145+# define voidp z_voidp
146+# define voidpc z_voidpc
147+# define voidpf z_voidpf
148+
149+/* all zlib structs in zlib.h and zconf.h */
150+# define gz_header_s z_gz_header_s
151+# define internal_state z_internal_state
152+
153+#endif
154+
155+#if defined(__MSDOS__) && !defined(MSDOS)
156+# define MSDOS
157+#endif
158+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
159+# define OS2
160+#endif
161+#if defined(_WINDOWS) && !defined(WINDOWS)
162+# define WINDOWS
163+#endif
164+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
165+# ifndef WIN32
166+# define WIN32
167+# endif
168+#endif
169+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
170+# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
171+# ifndef SYS16BIT
172+# define SYS16BIT
173+# endif
174+# endif
175+#endif
176+
177+/*
178+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
179+ * than 64k bytes at a time (needed on systems with 16-bit int).
180+ */
181+#ifdef SYS16BIT
182+# define MAXSEG_64K
183+#endif
184+#ifdef MSDOS
185+# define UNALIGNED_OK
186+#endif
187+
188+#ifdef __STDC_VERSION__
189+# ifndef STDC
190+# define STDC
191+# endif
192+# if __STDC_VERSION__ >= 199901L
193+# ifndef STDC99
194+# define STDC99
195+# endif
196+# endif
197+#endif
198+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
199+# define STDC
200+#endif
201+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
202+# define STDC
203+#endif
204+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
205+# define STDC
206+#endif
207+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
208+# define STDC
209+#endif
210+
211+#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
212+# define STDC
213+#endif
214+
215+#ifndef STDC
216+# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
217+# define const /* note: need a more gentle solution here */
218+# endif
219+#endif
220+
221+#if defined(ZLIB_CONST) && !defined(z_const)
222+# define z_const const
223+#else
224+# define z_const
225+#endif
226+
227+/* Some Mac compilers merge all .h files incorrectly: */
228+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
229+# define NO_DUMMY_DECL
230+#endif
231+
232+/* Maximum value for memLevel in deflateInit2 */
233+#ifndef MAX_MEM_LEVEL
234+# ifdef MAXSEG_64K
235+# define MAX_MEM_LEVEL 8
236+# else
237+# define MAX_MEM_LEVEL 9
238+# endif
239+#endif
240+
241+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
242+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
243+ * created by gzip. (Files created by minigzip can still be extracted by
244+ * gzip.)
245+ */
246+#ifndef MAX_WBITS
247+# define MAX_WBITS 15 /* 32K LZ77 window */
248+#endif
249+
250+/* The memory requirements for deflate are (in bytes):
251+ (1 << (windowBits+2)) + (1 << (memLevel+9))
252+ that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
253+ plus a few kilobytes for small objects. For example, if you want to reduce
254+ the default memory requirements from 256K to 128K, compile with
255+ make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
256+ Of course this will generally degrade compression (there's no free lunch).
257+
258+ The memory requirements for inflate are (in bytes) 1 << windowBits
259+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
260+ for small objects.
261+*/
262+
263+ /* Type declarations */
264+
265+#ifndef OF /* function prototypes */
266+# ifdef STDC
267+# define OF(args) args
268+# else
269+# define OF(args) ()
270+# endif
271+#endif
272+
273+#ifndef Z_ARG /* function prototypes for stdarg */
274+# if defined(STDC) || defined(Z_HAVE_STDARG_H)
275+# define Z_ARG(args) args
276+# else
277+# define Z_ARG(args) ()
278+# endif
279+#endif
280+
281+/* The following definitions for FAR are needed only for MSDOS mixed
282+ * model programming (small or medium model with some far allocations).
283+ * This was tested only with MSC; for other MSDOS compilers you may have
284+ * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
285+ * just define FAR to be empty.
286+ */
287+#ifdef SYS16BIT
288+# if defined(M_I86SM) || defined(M_I86MM)
289+ /* MSC small or medium model */
290+# define SMALL_MEDIUM
291+# ifdef _MSC_VER
292+# define FAR _far
293+# else
294+# define FAR far
295+# endif
296+# endif
297+# if (defined(__SMALL__) || defined(__MEDIUM__))
298+ /* Turbo C small or medium model */
299+# define SMALL_MEDIUM
300+# ifdef __BORLANDC__
301+# define FAR _far
302+# else
303+# define FAR far
304+# endif
305+# endif
306+#endif
307+
308+#if defined(WINDOWS) || defined(WIN32)
309+ /* If building or using zlib as a DLL, define ZLIB_DLL.
310+ * This is not mandatory, but it offers a little performance increase.
311+ */
312+# ifdef ZLIB_DLL
313+# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
314+# ifdef ZLIB_INTERNAL
315+# define ZEXTERN extern __declspec(dllexport)
316+# else
317+# define ZEXTERN extern __declspec(dllimport)
318+# endif
319+# endif
320+# endif /* ZLIB_DLL */
321+ /* If building or using zlib with the WINAPI/WINAPIV calling convention,
322+ * define ZLIB_WINAPI.
323+ * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
324+ */
325+# ifdef ZLIB_WINAPI
326+# ifdef FAR
327+# undef FAR
328+# endif
329+# include <windows.h>
330+ /* No need for _export, use ZLIB.DEF instead. */
331+ /* For complete Windows compatibility, use WINAPI, not __stdcall. */
332+# define ZEXPORT WINAPI
333+# ifdef WIN32
334+# define ZEXPORTVA WINAPIV
335+# else
336+# define ZEXPORTVA FAR CDECL
337+# endif
338+# endif
339+#endif
340+
341+#if defined (__BEOS__)
342+# ifdef ZLIB_DLL
343+# ifdef ZLIB_INTERNAL
344+# define ZEXPORT __declspec(dllexport)
345+# define ZEXPORTVA __declspec(dllexport)
346+# else
347+# define ZEXPORT __declspec(dllimport)
348+# define ZEXPORTVA __declspec(dllimport)
349+# endif
350+# endif
351+#endif
352+
353+#ifndef ZEXTERN
354+# define ZEXTERN extern
355+#endif
356+#ifndef ZEXPORT
357+# define ZEXPORT
358+#endif
359+#ifndef ZEXPORTVA
360+# define ZEXPORTVA
361+#endif
362+
363+#ifndef FAR
364+# define FAR
365+#endif
366+
367+#if !defined(__MACTYPES__)
368+typedef unsigned char Byte; /* 8 bits */
369+#endif
370+typedef unsigned int uInt; /* 16 bits or more */
371+typedef unsigned long uLong; /* 32 bits or more */
372+
373+#ifdef SMALL_MEDIUM
374+ /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
375+# define Bytef Byte FAR
376+#else
377+ typedef Byte FAR Bytef;
378+#endif
379+typedef char FAR charf;
380+typedef int FAR intf;
381+typedef uInt FAR uIntf;
382+typedef uLong FAR uLongf;
383+
384+#ifdef STDC
385+ typedef void const *voidpc;
386+ typedef void FAR *voidpf;
387+ typedef void *voidp;
388+#else
389+ typedef Byte const *voidpc;
390+ typedef Byte FAR *voidpf;
391+ typedef Byte *voidp;
392+#endif
393+
394+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
395+# include <limits.h>
396+# if (UINT_MAX == 0xffffffffUL)
397+# define Z_U4 unsigned
398+# elif (ULONG_MAX == 0xffffffffUL)
399+# define Z_U4 unsigned long
400+# elif (USHRT_MAX == 0xffffffffUL)
401+# define Z_U4 unsigned short
402+# endif
403+#endif
404+
405+#ifdef Z_U4
406+ typedef Z_U4 z_crc_t;
407+#else
408+ typedef unsigned long z_crc_t;
409+#endif
410+
411+#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
412+# define Z_HAVE_UNISTD_H
413+#endif
414+
415+#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */
416+# define Z_HAVE_STDARG_H
417+#endif
418+
419+#ifdef STDC
420+# ifndef Z_SOLO
421+# include <sys/types.h> /* for off_t */
422+# endif
423+#endif
424+
425+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
426+# ifndef Z_SOLO
427+# include <stdarg.h> /* for va_list */
428+# endif
429+#endif
430+
431+#ifdef _WIN32
432+# ifndef Z_SOLO
433+# include <stddef.h> /* for wchar_t */
434+# endif
435+#endif
436+
437+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
438+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
439+ * though the former does not conform to the LFS document), but considering
440+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
441+ * equivalently requesting no 64-bit operations
442+ */
443+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
444+# undef _LARGEFILE64_SOURCE
445+#endif
446+
447+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
448+# define Z_HAVE_UNISTD_H
449+#endif
450+#ifndef Z_SOLO
451+# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
452+# include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
453+# ifdef VMS
454+# include <unixio.h> /* for off_t */
455+# endif
456+# ifndef z_off_t
457+# define z_off_t off_t
458+# endif
459+# endif
460+#endif
461+
462+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
463+# define Z_LFS64
464+#endif
465+
466+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
467+# define Z_LARGE64
468+#endif
469+
470+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
471+# define Z_WANT64
472+#endif
473+
474+#if !defined(SEEK_SET) && !defined(Z_SOLO)
475+# define SEEK_SET 0 /* Seek from beginning of file. */
476+# define SEEK_CUR 1 /* Seek from current position. */
477+# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
478+#endif
479+
480+#ifndef z_off_t
481+# define z_off_t long
482+#endif
483+
484+#if !defined(_WIN32) && defined(Z_LARGE64)
485+# define z_off64_t off64_t
486+#else
487+# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
488+# define z_off64_t __int64
489+# else
490+# define z_off64_t z_off_t
491+# endif
492+#endif
493+
494+/* MVS linker does not support external names larger than 8 bytes */
495+#if defined(__MVS__)
496+ #pragma map(deflateInit_,"DEIN")
497+ #pragma map(deflateInit2_,"DEIN2")
498+ #pragma map(deflateEnd,"DEEND")
499+ #pragma map(deflateBound,"DEBND")
500+ #pragma map(inflateInit_,"ININ")
501+ #pragma map(inflateInit2_,"ININ2")
502+ #pragma map(inflateEnd,"INEND")
503+ #pragma map(inflateSync,"INSY")
504+ #pragma map(inflateSetDictionary,"INSEDI")
505+ #pragma map(compressBound,"CMBND")
506+ #pragma map(inflate_table,"INTABL")
507+ #pragma map(inflate_fast,"INFA")
508+ #pragma map(inflate_copyright,"INCOPY")
509+#endif
510+
511+#endif /* ZCONF_H */
--- pkg/tags/20220203/zlib/zlib.h (nonexistent)
+++ pkg/tags/20220203/zlib/zlib.h (revision 615)
@@ -0,0 +1,1768 @@
1+/* zlib.h -- interface of the 'zlib' general purpose compression library
2+ version 1.2.8, April 28th, 2013
3+
4+ Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
5+
6+ This software is provided 'as-is', without any express or implied
7+ warranty. In no event will the authors be held liable for any damages
8+ arising from the use of this software.
9+
10+ Permission is granted to anyone to use this software for any purpose,
11+ including commercial applications, and to alter it and redistribute it
12+ freely, subject to the following restrictions:
13+
14+ 1. The origin of this software must not be misrepresented; you must not
15+ claim that you wrote the original software. If you use this software
16+ in a product, an acknowledgment in the product documentation would be
17+ appreciated but is not required.
18+ 2. Altered source versions must be plainly marked as such, and must not be
19+ misrepresented as being the original software.
20+ 3. This notice may not be removed or altered from any source distribution.
21+
22+ Jean-loup Gailly Mark Adler
23+ jloup@gzip.org madler@alumni.caltech.edu
24+
25+
26+ The data format used by the zlib library is described by RFCs (Request for
27+ Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
28+ (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
29+*/
30+
31+#ifndef ZLIB_H
32+#define ZLIB_H
33+
34+#include "zconf.h"
35+
36+#ifdef __cplusplus
37+extern "C" {
38+#endif
39+
40+#define ZLIB_VERSION "1.2.8"
41+#define ZLIB_VERNUM 0x1280
42+#define ZLIB_VER_MAJOR 1
43+#define ZLIB_VER_MINOR 2
44+#define ZLIB_VER_REVISION 8
45+#define ZLIB_VER_SUBREVISION 0
46+
47+/*
48+ The 'zlib' compression library provides in-memory compression and
49+ decompression functions, including integrity checks of the uncompressed data.
50+ This version of the library supports only one compression method (deflation)
51+ but other algorithms will be added later and will have the same stream
52+ interface.
53+
54+ Compression can be done in a single step if the buffers are large enough,
55+ or can be done by repeated calls of the compression function. In the latter
56+ case, the application must provide more input and/or consume the output
57+ (providing more output space) before each call.
58+
59+ The compressed data format used by default by the in-memory functions is
60+ the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
61+ around a deflate stream, which is itself documented in RFC 1951.
62+
63+ The library also supports reading and writing files in gzip (.gz) format
64+ with an interface similar to that of stdio using the functions that start
65+ with "gz". The gzip format is different from the zlib format. gzip is a
66+ gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
67+
68+ This library can optionally read and write gzip streams in memory as well.
69+
70+ The zlib format was designed to be compact and fast for use in memory
71+ and on communications channels. The gzip format was designed for single-
72+ file compression on file systems, has a larger header than zlib to maintain
73+ directory information, and uses a different, slower check method than zlib.
74+
75+ The library does not install any signal handler. The decoder checks
76+ the consistency of the compressed data, so the library should never crash
77+ even in case of corrupted input.
78+*/
79+
80+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
81+typedef void (*free_func) OF((voidpf opaque, voidpf address));
82+
83+struct internal_state;
84+
85+typedef struct z_stream_s {
86+ z_const Bytef *next_in; /* next input byte */
87+ uInt avail_in; /* number of bytes available at next_in */
88+ uLong total_in; /* total number of input bytes read so far */
89+
90+ Bytef *next_out; /* next output byte should be put there */
91+ uInt avail_out; /* remaining free space at next_out */
92+ uLong total_out; /* total number of bytes output so far */
93+
94+ z_const char *msg; /* last error message, NULL if no error */
95+ struct internal_state FAR *state; /* not visible by applications */
96+
97+ alloc_func zalloc; /* used to allocate the internal state */
98+ free_func zfree; /* used to free the internal state */
99+ voidpf opaque; /* private data object passed to zalloc and zfree */
100+
101+ int data_type; /* best guess about the data type: binary or text */
102+ uLong adler; /* adler32 value of the uncompressed data */
103+ uLong reserved; /* reserved for future use */
104+} z_stream;
105+
106+typedef z_stream FAR *z_streamp;
107+
108+/*
109+ gzip header information passed to and from zlib routines. See RFC 1952
110+ for more details on the meanings of these fields.
111+*/
112+typedef struct gz_header_s {
113+ int text; /* true if compressed data believed to be text */
114+ uLong time; /* modification time */
115+ int xflags; /* extra flags (not used when writing a gzip file) */
116+ int os; /* operating system */
117+ Bytef *extra; /* pointer to extra field or Z_NULL if none */
118+ uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
119+ uInt extra_max; /* space at extra (only when reading header) */
120+ Bytef *name; /* pointer to zero-terminated file name or Z_NULL */
121+ uInt name_max; /* space at name (only when reading header) */
122+ Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */
123+ uInt comm_max; /* space at comment (only when reading header) */
124+ int hcrc; /* true if there was or will be a header crc */
125+ int done; /* true when done reading gzip header (not used
126+ when writing a gzip file) */
127+} gz_header;
128+
129+typedef gz_header FAR *gz_headerp;
130+
131+/*
132+ The application must update next_in and avail_in when avail_in has dropped
133+ to zero. It must update next_out and avail_out when avail_out has dropped
134+ to zero. The application must initialize zalloc, zfree and opaque before
135+ calling the init function. All other fields are set by the compression
136+ library and must not be updated by the application.
137+
138+ The opaque value provided by the application will be passed as the first
139+ parameter for calls of zalloc and zfree. This can be useful for custom
140+ memory management. The compression library attaches no meaning to the
141+ opaque value.
142+
143+ zalloc must return Z_NULL if there is not enough memory for the object.
144+ If zlib is used in a multi-threaded application, zalloc and zfree must be
145+ thread safe.
146+
147+ On 16-bit systems, the functions zalloc and zfree must be able to allocate
148+ exactly 65536 bytes, but will not be required to allocate more than this if
149+ the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers
150+ returned by zalloc for objects of exactly 65536 bytes *must* have their
151+ offset normalized to zero. The default allocation function provided by this
152+ library ensures this (see zutil.c). To reduce memory requirements and avoid
153+ any allocation of 64K objects, at the expense of compression ratio, compile
154+ the library with -DMAX_WBITS=14 (see zconf.h).
155+
156+ The fields total_in and total_out can be used for statistics or progress
157+ reports. After compression, total_in holds the total size of the
158+ uncompressed data and may be saved for use in the decompressor (particularly
159+ if the decompressor wants to decompress everything in a single step).
160+*/
161+
162+ /* constants */
163+
164+#define Z_NO_FLUSH 0
165+#define Z_PARTIAL_FLUSH 1
166+#define Z_SYNC_FLUSH 2
167+#define Z_FULL_FLUSH 3
168+#define Z_FINISH 4
169+#define Z_BLOCK 5
170+#define Z_TREES 6
171+/* Allowed flush values; see deflate() and inflate() below for details */
172+
173+#define Z_OK 0
174+#define Z_STREAM_END 1
175+#define Z_NEED_DICT 2
176+#define Z_ERRNO (-1)
177+#define Z_STREAM_ERROR (-2)
178+#define Z_DATA_ERROR (-3)
179+#define Z_MEM_ERROR (-4)
180+#define Z_BUF_ERROR (-5)
181+#define Z_VERSION_ERROR (-6)
182+/* Return codes for the compression/decompression functions. Negative values
183+ * are errors, positive values are used for special but normal events.
184+ */
185+
186+#define Z_NO_COMPRESSION 0
187+#define Z_BEST_SPEED 1
188+#define Z_BEST_COMPRESSION 9
189+#define Z_DEFAULT_COMPRESSION (-1)
190+/* compression levels */
191+
192+#define Z_FILTERED 1
193+#define Z_HUFFMAN_ONLY 2
194+#define Z_RLE 3
195+#define Z_FIXED 4
196+#define Z_DEFAULT_STRATEGY 0
197+/* compression strategy; see deflateInit2() below for details */
198+
199+#define Z_BINARY 0
200+#define Z_TEXT 1
201+#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
202+#define Z_UNKNOWN 2
203+/* Possible values of the data_type field (though see inflate()) */
204+
205+#define Z_DEFLATED 8
206+/* The deflate compression method (the only one supported in this version) */
207+
208+#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
209+
210+#define zlib_version zlibVersion()
211+/* for compatibility with versions < 1.0.2 */
212+
213+
214+ /* basic functions */
215+
216+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
217+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
218+ If the first character differs, the library code actually used is not
219+ compatible with the zlib.h header file used by the application. This check
220+ is automatically made by deflateInit and inflateInit.
221+ */
222+
223+/*
224+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
225+
226+ Initializes the internal stream state for compression. The fields
227+ zalloc, zfree and opaque must be initialized before by the caller. If
228+ zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
229+ allocation functions.
230+
231+ The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
232+ 1 gives best speed, 9 gives best compression, 0 gives no compression at all
233+ (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION
234+ requests a default compromise between speed and compression (currently
235+ equivalent to level 6).
236+
237+ deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
238+ memory, Z_STREAM_ERROR if level is not a valid compression level, or
239+ Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
240+ with the version assumed by the caller (ZLIB_VERSION). msg is set to null
241+ if there is no error message. deflateInit does not perform any compression:
242+ this will be done by deflate().
243+*/
244+
245+
246+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
247+/*
248+ deflate compresses as much data as possible, and stops when the input
249+ buffer becomes empty or the output buffer becomes full. It may introduce
250+ some output latency (reading input without producing any output) except when
251+ forced to flush.
252+
253+ The detailed semantics are as follows. deflate performs one or both of the
254+ following actions:
255+
256+ - Compress more input starting at next_in and update next_in and avail_in
257+ accordingly. If not all input can be processed (because there is not
258+ enough room in the output buffer), next_in and avail_in are updated and
259+ processing will resume at this point for the next call of deflate().
260+
261+ - Provide more output starting at next_out and update next_out and avail_out
262+ accordingly. This action is forced if the parameter flush is non zero.
263+ Forcing flush frequently degrades the compression ratio, so this parameter
264+ should be set only when necessary (in interactive applications). Some
265+ output may be provided even if flush is not set.
266+
267+ Before the call of deflate(), the application should ensure that at least
268+ one of the actions is possible, by providing more input and/or consuming more
269+ output, and updating avail_in or avail_out accordingly; avail_out should
270+ never be zero before the call. The application can consume the compressed
271+ output when it wants, for example when the output buffer is full (avail_out
272+ == 0), or after each call of deflate(). If deflate returns Z_OK and with
273+ zero avail_out, it must be called again after making room in the output
274+ buffer because there might be more output pending.
275+
276+ Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
277+ decide how much data to accumulate before producing output, in order to
278+ maximize compression.
279+
280+ If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
281+ flushed to the output buffer and the output is aligned on a byte boundary, so
282+ that the decompressor can get all input data available so far. (In
283+ particular avail_in is zero after the call if enough output space has been
284+ provided before the call.) Flushing may degrade compression for some
285+ compression algorithms and so it should be used only when necessary. This
286+ completes the current deflate block and follows it with an empty stored block
287+ that is three bits plus filler bits to the next byte, followed by four bytes
288+ (00 00 ff ff).
289+
290+ If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
291+ output buffer, but the output is not aligned to a byte boundary. All of the
292+ input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
293+ This completes the current deflate block and follows it with an empty fixed
294+ codes block that is 10 bits long. This assures that enough bytes are output
295+ in order for the decompressor to finish the block before the empty fixed code
296+ block.
297+
298+ If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
299+ for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
300+ seven bits of the current block are held to be written as the next byte after
301+ the next deflate block is completed. In this case, the decompressor may not
302+ be provided enough bits at this point in order to complete decompression of
303+ the data provided so far to the compressor. It may need to wait for the next
304+ block to be emitted. This is for advanced applications that need to control
305+ the emission of deflate blocks.
306+
307+ If flush is set to Z_FULL_FLUSH, all output is flushed as with
308+ Z_SYNC_FLUSH, and the compression state is reset so that decompression can
309+ restart from this point if previous compressed data has been damaged or if
310+ random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
311+ compression.
312+
313+ If deflate returns with avail_out == 0, this function must be called again
314+ with the same value of the flush parameter and more output space (updated
315+ avail_out), until the flush is complete (deflate returns with non-zero
316+ avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
317+ avail_out is greater than six to avoid repeated flush markers due to
318+ avail_out == 0 on return.
319+
320+ If the parameter flush is set to Z_FINISH, pending input is processed,
321+ pending output is flushed and deflate returns with Z_STREAM_END if there was
322+ enough output space; if deflate returns with Z_OK, this function must be
323+ called again with Z_FINISH and more output space (updated avail_out) but no
324+ more input data, until it returns with Z_STREAM_END or an error. After
325+ deflate has returned Z_STREAM_END, the only possible operations on the stream
326+ are deflateReset or deflateEnd.
327+
328+ Z_FINISH can be used immediately after deflateInit if all the compression
329+ is to be done in a single step. In this case, avail_out must be at least the
330+ value returned by deflateBound (see below). Then deflate is guaranteed to
331+ return Z_STREAM_END. If not enough output space is provided, deflate will
332+ not return Z_STREAM_END, and it must be called again as described above.
333+
334+ deflate() sets strm->adler to the adler32 checksum of all input read
335+ so far (that is, total_in bytes).
336+
337+ deflate() may update strm->data_type if it can make a good guess about
338+ the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
339+ binary. This field is only for information purposes and does not affect the
340+ compression algorithm in any manner.
341+
342+ deflate() returns Z_OK if some progress has been made (more input
343+ processed or more output produced), Z_STREAM_END if all input has been
344+ consumed and all output has been produced (only when flush is set to
345+ Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
346+ if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
347+ (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
348+ fatal, and deflate() can be called again with more input and more output
349+ space to continue compressing.
350+*/
351+
352+
353+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
354+/*
355+ All dynamically allocated data structures for this stream are freed.
356+ This function discards any unprocessed input and does not flush any pending
357+ output.
358+
359+ deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
360+ stream state was inconsistent, Z_DATA_ERROR if the stream was freed
361+ prematurely (some input or output was discarded). In the error case, msg
362+ may be set but then points to a static string (which must not be
363+ deallocated).
364+*/
365+
366+
367+/*
368+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
369+
370+ Initializes the internal stream state for decompression. The fields
371+ next_in, avail_in, zalloc, zfree and opaque must be initialized before by
372+ the caller. If next_in is not Z_NULL and avail_in is large enough (the
373+ exact value depends on the compression method), inflateInit determines the
374+ compression method from the zlib header and allocates all data structures
375+ accordingly; otherwise the allocation will be deferred to the first call of
376+ inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
377+ use default allocation functions.
378+
379+ inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
380+ memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
381+ version assumed by the caller, or Z_STREAM_ERROR if the parameters are
382+ invalid, such as a null pointer to the structure. msg is set to null if
383+ there is no error message. inflateInit does not perform any decompression
384+ apart from possibly reading the zlib header if present: actual decompression
385+ will be done by inflate(). (So next_in and avail_in may be modified, but
386+ next_out and avail_out are unused and unchanged.) The current implementation
387+ of inflateInit() does not process any header information -- that is deferred
388+ until inflate() is called.
389+*/
390+
391+
392+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
393+/*
394+ inflate decompresses as much data as possible, and stops when the input
395+ buffer becomes empty or the output buffer becomes full. It may introduce
396+ some output latency (reading input without producing any output) except when
397+ forced to flush.
398+
399+ The detailed semantics are as follows. inflate performs one or both of the
400+ following actions:
401+
402+ - Decompress more input starting at next_in and update next_in and avail_in
403+ accordingly. If not all input can be processed (because there is not
404+ enough room in the output buffer), next_in is updated and processing will
405+ resume at this point for the next call of inflate().
406+
407+ - Provide more output starting at next_out and update next_out and avail_out
408+ accordingly. inflate() provides as much output as possible, until there is
409+ no more input data or no more space in the output buffer (see below about
410+ the flush parameter).
411+
412+ Before the call of inflate(), the application should ensure that at least
413+ one of the actions is possible, by providing more input and/or consuming more
414+ output, and updating the next_* and avail_* values accordingly. The
415+ application can consume the uncompressed output when it wants, for example
416+ when the output buffer is full (avail_out == 0), or after each call of
417+ inflate(). If inflate returns Z_OK and with zero avail_out, it must be
418+ called again after making room in the output buffer because there might be
419+ more output pending.
420+
421+ The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
422+ Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much
423+ output as possible to the output buffer. Z_BLOCK requests that inflate()
424+ stop if and when it gets to the next deflate block boundary. When decoding
425+ the zlib or gzip format, this will cause inflate() to return immediately
426+ after the header and before the first block. When doing a raw inflate,
427+ inflate() will go ahead and process the first block, and will return when it
428+ gets to the end of that block, or when it runs out of data.
429+
430+ The Z_BLOCK option assists in appending to or combining deflate streams.
431+ Also to assist in this, on return inflate() will set strm->data_type to the
432+ number of unused bits in the last byte taken from strm->next_in, plus 64 if
433+ inflate() is currently decoding the last block in the deflate stream, plus
434+ 128 if inflate() returned immediately after decoding an end-of-block code or
435+ decoding the complete header up to just before the first byte of the deflate
436+ stream. The end-of-block will not be indicated until all of the uncompressed
437+ data from that block has been written to strm->next_out. The number of
438+ unused bits may in general be greater than seven, except when bit 7 of
439+ data_type is set, in which case the number of unused bits will be less than
440+ eight. data_type is set as noted here every time inflate() returns for all
441+ flush options, and so can be used to determine the amount of currently
442+ consumed input in bits.
443+
444+ The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
445+ end of each deflate block header is reached, before any actual data in that
446+ block is decoded. This allows the caller to determine the length of the
447+ deflate block header for later use in random access within a deflate block.
448+ 256 is added to the value of strm->data_type when inflate() returns
449+ immediately after reaching the end of the deflate block header.
450+
451+ inflate() should normally be called until it returns Z_STREAM_END or an
452+ error. However if all decompression is to be performed in a single step (a
453+ single call of inflate), the parameter flush should be set to Z_FINISH. In
454+ this case all pending input is processed and all pending output is flushed;
455+ avail_out must be large enough to hold all of the uncompressed data for the
456+ operation to complete. (The size of the uncompressed data may have been
457+ saved by the compressor for this purpose.) The use of Z_FINISH is not
458+ required to perform an inflation in one step. However it may be used to
459+ inform inflate that a faster approach can be used for the single inflate()
460+ call. Z_FINISH also informs inflate to not maintain a sliding window if the
461+ stream completes, which reduces inflate's memory footprint. If the stream
462+ does not complete, either because not all of the stream is provided or not
463+ enough output space is provided, then a sliding window will be allocated and
464+ inflate() can be called again to continue the operation as if Z_NO_FLUSH had
465+ been used.
466+
467+ In this implementation, inflate() always flushes as much output as
468+ possible to the output buffer, and always uses the faster approach on the
469+ first call. So the effects of the flush parameter in this implementation are
470+ on the return value of inflate() as noted below, when inflate() returns early
471+ when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
472+ memory for a sliding window when Z_FINISH is used.
473+
474+ If a preset dictionary is needed after this call (see inflateSetDictionary
475+ below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
476+ chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
477+ strm->adler to the Adler-32 checksum of all output produced so far (that is,
478+ total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
479+ below. At the end of the stream, inflate() checks that its computed adler32
480+ checksum is equal to that saved by the compressor and returns Z_STREAM_END
481+ only if the checksum is correct.
482+
483+ inflate() can decompress and check either zlib-wrapped or gzip-wrapped
484+ deflate data. The header type is detected automatically, if requested when
485+ initializing with inflateInit2(). Any information contained in the gzip
486+ header is not retained, so applications that need that information should
487+ instead use raw inflate, see inflateInit2() below, or inflateBack() and
488+ perform their own processing of the gzip header and trailer. When processing
489+ gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
490+ producted so far. The CRC-32 is checked against the gzip trailer.
491+
492+ inflate() returns Z_OK if some progress has been made (more input processed
493+ or more output produced), Z_STREAM_END if the end of the compressed data has
494+ been reached and all uncompressed output has been produced, Z_NEED_DICT if a
495+ preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
496+ corrupted (input stream not conforming to the zlib format or incorrect check
497+ value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
498+ next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
499+ Z_BUF_ERROR if no progress is possible or if there was not enough room in the
500+ output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
501+ inflate() can be called again with more input and more output space to
502+ continue decompressing. If Z_DATA_ERROR is returned, the application may
503+ then call inflateSync() to look for a good compression block if a partial
504+ recovery of the data is desired.
505+*/
506+
507+
508+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
509+/*
510+ All dynamically allocated data structures for this stream are freed.
511+ This function discards any unprocessed input and does not flush any pending
512+ output.
513+
514+ inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
515+ was inconsistent. In the error case, msg may be set but then points to a
516+ static string (which must not be deallocated).
517+*/
518+
519+
520+ /* Advanced functions */
521+
522+/*
523+ The following functions are needed only in some special applications.
524+*/
525+
526+/*
527+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
528+ int level,
529+ int method,
530+ int windowBits,
531+ int memLevel,
532+ int strategy));
533+
534+ This is another version of deflateInit with more compression options. The
535+ fields next_in, zalloc, zfree and opaque must be initialized before by the
536+ caller.
537+
538+ The method parameter is the compression method. It must be Z_DEFLATED in
539+ this version of the library.
540+
541+ The windowBits parameter is the base two logarithm of the window size
542+ (the size of the history buffer). It should be in the range 8..15 for this
543+ version of the library. Larger values of this parameter result in better
544+ compression at the expense of memory usage. The default value is 15 if
545+ deflateInit is used instead.
546+
547+ windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
548+ determines the window size. deflate() will then generate raw deflate data
549+ with no zlib header or trailer, and will not compute an adler32 check value.
550+
551+ windowBits can also be greater than 15 for optional gzip encoding. Add
552+ 16 to windowBits to write a simple gzip header and trailer around the
553+ compressed data instead of a zlib wrapper. The gzip header will have no
554+ file name, no extra data, no comment, no modification time (set to zero), no
555+ header crc, and the operating system will be set to 255 (unknown). If a
556+ gzip stream is being written, strm->adler is a crc32 instead of an adler32.
557+
558+ The memLevel parameter specifies how much memory should be allocated
559+ for the internal compression state. memLevel=1 uses minimum memory but is
560+ slow and reduces compression ratio; memLevel=9 uses maximum memory for
561+ optimal speed. The default value is 8. See zconf.h for total memory usage
562+ as a function of windowBits and memLevel.
563+
564+ The strategy parameter is used to tune the compression algorithm. Use the
565+ value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
566+ filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
567+ string match), or Z_RLE to limit match distances to one (run-length
568+ encoding). Filtered data consists mostly of small values with a somewhat
569+ random distribution. In this case, the compression algorithm is tuned to
570+ compress them better. The effect of Z_FILTERED is to force more Huffman
571+ coding and less string matching; it is somewhat intermediate between
572+ Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as
573+ fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The
574+ strategy parameter only affects the compression ratio but not the
575+ correctness of the compressed output even if it is not set appropriately.
576+ Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
577+ decoder for special applications.
578+
579+ deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
580+ memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
581+ method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
582+ incompatible with the version assumed by the caller (ZLIB_VERSION). msg is
583+ set to null if there is no error message. deflateInit2 does not perform any
584+ compression: this will be done by deflate().
585+*/
586+
587+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
588+ const Bytef *dictionary,
589+ uInt dictLength));
590+/*
591+ Initializes the compression dictionary from the given byte sequence
592+ without producing any compressed output. When using the zlib format, this
593+ function must be called immediately after deflateInit, deflateInit2 or
594+ deflateReset, and before any call of deflate. When doing raw deflate, this
595+ function must be called either before any call of deflate, or immediately
596+ after the completion of a deflate block, i.e. after all input has been
597+ consumed and all output has been delivered when using any of the flush
598+ options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The
599+ compressor and decompressor must use exactly the same dictionary (see
600+ inflateSetDictionary).
601+
602+ The dictionary should consist of strings (byte sequences) that are likely
603+ to be encountered later in the data to be compressed, with the most commonly
604+ used strings preferably put towards the end of the dictionary. Using a
605+ dictionary is most useful when the data to be compressed is short and can be
606+ predicted with good accuracy; the data can then be compressed better than
607+ with the default empty dictionary.
608+
609+ Depending on the size of the compression data structures selected by
610+ deflateInit or deflateInit2, a part of the dictionary may in effect be
611+ discarded, for example if the dictionary is larger than the window size
612+ provided in deflateInit or deflateInit2. Thus the strings most likely to be
613+ useful should be put at the end of the dictionary, not at the front. In
614+ addition, the current implementation of deflate will use at most the window
615+ size minus 262 bytes of the provided dictionary.
616+
617+ Upon return of this function, strm->adler is set to the adler32 value
618+ of the dictionary; the decompressor may later use this value to determine
619+ which dictionary has been used by the compressor. (The adler32 value
620+ applies to the whole dictionary even if only a subset of the dictionary is
621+ actually used by the compressor.) If a raw deflate was requested, then the
622+ adler32 value is not computed and strm->adler is not set.
623+
624+ deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
625+ parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
626+ inconsistent (for example if deflate has already been called for this stream
627+ or if not at a block boundary for raw deflate). deflateSetDictionary does
628+ not perform any compression: this will be done by deflate().
629+*/
630+
631+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
632+ z_streamp source));
633+/*
634+ Sets the destination stream as a complete copy of the source stream.
635+
636+ This function can be useful when several compression strategies will be
637+ tried, for example when there are several ways of pre-processing the input
638+ data with a filter. The streams that will be discarded should then be freed
639+ by calling deflateEnd. Note that deflateCopy duplicates the internal
640+ compression state which can be quite large, so this strategy is slow and can
641+ consume lots of memory.
642+
643+ deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
644+ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
645+ (such as zalloc being Z_NULL). msg is left unchanged in both source and
646+ destination.
647+*/
648+
649+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
650+/*
651+ This function is equivalent to deflateEnd followed by deflateInit,
652+ but does not free and reallocate all the internal compression state. The
653+ stream will keep the same compression level and any other attributes that
654+ may have been set by deflateInit2.
655+
656+ deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
657+ stream state was inconsistent (such as zalloc or state being Z_NULL).
658+*/
659+
660+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
661+ int level,
662+ int strategy));
663+/*
664+ Dynamically update the compression level and compression strategy. The
665+ interpretation of level and strategy is as in deflateInit2. This can be
666+ used to switch between compression and straight copy of the input data, or
667+ to switch to a different kind of input data requiring a different strategy.
668+ If the compression level is changed, the input available so far is
669+ compressed with the old level (and may be flushed); the new level will take
670+ effect only at the next call of deflate().
671+
672+ Before the call of deflateParams, the stream state must be set as for
673+ a call of deflate(), since the currently available input may have to be
674+ compressed and flushed. In particular, strm->avail_out must be non-zero.
675+
676+ deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
677+ stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
678+ strm->avail_out was zero.
679+*/
680+
681+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
682+ int good_length,
683+ int max_lazy,
684+ int nice_length,
685+ int max_chain));
686+/*
687+ Fine tune deflate's internal compression parameters. This should only be
688+ used by someone who understands the algorithm used by zlib's deflate for
689+ searching for the best matching string, and even then only by the most
690+ fanatic optimizer trying to squeeze out the last compressed bit for their
691+ specific input data. Read the deflate.c source code for the meaning of the
692+ max_lazy, good_length, nice_length, and max_chain parameters.
693+
694+ deflateTune() can be called after deflateInit() or deflateInit2(), and
695+ returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
696+ */
697+
698+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
699+ uLong sourceLen));
700+/*
701+ deflateBound() returns an upper bound on the compressed size after
702+ deflation of sourceLen bytes. It must be called after deflateInit() or
703+ deflateInit2(), and after deflateSetHeader(), if used. This would be used
704+ to allocate an output buffer for deflation in a single pass, and so would be
705+ called before deflate(). If that first deflate() call is provided the
706+ sourceLen input bytes, an output buffer allocated to the size returned by
707+ deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
708+ to return Z_STREAM_END. Note that it is possible for the compressed size to
709+ be larger than the value returned by deflateBound() if flush options other
710+ than Z_FINISH or Z_NO_FLUSH are used.
711+*/
712+
713+ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
714+ unsigned *pending,
715+ int *bits));
716+/*
717+ deflatePending() returns the number of bytes and bits of output that have
718+ been generated, but not yet provided in the available output. The bytes not
719+ provided would be due to the available output space having being consumed.
720+ The number of bits of output not provided are between 0 and 7, where they
721+ await more bits to join them in order to fill out a full byte. If pending
722+ or bits are Z_NULL, then those values are not set.
723+
724+ deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
725+ stream state was inconsistent.
726+ */
727+
728+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
729+ int bits,
730+ int value));
731+/*
732+ deflatePrime() inserts bits in the deflate output stream. The intent
733+ is that this function is used to start off the deflate output with the bits
734+ leftover from a previous deflate stream when appending to it. As such, this
735+ function can only be used for raw deflate, and must be used before the first
736+ deflate() call after a deflateInit2() or deflateReset(). bits must be less
737+ than or equal to 16, and that many of the least significant bits of value
738+ will be inserted in the output.
739+
740+ deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
741+ room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
742+ source stream state was inconsistent.
743+*/
744+
745+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
746+ gz_headerp head));
747+/*
748+ deflateSetHeader() provides gzip header information for when a gzip
749+ stream is requested by deflateInit2(). deflateSetHeader() may be called
750+ after deflateInit2() or deflateReset() and before the first call of
751+ deflate(). The text, time, os, extra field, name, and comment information
752+ in the provided gz_header structure are written to the gzip header (xflag is
753+ ignored -- the extra flags are set according to the compression level). The
754+ caller must assure that, if not Z_NULL, name and comment are terminated with
755+ a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
756+ available there. If hcrc is true, a gzip header crc is included. Note that
757+ the current versions of the command-line version of gzip (up through version
758+ 1.3.x) do not support header crc's, and will report that it is a "multi-part
759+ gzip file" and give up.
760+
761+ If deflateSetHeader is not used, the default gzip header has text false,
762+ the time set to zero, and os set to 255, with no extra, name, or comment
763+ fields. The gzip header is returned to the default state by deflateReset().
764+
765+ deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
766+ stream state was inconsistent.
767+*/
768+
769+/*
770+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
771+ int windowBits));
772+
773+ This is another version of inflateInit with an extra parameter. The
774+ fields next_in, avail_in, zalloc, zfree and opaque must be initialized
775+ before by the caller.
776+
777+ The windowBits parameter is the base two logarithm of the maximum window
778+ size (the size of the history buffer). It should be in the range 8..15 for
779+ this version of the library. The default value is 15 if inflateInit is used
780+ instead. windowBits must be greater than or equal to the windowBits value
781+ provided to deflateInit2() while compressing, or it must be equal to 15 if
782+ deflateInit2() was not used. If a compressed stream with a larger window
783+ size is given as input, inflate() will return with the error code
784+ Z_DATA_ERROR instead of trying to allocate a larger window.
785+
786+ windowBits can also be zero to request that inflate use the window size in
787+ the zlib header of the compressed stream.
788+
789+ windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
790+ determines the window size. inflate() will then process raw deflate data,
791+ not looking for a zlib or gzip header, not generating a check value, and not
792+ looking for any check values for comparison at the end of the stream. This
793+ is for use with other formats that use the deflate compressed data format
794+ such as zip. Those formats provide their own check values. If a custom
795+ format is developed using the raw deflate format for compressed data, it is
796+ recommended that a check value such as an adler32 or a crc32 be applied to
797+ the uncompressed data as is done in the zlib, gzip, and zip formats. For
798+ most applications, the zlib format should be used as is. Note that comments
799+ above on the use in deflateInit2() applies to the magnitude of windowBits.
800+
801+ windowBits can also be greater than 15 for optional gzip decoding. Add
802+ 32 to windowBits to enable zlib and gzip decoding with automatic header
803+ detection, or add 16 to decode only the gzip format (the zlib format will
804+ return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a
805+ crc32 instead of an adler32.
806+
807+ inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
808+ memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
809+ version assumed by the caller, or Z_STREAM_ERROR if the parameters are
810+ invalid, such as a null pointer to the structure. msg is set to null if
811+ there is no error message. inflateInit2 does not perform any decompression
812+ apart from possibly reading the zlib header if present: actual decompression
813+ will be done by inflate(). (So next_in and avail_in may be modified, but
814+ next_out and avail_out are unused and unchanged.) The current implementation
815+ of inflateInit2() does not process any header information -- that is
816+ deferred until inflate() is called.
817+*/
818+
819+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
820+ const Bytef *dictionary,
821+ uInt dictLength));
822+/*
823+ Initializes the decompression dictionary from the given uncompressed byte
824+ sequence. This function must be called immediately after a call of inflate,
825+ if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
826+ can be determined from the adler32 value returned by that call of inflate.
827+ The compressor and decompressor must use exactly the same dictionary (see
828+ deflateSetDictionary). For raw inflate, this function can be called at any
829+ time to set the dictionary. If the provided dictionary is smaller than the
830+ window and there is already data in the window, then the provided dictionary
831+ will amend what's there. The application must insure that the dictionary
832+ that was used for compression is provided.
833+
834+ inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
835+ parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
836+ inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
837+ expected one (incorrect adler32 value). inflateSetDictionary does not
838+ perform any decompression: this will be done by subsequent calls of
839+ inflate().
840+*/
841+
842+ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
843+ Bytef *dictionary,
844+ uInt *dictLength));
845+/*
846+ Returns the sliding dictionary being maintained by inflate. dictLength is
847+ set to the number of bytes in the dictionary, and that many bytes are copied
848+ to dictionary. dictionary must have enough space, where 32768 bytes is
849+ always enough. If inflateGetDictionary() is called with dictionary equal to
850+ Z_NULL, then only the dictionary length is returned, and nothing is copied.
851+ Similary, if dictLength is Z_NULL, then it is not set.
852+
853+ inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
854+ stream state is inconsistent.
855+*/
856+
857+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
858+/*
859+ Skips invalid compressed data until a possible full flush point (see above
860+ for the description of deflate with Z_FULL_FLUSH) can be found, or until all
861+ available input is skipped. No output is provided.
862+
863+ inflateSync searches for a 00 00 FF FF pattern in the compressed data.
864+ All full flush points have this pattern, but not all occurrences of this
865+ pattern are full flush points.
866+
867+ inflateSync returns Z_OK if a possible full flush point has been found,
868+ Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
869+ has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
870+ In the success case, the application may save the current current value of
871+ total_in which indicates where valid compressed data was found. In the
872+ error case, the application may repeatedly call inflateSync, providing more
873+ input each time, until success or end of the input data.
874+*/
875+
876+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
877+ z_streamp source));
878+/*
879+ Sets the destination stream as a complete copy of the source stream.
880+
881+ This function can be useful when randomly accessing a large stream. The
882+ first pass through the stream can periodically record the inflate state,
883+ allowing restarting inflate at those points when randomly accessing the
884+ stream.
885+
886+ inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
887+ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
888+ (such as zalloc being Z_NULL). msg is left unchanged in both source and
889+ destination.
890+*/
891+
892+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
893+/*
894+ This function is equivalent to inflateEnd followed by inflateInit,
895+ but does not free and reallocate all the internal decompression state. The
896+ stream will keep attributes that may have been set by inflateInit2.
897+
898+ inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
899+ stream state was inconsistent (such as zalloc or state being Z_NULL).
900+*/
901+
902+ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
903+ int windowBits));
904+/*
905+ This function is the same as inflateReset, but it also permits changing
906+ the wrap and window size requests. The windowBits parameter is interpreted
907+ the same as it is for inflateInit2.
908+
909+ inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
910+ stream state was inconsistent (such as zalloc or state being Z_NULL), or if
911+ the windowBits parameter is invalid.
912+*/
913+
914+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
915+ int bits,
916+ int value));
917+/*
918+ This function inserts bits in the inflate input stream. The intent is
919+ that this function is used to start inflating at a bit position in the
920+ middle of a byte. The provided bits will be used before any bytes are used
921+ from next_in. This function should only be used with raw inflate, and
922+ should be used before the first inflate() call after inflateInit2() or
923+ inflateReset(). bits must be less than or equal to 16, and that many of the
924+ least significant bits of value will be inserted in the input.
925+
926+ If bits is negative, then the input stream bit buffer is emptied. Then
927+ inflatePrime() can be called again to put bits in the buffer. This is used
928+ to clear out bits leftover after feeding inflate a block description prior
929+ to feeding inflate codes.
930+
931+ inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
932+ stream state was inconsistent.
933+*/
934+
935+ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
936+/*
937+ This function returns two values, one in the lower 16 bits of the return
938+ value, and the other in the remaining upper bits, obtained by shifting the
939+ return value down 16 bits. If the upper value is -1 and the lower value is
940+ zero, then inflate() is currently decoding information outside of a block.
941+ If the upper value is -1 and the lower value is non-zero, then inflate is in
942+ the middle of a stored block, with the lower value equaling the number of
943+ bytes from the input remaining to copy. If the upper value is not -1, then
944+ it is the number of bits back from the current bit position in the input of
945+ the code (literal or length/distance pair) currently being processed. In
946+ that case the lower value is the number of bytes already emitted for that
947+ code.
948+
949+ A code is being processed if inflate is waiting for more input to complete
950+ decoding of the code, or if it has completed decoding but is waiting for
951+ more output space to write the literal or match data.
952+
953+ inflateMark() is used to mark locations in the input data for random
954+ access, which may be at bit positions, and to note those cases where the
955+ output of a code may span boundaries of random access blocks. The current
956+ location in the input stream can be determined from avail_in and data_type
957+ as noted in the description for the Z_BLOCK flush parameter for inflate.
958+
959+ inflateMark returns the value noted above or -1 << 16 if the provided
960+ source stream state was inconsistent.
961+*/
962+
963+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
964+ gz_headerp head));
965+/*
966+ inflateGetHeader() requests that gzip header information be stored in the
967+ provided gz_header structure. inflateGetHeader() may be called after
968+ inflateInit2() or inflateReset(), and before the first call of inflate().
969+ As inflate() processes the gzip stream, head->done is zero until the header
970+ is completed, at which time head->done is set to one. If a zlib stream is
971+ being decoded, then head->done is set to -1 to indicate that there will be
972+ no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be
973+ used to force inflate() to return immediately after header processing is
974+ complete and before any actual data is decompressed.
975+
976+ The text, time, xflags, and os fields are filled in with the gzip header
977+ contents. hcrc is set to true if there is a header CRC. (The header CRC
978+ was valid if done is set to one.) If extra is not Z_NULL, then extra_max
979+ contains the maximum number of bytes to write to extra. Once done is true,
980+ extra_len contains the actual extra field length, and extra contains the
981+ extra field, or that field truncated if extra_max is less than extra_len.
982+ If name is not Z_NULL, then up to name_max characters are written there,
983+ terminated with a zero unless the length is greater than name_max. If
984+ comment is not Z_NULL, then up to comm_max characters are written there,
985+ terminated with a zero unless the length is greater than comm_max. When any
986+ of extra, name, or comment are not Z_NULL and the respective field is not
987+ present in the header, then that field is set to Z_NULL to signal its
988+ absence. This allows the use of deflateSetHeader() with the returned
989+ structure to duplicate the header. However if those fields are set to
990+ allocated memory, then the application will need to save those pointers
991+ elsewhere so that they can be eventually freed.
992+
993+ If inflateGetHeader is not used, then the header information is simply
994+ discarded. The header is always checked for validity, including the header
995+ CRC if present. inflateReset() will reset the process to discard the header
996+ information. The application would need to call inflateGetHeader() again to
997+ retrieve the header from the next gzip stream.
998+
999+ inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
1000+ stream state was inconsistent.
1001+*/
1002+
1003+/*
1004+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
1005+ unsigned char FAR *window));
1006+
1007+ Initialize the internal stream state for decompression using inflateBack()
1008+ calls. The fields zalloc, zfree and opaque in strm must be initialized
1009+ before the call. If zalloc and zfree are Z_NULL, then the default library-
1010+ derived memory allocation routines are used. windowBits is the base two
1011+ logarithm of the window size, in the range 8..15. window is a caller
1012+ supplied buffer of that size. Except for special applications where it is
1013+ assured that deflate was used with small window sizes, windowBits must be 15
1014+ and a 32K byte window must be supplied to be able to decompress general
1015+ deflate streams.
1016+
1017+ See inflateBack() for the usage of these routines.
1018+
1019+ inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
1020+ the parameters are invalid, Z_MEM_ERROR if the internal state could not be
1021+ allocated, or Z_VERSION_ERROR if the version of the library does not match
1022+ the version of the header file.
1023+*/
1024+
1025+typedef unsigned (*in_func) OF((void FAR *,
1026+ z_const unsigned char FAR * FAR *));
1027+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
1028+
1029+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
1030+ in_func in, void FAR *in_desc,
1031+ out_func out, void FAR *out_desc));
1032+/*
1033+ inflateBack() does a raw inflate with a single call using a call-back
1034+ interface for input and output. This is potentially more efficient than
1035+ inflate() for file i/o applications, in that it avoids copying between the
1036+ output and the sliding window by simply making the window itself the output
1037+ buffer. inflate() can be faster on modern CPUs when used with large
1038+ buffers. inflateBack() trusts the application to not change the output
1039+ buffer passed by the output function, at least until inflateBack() returns.
1040+
1041+ inflateBackInit() must be called first to allocate the internal state
1042+ and to initialize the state with the user-provided window buffer.
1043+ inflateBack() may then be used multiple times to inflate a complete, raw
1044+ deflate stream with each call. inflateBackEnd() is then called to free the
1045+ allocated state.
1046+
1047+ A raw deflate stream is one with no zlib or gzip header or trailer.
1048+ This routine would normally be used in a utility that reads zip or gzip
1049+ files and writes out uncompressed files. The utility would decode the
1050+ header and process the trailer on its own, hence this routine expects only
1051+ the raw deflate stream to decompress. This is different from the normal
1052+ behavior of inflate(), which expects either a zlib or gzip header and
1053+ trailer around the deflate stream.
1054+
1055+ inflateBack() uses two subroutines supplied by the caller that are then
1056+ called by inflateBack() for input and output. inflateBack() calls those
1057+ routines until it reads a complete deflate stream and writes out all of the
1058+ uncompressed data, or until it encounters an error. The function's
1059+ parameters and return types are defined above in the in_func and out_func
1060+ typedefs. inflateBack() will call in(in_desc, &buf) which should return the
1061+ number of bytes of provided input, and a pointer to that input in buf. If
1062+ there is no input available, in() must return zero--buf is ignored in that
1063+ case--and inflateBack() will return a buffer error. inflateBack() will call
1064+ out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
1065+ should return zero on success, or non-zero on failure. If out() returns
1066+ non-zero, inflateBack() will return with an error. Neither in() nor out()
1067+ are permitted to change the contents of the window provided to
1068+ inflateBackInit(), which is also the buffer that out() uses to write from.
1069+ The length written by out() will be at most the window size. Any non-zero
1070+ amount of input may be provided by in().
1071+
1072+ For convenience, inflateBack() can be provided input on the first call by
1073+ setting strm->next_in and strm->avail_in. If that input is exhausted, then
1074+ in() will be called. Therefore strm->next_in must be initialized before
1075+ calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called
1076+ immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in
1077+ must also be initialized, and then if strm->avail_in is not zero, input will
1078+ initially be taken from strm->next_in[0 .. strm->avail_in - 1].
1079+
1080+ The in_desc and out_desc parameters of inflateBack() is passed as the
1081+ first parameter of in() and out() respectively when they are called. These
1082+ descriptors can be optionally used to pass any information that the caller-
1083+ supplied in() and out() functions need to do their job.
1084+
1085+ On return, inflateBack() will set strm->next_in and strm->avail_in to
1086+ pass back any unused input that was provided by the last in() call. The
1087+ return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
1088+ if in() or out() returned an error, Z_DATA_ERROR if there was a format error
1089+ in the deflate stream (in which case strm->msg is set to indicate the nature
1090+ of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
1091+ In the case of Z_BUF_ERROR, an input or output error can be distinguished
1092+ using strm->next_in which will be Z_NULL only if in() returned an error. If
1093+ strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
1094+ non-zero. (in() will always be called before out(), so strm->next_in is
1095+ assured to be defined if out() returns non-zero.) Note that inflateBack()
1096+ cannot return Z_OK.
1097+*/
1098+
1099+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
1100+/*
1101+ All memory allocated by inflateBackInit() is freed.
1102+
1103+ inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
1104+ state was inconsistent.
1105+*/
1106+
1107+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
1108+/* Return flags indicating compile-time options.
1109+
1110+ Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
1111+ 1.0: size of uInt
1112+ 3.2: size of uLong
1113+ 5.4: size of voidpf (pointer)
1114+ 7.6: size of z_off_t
1115+
1116+ Compiler, assembler, and debug options:
1117+ 8: DEBUG
1118+ 9: ASMV or ASMINF -- use ASM code
1119+ 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
1120+ 11: 0 (reserved)
1121+
1122+ One-time table building (smaller code, but not thread-safe if true):
1123+ 12: BUILDFIXED -- build static block decoding tables when needed
1124+ 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
1125+ 14,15: 0 (reserved)
1126+
1127+ Library content (indicates missing functionality):
1128+ 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
1129+ deflate code when not needed)
1130+ 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
1131+ and decode gzip streams (to avoid linking crc code)
1132+ 18-19: 0 (reserved)
1133+
1134+ Operation variations (changes in library functionality):
1135+ 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
1136+ 21: FASTEST -- deflate algorithm with only one, lowest compression level
1137+ 22,23: 0 (reserved)
1138+
1139+ The sprintf variant used by gzprintf (zero is best):
1140+ 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
1141+ 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
1142+ 26: 0 = returns value, 1 = void -- 1 means inferred string length returned
1143+
1144+ Remainder:
1145+ 27-31: 0 (reserved)
1146+ */
1147+
1148+#ifndef Z_SOLO
1149+
1150+ /* utility functions */
1151+
1152+/*
1153+ The following utility functions are implemented on top of the basic
1154+ stream-oriented functions. To simplify the interface, some default options
1155+ are assumed (compression level and memory usage, standard memory allocation
1156+ functions). The source code of these utility functions can be modified if
1157+ you need special options.
1158+*/
1159+
1160+ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
1161+ const Bytef *source, uLong sourceLen));
1162+/*
1163+ Compresses the source buffer into the destination buffer. sourceLen is
1164+ the byte length of the source buffer. Upon entry, destLen is the total size
1165+ of the destination buffer, which must be at least the value returned by
1166+ compressBound(sourceLen). Upon exit, destLen is the actual size of the
1167+ compressed buffer.
1168+
1169+ compress returns Z_OK if success, Z_MEM_ERROR if there was not
1170+ enough memory, Z_BUF_ERROR if there was not enough room in the output
1171+ buffer.
1172+*/
1173+
1174+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
1175+ const Bytef *source, uLong sourceLen,
1176+ int level));
1177+/*
1178+ Compresses the source buffer into the destination buffer. The level
1179+ parameter has the same meaning as in deflateInit. sourceLen is the byte
1180+ length of the source buffer. Upon entry, destLen is the total size of the
1181+ destination buffer, which must be at least the value returned by
1182+ compressBound(sourceLen). Upon exit, destLen is the actual size of the
1183+ compressed buffer.
1184+
1185+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
1186+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
1187+ Z_STREAM_ERROR if the level parameter is invalid.
1188+*/
1189+
1190+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
1191+/*
1192+ compressBound() returns an upper bound on the compressed size after
1193+ compress() or compress2() on sourceLen bytes. It would be used before a
1194+ compress() or compress2() call to allocate the destination buffer.
1195+*/
1196+
1197+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
1198+ const Bytef *source, uLong sourceLen));
1199+/*
1200+ Decompresses the source buffer into the destination buffer. sourceLen is
1201+ the byte length of the source buffer. Upon entry, destLen is the total size
1202+ of the destination buffer, which must be large enough to hold the entire
1203+ uncompressed data. (The size of the uncompressed data must have been saved
1204+ previously by the compressor and transmitted to the decompressor by some
1205+ mechanism outside the scope of this compression library.) Upon exit, destLen
1206+ is the actual size of the uncompressed buffer.
1207+
1208+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
1209+ enough memory, Z_BUF_ERROR if there was not enough room in the output
1210+ buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In
1211+ the case where there is not enough room, uncompress() will fill the output
1212+ buffer with the uncompressed data up to that point.
1213+*/
1214+
1215+ /* gzip file access functions */
1216+
1217+/*
1218+ This library supports reading and writing files in gzip (.gz) format with
1219+ an interface similar to that of stdio, using the functions that start with
1220+ "gz". The gzip format is different from the zlib format. gzip is a gzip
1221+ wrapper, documented in RFC 1952, wrapped around a deflate stream.
1222+*/
1223+
1224+typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */
1225+
1226+/*
1227+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
1228+
1229+ Opens a gzip (.gz) file for reading or writing. The mode parameter is as
1230+ in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
1231+ a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
1232+ compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
1233+ for fixed code compression as in "wb9F". (See the description of
1234+ deflateInit2 for more information about the strategy parameter.) 'T' will
1235+ request transparent writing or appending with no compression and not using
1236+ the gzip format.
1237+
1238+ "a" can be used instead of "w" to request that the gzip stream that will
1239+ be written be appended to the file. "+" will result in an error, since
1240+ reading and writing to the same gzip file is not supported. The addition of
1241+ "x" when writing will create the file exclusively, which fails if the file
1242+ already exists. On systems that support it, the addition of "e" when
1243+ reading or writing will set the flag to close the file on an execve() call.
1244+
1245+ These functions, as well as gzip, will read and decode a sequence of gzip
1246+ streams in a file. The append function of gzopen() can be used to create
1247+ such a file. (Also see gzflush() for another way to do this.) When
1248+ appending, gzopen does not test whether the file begins with a gzip stream,
1249+ nor does it look for the end of the gzip streams to begin appending. gzopen
1250+ will simply append a gzip stream to the existing file.
1251+
1252+ gzopen can be used to read a file which is not in gzip format; in this
1253+ case gzread will directly read from the file without decompression. When
1254+ reading, this will be detected automatically by looking for the magic two-
1255+ byte gzip header.
1256+
1257+ gzopen returns NULL if the file could not be opened, if there was
1258+ insufficient memory to allocate the gzFile state, or if an invalid mode was
1259+ specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
1260+ errno can be checked to determine if the reason gzopen failed was that the
1261+ file could not be opened.
1262+*/
1263+
1264+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
1265+/*
1266+ gzdopen associates a gzFile with the file descriptor fd. File descriptors
1267+ are obtained from calls like open, dup, creat, pipe or fileno (if the file
1268+ has been previously opened with fopen). The mode parameter is as in gzopen.
1269+
1270+ The next call of gzclose on the returned gzFile will also close the file
1271+ descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
1272+ fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
1273+ mode);. The duplicated descriptor should be saved to avoid a leak, since
1274+ gzdopen does not close fd if it fails. If you are using fileno() to get the
1275+ file descriptor from a FILE *, then you will have to use dup() to avoid
1276+ double-close()ing the file descriptor. Both gzclose() and fclose() will
1277+ close the associated file descriptor, so they need to have different file
1278+ descriptors.
1279+
1280+ gzdopen returns NULL if there was insufficient memory to allocate the
1281+ gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
1282+ provided, or '+' was provided), or if fd is -1. The file descriptor is not
1283+ used until the next gz* read, write, seek, or close operation, so gzdopen
1284+ will not detect if fd is invalid (unless fd is -1).
1285+*/
1286+
1287+ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
1288+/*
1289+ Set the internal buffer size used by this library's functions. The
1290+ default buffer size is 8192 bytes. This function must be called after
1291+ gzopen() or gzdopen(), and before any other calls that read or write the
1292+ file. The buffer memory allocation is always deferred to the first read or
1293+ write. Two buffers are allocated, either both of the specified size when
1294+ writing, or one of the specified size and the other twice that size when
1295+ reading. A larger buffer size of, for example, 64K or 128K bytes will
1296+ noticeably increase the speed of decompression (reading).
1297+
1298+ The new buffer size also affects the maximum length for gzprintf().
1299+
1300+ gzbuffer() returns 0 on success, or -1 on failure, such as being called
1301+ too late.
1302+*/
1303+
1304+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
1305+/*
1306+ Dynamically update the compression level or strategy. See the description
1307+ of deflateInit2 for the meaning of these parameters.
1308+
1309+ gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
1310+ opened for writing.
1311+*/
1312+
1313+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
1314+/*
1315+ Reads the given number of uncompressed bytes from the compressed file. If
1316+ the input file is not in gzip format, gzread copies the given number of
1317+ bytes into the buffer directly from the file.
1318+
1319+ After reaching the end of a gzip stream in the input, gzread will continue
1320+ to read, looking for another gzip stream. Any number of gzip streams may be
1321+ concatenated in the input file, and will all be decompressed by gzread().
1322+ If something other than a gzip stream is encountered after a gzip stream,
1323+ that remaining trailing garbage is ignored (and no error is returned).
1324+
1325+ gzread can be used to read a gzip file that is being concurrently written.
1326+ Upon reaching the end of the input, gzread will return with the available
1327+ data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
1328+ gzclearerr can be used to clear the end of file indicator in order to permit
1329+ gzread to be tried again. Z_OK indicates that a gzip stream was completed
1330+ on the last gzread. Z_BUF_ERROR indicates that the input file ended in the
1331+ middle of a gzip stream. Note that gzread does not return -1 in the event
1332+ of an incomplete gzip stream. This error is deferred until gzclose(), which
1333+ will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
1334+ stream. Alternatively, gzerror can be used before gzclose to detect this
1335+ case.
1336+
1337+ gzread returns the number of uncompressed bytes actually read, less than
1338+ len for end of file, or -1 for error.
1339+*/
1340+
1341+ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
1342+ voidpc buf, unsigned len));
1343+/*
1344+ Writes the given number of uncompressed bytes into the compressed file.
1345+ gzwrite returns the number of uncompressed bytes written or 0 in case of
1346+ error.
1347+*/
1348+
1349+ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
1350+/*
1351+ Converts, formats, and writes the arguments to the compressed file under
1352+ control of the format string, as in fprintf. gzprintf returns the number of
1353+ uncompressed bytes actually written, or 0 in case of error. The number of
1354+ uncompressed bytes written is limited to 8191, or one less than the buffer
1355+ size given to gzbuffer(). The caller should assure that this limit is not
1356+ exceeded. If it is exceeded, then gzprintf() will return an error (0) with
1357+ nothing written. In this case, there may also be a buffer overflow with
1358+ unpredictable consequences, which is possible only if zlib was compiled with
1359+ the insecure functions sprintf() or vsprintf() because the secure snprintf()
1360+ or vsnprintf() functions were not available. This can be determined using
1361+ zlibCompileFlags().
1362+*/
1363+
1364+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
1365+/*
1366+ Writes the given null-terminated string to the compressed file, excluding
1367+ the terminating null character.
1368+
1369+ gzputs returns the number of characters written, or -1 in case of error.
1370+*/
1371+
1372+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
1373+/*
1374+ Reads bytes from the compressed file until len-1 characters are read, or a
1375+ newline character is read and transferred to buf, or an end-of-file
1376+ condition is encountered. If any characters are read or if len == 1, the
1377+ string is terminated with a null character. If no characters are read due
1378+ to an end-of-file or len < 1, then the buffer is left untouched.
1379+
1380+ gzgets returns buf which is a null-terminated string, or it returns NULL
1381+ for end-of-file or in case of error. If there was an error, the contents at
1382+ buf are indeterminate.
1383+*/
1384+
1385+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
1386+/*
1387+ Writes c, converted to an unsigned char, into the compressed file. gzputc
1388+ returns the value that was written, or -1 in case of error.
1389+*/
1390+
1391+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
1392+/*
1393+ Reads one byte from the compressed file. gzgetc returns this byte or -1
1394+ in case of end of file or error. This is implemented as a macro for speed.
1395+ As such, it does not do all of the checking the other functions do. I.e.
1396+ it does not check to see if file is NULL, nor whether the structure file
1397+ points to has been clobbered or not.
1398+*/
1399+
1400+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
1401+/*
1402+ Push one character back onto the stream to be read as the first character
1403+ on the next read. At least one character of push-back is allowed.
1404+ gzungetc() returns the character pushed, or -1 on failure. gzungetc() will
1405+ fail if c is -1, and may fail if a character has been pushed but not read
1406+ yet. If gzungetc is used immediately after gzopen or gzdopen, at least the
1407+ output buffer size of pushed characters is allowed. (See gzbuffer above.)
1408+ The pushed character will be discarded if the stream is repositioned with
1409+ gzseek() or gzrewind().
1410+*/
1411+
1412+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
1413+/*
1414+ Flushes all pending output into the compressed file. The parameter flush
1415+ is as in the deflate() function. The return value is the zlib error number
1416+ (see function gzerror below). gzflush is only permitted when writing.
1417+
1418+ If the flush parameter is Z_FINISH, the remaining data is written and the
1419+ gzip stream is completed in the output. If gzwrite() is called again, a new
1420+ gzip stream will be started in the output. gzread() is able to read such
1421+ concatented gzip streams.
1422+
1423+ gzflush should be called only when strictly necessary because it will
1424+ degrade compression if called too often.
1425+*/
1426+
1427+/*
1428+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
1429+ z_off_t offset, int whence));
1430+
1431+ Sets the starting position for the next gzread or gzwrite on the given
1432+ compressed file. The offset represents a number of bytes in the
1433+ uncompressed data stream. The whence parameter is defined as in lseek(2);
1434+ the value SEEK_END is not supported.
1435+
1436+ If the file is opened for reading, this function is emulated but can be
1437+ extremely slow. If the file is opened for writing, only forward seeks are
1438+ supported; gzseek then compresses a sequence of zeroes up to the new
1439+ starting position.
1440+
1441+ gzseek returns the resulting offset location as measured in bytes from
1442+ the beginning of the uncompressed stream, or -1 in case of error, in
1443+ particular if the file is opened for writing and the new starting position
1444+ would be before the current position.
1445+*/
1446+
1447+ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
1448+/*
1449+ Rewinds the given file. This function is supported only for reading.
1450+
1451+ gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
1452+*/
1453+
1454+/*
1455+ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
1456+
1457+ Returns the starting position for the next gzread or gzwrite on the given
1458+ compressed file. This position represents a number of bytes in the
1459+ uncompressed data stream, and is zero when starting, even if appending or
1460+ reading a gzip stream from the middle of a file using gzdopen().
1461+
1462+ gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
1463+*/
1464+
1465+/*
1466+ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
1467+
1468+ Returns the current offset in the file being read or written. This offset
1469+ includes the count of bytes that precede the gzip stream, for example when
1470+ appending or when using gzdopen() for reading. When reading, the offset
1471+ does not include as yet unused buffered input. This information can be used
1472+ for a progress indicator. On error, gzoffset() returns -1.
1473+*/
1474+
1475+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
1476+/*
1477+ Returns true (1) if the end-of-file indicator has been set while reading,
1478+ false (0) otherwise. Note that the end-of-file indicator is set only if the
1479+ read tried to go past the end of the input, but came up short. Therefore,
1480+ just like feof(), gzeof() may return false even if there is no more data to
1481+ read, in the event that the last read request was for the exact number of
1482+ bytes remaining in the input file. This will happen if the input file size
1483+ is an exact multiple of the buffer size.
1484+
1485+ If gzeof() returns true, then the read functions will return no more data,
1486+ unless the end-of-file indicator is reset by gzclearerr() and the input file
1487+ has grown since the previous end of file was detected.
1488+*/
1489+
1490+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
1491+/*
1492+ Returns true (1) if file is being copied directly while reading, or false
1493+ (0) if file is a gzip stream being decompressed.
1494+
1495+ If the input file is empty, gzdirect() will return true, since the input
1496+ does not contain a gzip stream.
1497+
1498+ If gzdirect() is used immediately after gzopen() or gzdopen() it will
1499+ cause buffers to be allocated to allow reading the file to determine if it
1500+ is a gzip file. Therefore if gzbuffer() is used, it should be called before
1501+ gzdirect().
1502+
1503+ When writing, gzdirect() returns true (1) if transparent writing was
1504+ requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note:
1505+ gzdirect() is not needed when writing. Transparent writing must be
1506+ explicitly requested, so the application already knows the answer. When
1507+ linking statically, using gzdirect() will include all of the zlib code for
1508+ gzip file reading and decompression, which may not be desired.)
1509+*/
1510+
1511+ZEXTERN int ZEXPORT gzclose OF((gzFile file));
1512+/*
1513+ Flushes all pending output if necessary, closes the compressed file and
1514+ deallocates the (de)compression state. Note that once file is closed, you
1515+ cannot call gzerror with file, since its structures have been deallocated.
1516+ gzclose must not be called more than once on the same file, just as free
1517+ must not be called more than once on the same allocation.
1518+
1519+ gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
1520+ file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
1521+ last read ended in the middle of a gzip stream, or Z_OK on success.
1522+*/
1523+
1524+ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
1525+ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
1526+/*
1527+ Same as gzclose(), but gzclose_r() is only for use when reading, and
1528+ gzclose_w() is only for use when writing or appending. The advantage to
1529+ using these instead of gzclose() is that they avoid linking in zlib
1530+ compression or decompression code that is not used when only reading or only
1531+ writing respectively. If gzclose() is used, then both compression and
1532+ decompression code will be included the application when linking to a static
1533+ zlib library.
1534+*/
1535+
1536+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
1537+/*
1538+ Returns the error message for the last error which occurred on the given
1539+ compressed file. errnum is set to zlib error number. If an error occurred
1540+ in the file system and not in the compression library, errnum is set to
1541+ Z_ERRNO and the application may consult errno to get the exact error code.
1542+
1543+ The application must not modify the returned string. Future calls to
1544+ this function may invalidate the previously returned string. If file is
1545+ closed, then the string previously returned by gzerror will no longer be
1546+ available.
1547+
1548+ gzerror() should be used to distinguish errors from end-of-file for those
1549+ functions above that do not distinguish those cases in their return values.
1550+*/
1551+
1552+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
1553+/*
1554+ Clears the error and end-of-file flags for file. This is analogous to the
1555+ clearerr() function in stdio. This is useful for continuing to read a gzip
1556+ file that is being written concurrently.
1557+*/
1558+
1559+#endif /* !Z_SOLO */
1560+
1561+ /* checksum functions */
1562+
1563+/*
1564+ These functions are not related to compression but are exported
1565+ anyway because they might be useful in applications using the compression
1566+ library.
1567+*/
1568+
1569+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
1570+/*
1571+ Update a running Adler-32 checksum with the bytes buf[0..len-1] and
1572+ return the updated checksum. If buf is Z_NULL, this function returns the
1573+ required initial value for the checksum.
1574+
1575+ An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
1576+ much faster.
1577+
1578+ Usage example:
1579+
1580+ uLong adler = adler32(0L, Z_NULL, 0);
1581+
1582+ while (read_buffer(buffer, length) != EOF) {
1583+ adler = adler32(adler, buffer, length);
1584+ }
1585+ if (adler != original_adler) error();
1586+*/
1587+
1588+/*
1589+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
1590+ z_off_t len2));
1591+
1592+ Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
1593+ and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
1594+ each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of
1595+ seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note
1596+ that the z_off_t type (like off_t) is a signed integer. If len2 is
1597+ negative, the result has no meaning or utility.
1598+*/
1599+
1600+ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
1601+/*
1602+ Update a running CRC-32 with the bytes buf[0..len-1] and return the
1603+ updated CRC-32. If buf is Z_NULL, this function returns the required
1604+ initial value for the crc. Pre- and post-conditioning (one's complement) is
1605+ performed within this function so it shouldn't be done by the application.
1606+
1607+ Usage example:
1608+
1609+ uLong crc = crc32(0L, Z_NULL, 0);
1610+
1611+ while (read_buffer(buffer, length) != EOF) {
1612+ crc = crc32(crc, buffer, length);
1613+ }
1614+ if (crc != original_crc) error();
1615+*/
1616+
1617+/*
1618+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
1619+
1620+ Combine two CRC-32 check values into one. For two sequences of bytes,
1621+ seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
1622+ calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32
1623+ check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
1624+ len2.
1625+*/
1626+
1627+
1628+ /* various hacks, don't look :) */
1629+
1630+/* deflateInit and inflateInit are macros to allow checking the zlib version
1631+ * and the compiler's view of z_stream:
1632+ */
1633+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
1634+ const char *version, int stream_size));
1635+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
1636+ const char *version, int stream_size));
1637+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
1638+ int windowBits, int memLevel,
1639+ int strategy, const char *version,
1640+ int stream_size));
1641+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
1642+ const char *version, int stream_size));
1643+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
1644+ unsigned char FAR *window,
1645+ const char *version,
1646+ int stream_size));
1647+#define deflateInit(strm, level) \
1648+ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
1649+#define inflateInit(strm) \
1650+ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
1651+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
1652+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
1653+ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
1654+#define inflateInit2(strm, windowBits) \
1655+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
1656+ (int)sizeof(z_stream))
1657+#define inflateBackInit(strm, windowBits, window) \
1658+ inflateBackInit_((strm), (windowBits), (window), \
1659+ ZLIB_VERSION, (int)sizeof(z_stream))
1660+
1661+#ifndef Z_SOLO
1662+
1663+/* gzgetc() macro and its supporting function and exposed data structure. Note
1664+ * that the real internal state is much larger than the exposed structure.
1665+ * This abbreviated structure exposes just enough for the gzgetc() macro. The
1666+ * user should not mess with these exposed elements, since their names or
1667+ * behavior could change in the future, perhaps even capriciously. They can
1668+ * only be used by the gzgetc() macro. You have been warned.
1669+ */
1670+struct gzFile_s {
1671+ unsigned have;
1672+ unsigned char *next;
1673+ z_off64_t pos;
1674+};
1675+ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
1676+#ifdef Z_PREFIX_SET
1677+# undef z_gzgetc
1678+# define z_gzgetc(g) \
1679+ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
1680+#else
1681+# define gzgetc(g) \
1682+ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
1683+#endif
1684+
1685+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
1686+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
1687+ * both are true, the application gets the *64 functions, and the regular
1688+ * functions are changed to 64 bits) -- in case these are set on systems
1689+ * without large file support, _LFS64_LARGEFILE must also be true
1690+ */
1691+#ifdef Z_LARGE64
1692+ ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
1693+ ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
1694+ ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
1695+ ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
1696+ ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
1697+ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
1698+#endif
1699+
1700+#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
1701+# ifdef Z_PREFIX_SET
1702+# define z_gzopen z_gzopen64
1703+# define z_gzseek z_gzseek64
1704+# define z_gztell z_gztell64
1705+# define z_gzoffset z_gzoffset64
1706+# define z_adler32_combine z_adler32_combine64
1707+# define z_crc32_combine z_crc32_combine64
1708+# else
1709+# define gzopen gzopen64
1710+# define gzseek gzseek64
1711+# define gztell gztell64
1712+# define gzoffset gzoffset64
1713+# define adler32_combine adler32_combine64
1714+# define crc32_combine crc32_combine64
1715+# endif
1716+# ifndef Z_LARGE64
1717+ ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
1718+ ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
1719+ ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
1720+ ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
1721+ ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
1722+ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
1723+# endif
1724+#else
1725+ ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
1726+ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
1727+ ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
1728+ ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
1729+ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
1730+ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
1731+#endif
1732+
1733+#else /* Z_SOLO */
1734+
1735+ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
1736+ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
1737+
1738+#endif /* !Z_SOLO */
1739+
1740+/* hack for buggy compilers */
1741+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
1742+ struct internal_state {int dummy;};
1743+#endif
1744+
1745+/* undocumented functions */
1746+ZEXTERN const char * ZEXPORT zError OF((int));
1747+ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
1748+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
1749+ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
1750+ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
1751+ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
1752+#if defined(_WIN32) && !defined(Z_SOLO)
1753+ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
1754+ const char *mode));
1755+#endif
1756+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
1757+# ifndef Z_SOLO
1758+ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file,
1759+ const char *format,
1760+ va_list va));
1761+# endif
1762+#endif
1763+
1764+#ifdef __cplusplus
1765+}
1766+#endif
1767+
1768+#endif /* ZLIB_H */
--- pkg/tags/20220203/Makefile (nonexistent)
+++ pkg/tags/20220203/Makefile (revision 615)
@@ -0,0 +1,87 @@
1+#
2+# pkg Makefile -- requires OpenWatcom (wmake)
3+# Copyright (C) 2021 Mateusz Viste
4+#
5+
6+CFLAGS = -0 -mc -os -wx -we -d0 -i=zlib
7+LDFLAGS = -lr -fe=pkg.exe
8+LIBS = zlib\zlib_c.lib svarlang.lib\svarlngc.lib
9+
10+all: pkg.exe
11+
12+release: pkg.exe .symbolic
13+ mkdir appinfo
14+ mkdir bin
15+ mkdir nls
16+ copy pkg.lng nls
17+ upx --8086 -9 pkg.exe -o bin\pkg.exe
18+ copy pkg.lsm appinfo
19+ zip -9moDkrX pkg.zip appinfo bin nls
20+ rmdir appinfo
21+ rmdir bin
22+ rmdir nls
23+
24+pkg.exe: main.obj crc32.obj fileexst.obj helpers.obj inf.obj kprintf.obj libunzip.obj loadconf.obj lsm.obj pkginst.obj pkgrem.obj trim.obj showinst.obj unzip.obj deflang.obj
25+ wcl $(LDFLAGS) $(LIBS) *.obj
26+
27+deflang.obj: nls_utf8\pkg_en.txt
28+ cd nls_utf8
29+ copy pkg_en.txt en.txt
30+ utf8tocp 850 pkg_de.txt > de.txt
31+ utf8tocp 850 pkg_fr.txt > fr.txt
32+ utf8tocp 850 pkg_dk.txt > dk.txt
33+ utf8tocp 852 pkg_si.txt > si.txt
34+ utf8tocp 857 pkg_tr.txt > tr.txt
35+ utf8tocp maz pkg_pl.txt > pl.txt
36+ ..\svarlang.lib\tlumacz en de fr dk si tr pl
37+ move out.lng ..\pkg.lng
38+ move deflang.c ..
39+ del ??.txt
40+ cd ..
41+ wcc $(CFLAGS) deflang.c
42+
43+main.obj: main.c
44+ wcc $(CFLAGS) main.c
45+
46+crc32.obj: crc32.c
47+ wcc $(CFLAGS) crc32.c
48+
49+fileexst.obj: fileexst.c
50+ wcc $(CFLAGS) fileexst.c
51+
52+helpers.obj: helpers.c
53+ wcc $(CFLAGS) helpers.c
54+
55+inf.obj: inf.c
56+ wcc $(CFLAGS) inf.c
57+
58+kprintf.obj: kprintf.c
59+ wcc $(CFLAGS) kprintf.c
60+
61+libunzip.obj: libunzip.c
62+ wcc $(CFLAGS) libunzip.c
63+
64+loadconf.obj: loadconf.c
65+ wcc $(CFLAGS) loadconf.c
66+
67+lsm.obj: lsm.c
68+ wcc $(CFLAGS) lsm.c
69+
70+pkginst.obj: pkginst.c
71+ wcc $(CFLAGS) pkginst.c
72+
73+pkgrem.obj: pkgrem.c
74+ wcc $(CFLAGS) pkgrem.c
75+
76+trim.obj: trim.c
77+ wcc $(CFLAGS) trim.c
78+
79+showinst.obj: showinst.c
80+ wcc $(CFLAGS) showinst.c
81+
82+unzip.obj: unzip.c
83+ wcc $(CFLAGS) unzip.c
84+
85+clean: .symbolic
86+ del *.obj
87+ del pkg.exe
--- pkg/tags/20220203/crc32.c (nonexistent)
+++ pkg/tags/20220203/crc32.c (revision 615)
@@ -0,0 +1,128 @@
1+/*
2+ * $Id: crc32.c,v 1.1.1.1 1996/02/18 21:38:12 ylo Exp $
3+ * $Log: crc32.c,v $
4+ * Revision 1.1.1.1 1996/02/18 21:38:12 ylo
5+ * Imported ssh-1.2.13.
6+ *
7+ * Revision 1.2 1995/07/13 01:21:34 ylo
8+ * Added cvs log.
9+ *
10+ * $Endlog$
11+ */
12+
13+/* The implementation here was originally done by Gary S. Brown. I have
14+ borrowed the tables directly, and made some minor changes to the
15+ crc32-function (including changing the interface). */
16+
17+#include "crc32.h"
18+
19+ /* ============================================================= */
20+ /* COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or */
21+ /* code or tables extracted from it, as desired without restriction. */
22+ /* */
23+ /* First, the polynomial itself and its table of feedback terms. The */
24+ /* polynomial is */
25+ /* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
26+ /* */
27+ /* Note that we take it "backwards" and put the highest-order term in */
28+ /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
29+ /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
30+ /* the MSB being 1. */
31+ /* */
32+ /* Note that the usual hardware shift register implementation, which */
33+ /* is what we're using (we're merely optimizing it by doing eight-bit */
34+ /* chunks at a time) shifts bits into the lowest-order term. In our */
35+ /* implementation, that means shifting towards the right. Why do we */
36+ /* do it this way? Because the calculated CRC must be transmitted in */
37+ /* order from highest-order term to lowest-order term. UARTs transmit */
38+ /* characters in order from LSB to MSB. By storing the CRC this way, */
39+ /* we hand it to the UART in the order low-byte to high-byte; the UART */
40+ /* sends each low-bit to hight-bit; and the result is transmission bit */
41+ /* by bit from highest- to lowest-order term without requiring any bit */
42+ /* shuffling on our part. Reception works similarly. */
43+ /* */
44+ /* The feedback terms table consists of 256, 32-bit entries. Notes: */
45+ /* */
46+ /* The table can be generated at runtime if desired; code to do so */
47+ /* is shown later. It might not be obvious, but the feedback */
48+ /* terms simply represent the results of eight shift/xor opera- */
49+ /* tions for all combinations of data and CRC register values. */
50+ /* */
51+ /* The values must be right-shifted by eight bits by the "updcrc" */
52+ /* logic; the shift must be unsigned (bring in zeroes). On some */
53+ /* hardware you could probably optimize the shift in assembler by */
54+ /* using byte-swap instructions. */
55+ /* polynomial $edb88320 */
56+ /* */
57+ /* -------------------------------------------------------------------- */
58+
59+const unsigned long crc32_tab[256] = {
60+ 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
61+ 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
62+ 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
63+ 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
64+ 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
65+ 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
66+ 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
67+ 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
68+ 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
69+ 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
70+ 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
71+ 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
72+ 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
73+ 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
74+ 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
75+ 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
76+ 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
77+ 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
78+ 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
79+ 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
80+ 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
81+ 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
82+ 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
83+ 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
84+ 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
85+ 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
86+ 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
87+ 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
88+ 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
89+ 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
90+ 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
91+ 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
92+ 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
93+ 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
94+ 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
95+ 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
96+ 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
97+ 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
98+ 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
99+ 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
100+ 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
101+ 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
102+ 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
103+ 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
104+ 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
105+ 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
106+ 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
107+ 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
108+ 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
109+ 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
110+ 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
111+ 0x2d02ef8dL
112+ };
113+
114+/* Return a 32-bit CRC of the contents of the buffer. */
115+
116+
117+unsigned long crc32_init(void) {
118+ return(0xFFFFFFFFlu);
119+}
120+
121+void crc32_feed(unsigned long *crc32val, const unsigned char *s, unsigned int len) {
122+ unsigned long i;
123+ for (i = 0; i < len; i++) *crc32val = crc32_tab[(*crc32val ^ s[i]) & 0xff] ^ (*crc32val >> 8);
124+}
125+
126+void crc32_finish(unsigned long *crc32val) {
127+ *crc32val ^= 0xFFFFFFFFlu;
128+}
--- pkg/tags/20220203/crc32.h (nonexistent)
+++ pkg/tags/20220203/crc32.h (revision 615)
@@ -0,0 +1,25 @@
1+/*
2+ * $Id: crc32.h,v 1.1.1.1 1996/02/18 21:38:11 ylo Exp $
3+ * $Log: crc32.h,v $
4+ * Revision 1.1.1.1 1996/02/18 21:38:11 ylo
5+ * Imported ssh-1.2.13.
6+ *
7+ * Revision 1.2 1995/07/13 01:21:45 ylo
8+ * Removed "Last modified" header.
9+ * Added cvs log.
10+ *
11+ * $Endlog$
12+ */
13+
14+#ifndef CRC32_H_SENTINEL
15+#define CRC32_H_SENTINEL
16+
17+unsigned long crc32_init(void);
18+
19+/* This computes a 32 bit CRC of the data in the buffer, and returns the
20+ CRC. The polynomial used is 0xedb88320. */
21+void crc32_feed(unsigned long *crc32val, const unsigned char *buf, unsigned int len);
22+
23+void crc32_finish(unsigned long *crc32val);
24+
25+#endif /* CRC32_H_SENTINEL */
--- pkg/tags/20220203/fileexst.c (nonexistent)
+++ pkg/tags/20220203/fileexst.c (revision 615)
@@ -0,0 +1,15 @@
1+/*
2+ * fileexists checks whether a file exists or not.
3+ * returns 0 if file not found, non-zero otherwise.
4+ */
5+
6+#include <stdio.h>
7+#include "fileexst.h"
8+
9+int fileexists(const char *filename) {
10+ FILE *fd;
11+ fd = fopen(filename, "rb");
12+ if (fd == NULL) return(0); /* file does not exists */
13+ fclose(fd);
14+ return(1);
15+}
--- pkg/tags/20220203/fileexst.h (nonexistent)
+++ pkg/tags/20220203/fileexst.h (revision 615)
@@ -0,0 +1,11 @@
1+/*
2+ * fileexists checks whether a file exists or not.
3+ * returns 0 if file not found, non-zero otherwise.
4+ */
5+
6+#ifndef fileexists_sentinel
7+#define fileexists_sentinel
8+
9+int fileexists(const char *filename);
10+
11+#endif
--- pkg/tags/20220203/helpers.c (nonexistent)
+++ pkg/tags/20220203/helpers.c (revision 615)
@@ -0,0 +1,165 @@
1+/*
2+ * This file is part of pkginst
3+ * Copyright (C) 2012-2021 Mateusz Viste
4+ *
5+ * It contains a few helper function...
6+ */
7+
8+
9+#include <ctype.h> /* tolower() */
10+#include <direct.h> /* provides the mkdir() prototype */
11+#include <string.h> /* */
12+#include <stdio.h> /* sprintf() */
13+#include <stdlib.h> /* atoi() */
14+#include <sys/stat.h> /* mkdir() */
15+
16+#include "trim.h"
17+#include "helpers.h"
18+
19+
20+/* change all / to \ in a string */
21+void slash2backslash(char *str) {
22+ int x;
23+ for (x = 0; str[x] != 0; x++) {
24+ if (str[x] == '/') str[x] = '\\';
25+ }
26+}
27+
28+
29+void removeDoubleBackslashes(char *str) {
30+ char *curpos;
31+ int x;
32+ for (;;) {
33+ curpos = strstr(str, "\\\\");
34+ if (curpos == NULL) return; /* job done */
35+ for (x = 1; curpos[x] != 0; x++) {
36+ curpos[x - 1] = curpos[x];
37+ }
38+ curpos[x - 1] = 0;
39+ }
40+}
41+
42+
43+/* converts a string to all lowercase */
44+void strtolower(char *mystring) {
45+ int x;
46+ for (x = 0; mystring[x] != 0; x++) mystring[x] = tolower(mystring[x]);
47+}
48+
49+
50+/* Find the first occurrence of find in s, ignore case. */
51+char *fdnpkg_strcasestr(const char *s, const char *find) {
52+ char c, sc;
53+ size_t len;
54+ if ((c = *find++) != 0) {
55+ c = tolower((unsigned char)c);
56+ len = strlen(find);
57+ do {
58+ do {
59+ if ((sc = *s++) == 0) return(NULL);
60+ } while ((char)tolower((unsigned char)sc) != c);
61+ } while (strncasecmp(s, find, len) != 0);
62+ s--;
63+ }
64+ return((char *)s);
65+}
66+
67+
68+/* Creates directories recursively */
69+void mkpath(char *dirs) {
70+ int x;
71+ char savechar;
72+ for (x = 0; dirs[x] != 0; x++) {
73+ if (((dirs[x] == '/') || (dirs[x] == '\\')) && (x > 0)) {
74+ if (dirs[x - 1] != ':') { /* avoid d:\ stuff */
75+ savechar = dirs[x];
76+ dirs[x] = 0;
77+ /* make the dir */
78+ mkdir(dirs);
79+ dirs[x] = savechar;
80+ }
81+ }
82+ }
83+}
84+
85+
86+/* returns a pointer to the start of the filename, out of a path\to\file string, and
87+ fills respath with the local folder where the file should be placed. */
88+char *computelocalpath(char *longfilename, char *respath, const char *dosdir, const struct customdirs *dirlist) {
89+ int x, lastsep = 0, firstsep = -1;
90+ char savedchar;
91+ char *shortfilename, *pathstart;
92+ pathstart = longfilename;
93+ for (x = 0; longfilename[x] != 0; x++) {
94+ if ((longfilename[x] == '/') || (longfilename[x] == '\\')) {
95+ lastsep = x;
96+ if (firstsep < 0) firstsep = x;
97+ }
98+ }
99+ shortfilename = &longfilename[lastsep + 1];
100+ /* look for possible custom path */
101+ if (firstsep > 0) {
102+ savedchar = longfilename[firstsep];
103+ longfilename[firstsep] = 0;
104+ for (; dirlist != NULL; dirlist = dirlist->next) {
105+ if (fdnpkg_strcasestr(longfilename, dirlist->name) == longfilename) { /* found! */
106+ /* sprintf(respath, "%s\\%s", dirlist->location, &longfilename[firstsep + 1]); */
107+ pathstart = &longfilename[firstsep + 1];
108+ dosdir = dirlist->location;
109+ break;
110+ }
111+ }
112+ longfilename[firstsep] = savedchar; /* restore longfilename as it was */
113+ }
114+ /* apply the default (DOSDIR) path */
115+ savedchar = longfilename[lastsep + 1];
116+ longfilename[lastsep + 1] = 0;
117+ sprintf(respath, "%s\\%s", dosdir, pathstart);
118+ slash2backslash(respath);
119+ removeDoubleBackslashes(respath);
120+ longfilename[lastsep + 1] = savedchar;
121+ return(shortfilename);
122+}
123+
124+
125+/* analyzes a filename string and returns the pointer to the file's extension
126+ * (which can be empty) */
127+char *getfext(char *fname) {
128+ char *res = NULL;
129+ for (; *fname != 0; fname++) {
130+ if (*fname == '.') res = fname + 1;
131+ }
132+ /* if no dot found, then point to the string's null terminator */
133+ if (res == NULL) return(fname);
134+ return(res);
135+}
136+
137+
138+/* reads a line from a "token = value" file, returns 0 on success
139+ * val (if not NULL) is updated with a pointer to the "value" part
140+ * delim is the delimiter char (typically ':' or '=' but can be anything) */
141+int freadtokval(FILE *fd, char *line, size_t maxlen, char **val, char delim) {
142+ int bytebuff, linelen = 0;
143+ if (val != NULL) *val = NULL;
144+ for (;;) {
145+ bytebuff = fgetc(fd);
146+ if (bytebuff == EOF) {
147+ if (linelen == 0) return(-1);
148+ break;
149+ }
150+ if (bytebuff < 0) return(-1);
151+ if ((*val == NULL) && (bytebuff == delim)) {
152+ line[linelen++] = 0;
153+ *val = line + linelen;
154+ continue;
155+ }
156+ if (bytebuff == '\r') continue; /* ignore CR */
157+ if (bytebuff == '\n') break;
158+ if (linelen < maxlen - 1) line[linelen++] = bytebuff;
159+ }
160+ /* terminate line and trim token and value (if any) */
161+ line[linelen] = 0;
162+ trim(line);
163+ if ((val != NULL) && (*val != NULL)) trim(*val);
164+ return(0);
165+}
--- pkg/tags/20220203/helpers.h (nonexistent)
+++ pkg/tags/20220203/helpers.h (revision 615)
@@ -0,0 +1,19 @@
1+/*
2+ * This file is part of pkginst
3+ * Copyright (C) 2012-2021 Mateusz Viste
4+ *
5+ * It contains a few helper function...
6+ */
7+
8+#ifndef helpers_sentinel
9+#define helpers_sentinel
10+#include "loadconf.h" /* required for the customdirs struct */
11+void slash2backslash(char *str);
12+void strtolower(char *mystring);
13+char *fdnpkg_strcasestr(const char *s, const char *find);
14+void mkpath(char *dirs);
15+char *computelocalpath(char *longfilename, char *respath, const char *dosdir, const struct customdirs *dirlist);
16+void removeDoubleBackslashes(char *str);
17+char *getfext(char *fname);
18+int freadtokval(FILE *fd, char *line, size_t maxlen, char **val, char delim);
19+#endif
--- pkg/tags/20220203/inf.c (nonexistent)
+++ pkg/tags/20220203/inf.c (revision 615)
@@ -0,0 +1,85 @@
1+/* This file is part of the FDNPKG project. It is an adaptation of the
2+ * "zpipe.c" example of zlib's inflate() and deflate() usage.
3+ *
4+ * Not copyrighted -- provided to the public domain
5+ * original version 1.4 11 December 2005 Mark Adler
6+ * adaptations for FDNPKG integration by Mateusz Viste, 2015
7+ */
8+
9+#include <stdio.h>
10+#include <string.h>
11+
12+#include "crc32.h"
13+#include "zlib\zlib.h"
14+
15+#include "inf.h"
16+
17+#define CHUNK 16384
18+
19+/* Decompress from file source to file dest until stream ends or EOF.
20+ * inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated
21+ * for processing, Z_DATA_ERROR if the deflate data is invalid or incomplete,
22+ * Z_VERSION_ERROR if the version of zlib.h and the version of the library
23+ * linked do not match, or Z_ERRNO if there is an error reading or writing the
24+ * files. */
25+int inf(FILE *source, FILE *dest, unsigned char *buff32K, unsigned long *cksum, long streamlen) {
26+ int ret;
27+ unsigned int have;
28+ z_stream strm;
29+ unsigned char *in = buff32K;
30+ unsigned char *out = buff32K + CHUNK;
31+
32+ /* allocate inflate state */
33+ strm.zalloc = Z_NULL;
34+ strm.zfree = Z_NULL;
35+ strm.opaque = Z_NULL;
36+ strm.avail_in = 0;
37+ strm.next_in = Z_NULL;
38+ ret = inflateInit2(&strm, -15); /* according to the zlib doc, passing -15 to inflateInit2() means "this is a raw deflate stream" (as opposed to a zlib- or gz- wrapped stream) */
39+ if (ret != Z_OK) return(ret);
40+
41+ /* decompress until deflate stream ends or end of file */
42+ do {
43+ strm.avail_in = fread(in, 1, (streamlen > CHUNK ? CHUNK : streamlen), source);
44+ if (ferror(source)) {
45+ (void)inflateEnd(&strm);
46+ return(Z_ERRNO);
47+ }
48+ streamlen -= strm.avail_in;
49+ if (strm.avail_in == 0) break;
50+ strm.next_in = in;
51+
52+ /* run inflate() on input until output buffer not full */
53+ do {
54+ strm.avail_out = CHUNK;
55+ strm.next_out = out;
56+ ret = inflate(&strm, Z_NO_FLUSH);
57+ switch (ret) {
58+ case Z_NEED_DICT:
59+ ret = Z_DATA_ERROR; /* and fall through */
60+ case Z_DATA_ERROR:
61+ case Z_MEM_ERROR:
62+ (void)inflateEnd(&strm);
63+ return(ret);
64+ }
65+ have = CHUNK - strm.avail_out;
66+ if ((fwrite(out, 1, have, dest) != have) || (ferror(dest))) {
67+ (void)inflateEnd(&strm);
68+ return(Z_ERRNO);
69+ }
70+ /* feed the CRC32 */
71+ crc32_feed(cksum, out, have);
72+ } while (strm.avail_out == 0);
73+
74+ /* done when inflate() says it's done */
75+ } while (ret != Z_STREAM_END);
76+
77+ /* clean up and return */
78+ (void)inflateEnd(&strm);
79+
80+ if (Z_STREAM_END) {
81+ return(Z_OK);
82+ } else {
83+ return(Z_DATA_ERROR);
84+ }
85+}
--- pkg/tags/20220203/inf.h (nonexistent)
+++ pkg/tags/20220203/inf.h (revision 615)
@@ -0,0 +1,13 @@
1+
2+#ifndef INF_H
3+#define INF_H
4+
5+/* Decompress from file source to file dest until stream ends or EOF.
6+ * inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated
7+ * for processing, Z_DATA_ERROR if the deflate data is invalid or incomplete,
8+ * Z_VERSION_ERROR if the version of zlib.h and the version of the library
9+ * linked do not match, or Z_ERRNO if there is an error reading or writing the
10+ * files. */
11+int inf(FILE *source, FILE *dest, unsigned char *buff32k, unsigned long *cksum, long streamlen);
12+
13+#endif
--- pkg/tags/20220203/kprintf.c (nonexistent)
+++ pkg/tags/20220203/kprintf.c (revision 615)
@@ -0,0 +1,20 @@
1+/*
2+ * This file provides dummy functions that simulate kitten-enabled routines
3+ * without actually having kitten.
4+ *
5+ * Copyright (C) 2015-2022 Mateusz Viste
6+ */
7+
8+#include <stdio.h> /* vprintf() */
9+#include <stdarg.h> /* va_list, va_start()... */
10+
11+#include "svarlang.lib\svarlang.h"
12+
13+#include "kprintf.h"
14+
15+void kitten_printf(short x, short y, ...) {
16+ va_list args;
17+ va_start(args, y);
18+ vprintf(svarlang_str(x, y), args);
19+ va_end(args);
20+}
--- pkg/tags/20220203/kprintf.h (nonexistent)
+++ pkg/tags/20220203/kprintf.h (revision 615)
@@ -0,0 +1,11 @@
1+/*
2+ * The following is a macro-like function that uses kitten instead
3+ * of directly doing printf.
4+ */
5+
6+#ifndef kprintf_sentinel
7+#define kprintf_sentinel
8+
9+void kitten_printf(short x, short y, ...);
10+
11+#endif
--- pkg/tags/20220203/libunzip.c (nonexistent)
+++ pkg/tags/20220203/libunzip.c (revision 615)
@@ -0,0 +1,254 @@
1+/*
2+ * This file is part of pkg (SvarDOS)
3+ * Copyright (C) 2012-2021 Mateusz Viste.
4+ *
5+ * Simple library providing functions to unzip files from zip archives.
6+ */
7+
8+#include <stdio.h> /* printf(), FILE, fclose()... */
9+#include <stdlib.h> /* NULL */
10+#include <string.h> /* memset() */
11+#include <time.h> /* mktime() */
12+#include <utime.h> /* utime() */
13+#include <unistd.h> /* unlink() */
14+
15+#include "crc32.h"
16+#include "kprintf.h"
17+#include "inf.h" /* INFLATE support */
18+
19+#include "libunzip.h" /* include self for control */
20+
21+
22+/* converts a "DOS format" timestamp into unix timestamp. The DOS timestamp is constructed an array of 4 bytes, that contains following data at the bit level:
23+ * HHHHHMMM MMMSSSSS YYYYYYYM MMMDDDDD
24+ * where:
25+ * day of month is always within 1-31 range;
26+ * month is always within 1-12 range;
27+ * year starts from 1980 and continues for 127 years
28+ * seconds are actually not 0-59 but rather 0-29 as there are only 32 possible values – to get actual seconds multiply this field by 2;
29+ * minutes are always within 0-59 range;
30+ * hours are always within 0-23 range. */
31+static time_t dostime2unix(const unsigned char *buff) {
32+ struct tm curtime;
33+ time_t result;
34+ memset(&curtime, 0, sizeof(curtime)); /* make sure to set everything in curtime to 0's */
35+ curtime.tm_sec = (buff[0] & 31) << 1; /* seconds (0..60) */
36+ curtime.tm_min = (((buff[1] << 8) | buff[0]) >> 5) & 63 ; /* minutes after the hour (0..59) */
37+ curtime.tm_hour = (buff[1] >> 3); /* hours since midnight (0..23) */
38+ curtime.tm_mday = buff[2] & 31; /* day of the month (1..31) */
39+ curtime.tm_mon = ((((buff[3] << 8) | buff[2]) >> 5) & 15) - 1; /* months since January (0, 11) */
40+ curtime.tm_year = (buff[3] >> 1) + 80; /* years since 1900 */
41+ curtime.tm_wday = 0; /* days since Sunday (0..6) - leave 0, mktime() will set it */
42+ curtime.tm_yday = 0; /* days since January 1 (0..365]) - leave 0, mktime() will set it */
43+ curtime.tm_isdst = -1; /* Daylight Saving Time flag. Positive if DST is in effect, zero if not and negative if no information is available */
44+ result = mktime(&curtime);
45+ if (result == (time_t)-1) return(0);
46+ return(result);
47+}
48+
49+
50+/* opens a zip file and provides the list of files in the archive.
51+ returns a pointer to a ziplist (linked list) with all records, or NULL on error.
52+ The ziplist is allocated automatically, and must be freed via zip_freelist. */
53+struct ziplist *zip_listfiles(FILE *fd) {
54+ struct ziplist *reslist = NULL;
55+ struct ziplist *newentry;
56+ unsigned long entrysig;
57+ unsigned short filenamelen, extrafieldlen, filecommentlen;
58+ unsigned long compfilelen;
59+ int centraldirectoryfound = 0;
60+ unsigned int ux;
61+ unsigned char hdrbuff[64];
62+
63+ rewind(fd); /* make sure the file cursor is at the very beginning of the file */
64+
65+ for (;;) { /* read entry after entry */
66+ int x, eofflag;
67+ long longbuff;
68+ entrysig = 0;
69+ eofflag = 0;
70+ /* read the entry signature first */
71+ for (x = 0; x < 32; x += 8) {
72+ if ((longbuff = fgetc(fd)) == EOF) {
73+ eofflag = 1;
74+ break;
75+ }
76+ entrysig |= (longbuff << x);
77+ }
78+ if (eofflag != 0) break;
79+ /* printf("sig: 0x%08x\n", entrysig); */
80+ if (entrysig == 0x04034b50ul) { /* local file */
81+ unsigned int generalpurposeflags;
82+ /* read and parse the zip header */
83+ fread(hdrbuff, 1, 26, fd);
84+ /* read filename's length so I can allocate the proper amound of mem */
85+ filenamelen = hdrbuff[23];
86+ filenamelen <<= 8;
87+ filenamelen |= hdrbuff[22];
88+ /* create new entry and link it into the list */
89+ newentry = calloc(sizeof(struct ziplist) + filenamelen, 1);
90+ if (newentry == NULL) {
91+ kitten_printf(2, 14, "libunzip"); /* "Out of memory! (%s)" */
92+ puts("");
93+ zip_freelist(&reslist);
94+ break;
95+ }
96+ newentry->nextfile = reslist;
97+ newentry->flags = 0;
98+ reslist = newentry;
99+ /* read further areas of the header, and fill zip entry */
100+ generalpurposeflags = hdrbuff[3]; /* parse the general */
101+ generalpurposeflags <<= 8; /* purpose flags and */
102+ generalpurposeflags |= hdrbuff[2]; /* save them for later */
103+ newentry->compmethod = hdrbuff[4] | (hdrbuff[5] << 8);
104+ newentry->timestamp = dostime2unix(&hdrbuff[6]);
105+ newentry->crc32 = 0;
106+ for (x = 13; x >= 10; x--) {
107+ newentry->crc32 <<= 8;
108+ newentry->crc32 |= hdrbuff[x];
109+ }
110+ newentry->compressedfilelen = 0;
111+ for (x = 17; x >= 14; x--) {
112+ newentry->compressedfilelen <<= 8;
113+ newentry->compressedfilelen |= hdrbuff[x];
114+ }
115+ newentry->filelen = 0;
116+ for (x = 21; x >= 18; x--) {
117+ newentry->filelen <<= 8;
118+ newentry->filelen |= hdrbuff[x];
119+ }
120+ extrafieldlen = hdrbuff[25];
121+ extrafieldlen <<= 8;
122+ extrafieldlen |= hdrbuff[24];
123+ /* printf("Filename len: %d / extrafield len: %d / compfile len: %ld / filelen: %ld\n", filenamelen, extrafieldlen, newentry->compressedfilelen, newentry->filelen); */
124+ /* check general purpose flags */
125+ if ((generalpurposeflags & 1) != 0) newentry->flags |= ZIP_FLAG_ENCRYPTED;
126+ /* parse the filename */
127+ for (ux = 0; ux < filenamelen; ux++) newentry->filename[ux] = fgetc(fd); /* store filename */
128+ if (newentry->filename[filenamelen - 1] == '/') newentry->flags |= ZIP_FLAG_ISADIR; /* if filename ends with / it's a dir. Note that ZIP forbids the usage of '\' in ZIP paths anyway */
129+ /* printf("Filename: %s (%ld bytes compressed)\n", newentry->filename, newentry->compressedfilelen); */
130+ newentry->dataoffset = ftell(fd) + extrafieldlen;
131+ /* skip rest of fields and data */
132+ fseek(fd, (extrafieldlen + newentry->compressedfilelen), SEEK_CUR);
133+ } else if (entrysig == 0x02014b50ul) { /* central directory */
134+ centraldirectoryfound = 1;
135+ /* parse header now */
136+ fread(hdrbuff, 1, 42, fd);
137+ filenamelen = hdrbuff[22] | (hdrbuff[23] << 8);
138+ extrafieldlen = hdrbuff[24] | (hdrbuff[25] << 8);
139+ filecommentlen = hdrbuff[26] | (hdrbuff[27] << 8);
140+ compfilelen = 0;
141+ for (x = 17; x >= 14; x--) {
142+ compfilelen <<= 8;
143+ compfilelen |= hdrbuff[x];
144+ }
145+ /* printf("central dir\n"); */
146+ /* skip rest of fields and data */
147+ fseek(fd, (filenamelen + extrafieldlen + compfilelen + filecommentlen), SEEK_CUR);
148+ } else if (entrysig == 0x08074b50ul) { /* Data descriptor header */
149+ /* no need to read the header we just have to skip it */
150+ fseek(fd, 12, SEEK_CUR); /* the header is 3x4 bytes (CRC + compressed len + uncompressed len) */
151+ } else { /* unknown sig */
152+ kitten_printf(8, 1, entrysig); /* "unknown zip sig: 0x%08lx" */
153+ puts("");
154+ zip_freelist(&reslist);
155+ break;
156+ }
157+ }
158+ /* if we got no central directory record, the file is incomplete */
159+ if (centraldirectoryfound == 0) zip_freelist(&reslist);
160+ return(reslist);
161+}
162+
163+
164+
165+/* unzips a file. zipfd points to the open zip file, curzipnode to the entry to extract, and fulldestfilename is the destination file where to unzip it. returns 0 on success, non-zero otherwise. */
166+int zip_unzip(FILE *zipfd, struct ziplist *curzipnode, const char *fulldestfilename) {
167+ #define buffsize 32 * 1024l /* MUST be at least 32K */
168+ FILE *filefd;
169+ unsigned long cksum;
170+ int extract_res;
171+ unsigned char *buff;
172+ struct utimbuf filetimestamp;
173+
174+ /* first of all, check we support the compression method */
175+ switch (curzipnode->compmethod) {
176+ case ZIP_METH_STORE:
177+ case ZIP_METH_DEFLATE:
178+ break;
179+ default: /* unsupported compression method, sorry */
180+ return(-1);
181+ break;
182+ }
183+
184+ /* open the dst file */
185+ filefd = fopen(fulldestfilename, "wb");
186+ if (filefd == NULL) return(-2); /* failed to open the dst file */
187+
188+ /* allocate buffers for data I/O */
189+ buff = malloc(buffsize);
190+ if (buff == NULL) {
191+ fclose(filefd);
192+ unlink(fulldestfilename); /* remove the failed file once it is closed */
193+ return(-6);
194+ }
195+
196+ if (fseek(zipfd, curzipnode->dataoffset, SEEK_SET) != 0) { /* set the reading position inside the zip file */
197+ free(buff);
198+ fclose(filefd);
199+ unlink(fulldestfilename); /* remove the failed file once it is closed */
200+ return(-7);
201+ }
202+ extract_res = -255;
203+
204+ cksum = crc32_init(); /* init the crc32 */
205+
206+ if (curzipnode->compmethod == 0) { /* if the file is stored, copy it over */
207+ long i, toread;
208+ extract_res = 0; /* assume we will succeed */
209+ for (i = 0; i < curzipnode->filelen;) {
210+ toread = curzipnode->filelen - i;
211+ if (toread > buffsize) toread = buffsize;
212+ if (fread(buff, toread, 1, zipfd) != 1) extract_res = -3; /* read a chunk of data */
213+ crc32_feed(&cksum, buff, toread); /* update the crc32 checksum */
214+ if (fwrite(buff, toread, 1, filefd) != 1) extract_res = -4; /* write data chunk to dst file */
215+ i += toread;
216+ }
217+ } else if (curzipnode->compmethod == 8) { /* if the file is deflated, inflate it */
218+ extract_res = inf(zipfd, filefd, buff, &cksum, curzipnode->compressedfilelen);
219+ }
220+
221+ /* clean up memory, close the dst file and terminates crc32 */
222+ free(buff);
223+ fclose(filefd); /* close the dst file */
224+ crc32_finish(&cksum);
225+
226+ /* printf("extract_res=%d / cksum_expected=%08lX / cksum_obtained=%08lX\n", extract_res, curzipnode->crc32, cksum); */
227+ if (extract_res != 0) { /* was the extraction process successful? */
228+ unlink(fulldestfilename); /* remove the failed file */
229+ return(extract_res);
230+ }
231+ if (cksum != curzipnode->crc32) { /* is the crc32 ok after extraction? */
232+ unlink(fulldestfilename); /* remove the failed file */
233+ return(-9);
234+ }
235+ /* Set the timestamp of the new file to what was set in the zip file */
236+ filetimestamp.actime = curzipnode->timestamp;
237+ filetimestamp.modtime = curzipnode->timestamp;
238+ utime(fulldestfilename, &filetimestamp);
239+ return(0);
240+}
241+
242+
243+
244+/* Call this to free a ziplist computed by zip_listfiles() */
245+void zip_freelist(struct ziplist **ziplist) {
246+ struct ziplist *zipentrytobefreed;
247+ while (*ziplist != NULL) { /* iterate through the linked list and free all nodes */
248+ zipentrytobefreed = *ziplist;
249+ *ziplist = zipentrytobefreed->nextfile;
250+ /* free the node entry */
251+ free(zipentrytobefreed);
252+ }
253+ *ziplist = NULL;
254+}
--- pkg/tags/20220203/libunzip.h (nonexistent)
+++ pkg/tags/20220203/libunzip.h (revision 615)
@@ -0,0 +1,38 @@
1+/*
2+ * This file is part of the FDNPKG project
3+ * http://fdnpkg.sourceforge.net
4+ *
5+ * Copyright (C) 2012-2016 Mateusz Viste. All rights reserved.
6+ *
7+ * Simple library providing functions to unzip files from zip archives.
8+ */
9+
10+
11+#ifndef libunzip_sentinel
12+#define libunzip_sentinel
13+
14+#include <time.h> /* required for the time_t definition */
15+
16+#define ZIP_FLAG_ISADIR 1
17+#define ZIP_FLAG_ENCRYPTED 2
18+
19+#define ZIP_METH_STORE 0
20+#define ZIP_METH_DEFLATE 8
21+
22+struct ziplist {
23+ long filelen;
24+ long compressedfilelen;
25+ unsigned long crc32;
26+ long dataoffset; /* offset in the file where compressed data starts */
27+ struct ziplist *nextfile;
28+ time_t timestamp; /* the timestamp of the file */
29+ short compmethod; /* compression method (ZIP_METH_xxx) */
30+ unsigned char flags; /* see ZIP_FLAG_xxx above */
31+ char filename[1]; /* must be last element (gets expanded at runtime) */
32+};
33+
34+struct ziplist *zip_listfiles(FILE *fd);
35+int zip_unzip(FILE *zipfd, struct ziplist *curzipnode, const char *fulldestfilename);
36+void zip_freelist(struct ziplist **ziplist);
37+
38+#endif
--- pkg/tags/20220203/loadconf.c (nonexistent)
+++ pkg/tags/20220203/loadconf.c (revision 615)
@@ -0,0 +1,158 @@
1+/*
2+ * This file is part of pkg (SvarDOS).
3+ * Copyright (C) 2012-2021 Mateusz Viste
4+ */
5+
6+#include <stdio.h> /* printf(), fclose(), fopen()... */
7+#include <string.h> /* strcasecmp() */
8+#include <stdlib.h> /* malloc(), free() */
9+
10+#include "helpers.h" /* slash2backslash(), removeDoubleBackslashes()... */
11+#include "kprintf.h"
12+
13+#include "loadconf.h"
14+
15+
16+void freeconf(struct customdirs **dirlist) {
17+ struct customdirs *curpos;
18+ /* free the linked list of custom dirs */
19+ while (*dirlist != NULL) {
20+ curpos = *dirlist;
21+ *dirlist = (*dirlist)->next;
22+ free(curpos);
23+ }
24+}
25+
26+
27+static int checkfordoubledirlist(const struct customdirs *dirlist) {
28+ struct customdirs *curpos;
29+ for (; dirlist != NULL; dirlist = dirlist->next) {
30+ for (curpos = dirlist->next; curpos != NULL; curpos = curpos->next) {
31+ if (strcasecmp(curpos->name, dirlist->name) == 0) {
32+ kitten_printf(7, 0, curpos->name); /* "ERROR: custom dir '%s' is listed twice!" */
33+ puts("");
34+ return(-1);
35+ }
36+ }
37+ }
38+ return(0);
39+}
40+
41+
42+/* validates dirlist entries: check that they are absolute paths and are not using restricted names */
43+static int validatedirlist(const struct customdirs *dirlist) {
44+ for (; dirlist != NULL; dirlist = dirlist->next) {
45+ /* the location must be at least 3 characters long to be a valid absolute path (like 'c:\')*/
46+ if (strlen(dirlist->location) < 3) {
47+ kitten_printf(7, 15, dirlist->name); /* "ERROR: custom dir '%s' is not a valid absolute path!" */
48+ puts("");
49+ return(-1);
50+ }
51+ /* is it a valid absolute path? should start with [a..Z]:\ */
52+ if ((dirlist->location[1] != ':') ||
53+ ((dirlist->location[2] != '/') && (dirlist->location[2] != '\\')) ||
54+ (((dirlist->location[0] < 'a') || (dirlist->location[0] > 'z')) && ((dirlist->location[0] < 'A') || (dirlist->location[0] > 'Z')))) {
55+ kitten_printf(7, 15, dirlist->name); /* "ERROR: custom dir '%s' is not a valid absolute path!" */
56+ puts("");
57+ return(-1);
58+ }
59+ /* check for forbidden names */
60+ if ((strcasecmp(dirlist->name, "appinfo") == 0) ||
61+ (strcasecmp(dirlist->name, "bin") == 0) ||
62+ (strcasecmp(dirlist->name, "doc") == 0) ||
63+ (strcasecmp(dirlist->name, "help") == 0) ||
64+ (strcasecmp(dirlist->name, "nls") == 0) ||
65+ (strcasecmp(dirlist->name, "packages") == 0)) {
66+ kitten_printf(7, 16, dirlist->name); /* "ERROR: custom dir '%s' is a reserved name!" */
67+ puts("");
68+ return(-1);
69+ }
70+ }
71+ return(0);
72+}
73+
74+
75+/* add (and allocates) a new custom dir entry to dirlist. Returns 0 on success,
76+ or non-zero on failure (failures happen on out of memory events). */
77+static int addnewdir(struct customdirs **dirlist, const char *name, const char *location) {
78+ struct customdirs *newentry;
79+ if (strlen(name) >= sizeof(newentry->name)) return(-2);
80+ newentry = malloc(sizeof(struct customdirs) + strlen(location) + 1);
81+ if (newentry == NULL) return(-1);
82+ strcpy(newentry->name, name);
83+ strcpy(newentry->location, location);
84+ newentry->next = *dirlist;
85+ *dirlist = newentry;
86+ return(0);
87+}
88+
89+
90+int loadconf(const char *dosdir, struct customdirs **dirlist) {
91+ FILE *fd;
92+ char *value = NULL;
93+ char token[512];
94+ int nline = 0;
95+
96+ snprintf(token, sizeof(token), "%s\\cfg\\pkg.cfg", dosdir);
97+ fd = fopen(token, "r");
98+ if (fd == NULL) {
99+ kitten_printf(7, 1, token); /* "ERROR: Could not open config file (%s)!" */
100+ puts("");
101+ return(-1);
102+ }
103+
104+ *dirlist = NULL;
105+
106+ /* read the config file line by line */
107+ while (freadtokval(fd, token, sizeof(token), &value, ' ') == 0) {
108+ nline++;
109+
110+ /* skip comments and empty lines */
111+ if ((token[0] == '#') || (token[0] == 0)) continue;
112+
113+ if ((value == NULL) || (value[0] == 0)) {
114+ kitten_printf(7, 4, nline); /* "Warning: token with empty value on line #%d" */
115+ puts("");
116+ continue;
117+ }
118+
119+ /* printf("token='%s' ; value = '%s'\n", token, value); */
120+ if (strcasecmp(token, "DIR") == 0) { /* custom directory entry */
121+ char *location = NULL;
122+ int i;
123+ /* find nearer space */
124+ for (i = 0; (value[i] != ' ') && (value[i] != 0); i++);
125+ if (value[i] == 0) {
126+ kitten_printf(7, 11, nline); /* "Warning: Invalid 'DIR' directive found at line #%d" */
127+ puts("");
128+ continue;
129+ }
130+ value[i] = 0;
131+ location = value + i + 1;
132+
133+ /* add the entry to the list */
134+ slash2backslash(location);
135+ removeDoubleBackslashes(location);
136+ if (location[strlen(location) - 1] != '\\') strcat(location, "\\"); /* make sure to end dirs with a backslash */
137+ if (addnewdir(dirlist, value, location) != 0) {
138+ kitten_printf(2, 14, "addnewdir"); /* "Out of memory! (%s)" */
139+ puts("");
140+ freeconf(dirlist);
141+ fclose(fd);
142+ return(-1);
143+ }
144+ } else { /* unknown token */
145+ kitten_printf(7, 8, token, nline); /* "Warning: Unknown token '%s' at line #%d" */
146+ puts("");
147+ }
148+ }
149+ fclose(fd);
150+
151+ /* perform some validations */
152+ if ((checkfordoubledirlist(*dirlist) != 0) || (validatedirlist(*dirlist) != 0)) {
153+ freeconf(dirlist);
154+ return(-1);
155+ }
156+
157+ return(0);
158+}
--- pkg/tags/20220203/loadconf.h (nonexistent)
+++ pkg/tags/20220203/loadconf.h (revision 615)
@@ -0,0 +1,23 @@
1+/*
2+ * This file is part of pkg.
3+ *
4+ * Copyright (C) 2012-2021 Mateusz Viste
5+ */
6+
7+#ifndef loadrepolist_sentinel
8+#define loadrepolist_sentinel
9+
10+struct customdirs {
11+ struct customdirs *next;
12+ char name[9];
13+ char location[1]; /* extended at alloc time */
14+};
15+
16+/* Loads the list of custom directories from the config file
17+ * Returns 0 on success, or -1 on failure. */
18+int loadconf(const char *dosdir, struct customdirs **dirlist);
19+
20+/* Free the memory allocated at configuration load. */
21+void freeconf(struct customdirs **dirlist);
22+
23+#endif
--- pkg/tags/20220203/lsm.c (nonexistent)
+++ pkg/tags/20220203/lsm.c (revision 615)
@@ -0,0 +1,33 @@
1+/*
2+ * This file is part of pkg (SvarDOS)
3+ * Copyright (C) 2013-2021 Mateusz Viste
4+ */
5+
6+#include <stdio.h> /* fopen, fclose... */
7+#include <string.h> /* strcasecmp() */
8+
9+#include "helpers.h"
10+
11+#include "lsm.h" /* include self for control */
12+
13+
14+/* Loads metadata from an LSM file. Returns 0 on success, non-zero on error. */
15+int readlsm(const char *filename, char *version, size_t version_maxlen) {
16+ char linebuff[128];
17+ char *valuestr;
18+ FILE *fd;
19+ /* reset fields to be read to empty values */
20+ version[0] = 0;
21+ /* open the file */
22+ fd = fopen(filename, "rb");
23+ if (fd == NULL) return(-1);
24+ /* read the LSM file line by line */
25+
26+ while (freadtokval(fd, linebuff, sizeof(linebuff), &valuestr, ':') == 0) {
27+ if (valuestr != NULL) {
28+ if (strcasecmp(linebuff, "version") == 0) snprintf(version, version_maxlen, "%s", valuestr);
29+ }
30+ }
31+ fclose(fd);
32+ return(0);
33+}
--- pkg/tags/20220203/lsm.h (nonexistent)
+++ pkg/tags/20220203/lsm.h (revision 615)
@@ -0,0 +1,10 @@
1+/*
2+ * This file is part of pkg (SvarDOS)
3+ * Copyright (C) 2013-2021 Mateusz Viste
4+ */
5+
6+#ifndef readlsm_h_sentinel
7+ #define readlsm_h_sentinel
8+ /* Loads metadata from an LSM file. Returns 0 on success, non-zero on error. */
9+ int readlsm(const char *filename, char *version, size_t version_maxlen);
10+#endif
--- pkg/tags/20220203/main.c (nonexistent)
+++ pkg/tags/20220203/main.c (revision 615)
@@ -0,0 +1,178 @@
1+/*
2+ * PKG - SvarDOS package installer
3+ *
4+ * PUBLISHED UNDER THE TERMS OF THE MIT LICENSE
5+ *
6+ * COPYRIGHT (C) 2016-2022 MATEUSZ VISTE, ALL RIGHTS RESERVED.
7+ *
8+ * Permission is hereby granted, free of charge, to any person obtaining a
9+ * copy of this software and associated documentation files (the "Software"),
10+ * to deal in the Software without restriction, including without limitation
11+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12+ * and/or sell copies of the Software, and to permit persons to whom the
13+ * Software is furnished to do so, subject to the following conditions:
14+ *
15+ * The above copyright notice and this permission notice shall be included in
16+ * all copies or substantial portions of the Software.
17+ *
18+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24+ * DEALINGS IN THE SOFTWARE.
25+ */
26+
27+
28+#include <stdio.h> /* printf() */
29+#include <stdlib.h> /* malloc() and friends */
30+#include <string.h> /* strcasecmp() */
31+
32+#include "svarlang.lib/svarlang.h"
33+#include "kprintf.h"
34+#include "libunzip.h"
35+#include "pkginst.h"
36+#include "pkgrem.h"
37+#include "showinst.h"
38+#include "unzip.h"
39+#include "version.h"
40+
41+
42+enum ACTIONTYPES {
43+ ACTION_INSTALL,
44+ ACTION_UPDATE,
45+ ACTION_REMOVE,
46+ ACTION_LISTFILES,
47+ ACTION_LISTLOCAL,
48+ ACTION_UNZIP,
49+ ACTION_HELP
50+};
51+
52+
53+static int showhelp(void) {
54+ puts("PKG ver " PVER " Copyright (C) " PDATE " Mateusz Viste");
55+ puts("");
56+ puts(svarlang_str(1, 0)); /* "PKG is the package installer for SvarDOS." */
57+ puts("");
58+ puts(svarlang_str(1, 20)); /* "Usage: pkg install package.zip */
59+ puts(svarlang_str(1, 21)); /* " pkg update package.zip" */
60+ puts(svarlang_str(1, 22)); /* " pkg remove package" */
61+ puts(svarlang_str(1, 23)); /* " pkg listfiles package" */
62+ puts(svarlang_str(1, 24)); /* " pkg listlocal [filter]" */
63+ puts(svarlang_str(1, 27)); /* " pkg unzip file.zip" */
64+ puts("");
65+ puts(svarlang_str(1, 25)); /* "PKG is published under the MIT license." */
66+ puts(svarlang_str(1, 26)); /* "It is configured through %DOSDIR%\CFG\PKG.CFG" */
67+ return(1);
68+}
69+
70+
71+static enum ACTIONTYPES parsearg(int argc, char * const *argv) {
72+ /* look for valid actions */
73+ if ((argc == 3) && (strcasecmp(argv[1], "install") == 0)) {
74+ return(ACTION_INSTALL);
75+ } else if ((argc == 3) && (strcasecmp(argv[1], "update") == 0)) {
76+ return(ACTION_UPDATE);
77+ } else if ((argc == 3) && (strcasecmp(argv[1], "remove") == 0)) {
78+ return(ACTION_REMOVE);
79+ } else if ((argc == 3) && (strcasecmp(argv[1], "listfiles") == 0)) {
80+ return(ACTION_LISTFILES);
81+ } else if ((argc >= 2) && (argc <= 3) && (strcasecmp(argv[1], "listlocal") == 0)) {
82+ return(ACTION_LISTLOCAL);
83+ } else if ((argc == 3) && (strcasecmp(argv[1], "unzip") == 0)) {
84+ return(ACTION_UNZIP);
85+ } else {
86+ return(ACTION_HELP);
87+ }
88+}
89+
90+
91+static int pkginst(const char *file, int flags, const char *dosdir, const struct customdirs *dirlist) {
92+ char pkgname[9];
93+ int t, lastpathdelim = -1, lastdot = -1, res = 1;
94+ struct ziplist *zipfileidx;
95+ FILE *zipfilefd;
96+ /* copy the filename into pkgname (without path elements and without extension) */
97+ for (t = 0; file[t] != 0; t++) {
98+ switch (file[t]) {
99+ case '/':
100+ case '\\':
101+ lastpathdelim = t;
102+ break;
103+ case '.':
104+ lastdot = t;
105+ break;
106+ }
107+ }
108+ if (lastdot <= lastpathdelim) lastdot = t; /* a dot before last path delimiters is not an extension prefix */
109+ t = lastdot - (lastpathdelim + 1);
110+ if (t + 1 > sizeof(pkgname)) {
111+ puts(svarlang_str(3, 24)); /* "ERROR: package name too long" */
112+ return(1);
113+ }
114+ memcpy(pkgname, file + lastpathdelim + 1, t);
115+ pkgname[t] = 0;
116+ /* prepare the zip file and install it */
117+ zipfileidx = pkginstall_preparepackage(pkgname, file, flags, &zipfilefd, dosdir, dirlist);
118+ if (zipfileidx != NULL) {
119+ res = pkginstall_installpackage(pkgname, dosdir, dirlist, zipfileidx, zipfilefd);
120+ zip_freelist(&zipfileidx);
121+ }
122+
123+ fclose(zipfilefd);
124+ return(res);
125+}
126+
127+
128+int main(int argc, char **argv) {
129+ int res = 1;
130+ enum ACTIONTYPES action;
131+ const char *dosdir;
132+ struct customdirs *dirlist;
133+
134+ svarlang_autoload("pkg"); /* NLS init */
135+
136+ action = parsearg(argc, argv);
137+ if (action == ACTION_HELP) {
138+ showhelp();
139+ goto GAMEOVER;
140+ }
141+
142+ /* read the DOSDIR environment variable */
143+ dosdir = getenv("DOSDIR");
144+ if (dosdir == NULL) {
145+ puts(svarlang_str(2, 2)); /* "%DOSDIR% not set! You should make it point to the FreeDOS main directory." */
146+ puts(svarlang_str(2, 3)); /* "Example: SET DOSDIR=C:\FDOS" */
147+ goto GAMEOVER;
148+ }
149+
150+ /* load configuration */
151+ if (loadconf(dosdir, &dirlist) != 0) goto GAMEOVER;
152+
153+ switch (action) {
154+ case ACTION_UPDATE:
155+ case ACTION_INSTALL:
156+ res = pkginst(argv[2], (action == ACTION_UPDATE)?PKGINST_UPDATE:0, dosdir, dirlist);
157+ break;
158+ case ACTION_REMOVE:
159+ res = pkgrem(argv[2], dosdir);
160+ break;
161+ case ACTION_LISTFILES:
162+ res = listfilesofpkg(argv[2], dosdir);
163+ break;
164+ case ACTION_LISTLOCAL:
165+ res = showinstalledpkgs((argc == 3)?argv[2]:NULL, dosdir);
166+ break;
167+ case ACTION_UNZIP:
168+ res = unzip(argv[2]);
169+ break;
170+ default:
171+ res = showhelp();
172+ break;
173+ }
174+
175+ GAMEOVER:
176+ if (res != 0) return(1);
177+ return(0);
178+}
--- pkg/tags/20220203/pkginst.c (nonexistent)
+++ pkg/tags/20220203/pkginst.c (revision 615)
@@ -0,0 +1,266 @@
1+/*
2+ * This file is part of pkg (SvarDOS)
3+ * Copyright (C) 2012-2022 Mateusz Viste
4+ */
5+
6+#include <ctype.h> /* toupper() */
7+#include <stdio.h>
8+#include <stdlib.h> /* system() */
9+#include <string.h> /* strcpy() */
10+#include <unistd.h> /* read() */
11+#include <sys/types.h> /* struct utimbuf */
12+
13+#include "helpers.h" /* slash2backslash(), strtolower() */
14+#include "fileexst.h"
15+#include "kprintf.h"
16+#include "libunzip.h" /* zip_listfiles()... */
17+#include "showinst.h" /* pkg_loadflist() */
18+#include "svarlang.lib\svarlang.h"
19+
20+#include "pkginst.h" /* include self for control */
21+
22+
23+/* validate a filename (8+3, no weird characters, etc). returns 0 on success,
24+ * nonzero otherwise. */
25+static int validfilename(const char *fname) {
26+ int i, i2;
27+ char *validchars = "!#$%&'()-@^_`{}~";
28+ int elemlen = 0;
29+ int elemmaxlen = 8; /* switches from 8 to 3 depending wheter I am analyzing
30+ a filename or an extension */
31+ /* look for invalid chars in the entire string, and check the length of the
32+ * element at the same time */
33+ for (i = 0; fname[i] != 0; i++) {
34+ /* director separators are threated specially */
35+ if (fname[i] == '\\') {
36+ elemlen = 0;
37+ elemmaxlen = 8;
38+ continue;
39+ }
40+ /* '.' switches the check into extension mode */
41+ if (fname[i] == '.') {
42+ if (elemlen == 0) return(-1); /* a file must have a base name */
43+ if (elemmaxlen == 3) return(-2); /* a file cannot have two extensions */
44+ elemlen = 0;
45+ elemmaxlen = 3;
46+ continue;
47+ }
48+ /* check that the element is not too long */
49+ if (++elemlen > elemmaxlen) return(-3);
50+ /* look for valid characters */
51+ if ((fname[i] >= 'a') && (fname[i] <= 'z')) continue;
52+ if ((fname[i] >= 'A') && (fname[i] <= 'Z')) continue;
53+ if ((fname[i] >= '0') && (fname[i] <= '9')) continue;
54+ if ((fname[i] & 128) != 0) continue; /* high bytes are okay (NLS) */
55+ /* look for other valid characters */
56+ for (i2 = 0; validchars[i2] != 0; i2++) {
57+ if (fname[i] == validchars[i2]) break;
58+ }
59+ if (validchars[i2] != 0) continue;
60+ /* if we are here, then the character is invalid */
61+ return(-4);
62+ }
63+ /* all checks passed */
64+ return(0);
65+}
66+
67+
68+/* returns 0 if pkgname is not installed, non-zero otherwise */
69+int is_package_installed(const char *pkgname, const char *dosdir) {
70+ char fname[512];
71+ sprintf(fname, "%s\\packages\\%s.lst", dosdir, pkgname);
72+ return(fileexists(fname)); /* file exists -> package is installed */
73+}
74+
75+
76+/* checks that pkgname is NOT installed. return 0 on success, non-zero otherwise. */
77+static int validate_package_not_installed(const char *pkgname, const char *dosdir) {
78+ if (is_package_installed(pkgname, dosdir) != 0) {
79+ kitten_printf(3, 18, pkgname); /* "Package %s is already installed! You might want to use the 'update' action." */
80+ puts("");
81+ return(-1);
82+ }
83+ return(0);
84+}
85+
86+
87+/* find a filename in a flist linked list, and returns a pointer to it */
88+static struct flist_t *findfileinlist(struct flist_t *flist, const char *fname) {
89+ while (flist != NULL) {
90+ if (strcasecmp(flist->fname, fname) == 0) return(flist);
91+ flist = flist->next;
92+ }
93+ return(NULL);
94+}
95+
96+
97+/* prepare a package for installation. this is mandatory before actually installing it!
98+ * returns a pointer to the zip file's index on success, NULL on failure. the **zipfd pointer is updated with a file descriptor to the open zip file to install. */
99+struct ziplist *pkginstall_preparepackage(const char *pkgname, const char *zipfile, int flags, FILE **zipfd, const char *dosdir, const struct customdirs *dirlist) {
100+ char fname[256];
101+ char appinfofile[256];
102+ int appinfopresence;
103+ char *shortfile;
104+ struct ziplist *ziplinkedlist = NULL, *curzipnode, *prevzipnode;
105+ struct flist_t *flist = NULL;
106+
107+ sprintf(appinfofile, "appinfo\\%s.lsm", pkgname); /* Prepare the appinfo/xxxx.lsm filename string for later use */
108+
109+ /* check if not already installed, if already here, print a message "you might want to use update instead"
110+ * of course this must not be done if we are in the process of upgrading said package */
111+ if (((flags & PKGINST_UPDATE) == 0) && (validate_package_not_installed(pkgname, dosdir) != 0)) {
112+ return(NULL);
113+ }
114+
115+ /* Now let's check the content of the zip file */
116+
117+ *zipfd = fopen(zipfile, "rb");
118+ if (*zipfd == NULL) {
119+ puts(svarlang_str(3, 8)); /* "ERROR: Invalid zip archive! Package not installed." */
120+ goto RAII;
121+ }
122+ ziplinkedlist = zip_listfiles(*zipfd);
123+ if (ziplinkedlist == NULL) {
124+ puts(svarlang_str(3, 8)); /* "ERROR: Invalid zip archive! Package not installed." */
125+ goto RAII;
126+ }
127+ /* if updating, load the list of files belonging to the current package */
128+ if ((flags & PKGINST_UPDATE) != 0) {
129+ flist = pkg_loadflist(pkgname, dosdir);
130+ }
131+ /* Verify that there's no collision with existing local files, look for the appinfo presence */
132+ appinfopresence = 0;
133+ prevzipnode = NULL;
134+ for (curzipnode = ziplinkedlist; curzipnode != NULL;) {
135+ /* change all slashes to backslashes, and switch into all-lowercase */
136+ slash2backslash(curzipnode->filename);
137+ strtolower(curzipnode->filename);
138+ /* remove 'directory' ZIP entries to avoid false alerts about directory already existing */
139+ if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) {
140+ curzipnode->filename[0] = 0; /* mark it "empty", will be removed in a short moment */
141+ }
142+ /* is it a "link file"? skip it - link files are no longer supported */
143+ if (fdnpkg_strcasestr(curzipnode->filename, "links\\") == curzipnode->filename) {
144+ curzipnode->filename[0] = 0; /* in fact, I just mark the file as 'empty' on the filename - see later below */
145+ }
146+
147+ if (curzipnode->filename[0] == 0) { /* ignore empty filenames (maybe it was empty originally, or has been emptied because it's a dropped source or link) */
148+ if (prevzipnode == NULL) { /* take the item out of the list */
149+ ziplinkedlist = curzipnode->nextfile;
150+ free(curzipnode); /* free the item */
151+ curzipnode = ziplinkedlist;
152+ } else {
153+ prevzipnode->nextfile = curzipnode->nextfile;
154+ free(curzipnode); /* free the item */
155+ curzipnode = prevzipnode->nextfile;
156+ }
157+ continue; /* go to the next item */
158+ }
159+ /* validate that the file has a valid filename (8+3, no shady chars...) */
160+ if (validfilename(curzipnode->filename) != 0) {
161+ puts(svarlang_str(3, 23)); /* "ERROR: Package contains an invalid filename:" */
162+ printf(" %s\n", curzipnode->filename);
163+ goto RAII_ERR;
164+ }
165+ /* look out for collisions with already existing files (unless we are
166+ * updating the package and the local file belongs to it */
167+ shortfile = computelocalpath(curzipnode->filename, fname, dosdir, dirlist);
168+ strcat(fname, shortfile);
169+ if ((findfileinlist(flist, fname) == NULL) && (fileexists(fname) != 0)) {
170+ puts(svarlang_str(3, 9)); /* "ERROR: Package contains a file that already exists locally:" */
171+ printf(" %s\n", fname);
172+ goto RAII_ERR;
173+ }
174+ /* abort if any entry is encrypted */
175+ if ((curzipnode->flags & ZIP_FLAG_ENCRYPTED) != 0) {
176+ puts(svarlang_str(3, 20)); /* "ERROR: Package contains an encrypted file:" */
177+ printf(" %s\n", curzipnode->filename);
178+ goto RAII_ERR;
179+ }
180+ /* abort if any file is compressed with an unsupported method */
181+ if ((curzipnode->compmethod != ZIP_METH_STORE) && (curzipnode->compmethod != ZIP_METH_DEFLATE)) { /* unsupported compression method */
182+ kitten_printf(8, 2, curzipnode->compmethod); /* "ERROR: Package contains a file compressed with an unsupported method (%d):" */
183+ puts("");
184+ printf(" %s\n", curzipnode->filename);
185+ goto RAII_ERR;
186+ }
187+ if (strcmp(curzipnode->filename, appinfofile) == 0) appinfopresence = 1;
188+ prevzipnode = curzipnode;
189+ curzipnode = curzipnode->nextfile;
190+ }
191+ /* if appinfo file not found, this is not a real FreeDOS package */
192+ if (appinfopresence != 1) {
193+ kitten_printf(3, 12, appinfofile); /* "ERROR: Package do not contain the %s file! Not a valid SvarDOS package." */
194+ puts("");
195+ goto RAII_ERR;
196+ }
197+
198+ goto RAII;
199+
200+ RAII_ERR:
201+ zip_freelist(&ziplinkedlist);
202+ ziplinkedlist = NULL;
203+ if ((zipfd != NULL) && (*zipfd != NULL)) {
204+ fclose(*zipfd);
205+ *zipfd = NULL;
206+ }
207+
208+ RAII:
209+ pkg_freeflist(flist);
210+ return(ziplinkedlist);
211+}
212+
213+
214+/* install a package that has been prepared already. returns 0 on success,
215+ * or a negative value on error, or a positive value on warning */
216+int pkginstall_installpackage(const char *pkgname, const char *dosdir, const struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd) {
217+ char buff[256];
218+ char fulldestfilename[256];
219+ char packageslst[32];
220+ char *shortfile;
221+ long filesextractedsuccess = 0, filesextractedfailure = 0;
222+ struct ziplist *curzipnode;
223+ FILE *lstfd;
224+
225+ sprintf(packageslst, "packages\\%s.lst", pkgname); /* Prepare the packages/xxxx.lst filename string for later use */
226+
227+ /* create the %DOSDIR%/packages directory, just in case it doesn't exist yet */
228+ sprintf(buff, "%s\\packages\\", dosdir);
229+ mkpath(buff);
230+
231+ /* open the lst file */
232+ sprintf(buff, "%s\\%s", dosdir, packageslst);
233+ lstfd = fopen(buff, "wb"); /* opening it in binary mode, because I like to have control over line terminators (CR/LF) */
234+ if (lstfd == NULL) {
235+ kitten_printf(3, 10, buff); /* "ERROR: Could not create %s!" */
236+ puts("");
237+ return(-2);
238+ }
239+
240+ /* write list of files in zip into the lst, and create the directories structure */
241+ for (curzipnode = ziplinkedlist; curzipnode != NULL; curzipnode = curzipnode->nextfile) {
242+ int unzip_result;
243+ if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) continue; /* skip directories */
244+ shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist); /* substitute paths to custom dirs */
245+ /* log the filename to packages\pkg.lst */
246+ fprintf(lstfd, "%s%s\r\n", buff, shortfile);
247+ /* create the path, just in case it doesn't exist yet */
248+ mkpath(buff);
249+ sprintf(fulldestfilename, "%s%s", buff, shortfile);
250+ /* Now unzip the file */
251+ unzip_result = zip_unzip(zipfd, curzipnode, fulldestfilename);
252+ if (unzip_result != 0) {
253+ kitten_printf(8, 3, curzipnode->filename, fulldestfilename); /* "ERROR: failed extracting '%s' to '%s'!" */
254+ printf(" [%d]\n", unzip_result);
255+ filesextractedfailure += 1;
256+ } else {
257+ printf(" %s -> %s\n", curzipnode->filename, buff);
258+ filesextractedsuccess += 1;
259+ }
260+ }
261+ fclose(lstfd);
262+
263+ kitten_printf(3, 19, pkgname, filesextractedsuccess, filesextractedfailure); /* "Package %s installed: %ld files extracted, %ld errors." */
264+ puts("");
265+ return(filesextractedfailure);
266+}
--- pkg/tags/20220203/pkginst.h (nonexistent)
+++ pkg/tags/20220203/pkginst.h (revision 615)
@@ -0,0 +1,17 @@
1+/*
2+ * This file is part of SvarDOS
3+ * Copyright (C) 2012-2021 Mateusz Viste
4+ */
5+
6+#ifndef pkginst_sentinel
7+#define pkginst_sentinel
8+
9+#include "loadconf.h" /* required for struct customdirs */
10+
11+#define PKGINST_UPDATE 2
12+
13+int is_package_installed(const char *pkgname, const char *dosdir);
14+struct ziplist *pkginstall_preparepackage(const char *pkgname, const char *localfile, int flags, FILE **zipfd, const char *dosdir, const struct customdirs *dirlist);
15+int pkginstall_installpackage(const char *pkgname, const char *dosdir, const struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd);
16+
17+#endif
--- pkg/tags/20220203/pkgrem.c (nonexistent)
+++ pkg/tags/20220203/pkgrem.c (revision 615)
@@ -0,0 +1,142 @@
1+/*
2+ * This file is part of the pkg (SvarDOS) project.
3+ * Copyright (C) Mateusz Viste 2012-2022
4+ */
5+
6+#include <ctype.h> /* toupper() */
7+#include <stdio.h>
8+#include <string.h> /* strlen() */
9+#include <stdlib.h> /* free() */
10+#include <unistd.h> /* rmdir(), unlink() */
11+#include <direct.h> /* watcom needs this for the rmdir() prototype */
12+
13+#include "helpers.h" /* slash2backslash() */
14+#include "kprintf.h"
15+
16+#include "pkgrem.h"
17+
18+
19+struct dirliststruct {
20+ struct dirliststruct *next;
21+ char dirname[2]; /* this must be the last item in the structure */
22+};
23+
24+
25+/* adds a directory to dirlist, if not already present */
26+static struct dirliststruct *rememberdir(struct dirliststruct *dirlist, const char *path) {
27+ struct dirliststruct *res;
28+ /* if already present, do nothing */
29+ for (res = dirlist; res != NULL; res = res->next) {
30+ if (strcasecmp(res->dirname, path) == 0) return(dirlist);
31+ }
32+ /* not in the list yet - add it */
33+ res = malloc(sizeof(struct dirliststruct) + strlen(path));
34+ if (res == NULL) { /* out of memory */
35+ kitten_printf(4, 3, path); /* "Out of memory! Could not store directory %s!" */
36+ puts("");
37+ return(NULL);
38+ }
39+ strcpy(res->dirname, path);
40+ res->next = dirlist;
41+ return(res);
42+}
43+
44+
45+/* explode a path into subdirectories, and remember each one inside dirlist */
46+static struct dirliststruct *rememberpath(struct dirliststruct *dirlist, char *path) {
47+ int x, gameover = 0;
48+ /* iterate on the path, and add each subdirectory */
49+ for (x = 0;; x++) {
50+ switch (path[x]) {
51+ case 0:
52+ gameover = 1;
53+ case '/':
54+ case '\\':
55+ path[x] = 0;
56+ dirlist = rememberdir(dirlist, path);
57+ path[x] = '\\';
58+ }
59+ if (gameover != 0) break;
60+ }
61+ return(dirlist);
62+}
63+
64+
65+/* removes a package from the system. Returns 0 on success, non-zero otherwise */
66+int pkgrem(const char *pkgname, const char *dosdir) {
67+ char fpath[256];
68+ char buff[256];
69+ FILE *flist;
70+ int lastdirsep;
71+ struct dirliststruct *dirlist = NULL; /* used to remember directories to remove */
72+
73+ /* open the file %DOSDIR%\packages\pkgname.lst */
74+ sprintf(fpath, "%s\\packages\\%s.lst", dosdir, pkgname);
75+ flist = fopen(fpath, "rb");
76+ if (flist == NULL) {
77+ kitten_printf(4, 0, pkgname); /* "Package %s is not installed, so not removed." */
78+ puts("");
79+ return(-1);
80+ }
81+
82+ /* remove all files/folders listed in pkgname.lst but NOT pkgname.lst */
83+ while (freadtokval(flist, buff, sizeof(buff), NULL, 0) == 0) {
84+ int x;
85+ slash2backslash(buff); /* change all slash to backslash */
86+ if (buff[0] == 0) continue; /* skip empty lines */
87+
88+ /* remember the path part for removal later */
89+ lastdirsep = -1;
90+ for (x = 1; buff[x] != 0; x++) {
91+ if ((buff[x] == '\\') && (buff[x - 1] != ':')) lastdirsep = x;
92+ }
93+ if (lastdirsep > 0) {
94+ buff[lastdirsep] = 0;
95+ dirlist = rememberpath(dirlist, buff);
96+ buff[lastdirsep] = '\\';
97+ }
98+
99+ /* if it's a directory, skip it */
100+ if (buff[strlen(buff) - 1] == '\\') continue;
101+
102+ /* do not delete pkgname.lst at this point - I am using it (will be deleted later) */
103+ if (strcasecmp(buff, fpath) == 0) continue;
104+
105+ /* remove it */
106+ kitten_printf(4, 4, buff); /* "removing %s" */
107+ puts("");
108+ unlink(buff);
109+ }
110+
111+ /* close the lst file */
112+ fclose(flist);
113+
114+ /* iterate over dirlist and remove directories if empty, from longest to shortest */
115+ while (dirlist != NULL) {
116+ struct dirliststruct *dirlistpos, *previousdir;
117+ /* find the longest path, and put it on top */
118+ previousdir = dirlist;
119+ for (dirlistpos = dirlist->next; dirlistpos != NULL; dirlistpos = dirlistpos->next) {
120+ if (strlen(dirlistpos->dirname) > strlen(dirlist->dirname)) {
121+ previousdir->next = dirlistpos->next;
122+ dirlistpos->next = dirlist;
123+ dirlist = dirlistpos;
124+ dirlistpos = previousdir;
125+ } else {
126+ previousdir = dirlistpos;
127+ }
128+ }
129+ /* printf("RMDIR %s\n", dirlist->dirname); */
130+ rmdir(dirlist->dirname);
131+ /* free the allocated memory for this entry */
132+ dirlistpos = dirlist;
133+ dirlist = dirlistpos->next;
134+ free(dirlistpos);
135+ }
136+
137+ /* remove the lst file */
138+ unlink(fpath);
139+ kitten_printf(4, 5, pkgname); /* "Package %s has been removed." */
140+ puts("");
141+ return(0);
142+}
--- pkg/tags/20220203/pkgrem.h (nonexistent)
+++ pkg/tags/20220203/pkgrem.h (revision 615)
@@ -0,0 +1,9 @@
1+/*
2+ * This file is part of the SvarDOS project.
3+ * Copyright (C) Mateusz Viste 2012-2021
4+ */
5+
6+#ifndef pkgrem_sentinel
7+#define pkgrem_sentinel
8+int pkgrem(const char *pkgname, const char *dosdir);
9+#endif
--- pkg/tags/20220203/showinst.c (nonexistent)
+++ pkg/tags/20220203/showinst.c (revision 615)
@@ -0,0 +1,119 @@
1+/*
2+ * This file is part of PKG (SvarDOS)
3+ * Copyright (C) 2013-2022 Mateusz Viste
4+ */
5+
6+#include <stdio.h>
7+#include <ctype.h> /* tolower() */
8+#include <stdlib.h> /* atoi(), qsort() - not using it after all, redefining it manually later */
9+#include <string.h> /* strlen() */
10+#include <sys/types.h>
11+#include <direct.h> /* opendir() and friends */
12+
13+#include "helpers.h" /* fdnpkg_strcasestr(), slash2backslash()... */
14+#include "kprintf.h"
15+#include "libunzip.h" /* zip_freelist()... */
16+#include "lsm.h"
17+#include "svarlang.lib\svarlang.h"
18+
19+#include "showinst.h" /* include self for control */
20+
21+
22+int showinstalledpkgs(const char *filterstr, const char *dosdir) {
23+ DIR *dp;
24+ struct dirent *ep;
25+ char buff[256];
26+ char ver[16];
27+ int matchfound = 0;
28+
29+ sprintf(buff, "%s\\packages", dosdir);
30+ dp = opendir(buff);
31+ if (dp == NULL) {
32+ kitten_printf(9, 0, buff); /* "ERROR: Could not access directory %s" */
33+ puts("");
34+ return(-1);
35+ }
36+
37+ while ((ep = readdir(dp)) != NULL) { /* readdir() result must never be freed (statically allocated) */
38+ int tlen = strlen(ep->d_name);
39+ if (ep->d_name[0] == '.') continue; /* ignore '.', '..', and hidden directories */
40+ if (tlen < 4) continue; /* files must be at least 5 bytes long ("x.lst") */
41+ if (strcasecmp(ep->d_name + tlen - 4, ".lst") != 0) continue; /* if not an .lst file, skip it silently */
42+ ep->d_name[tlen - 4] = 0; /* trim out the ".lst" suffix */
43+
44+ if (filterstr != NULL) {
45+ if (fdnpkg_strcasestr(ep->d_name, filterstr) == NULL) continue; /* if it's not matching the non-NULL filter, skip it */
46+ }
47+
48+ /* load the metadata from %DOSDIR\APPINFO\*.lsm */
49+ sprintf(buff, "%s\\appinfo\\%s.lsm", dosdir, ep->d_name);
50+ readlsm(buff, ver, sizeof(ver));
51+
52+ printf("%s %s", ep->d_name, ver);
53+ puts("");
54+ matchfound = 1;
55+ }
56+ if (matchfound == 0) puts(svarlang_str(5, 0)); /* "No package matched the search." */
57+
58+ closedir(dp);
59+ return(0);
60+}
61+
62+
63+/* frees a linked list of filenames */
64+void pkg_freeflist(struct flist_t *flist) {
65+ while (flist != NULL) {
66+ struct flist_t *victim = flist;
67+ flist = flist->next;
68+ free(victim);
69+ }
70+}
71+
72+
73+/* returns a linked list of the files that belong to package pkgname */
74+struct flist_t *pkg_loadflist(const char *pkgname, const char *dosdir) {
75+ struct flist_t *res = NULL, *newnode;
76+ FILE *fd;
77+ char buff[256];
78+
79+ sprintf(buff, "%s\\packages\\%s.lst", dosdir, pkgname);
80+ fd = fopen(buff, "rb");
81+ if (fd == NULL) {
82+ kitten_printf(9, 1, pkgname); /* "ERROR: Local package '%s' not found." */
83+ puts("");
84+ return(NULL);
85+ }
86+ /* iterate through all lines of the file */
87+ while (freadtokval(fd, buff, sizeof(buff), NULL, 0) == 0) {
88+ slash2backslash(buff); /* change all / to \ */
89+ if (buff[0] == 0) continue; /* skip empty lines */
90+ if (buff[strlen(buff) - 1] == '\\') continue; /* skip directories */
91+ /* add the new node to the result */
92+ newnode = malloc(sizeof(struct flist_t) + strlen(buff));
93+ if (newnode == NULL) {
94+ kitten_printf(2, 14, "malloc failure"); /* "Out of memory! (%s)" */
95+ continue;
96+ }
97+ newnode->next = res;
98+ strcpy(newnode->fname, buff);
99+ res = newnode;
100+ }
101+ fclose(fd);
102+ return(res);
103+}
104+
105+
106+/* Prints files owned by a package */
107+int listfilesofpkg(const char *pkgname, const char *dosdir) {
108+ struct flist_t *flist, *flist_ptr;
109+ /* load the list of files belonging to pkgname */
110+ flist = pkg_loadflist(pkgname, dosdir);
111+ if (flist == NULL) return(-1);
112+ /* display each filename on screen */
113+ for (flist_ptr = flist; flist_ptr != NULL; flist_ptr = flist_ptr->next) {
114+ puts(flist_ptr->fname);
115+ }
116+ /* free the list of files */
117+ pkg_freeflist(flist);
118+ return(0);
119+}
--- pkg/tags/20220203/showinst.h (nonexistent)
+++ pkg/tags/20220203/showinst.h (revision 615)
@@ -0,0 +1,18 @@
1+/*
2+ * This file is part of pkg (SvarDOS)
3+ * Copyright (C) 2013-2021 Mateusz Viste
4+ */
5+
6+#ifndef showinst_h_sentinel
7+ #define showinst_h_sentinel
8+
9+ struct flist_t {
10+ struct flist_t *next;
11+ char fname[1]; /* this must be the last item in the structure, it will be expanded to fit the filename */
12+ };
13+
14+ void pkg_freeflist(struct flist_t *flist);
15+ struct flist_t *pkg_loadflist(const char *pkgname, const char *dosdir);
16+ int showinstalledpkgs(const char *filterstr, const char *dosdir);
17+ int listfilesofpkg(const char *pkgname, const char *dosdir);
18+#endif
--- pkg/tags/20220203/trim.c (nonexistent)
+++ pkg/tags/20220203/trim.c (revision 615)
@@ -0,0 +1,35 @@
1+/*
2+ * trims any space, tab, cr or lf
3+ * Copyright (C) 2012-2021 Mateusz Viste
4+ */
5+
6+#include "trim.h"
7+
8+void trim(char *str) {
9+ int x, y, firstchar = -1, lastchar = -1;
10+
11+ /* find out first and last non-whitespace char */
12+ for (x = 0; str[x] != 0; x++) {
13+ switch (str[x]) {
14+ case ' ':
15+ case '\t':
16+ case '\n':
17+ case '\r':
18+ break;
19+ default:
20+ if (firstchar < 0) firstchar = x;
21+ lastchar = x;
22+ break;
23+ }
24+ }
25+
26+ /* right trim */
27+ str[lastchar + 1] = 0;
28+
29+ /* left trim (shift to the left ) */
30+ if (firstchar > 0) {
31+ y = 0;
32+ for (x = firstchar; str[x] != 0; x++) str[y++] = str[x];
33+ str[y] = 0;
34+ }
35+}
--- pkg/tags/20220203/trim.h (nonexistent)
+++ pkg/tags/20220203/trim.h (revision 615)
@@ -0,0 +1,11 @@
1+/*
2+ * trims any space, tab, cr or lf
3+ * Copyright (C) 2012-2021 Mateusz Viste
4+ */
5+
6+#ifndef trim_sentinel
7+#define trim_sentinel
8+
9+void trim(char *str);
10+
11+#endif
--- pkg/tags/20220203/unzip.c (nonexistent)
+++ pkg/tags/20220203/unzip.c (revision 615)
@@ -0,0 +1,69 @@
1+/*
2+ * simple unzip tool that unzips the content of a zip archive to current directory
3+ * returns 0 on success
4+ *
5+ * this file is part of pkg (SvarDOS)
6+ * copyright (C) 2021-2022 Mateusz Viste
7+ */
8+
9+#include <stdio.h>
10+
11+#include "fileexst.h"
12+#include "helpers.h"
13+#include "kprintf.h"
14+#include "libunzip.h"
15+#include "svarlang.lib\svarlang.h"
16+
17+#include "unzip.h"
18+
19+
20+int unzip(const char *zipfile) {
21+ struct ziplist *zlist, *znode;
22+ FILE *fd;
23+ int r = 0;
24+
25+ fd = fopen(zipfile, "rb");
26+ if (fd == NULL) {
27+ puts(svarlang_str(10, 1)); /* "ERROR: Failed to open the archive file" */
28+ return(1);
29+ }
30+
31+ zlist = zip_listfiles(fd);
32+ if (zlist == NULL) {
33+ puts(svarlang_str(10, 2)); /* "ERROR: Invalid ZIP archive" */
34+ fclose(fd);
35+ return(-1);
36+ }
37+
38+ /* examine the list of zipped files - make sure that no file currently
39+ * exists and that files are neither encrypted nor compressed with an
40+ * unsupported method */
41+ for (znode = zlist; znode != NULL; znode = znode->nextfile) {
42+ int zres;
43+ /* convert slash to backslash, print filename and create the directories path */
44+ slash2backslash(znode->filename);
45+ printf("%s ", znode->filename);
46+ mkpath(znode->filename);
47+ /* if a dir, we good already */
48+ if (znode->flags == ZIP_FLAG_ISADIR) goto OK;
49+ /* file already exists? */
50+ if (fileexists(znode->filename) != 0) {
51+ puts(svarlang_str(10, 3)); /* "ERROR: File already exists" */
52+ r = 1;
53+ continue;
54+ }
55+ /* uncompress */
56+ zres = zip_unzip(fd, znode, znode->filename);
57+ if (zres != 0) {
58+ kitten_printf(10, 4, "ERROR: unzip failure (%d)", zres);
59+ puts("");
60+ continue;
61+ }
62+ OK:
63+ puts(svarlang_str(10, 0)); /* "OK" */
64+ }
65+
66+ zip_freelist(&zlist);
67+ fclose(fd);
68+ return(r);
69+}
--- pkg/tags/20220203/unzip.h (nonexistent)
+++ pkg/tags/20220203/unzip.h (revision 615)
@@ -0,0 +1,14 @@
1+/*
2+ * simple unzip tool that unzips the content of a zip archive to current directory
3+ * returns 0 on success
4+ *
5+ * this file is part of pkg (SvarDOS)
6+ * copyright (C) 2021 Mateusz Viste
7+ */
8+
9+#ifndef unzip_h
10+#define unzip_h
11+
12+int unzip(const char *zipfile);
13+
14+#endif
--- pkg/tags/20220203/version.h (nonexistent)
+++ pkg/tags/20220203/version.h (revision 615)
@@ -0,0 +1,10 @@
1+/*
2+ */
3+
4+#ifndef COMMON_H_SENTINEL
5+#define COMMON_H_SENTINEL
6+
7+#define PVER "20220203"
8+#define PDATE "2012-2022"
9+
10+#endif
Show on old repository browser