219 |
mateuszvis |
1 |
/*
|
|
|
2 |
* This file is part of FDNPKG
|
|
|
3 |
* Copyright (C) 2012-2021 Mateusz Viste
|
|
|
4 |
* Changes by TK Chia
|
|
|
5 |
*/
|
|
|
6 |
|
|
|
7 |
#include <ctype.h> /* toupper() */
|
|
|
8 |
#include <stdio.h>
|
|
|
9 |
#include <stdlib.h> /* system() */
|
|
|
10 |
#include <string.h> /* strcpy() */
|
|
|
11 |
#include <unistd.h> /* read() */
|
|
|
12 |
#include <sys/types.h> /* struct utimbuf */
|
|
|
13 |
|
|
|
14 |
#include "crc32.h" /* all CRC32 related stuff */
|
|
|
15 |
#include "fdnpkg.h" /* PKGINST_NOSOURCE, PKGINST_SKIPLINKS... */
|
|
|
16 |
#include "http.h"
|
|
|
17 |
#include "helpers.h" /* slash2backslash(), strtolower() */
|
|
|
18 |
#include "fileexst.h"
|
|
|
19 |
#include "kprintf.h"
|
|
|
20 |
#include "libunzip.h" /* zip_listfiles()... */
|
|
|
21 |
#include "showinst.h" /* pkg_loadflist() */
|
|
|
22 |
#include "pkginst.h" /* include self for control */
|
|
|
23 |
#include "version.h"
|
|
|
24 |
|
|
|
25 |
|
|
|
26 |
/* return 1 if fname looks like a link filename, 0 otherwise */
|
|
|
27 |
static int islinkfile(char *fname) {
|
|
|
28 |
char *link1 = "LINKS\\";
|
|
|
29 |
char *link2 = "links\\";
|
|
|
30 |
int x;
|
|
|
31 |
for (x = 0; ; x++) {
|
|
|
32 |
if (link1[x] == 0) return(1);
|
|
|
33 |
if ((fname[x] != link1[x]) && (fname[x] != link2[x])) return(0);
|
|
|
34 |
}
|
|
|
35 |
}
|
|
|
36 |
|
|
|
37 |
|
|
|
38 |
/* validate a filename (8+3, no weird characters, etc). returns 0 on success,
|
|
|
39 |
* nonzero otherwise. */
|
|
|
40 |
static int validfilename(char *fname) {
|
|
|
41 |
int i, i2;
|
|
|
42 |
char *validchars = "!#$%&'()-@^_`{}~";
|
|
|
43 |
int elemlen = 0;
|
|
|
44 |
int elemmaxlen = 8; /* switches from 8 to 3 depending wheter I am analyzing
|
|
|
45 |
a filename or an extension */
|
|
|
46 |
/* look for invalid chars in the entire string, and check the length of the
|
|
|
47 |
* element at the same time */
|
|
|
48 |
for (i = 0; fname[i] != 0; i++) {
|
|
|
49 |
/* director separators are threated specially */
|
|
|
50 |
if (fname[i] == '\\') {
|
|
|
51 |
elemlen = 0;
|
|
|
52 |
elemmaxlen = 8;
|
|
|
53 |
continue;
|
|
|
54 |
}
|
|
|
55 |
/* '.' switches the check into extension mode */
|
|
|
56 |
if (fname[i] == '.') {
|
|
|
57 |
if (elemlen == 0) return(-1); /* a file must have a base name */
|
|
|
58 |
if (elemmaxlen == 3) return(-2); /* a file cannot have two extensions */
|
|
|
59 |
elemlen = 0;
|
|
|
60 |
elemmaxlen = 3;
|
|
|
61 |
continue;
|
|
|
62 |
}
|
|
|
63 |
/* check that the element is not too long */
|
|
|
64 |
if (++elemlen > elemmaxlen) return(-3);
|
|
|
65 |
/* look for valid characters */
|
|
|
66 |
if ((fname[i] >= 'a') && (fname[i] <= 'z')) continue;
|
|
|
67 |
if ((fname[i] >= 'A') && (fname[i] <= 'Z')) continue;
|
|
|
68 |
if ((fname[i] >= '0') && (fname[i] <= '9')) continue;
|
|
|
69 |
if ((fname[i] & 128) != 0) continue; /* high bytes are okay (NLS) */
|
|
|
70 |
/* look for other valid characters */
|
|
|
71 |
for (i2 = 0; validchars[i2] != 0; i2++) {
|
|
|
72 |
if (fname[i] == validchars[i2]) break;
|
|
|
73 |
}
|
|
|
74 |
if (validchars[i2] != 0) continue;
|
|
|
75 |
/* if we are here, then the character is invalid */
|
|
|
76 |
return(-4);
|
|
|
77 |
}
|
|
|
78 |
/* all checks passed */
|
|
|
79 |
return(0);
|
|
|
80 |
}
|
|
|
81 |
|
|
|
82 |
|
|
|
83 |
/* processes a link file - that is, reads the target inside, and overwrite
|
|
|
84 |
* the file with new content */
|
|
|
85 |
static void processlinkfile(char *linkfile, char *dosdir, struct customdirs *dirlist, char *buff) {
|
|
|
86 |
char origtarget[512];
|
|
|
87 |
int x;
|
|
|
88 |
char *shortfile;
|
|
|
89 |
unsigned char comstub[] = { /* machine code of a COM stub launcher */
|
|
|
90 |
0xBC,0x00,0x00,0xBB,0x00,0x10,0xB4,0x4A,0xCD,0x21,0xBB,0x2A,0x01,0x8C,0x5F,0x04,
|
|
|
91 |
0x8C,0x5F,0x08,0x8C,0x5F,0x0C,0xB8,0x00,0x4B,0xBA,0x38,0x01,0xCD,0x21,0xB0,0x7F,
|
|
|
92 |
0x72,0x04,0xB4,0x4D,0xCD,0x21,0xB4,0x4C,0xCD,0x21,0x00,0x00,0x80,0x00,0x00,0x00,
|
|
|
93 |
0x5C,0x00,0x00,0x00,0x6C,0x00,0x00,0x00}; /* read comlink.asm for details */
|
|
|
94 |
const unsigned stack_paras = 12;
|
|
|
95 |
unsigned alloc_paras, alloc_bytes;
|
|
|
96 |
FILE *fd;
|
|
|
97 |
/* open the link file and read the original target */
|
|
|
98 |
fd = fopen(linkfile, "r");
|
|
|
99 |
if (fd == NULL) {
|
|
|
100 |
kitten_printf(3, 21, "Error: Failed to open link file '%s' for read access.", linkfile);
|
|
|
101 |
puts("");
|
|
|
102 |
return;
|
|
|
103 |
}
|
|
|
104 |
x = fread(origtarget, 1, sizeof(origtarget) - 1, fd);
|
|
|
105 |
origtarget[x] = 0;
|
|
|
106 |
fclose(fd);
|
|
|
107 |
/* validate the original target (ltrim to first \r or \n) */
|
|
|
108 |
for (x = 0; origtarget[x] != 0; x++) {
|
|
|
109 |
if ((origtarget[x] == '\r') || (origtarget[x] == '\n')) {
|
|
|
110 |
origtarget[x] = 0;
|
|
|
111 |
break;
|
|
|
112 |
}
|
|
|
113 |
}
|
|
|
114 |
/* translate the original target to a local path */
|
|
|
115 |
shortfile = computelocalpath(origtarget, buff, dosdir, dirlist);
|
|
|
116 |
/* compute the amount of memory the stub should leave for itself:
|
|
|
117 |
- 16 paragraphs needed for the PSP
|
|
|
118 |
- sizeof(comstub) bytes needed for code and data
|
|
|
119 |
- strlen(shortfile) + 1 for the command line
|
|
|
120 |
- stack_paras paragraphs for the stack */
|
|
|
121 |
alloc_paras = 16 + (sizeof(comstub) + strlen(shortfile) + 16) / 16 + stack_paras;
|
|
|
122 |
alloc_bytes = 16 * alloc_paras;
|
|
|
123 |
comstub[1] = alloc_bytes & 0xff;
|
|
|
124 |
comstub[2] = alloc_bytes >> 8;
|
|
|
125 |
comstub[4] = alloc_paras & 0xff;
|
|
|
126 |
comstub[5] = alloc_paras >> 8;
|
|
|
127 |
/* write new content into the link file */
|
|
|
128 |
fd = fopen(linkfile, "wb");
|
|
|
129 |
if (fd == NULL) {
|
|
|
130 |
kitten_printf(3, 22, "Error: Failed to open link file '%s' for write access.", linkfile);
|
|
|
131 |
puts("");
|
|
|
132 |
return;
|
|
|
133 |
}
|
|
|
134 |
fwrite(comstub, 1, sizeof(comstub), fd);
|
|
|
135 |
fprintf(fd, "%s%s%c", buff, shortfile, 0);
|
|
|
136 |
fclose(fd);
|
|
|
137 |
}
|
|
|
138 |
|
|
|
139 |
|
|
|
140 |
/* returns 0 if pkgname is not installed, non-zero otherwise */
|
|
|
141 |
int is_package_installed(char *pkgname, char *dosdir, char *mapdrv) {
|
|
|
142 |
char fname[512];
|
|
|
143 |
sprintf(fname, "%s\\packages\\%s.lst", dosdir, pkgname);
|
|
|
144 |
mapdrives(fname, mapdrv);
|
|
|
145 |
if (fileexists(fname) != 0) { /* file exists -> package is installed */
|
|
|
146 |
return(1);
|
|
|
147 |
} else {
|
|
|
148 |
return(0);
|
|
|
149 |
}
|
|
|
150 |
}
|
|
|
151 |
|
|
|
152 |
|
|
|
153 |
/* checks that pkgname is NOT installed. return 0 on success, non-zero otherwise. */
|
|
|
154 |
int validate_package_not_installed(char *pkgname, char *dosdir, char *mapdrv) {
|
|
|
155 |
if (is_package_installed(pkgname, dosdir, mapdrv) != 0) {
|
|
|
156 |
kitten_printf(3, 18, "Package %s is already installed! You might want to use the 'update' action.", pkgname);
|
|
|
157 |
puts("");
|
|
|
158 |
return(-1);
|
|
|
159 |
}
|
|
|
160 |
return(0);
|
|
|
161 |
}
|
|
|
162 |
|
|
|
163 |
|
|
|
164 |
/* find a filename in a flist linked list, and returns a pointer to it */
|
|
|
165 |
static struct flist_t *findfileinlist(struct flist_t *flist, char *fname) {
|
|
|
166 |
while (flist != NULL) {
|
|
|
167 |
if (strcmp(flist->fname, fname) == 0) return(flist);
|
|
|
168 |
flist = flist->next;
|
|
|
169 |
}
|
|
|
170 |
return(NULL);
|
|
|
171 |
}
|
|
|
172 |
|
|
|
173 |
|
|
|
174 |
/* prepare a package for installation. this is mandatory before actually installing it!
|
|
|
175 |
* returns a pointer to the zip file's index on success, NULL on failure. the *zipfile pointer is updated with a file descriptor to the open zip file to install. */
|
|
|
176 |
struct ziplist *pkginstall_preparepackage(struct pkgdb *pkgdb, char *pkgname, char *tempdir, char *localfile, int flags, char **repolist, FILE **zipfd, char *proxy, int proxyport, char *downloadingstring, char *dosdir, struct customdirs *dirlist, char *buffmem1k, char *mapdrv) {
|
|
|
177 |
char *fname;
|
|
|
178 |
char *zipfile;
|
|
|
179 |
char *appinfofile;
|
|
|
180 |
int appinfopresence;
|
|
|
181 |
char *shortfile;
|
|
|
182 |
struct ziplist *ziplinkedlist, *curzipnode, *prevzipnode;
|
|
|
183 |
struct flist_t *flist;
|
|
|
184 |
|
|
|
185 |
fname = buffmem1k;
|
|
|
186 |
zipfile = buffmem1k + 256;
|
|
|
187 |
appinfofile = buffmem1k + 512;
|
|
|
188 |
|
|
|
189 |
strtolower(pkgname); /* convert pkgname to lower case, because the http repo is probably case sensitive */
|
|
|
190 |
sprintf(appinfofile, "appinfo\\%s.lsm", pkgname); /* Prepare the appinfo/xxxx.lsm filename string for later use */
|
|
|
191 |
|
|
|
192 |
/* check if not already installed, if already here, print a message "you might want to use update instead"
|
|
|
193 |
* of course this must not be done if we are in the process of upgrading said package */
|
|
|
194 |
if (((flags & PKGINST_UPDATE) == 0) && (validate_package_not_installed(pkgname, dosdir, mapdrv) != 0)) {
|
|
|
195 |
return(NULL);
|
|
|
196 |
}
|
|
|
197 |
|
|
|
198 |
if (localfile != NULL) { /* if it's a local file, then we will have to skip all the network stuff */
|
|
|
199 |
strcpy(zipfile, localfile);
|
|
|
200 |
} else {
|
|
|
201 |
zipfile[0] = 0;
|
|
|
202 |
}
|
|
|
203 |
|
|
|
204 |
#ifndef NOREPOS
|
|
|
205 |
if (zipfile[0] == 0) { /* need to download the package from a repository */
|
|
|
206 |
char *instrepo;
|
|
|
207 |
struct pkgdb *pkgnode, *lastnode;
|
|
|
208 |
struct pkgrepo *pkgrepo;
|
|
|
209 |
int repoid;
|
|
|
210 |
unsigned long zipfilecrc, remotecrc;
|
|
|
211 |
unsigned char *buff;
|
|
|
212 |
int buffreadres;
|
|
|
213 |
char *pkgext; /* zip or zib */
|
|
|
214 |
|
|
|
215 |
/* look into the db to find the package */
|
|
|
216 |
pkgnode = findpkg(pkgdb, pkgname, &lastnode);
|
|
|
217 |
if (pkgnode == NULL) { /* no such package found in repositories */
|
|
|
218 |
kitten_printf(3, 1, "No package '%s' found in online repositories.", pkgname);
|
|
|
219 |
puts("");
|
|
|
220 |
return(NULL);
|
|
|
221 |
}
|
|
|
222 |
|
|
|
223 |
/* if found - check the list of repositories */
|
|
|
224 |
if (pkgnode->repolist == NULL) {
|
|
|
225 |
kitten_printf(3, 2, "Package '%s' is not available in repositories.", pkgname);
|
|
|
226 |
puts("");
|
|
|
227 |
return(NULL);
|
|
|
228 |
}
|
|
|
229 |
|
|
|
230 |
if (pkgnode->repolist->nextrepo != NULL) { /* available from more than 1 repo.. */
|
|
|
231 |
char userchoicestr[8];
|
|
|
232 |
int userchoice, latestver_repoid = 1;
|
|
|
233 |
struct pkgrepo *xrepo, *latestver = pkgnode->repolist;
|
|
|
234 |
/* check out if we are able to find out the newest version */
|
|
|
235 |
repoid = 2; /* setting to 2, because we start iterating at the second repo entry */
|
|
|
236 |
for (xrepo = pkgnode->repolist->nextrepo; xrepo != NULL; xrepo = xrepo->nextrepo) {
|
|
|
237 |
int versionnewerres = isversionnewer(latestver->version, xrepo->version);
|
|
|
238 |
if (versionnewerres > 0) {
|
|
|
239 |
latestver = xrepo;
|
|
|
240 |
latestver_repoid = repoid;
|
|
|
241 |
} else if (versionnewerres < 0) { /* unable to tell which version is newer */
|
|
|
242 |
latestver_repoid = -1;
|
|
|
243 |
break;
|
|
|
244 |
}
|
|
|
245 |
repoid += 1;
|
|
|
246 |
}
|
|
|
247 |
if (latestver_repoid > 0) {
|
|
|
248 |
repoid = latestver_repoid;
|
|
|
249 |
} else { /* newest version could not be figured out, so let's ask the user to choose */
|
|
|
250 |
puts("");
|
|
|
251 |
kitten_printf(3, 3, "%s is available from several repositories. Choose which one to use:", pkgname);
|
|
|
252 |
puts("");
|
|
|
253 |
repoid = 1;
|
|
|
254 |
for (xrepo = pkgnode->repolist; xrepo != NULL; xrepo = xrepo->nextrepo) {
|
|
|
255 |
printf(" %d) %s %s (%s)\n", repoid, pkgnode->name, xrepo->version, repolist[xrepo->repo]);
|
|
|
256 |
repoid += 1;
|
|
|
257 |
}
|
|
|
258 |
for (;;) {
|
|
|
259 |
kitten_printf(3, 4, "Your choice:");
|
|
|
260 |
printf(" ");
|
|
|
261 |
fgets(userchoicestr, 6, stdin);
|
|
|
262 |
userchoice = atoi(userchoicestr);
|
|
|
263 |
if ((userchoice < 1) || (userchoice >= repoid)) {
|
|
|
264 |
kitten_puts(3, 5, "Invalid choice!");
|
|
|
265 |
} else {
|
|
|
266 |
break;
|
|
|
267 |
}
|
|
|
268 |
}
|
|
|
269 |
repoid = userchoice;
|
|
|
270 |
}
|
|
|
271 |
} else { /* available only from one repository - get it there */
|
|
|
272 |
repoid = 1;
|
|
|
273 |
}
|
|
|
274 |
pkgrepo = pkgnode->repolist;
|
|
|
275 |
for (; repoid > 1; repoid--) pkgrepo = pkgrepo->nextrepo;
|
|
|
276 |
instrepo = repolist[pkgrepo->repo];
|
|
|
277 |
|
|
|
278 |
/* select the package extension: zip or zib */
|
|
|
279 |
if ((flags & PKGINST_NOSOURCE) && (pkgrepo->crc32zib != 0)) { /* use zib if available and if no sources needed */
|
|
|
280 |
pkgext = "zib"; /* zib is the same thing as zip, but binary-only (no sources) */
|
|
|
281 |
remotecrc = pkgrepo->crc32zib;
|
|
|
282 |
} else { /* otherwise use the full-blown zip package */
|
|
|
283 |
pkgext = "zip";
|
|
|
284 |
remotecrc = pkgrepo->crc32zip;
|
|
|
285 |
}
|
|
|
286 |
|
|
|
287 |
/* if it's a network repo, download the package from repoid into the temp directory */
|
|
|
288 |
if (detect_localpath(instrepo) == 0) {
|
|
|
289 |
sprintf(fname, "%s%s.%s", instrepo, pkgname, pkgext);
|
|
|
290 |
sprintf(zipfile, "%s\\fdnpkg.tmp", tempdir);
|
|
|
291 |
kitten_printf(3, 6, "Downloading package %s...", fname);
|
|
|
292 |
puts("");
|
|
|
293 |
if (http_get(fname, zipfile, proxy, proxyport, downloadingstring) <= 0) {
|
|
|
294 |
kitten_puts(3, 7, "Error downloading package. Aborted.");
|
|
|
295 |
return(NULL);
|
|
|
296 |
}
|
|
|
297 |
} else { /* else it's an on-disk repo, so we can use the package right from there */
|
|
|
298 |
sprintf(zipfile, "%s%s.%s", instrepo, pkgname, pkgext);
|
|
|
299 |
}
|
|
|
300 |
/* check the CRC of the downloaded file */
|
|
|
301 |
buff = malloc(4096); /* use a 4K buffer to compute file's CRC */
|
|
|
302 |
if (buff == NULL) {
|
|
|
303 |
kitten_puts(3, 15, "Error: Out of memory while computing the CRC of the package!");
|
|
|
304 |
return(NULL);
|
|
|
305 |
}
|
|
|
306 |
*zipfd = fopen(zipfile, "rb");
|
|
|
307 |
if (*zipfd == NULL) {
|
|
|
308 |
kitten_puts(3, 14, "Error: Failed to open the downloaded package. Installation aborted.");
|
|
|
309 |
free(buff);
|
|
|
310 |
return(NULL);
|
|
|
311 |
}
|
|
|
312 |
zipfilecrc = crc32_init();
|
|
|
313 |
while ((buffreadres = read(fileno(*zipfd), buff, 4096)) > 0) {
|
|
|
314 |
crc32_feed(&zipfilecrc, buff, buffreadres);
|
|
|
315 |
}
|
|
|
316 |
crc32_finish(&zipfilecrc);
|
|
|
317 |
fclose(*zipfd);
|
|
|
318 |
free(buff);
|
|
|
319 |
if (zipfilecrc != remotecrc) {
|
|
|
320 |
kitten_puts(3, 13, "Error: Downloaded package had wrong CRC. Installation aborted.");
|
|
|
321 |
return(NULL);
|
|
|
322 |
}
|
|
|
323 |
} /* if (zipfile[0] == 0) */
|
|
|
324 |
#endif
|
|
|
325 |
|
|
|
326 |
/* Now let's check the content of the zip file */
|
|
|
327 |
|
|
|
328 |
*zipfd = fopen(zipfile, "rb");
|
|
|
329 |
if (*zipfd == NULL) {
|
|
|
330 |
kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed.");
|
|
|
331 |
return(NULL);
|
|
|
332 |
}
|
|
|
333 |
ziplinkedlist = zip_listfiles(*zipfd);
|
|
|
334 |
if (ziplinkedlist == NULL) {
|
|
|
335 |
kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed.");
|
|
|
336 |
fclose(*zipfd);
|
|
|
337 |
return(NULL);
|
|
|
338 |
}
|
|
|
339 |
/* if updating, load the list of files belonging to the current package */
|
|
|
340 |
if ((flags & PKGINST_UPDATE) != 0) {
|
|
|
341 |
flist = pkg_loadflist(pkgname, dosdir);
|
|
|
342 |
} else {
|
|
|
343 |
flist = NULL;
|
|
|
344 |
}
|
|
|
345 |
/* Verify that there's no collision with existing local files, look for the appinfo presence, get rid of sources if required, and rename BAT links into COM files */
|
|
|
346 |
appinfopresence = 0;
|
|
|
347 |
prevzipnode = NULL;
|
|
|
348 |
for (curzipnode = ziplinkedlist; curzipnode != NULL;) {
|
|
|
349 |
/* change all slashes to backslashes, and switch into all-lowercase */
|
|
|
350 |
slash2backslash(curzipnode->filename);
|
|
|
351 |
strtolower(curzipnode->filename);
|
|
|
352 |
/* remove 'directory' ZIP entries to avoid false alerts about directory already existing */
|
|
|
353 |
if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) {
|
|
|
354 |
curzipnode->filename[0] = 0; /* mark it "empty", will be removed in a short moment */
|
|
|
355 |
}
|
|
|
356 |
/* if --nosource specified, skip sources */
|
|
|
357 |
if ((flags & PKGINST_NOSOURCE) != 0) {
|
|
|
358 |
if (fdnpkg_strcasestr(curzipnode->filename, "source\\") == curzipnode->filename) { /* drop this file */
|
|
|
359 |
curzipnode->filename[0] = 0; /* in fact, we just mark the file as 'empty' on the filename.. see below */
|
|
|
360 |
}
|
|
|
361 |
}
|
|
|
362 |
/* is it a "link file"? */
|
|
|
363 |
if (fdnpkg_strcasestr(curzipnode->filename, "links\\") == curzipnode->filename) {
|
|
|
364 |
/* skip links, if that's what the user wants */
|
|
|
365 |
if ((flags & PKGINST_SKIPLINKS) != 0) {
|
|
|
366 |
curzipnode->filename[0] = 0; /* in fact, we just mark the file as 'empty' on the filename.. see later below */
|
|
|
367 |
} else {
|
|
|
368 |
/* if it's a *.BAT link, then rename it to *.COM */
|
|
|
369 |
char *ext = getfext(curzipnode->filename);
|
|
|
370 |
if (strcasecmp(ext, "bat") == 0) sprintf(ext, "com");
|
|
|
371 |
}
|
|
|
372 |
}
|
|
|
373 |
|
|
|
374 |
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) */
|
|
|
375 |
if (prevzipnode == NULL) { /* take the item out of the list */
|
|
|
376 |
ziplinkedlist = curzipnode->nextfile;
|
|
|
377 |
free(curzipnode); /* free the item */
|
|
|
378 |
curzipnode = ziplinkedlist;
|
|
|
379 |
} else {
|
|
|
380 |
prevzipnode->nextfile = curzipnode->nextfile;
|
|
|
381 |
free(curzipnode); /* free the item */
|
|
|
382 |
curzipnode = prevzipnode->nextfile;
|
|
|
383 |
}
|
|
|
384 |
continue; /* go to the next item */
|
|
|
385 |
}
|
|
|
386 |
/* validate that the file has a valid filename (8+3, no shady chars...) */
|
|
|
387 |
if (validfilename(curzipnode->filename) != 0) {
|
|
|
388 |
kitten_puts(3, 23, "Error: Package contains an invalid filename:");
|
|
|
389 |
printf(" %s\n", curzipnode->filename);
|
|
|
390 |
zip_freelist(&ziplinkedlist);
|
|
|
391 |
fclose(*zipfd);
|
|
|
392 |
return(NULL);
|
|
|
393 |
}
|
|
|
394 |
/* look out for collisions with already existing files (unless we are
|
|
|
395 |
* updating the package and the local file belongs to it */
|
|
|
396 |
shortfile = computelocalpath(curzipnode->filename, fname, dosdir, dirlist);
|
|
|
397 |
mapdrives(fname, mapdrv);
|
|
|
398 |
strcat(fname, shortfile);
|
|
|
399 |
if ((findfileinlist(flist, fname) == NULL) && (fileexists(fname) != 0)) {
|
|
|
400 |
kitten_puts(3, 9, "Error: Package contains a file that already exists locally:");
|
|
|
401 |
printf(" %s\n", fname);
|
|
|
402 |
zip_freelist(&ziplinkedlist);
|
|
|
403 |
fclose(*zipfd);
|
|
|
404 |
return(NULL);
|
|
|
405 |
}
|
|
|
406 |
/* abort if any entry is encrypted */
|
|
|
407 |
if ((curzipnode->flags & ZIP_FLAG_ENCRYPTED) != 0) {
|
|
|
408 |
kitten_printf(3, 20, "Error: Package contains an encrypted file:");
|
|
|
409 |
puts("");
|
|
|
410 |
printf(" %s\n", curzipnode->filename);
|
|
|
411 |
zip_freelist(&ziplinkedlist);
|
|
|
412 |
fclose(*zipfd);
|
|
|
413 |
return(NULL);
|
|
|
414 |
}
|
|
|
415 |
/* abort if any file is compressed with an unsupported method */
|
|
|
416 |
if ((curzipnode->compmethod != 0/*store*/) && (curzipnode->compmethod != 8/*deflate*/) && (curzipnode->compmethod != 14/*lzma*/)) { /* unsupported compression method */
|
|
|
417 |
kitten_printf(8, 2, "Error: Package contains a file compressed with an unsupported method (%d):", curzipnode->compmethod);
|
|
|
418 |
puts("");
|
|
|
419 |
printf(" %s\n", curzipnode->filename);
|
|
|
420 |
zip_freelist(&ziplinkedlist);
|
|
|
421 |
fclose(*zipfd);
|
|
|
422 |
return(NULL);
|
|
|
423 |
}
|
|
|
424 |
if (strcmp(curzipnode->filename, appinfofile) == 0) appinfopresence = 1;
|
|
|
425 |
prevzipnode = curzipnode;
|
|
|
426 |
curzipnode = curzipnode->nextfile;
|
|
|
427 |
}
|
|
|
428 |
/* if appinfo file not found, this is not a real FreeDOS package */
|
|
|
429 |
if (appinfopresence != 1) {
|
|
|
430 |
kitten_printf(3, 12, "Error: Package do not contain the %s file! Not a valid FreeDOS package.", appinfofile);
|
|
|
431 |
puts("");
|
|
|
432 |
zip_freelist(&ziplinkedlist);
|
|
|
433 |
fclose(*zipfd);
|
|
|
434 |
return(NULL);
|
|
|
435 |
}
|
|
|
436 |
|
|
|
437 |
return(ziplinkedlist);
|
|
|
438 |
}
|
|
|
439 |
|
|
|
440 |
|
|
|
441 |
/* install a package that has been prepared already. returns 0 on success,
|
|
|
442 |
* or a negative value on error, or a positive value on warning */
|
|
|
443 |
int pkginstall_installpackage(char *pkgname, char *dosdir, struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd, char *mapdrv) {
|
|
|
444 |
char *buff;
|
|
|
445 |
char *fulldestfilename;
|
|
|
446 |
char packageslst[64];
|
|
|
447 |
char *shortfile;
|
|
|
448 |
long filesextractedsuccess = 0, filesextractedfailure = 0;
|
|
|
449 |
struct ziplist *curzipnode;
|
|
|
450 |
FILE *lstfd;
|
|
|
451 |
|
|
|
452 |
sprintf(packageslst, "packages\\%s.lst", pkgname); /* Prepare the packages/xxxx.lst filename string for later use */
|
|
|
453 |
|
|
|
454 |
buff = malloc(512);
|
|
|
455 |
fulldestfilename = malloc(1024);
|
|
|
456 |
if ((buff == NULL) || (fulldestfilename == NULL)) {
|
|
|
457 |
kitten_puts(8, 0, "Out of memory!");
|
|
|
458 |
zip_freelist(&ziplinkedlist);
|
|
|
459 |
free(buff);
|
|
|
460 |
free(fulldestfilename);
|
|
|
461 |
return(-1);
|
|
|
462 |
}
|
|
|
463 |
|
|
|
464 |
/* create the %DOSDIR%/packages directory, just in case it doesn't exist yet */
|
|
|
465 |
sprintf(buff, "%s\\packages\\", dosdir);
|
|
|
466 |
mkpath(buff);
|
|
|
467 |
|
|
|
468 |
/* open the lst file */
|
|
|
469 |
sprintf(buff, "%s\\%s", dosdir, packageslst);
|
|
|
470 |
mapdrives(buff, mapdrv);
|
|
|
471 |
lstfd = fopen(buff, "wb"); /* opening it in binary mode, because I like to have control over line terminators (CR/LF) */
|
|
|
472 |
if (lstfd == NULL) {
|
|
|
473 |
kitten_printf(3, 10, "Error: Could not create %s!", buff);
|
|
|
474 |
puts("");
|
|
|
475 |
zip_freelist(&ziplinkedlist);
|
|
|
476 |
free(buff);
|
|
|
477 |
free(fulldestfilename);
|
|
|
478 |
return(-2);
|
|
|
479 |
}
|
|
|
480 |
|
|
|
481 |
/* write list of files in zip into the lst, and create the directories structure */
|
|
|
482 |
for (curzipnode = ziplinkedlist; curzipnode != NULL; curzipnode = curzipnode->nextfile) {
|
|
|
483 |
int unzip_result;
|
|
|
484 |
if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) continue; /* skip directories */
|
|
|
485 |
if (strcasecmp(curzipnode->filename, packageslst) == 0) continue; /* skip silently the package.lst file, if found */
|
|
|
486 |
shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist); /* substitute paths to custom dirs */
|
|
|
487 |
/* log the filename to packages\pkg.lst (with original, unmapped drive) */
|
|
|
488 |
fprintf(lstfd, "%s%s\r\n", buff, shortfile);
|
|
|
489 |
/* remap drive letter, if needed (AFTER writing to lstfd) */
|
|
|
490 |
mapdrives(buff, mapdrv);
|
|
|
491 |
/* create the path, just in case it doesn't exist yet */
|
|
|
492 |
mkpath(buff);
|
|
|
493 |
sprintf(fulldestfilename, "%s%s", buff, shortfile);
|
|
|
494 |
/* Now unzip the file */
|
|
|
495 |
unzip_result = zip_unzip(zipfd, curzipnode, fulldestfilename);
|
|
|
496 |
if (unzip_result != 0) {
|
|
|
497 |
kitten_printf(8, 3, "Error while extracting '%s' to '%s'!", curzipnode->filename, fulldestfilename);
|
|
|
498 |
printf(" [%d]\n", unzip_result);
|
|
|
499 |
filesextractedfailure += 1;
|
|
|
500 |
} else {
|
|
|
501 |
printf(" %s -> %s\n", curzipnode->filename, buff);
|
|
|
502 |
filesextractedsuccess += 1;
|
|
|
503 |
}
|
|
|
504 |
/* if it's a LINK file, recompute a new content */
|
|
|
505 |
if (islinkfile(curzipnode->filename) != 0) {
|
|
|
506 |
unmapdrives(buff, mapdrv);
|
|
|
507 |
processlinkfile(fulldestfilename, dosdir, dirlist, buff);
|
|
|
508 |
}
|
|
|
509 |
}
|
|
|
510 |
fclose(lstfd);
|
|
|
511 |
|
|
|
512 |
/* free the ziplist and close file descriptor */
|
|
|
513 |
zip_freelist(&ziplinkedlist);
|
|
|
514 |
free(buff);
|
|
|
515 |
free(fulldestfilename);
|
|
|
516 |
|
|
|
517 |
kitten_printf(3, 19, "Package %s installed: %ld files extracted, %ld errors.", pkgname, filesextractedsuccess, filesextractedfailure);
|
|
|
518 |
puts("");
|
|
|
519 |
return(filesextractedfailure);
|
|
|
520 |
}
|