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


/*
 * This file is part of pkg (SvarDOS)
 * Copyright (C) 2012-2024 Mateusz Viste
 */
 
#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 "helpers.h"   /* slash2backslash() */
#include "fileexst.h"
#include "kprintf.h"
#include "libunzip.h"  /* zip_listfiles()... */
#include "showinst.h"  /* pkg_loadflist() */
#include "svarlang.lib\svarlang.h"
 
#include "pkginst.h"   /* include self for control */
 
 
/* validate a filename (8+3, no weird characters, etc). returns 0 on success,
 * nonzero otherwise. */
static int validfilename(const 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);
}
 
 
/* returns 0 if pkgname is not installed, non-zero otherwise */
int is_package_installed(const char *pkgname, const char *dosdir) {
  char fname[256];
  sprintf(fname, "%s\\appinfo\\%s.lsm", 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, pkgname); /* "Package %s is already installed! You might want to use the 'update' action." */
    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, const char *fname) {
  while (flist != NULL) {
    if (strcasecmp(flist->fname, fname) == 0) return(flist);
    flist = flist->next;
  }
  return(NULL);
}
 
 
/* prepare a package for installation. this is mandatory before installing it!
 * returns a pointer to the zip file's index on success, NULL on failure.
 * the **zipfd pointer is updated with file descriptor of the open (to be
 * installed) zip file.
 * the returned ziplist is guaranteed to have the APPINFO file as first node
 * the ziplist is also guaranteed not to contain any directory entries */
struct ziplist *pkginstall_preparepackage(const char *pkgname, const char *zipfile, int flags, FILE **zipfd, const char *dosdir, const struct customdirs *dirlist) {
  char fname[256];
  char appinfofile[32];
  struct ziplist *appinfoptr;
  char *shortfile;
  struct ziplist *ziplinkedlist = NULL, *curzipnode, *prevzipnode;
  struct flist_t *flist = NULL;
 
  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);
  }
 
  /* copy zip filename into fname */
  strcpy(fname, zipfile);
 
  /* append an .SVP extension if not present */
  {
    int slen = strlen(fname);
    if ((slen < 4) || (fname[slen - 4] != '.')) strcat(fname, ".SVP");
  }
 
  /* now let's check the content of the zip file */
 
  *zipfd = fopen(fname, "rb");
  if (*zipfd == NULL) {
    puts(svarlang_str(3, 8)); /* "ERROR: Invalid zip archive! Package not installed." */
    goto RAII;
  }
  ziplinkedlist = zip_listfiles(*zipfd);
  if (ziplinkedlist == NULL) {
    puts(svarlang_str(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 */
  appinfoptr = NULL;
  prevzipnode = NULL;
 
  for (curzipnode = ziplinkedlist; curzipnode != NULL;) {
    /* change all slashes to backslashes, and switch into all-lowercase */
    slash2backslash(curzipnode->filename);
    strlwr(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"? skip it - link files are no longer supported */
    if (strstr(curzipnode->filename, "links\\") == curzipnode->filename) {
      curzipnode->filename[0] = 0; /* in fact, I just mark the file as 'empty' on the filename - see later below */
    }
 
    /* is it the appinfo file? remember it and keep it separate from the list for now */
    if (strcmp(curzipnode->filename, appinfofile) == 0) {
      appinfoptr = curzipnode;
      curzipnode = curzipnode->nextfile;
      if (prevzipnode != NULL) prevzipnode->nextfile = curzipnode;
      continue;
    }
 
    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) {
      puts(svarlang_str(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)) {
      puts(svarlang_str(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) {
      puts(svarlang_str(3, 20)); /* "ERROR: Package contains an encrypted file:" */
      printf(" %s\n", curzipnode->filename);
      goto RAII_ERR;
    }
 
    /* abort if any file is compressed with an unsupported method */
    if ((curzipnode->compmethod != ZIP_METH_STORE) && (curzipnode->compmethod != ZIP_METH_DEFLATE)) { /* unsupported compression method */
      kitten_printf(8, 2, curzipnode->compmethod); /* "ERROR: Package contains a file compressed with an unsupported method (%d):" */
      puts("");
      printf(" %s\n", curzipnode->filename);
      goto RAII_ERR;
    }
 
    /* add node to list */
    prevzipnode = curzipnode;
    curzipnode = curzipnode->nextfile;
  }
 
  /* if appinfo file not found, this is not a real SvarDOS package */
  if (appinfoptr == NULL) {
    kitten_printf(3, 12, appinfofile); /* "ERROR: Package do not contain the %s file! Not a valid SvarDOS package." */
    puts("");
    goto RAII_ERR;
  }
 
  /* attach the appinfo node to the top of the list (installation second stage
   * relies on this) */
  appinfoptr->nextfile = ziplinkedlist;
  ziplinkedlist = appinfoptr;
 
  goto RAII;
 
  RAII_ERR:
  zip_freelist(&ziplinkedlist);
  ziplinkedlist = NULL;
  if ((zipfd != NULL) && (*zipfd != NULL)) {
    fclose(*zipfd);
    *zipfd = NULL;
  }
 
  RAII:
  pkg_freeflist(flist);
  return(ziplinkedlist);
}
 
 
/* look for a "warn" field in the package's LSM file and display it if found */
static void display_warn_if_exists(const char *pkgname, const char *dosdir, char *buff, size_t buffsz) {
  FILE *fd;
  char *msgptr;
  int warncount = 0, i;
 
  sprintf(buff, "%s\\appinfo\\%s.lsm", dosdir, pkgname);
  fd = fopen(buff, "rb");
  if (fd == NULL) return;
 
  while (freadtokval(fd, buff, buffsz, &msgptr, ':') == 0) {
    if (msgptr != NULL) {
      if (strcasecmp(buff, "warn") == 0) {
        /* print a visual delimiter */
        if (warncount == 0) {
          puts("");
          for (i = 0; i < 79; i++) putchar('*');
          puts("");
        }
        /* there may be more than one "warn" line */
        puts(msgptr);
        warncount++;
      }
    }
  }
 
  fclose(fd);
 
  /* if one or more warn lines have been displayed then close with a delimiter again */
  if (warncount > 0) {
    for (i = 0; i < 79; i++) putchar('*');
    puts("");
  }
 
}
 
 
/* 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(const char *pkgname, const char *dosdir, const struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd) {
  char buff[256];
  char fulldestfilename[256];
 
  char *shortfile;
  long filesextractedsuccess = 0, filesextractedfailure = 0;
  struct ziplist *curzipnode;
  FILE *lsmfd;
 
  int unzip_result;
 
  /* create the %DOSDIR%/APPINFO directory, just in case it doesn't exist yet */
  sprintf(buff, "%s\\appinfo\\%s.lsm", dosdir, pkgname);
  mkpath(buff);
 
  /* start by extracting the APPINFO (LSM) file - I need it so I can append the
   * list of files belonging to the packages later */
  unzip_result = zip_unzip(zipfd, ziplinkedlist, buff);
  if (unzip_result != 0) {
    kitten_printf(8, 3, ziplinkedlist, buff); /* "ERROR: failed extracting '%s' to '%s'!" */
    printf(" [%d]\n", unzip_result);
    return(-1);
  }
  printf(" %s -> %s\n", ziplinkedlist->filename, buff);
  filesextractedsuccess++;
 
  /* open the (freshly created) LSM file */
  lsmfd = fopen(buff, "ab"); /* opening in APPEND mode so I do not loose the LSM content */
  if (lsmfd == NULL) {
    kitten_printf(3, 10, buff); /* "ERROR: Could not create %s!" */
    puts("");
    return(-2);
  }
  fprintf(lsmfd, "\r\n"); /* in case the LSM does not end with a clear line already */
 
  /* write list of files in zip into the lst, and create the directories structure */
  for (curzipnode = ziplinkedlist->nextfile; curzipnode != NULL; curzipnode = curzipnode->nextfile) {
 
    /* substitute paths to custom dirs */
 
    shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist);
 
    /* log the filename to LSM metadata file + its CRC */
    fprintf(lsmfd, "%s%s?%08lX\r\n", buff, shortfile, curzipnode->crc32);
 
    /* 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, curzipnode->filename, fulldestfilename); /* "ERROR: failed extracting '%s' to '%s'!" */
      printf(" [%d]\n", unzip_result);
      filesextractedfailure += 1;
    } else {
      printf(" %s -> %s\n", curzipnode->filename, buff);
      filesextractedsuccess += 1;
    }
  }
  fclose(lsmfd);
 
  kitten_printf(3, 19, pkgname, filesextractedsuccess, filesextractedfailure); /* "Package %s installed: %ld files extracted, %ld errors." */
  puts("");
 
  /* scan the LSM file for a "warn" message to display */
  display_warn_if_exists(pkgname, dosdir, buff, sizeof(buff));
 
  return(filesextractedfailure);
}
 

Rev 1601	Rev 1678
1	`/*`	1	`/*`
2	`* This file is part of pkg (SvarDOS)`	2	`* This file is part of pkg (SvarDOS)`
3	`* Copyright (C) 2012-2023 Mateusz Viste`	3	`* Copyright (C) 2012-2024 Mateusz Viste`
4	`*/`	4	`*/`
5		5
6	`#include <ctype.h> /* toupper() */`	6	`#include <ctype.h> /* toupper() */`
7	`#include <stdio.h>`	7	`#include <stdio.h>`
8	`#include <stdlib.h> /* system() */`	8	`#include <stdlib.h> /* system() */`
9	`#include <string.h> /* strcpy() */`	9	`#include <string.h> /* strcpy() */`
10	`#include <unistd.h> /* read() */`	10	`#include <unistd.h> /* read() */`
11	`#include <sys/types.h> /* struct utimbuf */`	11	`#include <sys/types.h> /* struct utimbuf */`
12		12
13	`#include "helpers.h" /* slash2backslash() */`	13	`#include "helpers.h" /* slash2backslash() */`
14	`#include "fileexst.h"`	14	`#include "fileexst.h"`
15	`#include "kprintf.h"`	15	`#include "kprintf.h"`
16	`#include "libunzip.h" /* zip_listfiles()... */`	16	`#include "libunzip.h" /* zip_listfiles()... */`
17	`#include "showinst.h" /* pkg_loadflist() */`	17	`#include "showinst.h" /* pkg_loadflist() */`
18	`#include "svarlang.lib\svarlang.h"`	18	`#include "svarlang.lib\svarlang.h"`
19		19
20	`#include "pkginst.h" /* include self for control */`	20	`#include "pkginst.h" /* include self for control */`
21		21
22		22
23	`/* validate a filename (8+3, no weird characters, etc). returns 0 on success,`	23	`/* validate a filename (8+3, no weird characters, etc). returns 0 on success,`
24	`* nonzero otherwise. */`	24	`* nonzero otherwise. */`
25	`static int validfilename(const char *fname) {`	25	`static int validfilename(const char *fname) {`
26	`int i, i2;`	26	`int i, i2;`
27	char *validchars = "!#$%&'()-@^_`{}~";	27	char *validchars = "!#$%&'()-@^_`{}~";
28	`int elemlen = 0;`	28	`int elemlen = 0;`
29	`int elemmaxlen = 8; /* switches from 8 to 3 depending wheter I am analyzing`	29	`int elemmaxlen = 8; /* switches from 8 to 3 depending wheter I am analyzing`
30	`a filename or an extension */`	30	`a filename or an extension */`
31	`/* look for invalid chars in the entire string, and check the length of the`	31	`/* look for invalid chars in the entire string, and check the length of the`
32	`* element at the same time */`	32	`* element at the same time */`
33	`for (i = 0; fname[i] != 0; i++) {`	33	`for (i = 0; fname[i] != 0; i++) {`
34	`/* director separators are threated specially */`	34	`/* director separators are threated specially */`
35	`if (fname[i] == '\\') {`	35	`if (fname[i] == '\\') {`
36	`elemlen = 0;`	36	`elemlen = 0;`
37	`elemmaxlen = 8;`	37	`elemmaxlen = 8;`
38	`continue;`	38	`continue;`
39	`}`	39	`}`
40	`/* '.' switches the check into extension mode */`	40	`/* '.' switches the check into extension mode */`
41	`if (fname[i] == '.') {`	41	`if (fname[i] == '.') {`
42	`if (elemlen == 0) return(-1); /* a file must have a base name */`	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 */`	43	`if (elemmaxlen == 3) return(-2); /* a file cannot have two extensions */`
44	`elemlen = 0;`	44	`elemlen = 0;`
45	`elemmaxlen = 3;`	45	`elemmaxlen = 3;`
46	`continue;`	46	`continue;`
47	`}`	47	`}`
48	`/* check that the element is not too long */`	48	`/* check that the element is not too long */`
49	`if (++elemlen > elemmaxlen) return(-3);`	49	`if (++elemlen > elemmaxlen) return(-3);`
50	`/* look for valid characters */`	50	`/* look for valid characters */`
51	`if ((fname[i] >= 'a') && (fname[i] <= 'z')) continue;`	51	`if ((fname[i] >= 'a') && (fname[i] <= 'z')) continue;`
52	`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;`	53	`if ((fname[i] >= '0') && (fname[i] <= '9')) continue;`
54	`if ((fname[i] & 128) != 0) continue; /* high bytes are okay (NLS) */`	54	`if ((fname[i] & 128) != 0) continue; /* high bytes are okay (NLS) */`
55	`/* look for other valid characters */`	55	`/* look for other valid characters */`
56	`for (i2 = 0; validchars[i2] != 0; i2++) {`	56	`for (i2 = 0; validchars[i2] != 0; i2++) {`
57	`if (fname[i] == validchars[i2]) break;`	57	`if (fname[i] == validchars[i2]) break;`
58	`}`	58	`}`
59	`if (validchars[i2] != 0) continue;`	59	`if (validchars[i2] != 0) continue;`
60	`/* if we are here, then the character is invalid */`	60	`/* if we are here, then the character is invalid */`
61	`return(-4);`	61	`return(-4);`
62	`}`	62	`}`
63	`/* all checks passed */`	63	`/* all checks passed */`
64	`return(0);`	64	`return(0);`
65	`}`	65	`}`
66		66
67		67
68	`/* returns 0 if pkgname is not installed, non-zero otherwise */`	68	`/* returns 0 if pkgname is not installed, non-zero otherwise */`
69	`int is_package_installed(const char pkgname, const char dosdir) {`	69	`int is_package_installed(const char pkgname, const char dosdir) {`
70	`char fname[512];`	70	`char fname[256];`
71	`sprintf(fname, "%s\\packages\\%s.lst", dosdir, pkgname);`	71	`sprintf(fname, "%s\\appinfo\\%s.lsm", dosdir, pkgname);`
72	`return(fileexists(fname)); /* file exists -> package is installed */`	72	`return(fileexists(fname)); /* file exists -> package is installed */`
73	`}`	73	`}`
74		74
75		75
76	`/* checks that pkgname is NOT installed. return 0 on success, non-zero otherwise. */`	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) {`	77	`static int validate_package_not_installed(const char pkgname, const char dosdir) {`
78	`if (is_package_installed(pkgname, dosdir) != 0) {`	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." */`	79	`kitten_printf(3, 18, pkgname); /* "Package %s is already installed! You might want to use the 'update' action." */`
80	`puts("");`	80	`puts("");`
81	`return(-1);`	81	`return(-1);`
82	`}`	82	`}`
83	`return(0);`	83	`return(0);`
84	`}`	84	`}`
85		85
86		86
87	`/* find a filename in a flist linked list, and returns a pointer to it */`	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) {`	88	`static struct flist_t findfileinlist(struct flist_t flist, const char *fname) {`
89	`while (flist != NULL) {`	89	`while (flist != NULL) {`
90	`if (strcasecmp(flist->fname, fname) == 0) return(flist);`	90	`if (strcasecmp(flist->fname, fname) == 0) return(flist);`
91	`flist = flist->next;`	91	`flist = flist->next;`
92	`}`	92	`}`
93	`return(NULL);`	93	`return(NULL);`
94	`}`	94	`}`
95		95
96		96
97	`/* prepare a package for installation. this is mandatory before actually installing it!`	97	`/* prepare a package for installation. this is mandatory before 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. /`	98	`* returns a pointer to the zip file's index on success, NULL on failure.`
-		99	`* the **zipfd pointer is updated with file descriptor of the open (to be`
-		100	`* installed) zip file.`
-		101	`* the returned ziplist is guaranteed to have the APPINFO file as first node`
-		102	`* the ziplist is also guaranteed not to contain any directory entries */`
99	`struct ziplist pkginstall_preparepackage(const char pkgname, const char zipfile, int flags, FILE zipfd, const char dosdir, const struct customdirs *dirlist) {`	103	`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];`	104	`char fname[256];`
101	`char appinfofile[256];`	105	`char appinfofile[32];`
102	`int appinfopresence;`	106	`struct ziplist *appinfoptr;`
103	`char *shortfile;`	107	`char *shortfile;`
104	`struct ziplist ziplinkedlist = NULL, curzipnode, *prevzipnode;`	108	`struct ziplist ziplinkedlist = NULL, curzipnode, *prevzipnode;`
105	`struct flist_t *flist = NULL;`	109	`struct flist_t *flist = NULL;`
106		110
107	`sprintf(appinfofile, "appinfo\\%s.lsm", pkgname); /* Prepare the appinfo/xxxx.lsm filename string for later use */`	111	`sprintf(appinfofile, "appinfo\\%s.lsm", pkgname); /* Prepare the appinfo/xxxx.lsm filename string for later use */`
108		112
109	`/* check if not already installed, if already here, print a message "you might want to use update instead"`	113	`/* 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 */`	114	`* 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)) {`	115	`if (((flags & PKGINST_UPDATE) == 0) && (validate_package_not_installed(pkgname, dosdir) != 0)) {`
112	`return(NULL);`	116	`return(NULL);`
113	`}`	117	`}`
114		118
115	`/* copy zip filename into fname */`	119	`/* copy zip filename into fname */`
116	`strcpy(fname, zipfile);`	120	`strcpy(fname, zipfile);`
117		121
118	`/* append an .SVP extension if not present */`	122	`/* append an .SVP extension if not present */`
119	`{`	123	`{`
120	`int slen = strlen(fname);`	124	`int slen = strlen(fname);`
121	`if ((slen < 4) \|\| (fname[slen - 4] != '.')) strcat(fname, ".SVP");`	125	`if ((slen < 4) \|\| (fname[slen - 4] != '.')) strcat(fname, ".SVP");`
122	`}`	126	`}`
123		127
124	`/* Now let's check the content of the zip file */`	128	`/* now let's check the content of the zip file */`
125		129
126	`*zipfd = fopen(fname, "rb");`	130	`*zipfd = fopen(fname, "rb");`
127	`if (*zipfd == NULL) {`	131	`if (*zipfd == NULL) {`
128	`puts(svarlang_str(3, 8)); /* "ERROR: Invalid zip archive! Package not installed." */`	132	`puts(svarlang_str(3, 8)); /* "ERROR: Invalid zip archive! Package not installed." */`
129	`goto RAII;`	133	`goto RAII;`
130	`}`	134	`}`
131	`ziplinkedlist = zip_listfiles(*zipfd);`	135	`ziplinkedlist = zip_listfiles(*zipfd);`
132	`if (ziplinkedlist == NULL) {`	136	`if (ziplinkedlist == NULL) {`
133	`puts(svarlang_str(3, 8)); /* "ERROR: Invalid zip archive! Package not installed." */`	137	`puts(svarlang_str(3, 8)); /* "ERROR: Invalid zip archive! Package not installed." */`
134	`goto RAII;`	138	`goto RAII;`
135	`}`	139	`}`
136	`/* if updating, load the list of files belonging to the current package */`	140	`/* if updating, load the list of files belonging to the current package */`
137	`if ((flags & PKGINST_UPDATE) != 0) {`	141	`if ((flags & PKGINST_UPDATE) != 0) {`
138	`flist = pkg_loadflist(pkgname, dosdir);`	142	`flist = pkg_loadflist(pkgname, dosdir);`
139	`}`	143	`}`
-		144
140	`/* Verify that there's no collision with existing local files, look for the appinfo presence */`	145	`/* Verify that there's no collision with existing local files, look for the appinfo presence */`
141	`appinfopresence = 0;`	146	`appinfoptr = NULL;`
142	`prevzipnode = NULL;`	147	`prevzipnode = NULL;`
-		148
143	`for (curzipnode = ziplinkedlist; curzipnode != NULL;) {`	149	`for (curzipnode = ziplinkedlist; curzipnode != NULL;) {`
144	`/* change all slashes to backslashes, and switch into all-lowercase */`	150	`/* change all slashes to backslashes, and switch into all-lowercase */`
145	`slash2backslash(curzipnode->filename);`	151	`slash2backslash(curzipnode->filename);`
146	`strlwr(curzipnode->filename);`	152	`strlwr(curzipnode->filename);`
147	`/* remove 'directory' ZIP entries to avoid false alerts about directory already existing */`	153	`/* remove 'directory' ZIP entries to avoid false alerts about directory already existing */`
148	`if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) {`	154	`if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) {`
149	`curzipnode->filename[0] = 0; /* mark it "empty", will be removed in a short moment */`	155	`curzipnode->filename[0] = 0; /* mark it "empty", will be removed in a short moment */`
150	`}`	156	`}`
151	`/* is it a "link file"? skip it - link files are no longer supported */`	157	`/* is it a "link file"? skip it - link files are no longer supported */`
152	`if (fdnpkg_strcasestr(curzipnode->filename, "links\\") == curzipnode->filename) {`	158	`if (strstr(curzipnode->filename, "links\\") == curzipnode->filename) {`
153	`curzipnode->filename[0] = 0; /* in fact, I just mark the file as 'empty' on the filename - see later below */`	159	`curzipnode->filename[0] = 0; /* in fact, I just mark the file as 'empty' on the filename - see later below */`
154	`}`	160	`}`
155		161
-		162	`/* is it the appinfo file? remember it and keep it separate from the list for now */`
-		163	`if (strcmp(curzipnode->filename, appinfofile) == 0) {`
-		164	`appinfoptr = curzipnode;`
-		165	`curzipnode = curzipnode->nextfile;`
-		166	`if (prevzipnode != NULL) prevzipnode->nextfile = curzipnode;`
-		167	`continue;`
-		168	`}`
-		169
156	`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) */`	170	`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) */`
157	`if (prevzipnode == NULL) { /* take the item out of the list */`	171	`if (prevzipnode == NULL) { /* take the item out of the list */`
158	`ziplinkedlist = curzipnode->nextfile;`	172	`ziplinkedlist = curzipnode->nextfile;`
159	`free(curzipnode); /* free the item */`	173	`free(curzipnode); /* free the item */`
160	`curzipnode = ziplinkedlist;`	174	`curzipnode = ziplinkedlist;`
161	`} else {`	175	`} else {`
162	`prevzipnode->nextfile = curzipnode->nextfile;`	176	`prevzipnode->nextfile = curzipnode->nextfile;`
163	`free(curzipnode); /* free the item */`	177	`free(curzipnode); /* free the item */`
164	`curzipnode = prevzipnode->nextfile;`	178	`curzipnode = prevzipnode->nextfile;`
165	`}`	179	`}`
166	`continue; /* go to the next item */`	180	`continue; /* go to the next item */`
167	`}`	181	`}`
-		182
168	`/* validate that the file has a valid filename (8+3, no shady chars...) */`	183	`/* validate that the file has a valid filename (8+3, no shady chars...) */`
169	`if (validfilename(curzipnode->filename) != 0) {`	184	`if (validfilename(curzipnode->filename) != 0) {`
170	`puts(svarlang_str(3, 23)); /* "ERROR: Package contains an invalid filename:" */`	185	`puts(svarlang_str(3, 23)); /* "ERROR: Package contains an invalid filename:" */`
171	`printf(" %s\n", curzipnode->filename);`	186	`printf(" %s\n", curzipnode->filename);`
172	`goto RAII_ERR;`	187	`goto RAII_ERR;`
173	`}`	188	`}`
-		189
174	`/* look out for collisions with already existing files (unless we are`	190	`/* look out for collisions with already existing files (unless we are`
175	`* updating the package and the local file belongs to it */`	191	`* updating the package and the local file belongs to it */`
176	`shortfile = computelocalpath(curzipnode->filename, fname, dosdir, dirlist);`	192	`shortfile = computelocalpath(curzipnode->filename, fname, dosdir, dirlist);`
177	`strcat(fname, shortfile);`	193	`strcat(fname, shortfile);`
178	`if ((findfileinlist(flist, fname) == NULL) && (fileexists(fname) != 0)) {`	194	`if ((findfileinlist(flist, fname) == NULL) && (fileexists(fname) != 0)) {`
179	`puts(svarlang_str(3, 9)); /* "ERROR: Package contains a file that already exists locally:" */`	195	`puts(svarlang_str(3, 9)); /* "ERROR: Package contains a file that already exists locally:" */`
180	`printf(" %s\n", fname);`	196	`printf(" %s\n", fname);`
181	`goto RAII_ERR;`	197	`goto RAII_ERR;`
182	`}`	198	`}`
-		199
183	`/* abort if any entry is encrypted */`	200	`/* abort if any entry is encrypted */`
184	`if ((curzipnode->flags & ZIP_FLAG_ENCRYPTED) != 0) {`	201	`if ((curzipnode->flags & ZIP_FLAG_ENCRYPTED) != 0) {`
185	`puts(svarlang_str(3, 20)); /* "ERROR: Package contains an encrypted file:" */`	202	`puts(svarlang_str(3, 20)); /* "ERROR: Package contains an encrypted file:" */`
186	`printf(" %s\n", curzipnode->filename);`	203	`printf(" %s\n", curzipnode->filename);`
187	`goto RAII_ERR;`	204	`goto RAII_ERR;`
188	`}`	205	`}`
-		206
189	`/* abort if any file is compressed with an unsupported method */`	207	`/* abort if any file is compressed with an unsupported method */`
190	`if ((curzipnode->compmethod != ZIP_METH_STORE) && (curzipnode->compmethod != ZIP_METH_DEFLATE)) { /* unsupported compression method */`	208	`if ((curzipnode->compmethod != ZIP_METH_STORE) && (curzipnode->compmethod != ZIP_METH_DEFLATE)) { /* unsupported compression method */`
191	`kitten_printf(8, 2, curzipnode->compmethod); /* "ERROR: Package contains a file compressed with an unsupported method (%d):" */`	209	`kitten_printf(8, 2, curzipnode->compmethod); /* "ERROR: Package contains a file compressed with an unsupported method (%d):" */`
192	`puts("");`	210	`puts("");`
193	`printf(" %s\n", curzipnode->filename);`	211	`printf(" %s\n", curzipnode->filename);`
194	`goto RAII_ERR;`	212	`goto RAII_ERR;`
195	`}`	213	`}`
-		214
196	`if (strcmp(curzipnode->filename, appinfofile) == 0) appinfopresence = 1;`	215	`/* add node to list */`
197	`prevzipnode = curzipnode;`	216	`prevzipnode = curzipnode;`
198	`curzipnode = curzipnode->nextfile;`	217	`curzipnode = curzipnode->nextfile;`
199	`}`	218	`}`
-		219
200	`/* if appinfo file not found, this is not a real SvarDOS package */`	220	`/* if appinfo file not found, this is not a real SvarDOS package */`
201	`if (appinfopresence != 1) {`	221	`if (appinfoptr == NULL) {`
202	`kitten_printf(3, 12, appinfofile); /* "ERROR: Package do not contain the %s file! Not a valid SvarDOS package." */`	222	`kitten_printf(3, 12, appinfofile); /* "ERROR: Package do not contain the %s file! Not a valid SvarDOS package." */`
203	`puts("");`	223	`puts("");`
204	`goto RAII_ERR;`	224	`goto RAII_ERR;`
205	`}`	225	`}`
206		226
-		227	`/* attach the appinfo node to the top of the list (installation second stage`
-		228	`* relies on this) */`
-		229	`appinfoptr->nextfile = ziplinkedlist;`
-		230	`ziplinkedlist = appinfoptr;`
-		231
207	`goto RAII;`	232	`goto RAII;`
208		233
209	`RAII_ERR:`	234	`RAII_ERR:`
210	`zip_freelist(&ziplinkedlist);`	235	`zip_freelist(&ziplinkedlist);`
211	`ziplinkedlist = NULL;`	236	`ziplinkedlist = NULL;`
212	`if ((zipfd != NULL) && (*zipfd != NULL)) {`	237	`if ((zipfd != NULL) && (*zipfd != NULL)) {`
213	`fclose(*zipfd);`	238	`fclose(*zipfd);`
214	`*zipfd = NULL;`	239	`*zipfd = NULL;`
215	`}`	240	`}`
216		241
217	`RAII:`	242	`RAII:`
218	`pkg_freeflist(flist);`	243	`pkg_freeflist(flist);`
219	`return(ziplinkedlist);`	244	`return(ziplinkedlist);`
220	`}`	245	`}`
221		246
222		247
223	`/* look for a "warn" field in the package's LSM file and display it if found */`	248	`/* look for a "warn" field in the package's LSM file and display it if found */`
224	`static void display_warn_if_exists(const char pkgname, const char dosdir, char *buff, size_t buffsz) {`	249	`static void display_warn_if_exists(const char pkgname, const char dosdir, char *buff, size_t buffsz) {`
225	`FILE *fd;`	250	`FILE *fd;`
226	`char *msgptr;`	251	`char *msgptr;`
227	`int warncount = 0, i;`	252	`int warncount = 0, i;`
228		253
229	`sprintf(buff, "%s\\appinfo\\%s.lsm", dosdir, pkgname);`	254	`sprintf(buff, "%s\\appinfo\\%s.lsm", dosdir, pkgname);`
230	`fd = fopen(buff, "rb");`	255	`fd = fopen(buff, "rb");`
231	`if (fd == NULL) return;`	256	`if (fd == NULL) return;`
232		257
233	`while (freadtokval(fd, buff, buffsz, &msgptr, ':') == 0) {`	258	`while (freadtokval(fd, buff, buffsz, &msgptr, ':') == 0) {`
234	`if (msgptr != NULL) {`	259	`if (msgptr != NULL) {`
235	`if (strcasecmp(buff, "warn") == 0) {`	260	`if (strcasecmp(buff, "warn") == 0) {`
236	`/* print a visual delimiter */`	261	`/* print a visual delimiter */`
237	`if (warncount == 0) {`	262	`if (warncount == 0) {`
238	`puts("");`	263	`puts("");`
239	`for (i = 0; i < 79; i++) putchar('*');`	264	`for (i = 0; i < 79; i++) putchar('*');`
240	`puts("");`	265	`puts("");`
241	`}`	266	`}`
242	`/* there may be more than one "warn" line */`	267	`/* there may be more than one "warn" line */`
243	`puts(msgptr);`	268	`puts(msgptr);`
244	`warncount++;`	269	`warncount++;`
245	`}`	270	`}`
246	`}`	271	`}`
247	`}`	272	`}`
248		273
249	`fclose(fd);`	274	`fclose(fd);`
250		275
251	`/* if one or more warn lines have been displayed then close with a delimiter again */`	276	`/* if one or more warn lines have been displayed then close with a delimiter again */`
252	`if (warncount > 0) {`	277	`if (warncount > 0) {`
253	`for (i = 0; i < 79; i++) putchar('*');`	278	`for (i = 0; i < 79; i++) putchar('*');`
254	`puts("");`	279	`puts("");`
255	`}`	280	`}`
256		281
257	`}`	282	`}`
258		283
259		284
260	`/* install a package that has been prepared already. returns 0 on success,`	285	`/* install a package that has been prepared already. returns 0 on success,`
261	`* or a negative value on error, or a positive value on warning */`	286	`* or a negative value on error, or a positive value on warning */`
262	`int pkginstall_installpackage(const char pkgname, const char dosdir, const struct customdirs dirlist, struct ziplist ziplinkedlist, FILE *zipfd) {`	287	`int pkginstall_installpackage(const char pkgname, const char dosdir, const struct customdirs dirlist, struct ziplist ziplinkedlist, FILE *zipfd) {`
263	`char buff[256];`	288	`char buff[256];`
264	`char fulldestfilename[256];`	289	`char fulldestfilename[256];`
265	`char packageslst[32];`	-
266	`char *shortfile;`	290	`char *shortfile;`
267	`long filesextractedsuccess = 0, filesextractedfailure = 0;`	291	`long filesextractedsuccess = 0, filesextractedfailure = 0;`
268	`struct ziplist *curzipnode;`	292	`struct ziplist *curzipnode;`
269	`FILE *lstfd;`	293	`FILE *lsmfd;`
270		-
271	`sprintf(packageslst, "packages\\%s.lst", pkgname); /* Prepare the packages/xxxx.lst filename string for later use */`	294	`int unzip_result;`
272		295
273	`/* create the %DOSDIR%/packages directory, just in case it doesn't exist yet */`	296	`/* create the %DOSDIR%/APPINFO directory, just in case it doesn't exist yet */`
274	`sprintf(buff, "%s\\packages\\", dosdir);`	297	`sprintf(buff, "%s\\appinfo\\%s.lsm", dosdir, pkgname);`
275	`mkpath(buff);`	298	`mkpath(buff);`
276		299
-		300	`/* start by extracting the APPINFO (LSM) file - I need it so I can append the`
-		301	`* list of files belonging to the packages later */`
-		302	`unzip_result = zip_unzip(zipfd, ziplinkedlist, buff);`
277	`/* open the lst file */`	303	`if (unzip_result != 0) {`
-		304	`kitten_printf(8, 3, ziplinkedlist, buff); /* "ERROR: failed extracting '%s' to '%s'!" */`
278	`sprintf(buff, "%s\\%s", dosdir, packageslst);`	305	`printf(" [%d]\n", unzip_result);`
-		306	`return(-1);`
-		307	`}`
-		308	`printf(" %s -> %s\n", ziplinkedlist->filename, buff);`
-		309	`filesextractedsuccess++;`
-		310
-		311	`/* open the (freshly created) LSM file */`
279	`lstfd = fopen(buff, "wb"); /* opening it in binary mode, because I like to have control over line terminators (CR/LF) */`	312	`lsmfd = fopen(buff, "ab"); /* opening in APPEND mode so I do not loose the LSM content */`
280	`if (lstfd == NULL) {`	313	`if (lsmfd == NULL) {`
281	`kitten_printf(3, 10, buff); /* "ERROR: Could not create %s!" */`	314	`kitten_printf(3, 10, buff); /* "ERROR: Could not create %s!" */`
282	`puts("");`	315	`puts("");`
283	`return(-2);`	316	`return(-2);`
284	`}`	317	`}`
-		318	`fprintf(lsmfd, "\r\n"); /* in case the LSM does not end with a clear line already */`
285		319
286	`/* write list of files in zip into the lst, and create the directories structure */`	320	`/* write list of files in zip into the lst, and create the directories structure */`
287	`for (curzipnode = ziplinkedlist; curzipnode != NULL; curzipnode = curzipnode->nextfile) {`	321	`for (curzipnode = ziplinkedlist->nextfile; curzipnode != NULL; curzipnode = curzipnode->nextfile) {`
-		322
288	`int unzip_result;`	323	`/* substitute paths to custom dirs */`
289	`if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) continue; /* skip directories */`	-
290	`shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist); /* substitute paths to custom dirs */`	324	`shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist);`
-		325
291	`/* log the filename to packages\pkg.lst */`	326	`/* log the filename to LSM metadata file + its CRC */`
292	`fprintf(lstfd, "%s%s\r\n", buff, shortfile);`	327	`fprintf(lsmfd, "%s%s?%08lX\r\n", buff, shortfile, curzipnode->crc32);`
-		328
293	`/* create the path, just in case it doesn't exist yet */`	329	`/* create the path, just in case it doesn't exist yet */`
294	`mkpath(buff);`	330	`mkpath(buff);`
295	`sprintf(fulldestfilename, "%s%s", buff, shortfile);`	331	`sprintf(fulldestfilename, "%s%s", buff, shortfile);`
-		332
296	`/* Now unzip the file */`	333	`/* Now unzip the file */`
297	`unzip_result = zip_unzip(zipfd, curzipnode, fulldestfilename);`	334	`unzip_result = zip_unzip(zipfd, curzipnode, fulldestfilename);`
298	`if (unzip_result != 0) {`	335	`if (unzip_result != 0) {`
299	`kitten_printf(8, 3, curzipnode->filename, fulldestfilename); /* "ERROR: failed extracting '%s' to '%s'!" */`	336	`kitten_printf(8, 3, curzipnode->filename, fulldestfilename); /* "ERROR: failed extracting '%s' to '%s'!" */`
300	`printf(" [%d]\n", unzip_result);`	337	`printf(" [%d]\n", unzip_result);`
301	`filesextractedfailure += 1;`	338	`filesextractedfailure += 1;`
302	`} else {`	339	`} else {`
303	`printf(" %s -> %s\n", curzipnode->filename, buff);`	340	`printf(" %s -> %s\n", curzipnode->filename, buff);`
304	`filesextractedsuccess += 1;`	341	`filesextractedsuccess += 1;`
305	`}`	342	`}`
306	`}`	343	`}`
307	`fclose(lstfd);`	344	`fclose(lsmfd);`
308		345
309	`kitten_printf(3, 19, pkgname, filesextractedsuccess, filesextractedfailure); /* "Package %s installed: %ld files extracted, %ld errors." */`	346	`kitten_printf(3, 19, pkgname, filesextractedsuccess, filesextractedfailure); /* "Package %s installed: %ld files extracted, %ld errors." */`
310	`puts("");`	347	`puts("");`
311		348
312	`/* scan the LSM file for a "warn" message to display */`	349	`/* scan the LSM file for a "warn" message to display */`
313	`display_warn_if_exists(pkgname, dosdir, buff, sizeof(buff));`	350	`display_warn_if_exists(pkgname, dosdir, buff, sizeof(buff));`
314		351
315	`return(filesextractedfailure);`	352	`return(filesextractedfailure);`
316	`}`	353	`}`
317		354

Subversion Repositories SvarDOS

(root)/pkg/trunk/pkginst.c @ 1695 – Rev 1601 → 1678