WebSVN – SvarDOS – Diff – /pkg/trunk/pkginst.c


/*
 * This file is part of pkginst (SvarDOS)
 * Copyright (C) 2012-2021 Mateusz Viste
 * Changes by TK Chia
 */
 
#include <ctype.h>     /* toupper() */
#include <stdio.h>
#include <stdlib.h>    /* system() */
#include <string.h>    /* strcpy() */
#include <unistd.h>    /* read() */
#include <sys/types.h> /* struct utimbuf */
 
#include "crc32.h"     /* all CRC32 related stuff */
#include "fdnpkg.h"    /* PKGINST_SKIPLINKS... */
#include "helpers.h"   /* slash2backslash(), strtolower() */
#include "fileexst.h"
#include "kprintf.h"
#include "libunzip.h"  /* zip_listfiles()... */
#include "showinst.h"  /* pkg_loadflist() */
#include "pkginst.h"   /* include self for control */
#include "version.h"
 
 
/* return 1 if fname looks like a link filename, 0 otherwise */
static int islinkfile(char *fname) {
  char *link1 = "LINKS\\";
  char *link2 = "links\\";
  int x;
  for (x = 0; ; x++) {
    if (link1[x] == 0) return(1);
    if ((fname[x] != link1[x]) && (fname[x] != link2[x])) return(0);
  }
}
 
 
/* validate a filename (8+3, no weird characters, etc). returns 0 on success,
 * nonzero otherwise. */
static int validfilename(char *fname) {
  int i, i2;
  char *validchars = "!#$%&'()-@^_`{}~";
  int elemlen = 0;
  int elemmaxlen = 8; /* switches from 8 to 3 depending wheter I am analyzing
                         a filename or an extension */
  /* look for invalid chars in the entire string, and check the length of the
   * element at the same time */
  for (i = 0; fname[i] != 0; i++) {
    /* director separators are threated specially */
    if (fname[i] == '\\') {
      elemlen = 0;
      elemmaxlen = 8;
      continue;
    }
    /* '.' switches the check into extension mode */
    if (fname[i] == '.') {
      if (elemlen == 0) return(-1); /* a file must have a base name */
      if (elemmaxlen == 3) return(-2); /* a file cannot have two extensions */
      elemlen = 0;
      elemmaxlen = 3;
      continue;
    }
    /* check that the element is not too long */
    if (++elemlen > elemmaxlen) return(-3);
    /* look for valid characters */
    if ((fname[i] >= 'a') && (fname[i] <= 'z')) continue;
    if ((fname[i] >= 'A') && (fname[i] <= 'Z')) continue;
    if ((fname[i] >= '0') && (fname[i] <= '9')) continue;
    if ((fname[i] & 128) != 0) continue; /* high bytes are okay (NLS) */
    /* look for other valid characters */
    for (i2 = 0; validchars[i2] != 0; i2++) {
      if (fname[i] == validchars[i2]) break;
    }
    if (validchars[i2] != 0) continue;
    /* if we are here, then the character is invalid */
    return(-4);
  }
  /* all checks passed */
  return(0);
}
 
 
/* processes a link file - that is, reads the target inside, and overwrite
 * the file with new content */
static void processlinkfile(char *linkfile, char *dosdir, struct customdirs *dirlist, char *buff) {
  char origtarget[512];
  int x;
  char *shortfile;
  unsigned char comstub[] = { /* machine code of a COM stub launcher */
    0xBC,0x00,0x00,0xBB,0x00,0x10,0xB4,0x4A,0xCD,0x21,0xBB,0x2A,0x01,0x8C,0x5F,0x04,
    0x8C,0x5F,0x08,0x8C,0x5F,0x0C,0xB8,0x00,0x4B,0xBA,0x38,0x01,0xCD,0x21,0xB0,0x7F,
    0x72,0x04,0xB4,0x4D,0xCD,0x21,0xB4,0x4C,0xCD,0x21,0x00,0x00,0x80,0x00,0x00,0x00,
    0x5C,0x00,0x00,0x00,0x6C,0x00,0x00,0x00}; /* read comlink.asm for details */
  const unsigned stack_paras = 12;
  unsigned alloc_paras, alloc_bytes;
  FILE *fd;
  /* open the link file and read the original target */
  fd = fopen(linkfile, "r");
  if (fd == NULL) {
    kitten_printf(3, 21, "Error: Failed to open link file '%s' for read access.", linkfile);
    puts("");
    return;
  }
  x = fread(origtarget, 1, sizeof(origtarget) - 1, fd);
  origtarget[x] = 0;
  fclose(fd);
  /* validate the original target (ltrim to first \r or \n) */
  for (x = 0; origtarget[x] != 0; x++) {
    if ((origtarget[x] == '\r') || (origtarget[x] == '\n')) {
      origtarget[x] = 0;
      break;
    }
  }
  /* translate the original target to a local path */
  shortfile = computelocalpath(origtarget, buff, dosdir, dirlist);
  /* compute the amount of memory the stub should leave for itself:
	- 16 paragraphs needed for the PSP
	- sizeof(comstub) bytes needed for code and data
	- strlen(shortfile) + 1 for the command line
	- stack_paras paragraphs for the stack */
  alloc_paras = 16 + (sizeof(comstub) + strlen(shortfile) + 16) / 16 + stack_paras;
  alloc_bytes = 16 * alloc_paras;
  comstub[1] = alloc_bytes & 0xff;
  comstub[2] = alloc_bytes >> 8;
  comstub[4] = alloc_paras & 0xff;
  comstub[5] = alloc_paras >> 8;
  /* write new content into the link file */
  fd = fopen(linkfile, "wb");
  if (fd == NULL) {
    kitten_printf(3, 22, "Error: Failed to open link file '%s' for write access.", linkfile);
    puts("");
    return;
  }
  fwrite(comstub, 1, sizeof(comstub), fd);
  fprintf(fd, "%s%s%c", buff, shortfile, 0);
  fclose(fd);
}
 
 
/* returns 0 if pkgname is not installed, non-zero otherwise */
int is_package_installed(const char *pkgname, const char *dosdir) {
  char fname[512];
  sprintf(fname, "%s\\packages\\%s.lst", dosdir, pkgname);
  return(fileexists(fname)); /* file exists -> package is installed */
 
 
 
 
}
 
 
/* checks that pkgname is NOT installed. return 0 on success, non-zero otherwise. */
static int validate_package_not_installed(const char *pkgname, const char *dosdir) {
  if (is_package_installed(pkgname, dosdir) != 0) {
    kitten_printf(3, 18, "Package %s is already installed! You might want to use the 'update' action.", pkgname);
    puts("");
    return(-1);
  }
  return(0);
}
 
 
/* find a filename in a flist linked list, and returns a pointer to it */
static struct flist_t *findfileinlist(struct flist_t *flist, char *fname) {
  while (flist != NULL) {
    if (strcmp(flist->fname, fname) == 0) return(flist);
    flist = flist->next;
  }
  return(NULL);
}
 
 
/* prepare a package for installation. this is mandatory before actually installing it!
 * 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. */
struct ziplist *pkginstall_preparepackage(char *pkgname, char *localfile, int flags, FILE **zipfd, char *dosdir, struct customdirs *dirlist, char *buffmem1k) {
  char *fname;
  char *zipfile;
  char *appinfofile;
  int appinfopresence;
  char *shortfile;
  struct ziplist *ziplinkedlist = NULL, *curzipnode, *prevzipnode;
  struct flist_t *flist = NULL;
 
  fname = buffmem1k;
  zipfile = buffmem1k + 256;
  appinfofile = buffmem1k + 512;
 
  strtolower(pkgname); /* convert pkgname to lower case, because the http repo is probably case sensitive */
  sprintf(appinfofile, "appinfo\\%s.lsm", pkgname); /* Prepare the appinfo/xxxx.lsm filename string for later use */
 
  /* check if not already installed, if already here, print a message "you might want to use update instead"
   * of course this must not be done if we are in the process of upgrading said package */
  if (((flags & PKGINST_UPDATE) == 0) && (validate_package_not_installed(pkgname, dosdir) != 0)) {
    return(NULL);
  }
 
  if (localfile != NULL) {  /* if it's a local file, then we will have to skip all the network stuff */
    strcpy(zipfile, localfile);
  } else {
    zipfile[0] = 0;
  }
 
  /* Now let's check the content of the zip file */
 
  *zipfd = fopen(zipfile, "rb");
  if (*zipfd == NULL) {
    kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed.");
    goto RAII;
  }
  ziplinkedlist = zip_listfiles(*zipfd);
  if (ziplinkedlist == NULL) {
    kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed.");
 
    goto RAII;
  }
  /* if updating, load the list of files belonging to the current package */
  if ((flags & PKGINST_UPDATE) != 0) {
    flist = pkg_loadflist(pkgname, dosdir);
 
 
  }
  /* 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 */
  appinfopresence = 0;
  prevzipnode = NULL;
  for (curzipnode = ziplinkedlist; curzipnode != NULL;) {
    /* change all slashes to backslashes, and switch into all-lowercase */
    slash2backslash(curzipnode->filename);
    strtolower(curzipnode->filename);
    /* remove 'directory' ZIP entries to avoid false alerts about directory already existing */
    if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) {
      curzipnode->filename[0] = 0; /* mark it "empty", will be removed in a short moment */
    }
    /* is it a "link file"? */
    if (fdnpkg_strcasestr(curzipnode->filename, "links\\") == curzipnode->filename) {
      /* skip links, if that's what the user wants */
      if ((flags & PKGINST_SKIPLINKS) != 0) {
        curzipnode->filename[0] = 0; /* in fact, we just mark the file as 'empty' on the filename.. see later below */
      } else {
        /* if it's a *.BAT link, then rename it to *.COM */
        char *ext = getfext(curzipnode->filename);
        if (strcasecmp(ext, "bat") == 0) sprintf(ext, "com");
      }
    }
 
    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) */
      if (prevzipnode == NULL) {  /* take the item out of the list */
        ziplinkedlist = curzipnode->nextfile;
        free(curzipnode); /* free the item */
        curzipnode = ziplinkedlist;
      } else {
        prevzipnode->nextfile = curzipnode->nextfile;
        free(curzipnode); /* free the item */
        curzipnode = prevzipnode->nextfile;
      }
      continue; /* go to the next item */
    }
    /* validate that the file has a valid filename (8+3, no shady chars...) */
    if (validfilename(curzipnode->filename) != 0) {
      kitten_puts(3, 23, "Error: Package contains an invalid filename:");
      printf(" %s\n", curzipnode->filename);
 
 
      goto RAII_ERR;
    }
    /* look out for collisions with already existing files (unless we are
     * updating the package and the local file belongs to it */
    shortfile = computelocalpath(curzipnode->filename, fname, dosdir, dirlist);
    strcat(fname, shortfile);
    if ((findfileinlist(flist, fname) == NULL) && (fileexists(fname) != 0)) {
      kitten_puts(3, 9, "Error: Package contains a file that already exists locally:");
      printf(" %s\n", fname);
 
 
      goto RAII_ERR;
    }
    /* abort if any entry is encrypted */
    if ((curzipnode->flags & ZIP_FLAG_ENCRYPTED) != 0) {
      kitten_printf(3, 20, "Error: Package contains an encrypted file:");
      puts("");
      printf(" %s\n", curzipnode->filename);
 
 
      goto RAII_ERR;
    }
    /* abort if any file is compressed with an unsupported method */
    if ((curzipnode->compmethod != 0/*store*/) && (curzipnode->compmethod != 8/*deflate*/)) { /* unsupported compression method */
      kitten_printf(8, 2, "Error: Package contains a file compressed with an unsupported method (%d):", curzipnode->compmethod);
      puts("");
      printf(" %s\n", curzipnode->filename);
 
 
      goto RAII_ERR;
    }
    if (strcmp(curzipnode->filename, appinfofile) == 0) appinfopresence = 1;
    prevzipnode = curzipnode;
    curzipnode = curzipnode->nextfile;
  }
  /* if appinfo file not found, this is not a real FreeDOS package */
  if (appinfopresence != 1) {
    kitten_printf(3, 12, "Error: Package do not contain the %s file! Not a valid FreeDOS package.", appinfofile);
    puts("");
    goto RAII_ERR;
  }
 
  goto RAII;
 
  RAII_ERR:
  zip_freelist(&ziplinkedlist);
  ziplinkedlist = NULL;
  if ((zipfd != NULL) && (*zipfd != NULL)) {
    fclose(*zipfd);
    *zipfd = NULL;
  }
 
  RAII:
  pkg_freeflist(flist);
  return(ziplinkedlist);
}
 
 
/* install a package that has been prepared already. returns 0 on success,
 * or a negative value on error, or a positive value on warning */
int pkginstall_installpackage(char *pkgname, char *dosdir, struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd) {
  char *buff;
  char *fulldestfilename;
  char packageslst[64];
  char *shortfile;
  long filesextractedsuccess = 0, filesextractedfailure = 0;
  struct ziplist *curzipnode;
  FILE *lstfd;
 
  sprintf(packageslst, "packages\\%s.lst", pkgname); /* Prepare the packages/xxxx.lst filename string for later use */
 
  buff = malloc(512);
  fulldestfilename = malloc(1024);
  if ((buff == NULL) || (fulldestfilename == NULL)) {
    kitten_puts(8, 0, "Out of memory!");
    zip_freelist(&ziplinkedlist);
    free(buff);
    free(fulldestfilename);
    return(-1);
  }
 
  /* create the %DOSDIR%/packages directory, just in case it doesn't exist yet */
  sprintf(buff, "%s\\packages\\", dosdir);
  mkpath(buff);
 
  /* open the lst file */
  sprintf(buff, "%s\\%s", dosdir, packageslst);
  lstfd = fopen(buff, "wb"); /* opening it in binary mode, because I like to have control over line terminators (CR/LF) */
  if (lstfd == NULL) {
    kitten_printf(3, 10, "Error: Could not create %s!", buff);
    puts("");
    zip_freelist(&ziplinkedlist);
    free(buff);
    free(fulldestfilename);
    return(-2);
  }
 
  /* write list of files in zip into the lst, and create the directories structure */
  for (curzipnode = ziplinkedlist; curzipnode != NULL; curzipnode = curzipnode->nextfile) {
    int unzip_result;
    if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) continue; /* skip directories */
    if (strcasecmp(curzipnode->filename, packageslst) == 0) continue; /* skip silently the package.lst file, if found */
    shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist); /* substitute paths to custom dirs */
    /* log the filename to packages\pkg.lst (with original, unmapped drive) */
    fprintf(lstfd, "%s%s\r\n", buff, shortfile);
    /* create the path, just in case it doesn't exist yet */
    mkpath(buff);
    sprintf(fulldestfilename, "%s%s", buff, shortfile);
    /* Now unzip the file */
    unzip_result = zip_unzip(zipfd, curzipnode, fulldestfilename);
    if (unzip_result != 0) {
      kitten_printf(8, 3, "Error while extracting '%s' to '%s'!", curzipnode->filename, fulldestfilename);
      printf(" [%d]\n", unzip_result);
      filesextractedfailure += 1;
    } else {
      printf(" %s -> %s\n", curzipnode->filename, buff);
      filesextractedsuccess += 1;
    }
    /* if it's a LINK file, recompute a new content */
    if (islinkfile(curzipnode->filename) != 0) {
      processlinkfile(fulldestfilename, dosdir, dirlist, buff);
    }
  }
  fclose(lstfd);
 
  /* free the ziplist and close file descriptor */
  zip_freelist(&ziplinkedlist);
  free(buff);
  free(fulldestfilename);
 
  kitten_printf(3, 19, "Package %s installed: %ld files extracted, %ld errors.", pkgname, filesextractedsuccess, filesextractedfailure);
  puts("");
  return(filesextractedfailure);
}
 

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

Subversion Repositories SvarDOS

(root)/pkg/trunk/pkginst.c @ 727 – Rev 227 → 230