Subversion Repositories SvarDOS

Rev

Rev 224 | Rev 227 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
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 "helpers.h"   /* slash2backslash(), strtolower() */
17
#include "fileexst.h"
18
#include "kprintf.h"
19
#include "libunzip.h"  /* zip_listfiles()... */
20
#include "showinst.h"  /* pkg_loadflist() */
21
#include "pkginst.h"   /* include self for control */
22
#include "version.h"
23
 
24
 
25
/* return 1 if fname looks like a link filename, 0 otherwise */
26
static int islinkfile(char *fname) {
27
  char *link1 = "LINKS\\";
28
  char *link2 = "links\\";
29
  int x;
30
  for (x = 0; ; x++) {
31
    if (link1[x] == 0) return(1);
32
    if ((fname[x] != link1[x]) && (fname[x] != link2[x])) return(0);
33
  }
34
}
35
 
36
 
37
/* validate a filename (8+3, no weird characters, etc). returns 0 on success,
38
 * nonzero otherwise. */
39
static int validfilename(char *fname) {
40
  int i, i2;
41
  char *validchars = "!#$%&'()-@^_`{}~";
42
  int elemlen = 0;
43
  int elemmaxlen = 8; /* switches from 8 to 3 depending wheter I am analyzing
44
                         a filename or an extension */
45
  /* look for invalid chars in the entire string, and check the length of the
46
   * element at the same time */
47
  for (i = 0; fname[i] != 0; i++) {
48
    /* director separators are threated specially */
49
    if (fname[i] == '\\') {
50
      elemlen = 0;
51
      elemmaxlen = 8;
52
      continue;
53
    }
54
    /* '.' switches the check into extension mode */
55
    if (fname[i] == '.') {
56
      if (elemlen == 0) return(-1); /* a file must have a base name */
57
      if (elemmaxlen == 3) return(-2); /* a file cannot have two extensions */
58
      elemlen = 0;
59
      elemmaxlen = 3;
60
      continue;
61
    }
62
    /* check that the element is not too long */
63
    if (++elemlen > elemmaxlen) return(-3);
64
    /* look for valid characters */
65
    if ((fname[i] >= 'a') && (fname[i] <= 'z')) continue;
66
    if ((fname[i] >= 'A') && (fname[i] <= 'Z')) continue;
67
    if ((fname[i] >= '0') && (fname[i] <= '9')) continue;
68
    if ((fname[i] & 128) != 0) continue; /* high bytes are okay (NLS) */
69
    /* look for other valid characters */
70
    for (i2 = 0; validchars[i2] != 0; i2++) {
71
      if (fname[i] == validchars[i2]) break;
72
    }
73
    if (validchars[i2] != 0) continue;
74
    /* if we are here, then the character is invalid */
75
    return(-4);
76
  }
77
  /* all checks passed */
78
  return(0);
79
}
80
 
81
 
82
/* processes a link file - that is, reads the target inside, and overwrite
83
 * the file with new content */
84
static void processlinkfile(char *linkfile, char *dosdir, struct customdirs *dirlist, char *buff) {
85
  char origtarget[512];
86
  int x;
87
  char *shortfile;
88
  unsigned char comstub[] = { /* machine code of a COM stub launcher */
89
    0xBC,0x00,0x00,0xBB,0x00,0x10,0xB4,0x4A,0xCD,0x21,0xBB,0x2A,0x01,0x8C,0x5F,0x04,
90
    0x8C,0x5F,0x08,0x8C,0x5F,0x0C,0xB8,0x00,0x4B,0xBA,0x38,0x01,0xCD,0x21,0xB0,0x7F,
91
    0x72,0x04,0xB4,0x4D,0xCD,0x21,0xB4,0x4C,0xCD,0x21,0x00,0x00,0x80,0x00,0x00,0x00,
92
    0x5C,0x00,0x00,0x00,0x6C,0x00,0x00,0x00}; /* read comlink.asm for details */
93
  const unsigned stack_paras = 12;
94
  unsigned alloc_paras, alloc_bytes;
95
  FILE *fd;
96
  /* open the link file and read the original target */
97
  fd = fopen(linkfile, "r");
98
  if (fd == NULL) {
99
    kitten_printf(3, 21, "Error: Failed to open link file '%s' for read access.", linkfile);
100
    puts("");
101
    return;
102
  }
103
  x = fread(origtarget, 1, sizeof(origtarget) - 1, fd);
104
  origtarget[x] = 0;
105
  fclose(fd);
106
  /* validate the original target (ltrim to first \r or \n) */
107
  for (x = 0; origtarget[x] != 0; x++) {
108
    if ((origtarget[x] == '\r') || (origtarget[x] == '\n')) {
109
      origtarget[x] = 0;
110
      break;
111
    }
112
  }
113
  /* translate the original target to a local path */
114
  shortfile = computelocalpath(origtarget, buff, dosdir, dirlist);
115
  /* compute the amount of memory the stub should leave for itself:
116
	- 16 paragraphs needed for the PSP
117
	- sizeof(comstub) bytes needed for code and data
118
	- strlen(shortfile) + 1 for the command line
119
	- stack_paras paragraphs for the stack */
120
  alloc_paras = 16 + (sizeof(comstub) + strlen(shortfile) + 16) / 16 + stack_paras;
121
  alloc_bytes = 16 * alloc_paras;
122
  comstub[1] = alloc_bytes & 0xff;
123
  comstub[2] = alloc_bytes >> 8;
124
  comstub[4] = alloc_paras & 0xff;
125
  comstub[5] = alloc_paras >> 8;
126
  /* write new content into the link file */
127
  fd = fopen(linkfile, "wb");
128
  if (fd == NULL) {
129
    kitten_printf(3, 22, "Error: Failed to open link file '%s' for write access.", linkfile);
130
    puts("");
131
    return;
132
  }
133
  fwrite(comstub, 1, sizeof(comstub), fd);
134
  fprintf(fd, "%s%s%c", buff, shortfile, 0);
135
  fclose(fd);
136
}
137
 
138
 
139
/* returns 0 if pkgname is not installed, non-zero otherwise */
225 mateuszvis 140
int is_package_installed(char *pkgname, char *dosdir) {
219 mateuszvis 141
  char fname[512];
142
  sprintf(fname, "%s\\packages\\%s.lst", dosdir, pkgname);
143
  if (fileexists(fname) != 0) { /* file exists -> package is installed */
144
    return(1);
145
  } else {
146
    return(0);
147
  }
148
}
149
 
150
 
151
/* checks that pkgname is NOT installed. return 0 on success, non-zero otherwise. */
225 mateuszvis 152
int validate_package_not_installed(char *pkgname, char *dosdir) {
153
  if (is_package_installed(pkgname, dosdir) != 0) {
219 mateuszvis 154
    kitten_printf(3, 18, "Package %s is already installed! You might want to use the 'update' action.", pkgname);
155
    puts("");
156
    return(-1);
157
  }
158
  return(0);
159
}
160
 
161
 
162
/* find a filename in a flist linked list, and returns a pointer to it */
163
static struct flist_t *findfileinlist(struct flist_t *flist, char *fname) {
164
  while (flist != NULL) {
165
    if (strcmp(flist->fname, fname) == 0) return(flist);
166
    flist = flist->next;
167
  }
168
  return(NULL);
169
}
170
 
171
 
172
/* prepare a package for installation. this is mandatory before actually installing it!
173
 * 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. */
225 mateuszvis 174
struct ziplist *pkginstall_preparepackage(char *pkgname, char *localfile, int flags, FILE **zipfd, char *dosdir, struct customdirs *dirlist, char *buffmem1k) {
219 mateuszvis 175
  char *fname;
176
  char *zipfile;
177
  char *appinfofile;
178
  int appinfopresence;
179
  char *shortfile;
180
  struct ziplist *ziplinkedlist, *curzipnode, *prevzipnode;
181
  struct flist_t *flist;
182
 
183
  fname = buffmem1k;
184
  zipfile = buffmem1k + 256;
185
  appinfofile = buffmem1k + 512;
186
 
187
  strtolower(pkgname); /* convert pkgname to lower case, because the http repo is probably case sensitive */
188
  sprintf(appinfofile, "appinfo\\%s.lsm", pkgname); /* Prepare the appinfo/xxxx.lsm filename string for later use */
189
 
190
  /* check if not already installed, if already here, print a message "you might want to use update instead"
191
   * of course this must not be done if we are in the process of upgrading said package */
225 mateuszvis 192
  if (((flags & PKGINST_UPDATE) == 0) && (validate_package_not_installed(pkgname, dosdir) != 0)) {
219 mateuszvis 193
    return(NULL);
194
  }
195
 
196
  if (localfile != NULL) {  /* if it's a local file, then we will have to skip all the network stuff */
197
    strcpy(zipfile, localfile);
198
  } else {
199
    zipfile[0] = 0;
200
  }
201
 
202
  /* Now let's check the content of the zip file */
203
 
204
  *zipfd = fopen(zipfile, "rb");
205
  if (*zipfd == NULL) {
206
    kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed.");
207
    return(NULL);
208
  }
209
  ziplinkedlist = zip_listfiles(*zipfd);
210
  if (ziplinkedlist == NULL) {
211
    kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed.");
212
    fclose(*zipfd);
213
    return(NULL);
214
  }
215
  /* if updating, load the list of files belonging to the current package */
216
  if ((flags & PKGINST_UPDATE) != 0) {
217
    flist = pkg_loadflist(pkgname, dosdir);
218
  } else {
219
    flist = NULL;
220
  }
221
  /* 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 */
222
  appinfopresence = 0;
223
  prevzipnode = NULL;
224
  for (curzipnode = ziplinkedlist; curzipnode != NULL;) {
225
    /* change all slashes to backslashes, and switch into all-lowercase */
226
    slash2backslash(curzipnode->filename);
227
    strtolower(curzipnode->filename);
228
    /* remove 'directory' ZIP entries to avoid false alerts about directory already existing */
229
    if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) {
230
      curzipnode->filename[0] = 0; /* mark it "empty", will be removed in a short moment */
231
    }
232
    /* if --nosource specified, skip sources */
233
    if ((flags & PKGINST_NOSOURCE) != 0) {
234
      if (fdnpkg_strcasestr(curzipnode->filename, "source\\") == curzipnode->filename) { /* drop this file */
235
        curzipnode->filename[0] = 0; /* in fact, we just mark the file as 'empty' on the filename.. see below */
236
      }
237
    }
238
    /* is it a "link file"? */
239
    if (fdnpkg_strcasestr(curzipnode->filename, "links\\") == curzipnode->filename) {
240
      /* skip links, if that's what the user wants */
241
      if ((flags & PKGINST_SKIPLINKS) != 0) {
242
        curzipnode->filename[0] = 0; /* in fact, we just mark the file as 'empty' on the filename.. see later below */
243
      } else {
244
        /* if it's a *.BAT link, then rename it to *.COM */
245
        char *ext = getfext(curzipnode->filename);
246
        if (strcasecmp(ext, "bat") == 0) sprintf(ext, "com");
247
      }
248
    }
249
 
250
    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) */
251
      if (prevzipnode == NULL) {  /* take the item out of the list */
252
        ziplinkedlist = curzipnode->nextfile;
253
        free(curzipnode); /* free the item */
254
        curzipnode = ziplinkedlist;
255
      } else {
256
        prevzipnode->nextfile = curzipnode->nextfile;
257
        free(curzipnode); /* free the item */
258
        curzipnode = prevzipnode->nextfile;
259
      }
260
      continue; /* go to the next item */
261
    }
262
    /* validate that the file has a valid filename (8+3, no shady chars...) */
263
    if (validfilename(curzipnode->filename) != 0) {
264
      kitten_puts(3, 23, "Error: Package contains an invalid filename:");
265
      printf(" %s\n", curzipnode->filename);
266
      zip_freelist(&ziplinkedlist);
267
      fclose(*zipfd);
268
      return(NULL);
269
    }
270
    /* look out for collisions with already existing files (unless we are
271
     * updating the package and the local file belongs to it */
272
    shortfile = computelocalpath(curzipnode->filename, fname, dosdir, dirlist);
273
    strcat(fname, shortfile);
274
    if ((findfileinlist(flist, fname) == NULL) && (fileexists(fname) != 0)) {
275
      kitten_puts(3, 9, "Error: Package contains a file that already exists locally:");
276
      printf(" %s\n", fname);
277
      zip_freelist(&ziplinkedlist);
278
      fclose(*zipfd);
279
      return(NULL);
280
    }
281
    /* abort if any entry is encrypted */
282
    if ((curzipnode->flags & ZIP_FLAG_ENCRYPTED) != 0) {
283
      kitten_printf(3, 20, "Error: Package contains an encrypted file:");
284
      puts("");
285
      printf(" %s\n", curzipnode->filename);
286
      zip_freelist(&ziplinkedlist);
287
      fclose(*zipfd);
288
      return(NULL);
289
    }
290
    /* abort if any file is compressed with an unsupported method */
223 mateuszvis 291
    if ((curzipnode->compmethod != 0/*store*/) && (curzipnode->compmethod != 8/*deflate*/)) { /* unsupported compression method */
219 mateuszvis 292
      kitten_printf(8, 2, "Error: Package contains a file compressed with an unsupported method (%d):", curzipnode->compmethod);
293
      puts("");
294
      printf(" %s\n", curzipnode->filename);
295
      zip_freelist(&ziplinkedlist);
296
      fclose(*zipfd);
297
      return(NULL);
298
    }
299
    if (strcmp(curzipnode->filename, appinfofile) == 0) appinfopresence = 1;
300
    prevzipnode = curzipnode;
301
    curzipnode = curzipnode->nextfile;
302
  }
303
  /* if appinfo file not found, this is not a real FreeDOS package */
304
  if (appinfopresence != 1) {
305
    kitten_printf(3, 12, "Error: Package do not contain the %s file! Not a valid FreeDOS package.", appinfofile);
306
    puts("");
307
    zip_freelist(&ziplinkedlist);
308
    fclose(*zipfd);
309
    return(NULL);
310
  }
311
 
312
  return(ziplinkedlist);
313
}
314
 
315
 
316
/* install a package that has been prepared already. returns 0 on success,
317
 * or a negative value on error, or a positive value on warning */
225 mateuszvis 318
int pkginstall_installpackage(char *pkgname, char *dosdir, struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd) {
219 mateuszvis 319
  char *buff;
320
  char *fulldestfilename;
321
  char packageslst[64];
322
  char *shortfile;
323
  long filesextractedsuccess = 0, filesextractedfailure = 0;
324
  struct ziplist *curzipnode;
325
  FILE *lstfd;
326
 
327
  sprintf(packageslst, "packages\\%s.lst", pkgname); /* Prepare the packages/xxxx.lst filename string for later use */
328
 
329
  buff = malloc(512);
330
  fulldestfilename = malloc(1024);
331
  if ((buff == NULL) || (fulldestfilename == NULL)) {
332
    kitten_puts(8, 0, "Out of memory!");
333
    zip_freelist(&ziplinkedlist);
334
    free(buff);
335
    free(fulldestfilename);
336
    return(-1);
337
  }
338
 
339
  /* create the %DOSDIR%/packages directory, just in case it doesn't exist yet */
340
  sprintf(buff, "%s\\packages\\", dosdir);
341
  mkpath(buff);
342
 
343
  /* open the lst file */
344
  sprintf(buff, "%s\\%s", dosdir, packageslst);
345
  lstfd = fopen(buff, "wb"); /* opening it in binary mode, because I like to have control over line terminators (CR/LF) */
346
  if (lstfd == NULL) {
347
    kitten_printf(3, 10, "Error: Could not create %s!", buff);
348
    puts("");
349
    zip_freelist(&ziplinkedlist);
350
    free(buff);
351
    free(fulldestfilename);
352
    return(-2);
353
  }
354
 
355
  /* write list of files in zip into the lst, and create the directories structure */
356
  for (curzipnode = ziplinkedlist; curzipnode != NULL; curzipnode = curzipnode->nextfile) {
357
    int unzip_result;
358
    if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) continue; /* skip directories */
359
    if (strcasecmp(curzipnode->filename, packageslst) == 0) continue; /* skip silently the package.lst file, if found */
360
    shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist); /* substitute paths to custom dirs */
361
    /* log the filename to packages\pkg.lst (with original, unmapped drive) */
362
    fprintf(lstfd, "%s%s\r\n", buff, shortfile);
363
    /* create the path, just in case it doesn't exist yet */
364
    mkpath(buff);
365
    sprintf(fulldestfilename, "%s%s", buff, shortfile);
366
    /* Now unzip the file */
367
    unzip_result = zip_unzip(zipfd, curzipnode, fulldestfilename);
368
    if (unzip_result != 0) {
369
      kitten_printf(8, 3, "Error while extracting '%s' to '%s'!", curzipnode->filename, fulldestfilename);
370
      printf(" [%d]\n", unzip_result);
371
      filesextractedfailure += 1;
372
    } else {
373
      printf(" %s -> %s\n", curzipnode->filename, buff);
374
      filesextractedsuccess += 1;
375
    }
376
    /* if it's a LINK file, recompute a new content */
377
    if (islinkfile(curzipnode->filename) != 0) {
378
      processlinkfile(fulldestfilename, dosdir, dirlist, buff);
379
    }
380
  }
381
  fclose(lstfd);
382
 
383
  /* free the ziplist and close file descriptor */
384
  zip_freelist(&ziplinkedlist);
385
  free(buff);
386
  free(fulldestfilename);
387
 
388
  kitten_printf(3, 19, "Package %s installed: %ld files extracted, %ld errors.", pkgname, filesextractedsuccess, filesextractedfailure);
389
  puts("");
390
  return(filesextractedfailure);
391
}