| 0,0 → 1,275 |
|---|
| /* |
| * This file is part of FDNPKG |
| * Copyright (C) 2013-2017 Mateusz Viste. All rights reserved. |
| */ |
| |
| #include <stdio.h> |
| #include <ctype.h> /* tolower() */ |
| #include <stdlib.h> /* atoi(), qsort() - not using it after all, redefining it manually later */ |
| #include <string.h> /* strlen() */ |
| #include <sys/types.h> |
| |
| /* opendir() and friends */ |
| #ifdef __WATCOMC__ |
| #include <direct.h> |
| #else |
| #include <dirent.h> |
| #endif |
| |
| #include "fdnpkg.h" /* PKGINST_UPDATE */ |
| #include "fileexst.h" |
| #include "getdelim.h" |
| #include "helpers.h" /* fdnpkg_strcasestr(), slash2backslash()... */ |
| #include "kprintf.h" |
| #include "libunzip.h" /* zip_freelist()... */ |
| #include "lsm.h" |
| #include "pkgdb.h" |
| #include "pkginst.h" |
| #include "pkgrem.h" |
| #include "rtrim.h" |
| #include "showinst.h" /* include self for control */ |
| #include "version.h" |
| |
| |
| /* this is a wrapper around strcasecmp(), to be used by qsort() */ |
| static int strcompare(const void *str1, const void *str2) { |
| char **s1 = (char **)str1; |
| char **s2 = (char **)str2; |
| return(strcasecmp(*s1, *s2)); |
| } |
| |
| |
| /* clears current line */ |
| static void clrline(void) { |
| printf("\r \r"); |
| } |
| |
| |
| static int loadinstpkglist(char **packagelist, char **packagelist_ver, int packagelist_maxlen, char *filterstr, char *dosdir) { |
| DIR *dp; |
| int packagelist_len = 0, x; |
| struct dirent *ep; |
| #define verstr_maxlen 64 |
| char pkgdir[512], lsmfilename[1024], verstr[verstr_maxlen]; |
| sprintf(pkgdir, "%s\\packages", dosdir); |
| dp = opendir(pkgdir); |
| if (dp != NULL) { |
| while ((ep = readdir(dp)) != NULL) { |
| if (ep->d_name[0] != '.') { /* ignore '.', '..', and hidden directories */ |
| if (strlen(ep->d_name) > 4) { |
| int tlen = strlen(ep->d_name); |
| if ((ep->d_name[tlen - 4] != '.') || (tolower(ep->d_name[tlen - 3]) != 'l') || (tolower(ep->d_name[tlen - 2]) != 's') || (tolower(ep->d_name[tlen - 1]) != 't')) continue; /* if it's not an .lst file, skip it silently */ |
| |
| if (filterstr != NULL) { |
| if (fdnpkg_strcasestr(ep->d_name, filterstr) == NULL) continue; /* if it's not matching the non-NULL filter, skip it */ |
| } |
| if (packagelist_len >= packagelist_maxlen) { |
| closedir(dp); |
| return(-1); /* if not enough place in the list - return an error */ |
| } |
| packagelist[packagelist_len] = strdup(ep->d_name); |
| packagelist[packagelist_len][strlen(packagelist[packagelist_len]) - 4] = 0; /* cut out the .lst extension */ |
| packagelist_len += 1; |
| } |
| } |
| } |
| closedir(dp); |
| qsort(packagelist, packagelist_len, sizeof (char **), strcompare); /* sort the package list */ |
| for (x = 0; x < packagelist_len; x++) { |
| /* for each package, load the metadata from %DOSDIR\APPINFO\*.lsm */ |
| sprintf(lsmfilename, "%s\\appinfo\\%s.lsm", dosdir, packagelist[x]); |
| if (readlsm(lsmfilename, verstr, verstr_maxlen) != 0) sprintf(verstr, "(unknown version)"); |
| packagelist_ver[x] = strdup(verstr); |
| } |
| return(packagelist_len); |
| } else { |
| kitten_printf(9, 0, "Error: Could not access the %s directory.", pkgdir); |
| puts(""); |
| return(-1); |
| } |
| } |
| |
| #define packagelist_maxlen 1024 |
| |
| void showinstalledpkgs(char *filterstr, char *dosdir) { |
| char *packagelist[packagelist_maxlen]; |
| char *packagelist_ver[packagelist_maxlen]; |
| int packagelist_len, x; |
| |
| /* load the list of packages */ |
| packagelist_len = loadinstpkglist(packagelist, packagelist_ver, packagelist_maxlen, filterstr, dosdir); /* Populate the packages list */ |
| if (packagelist_len < 0) return; |
| if (packagelist_len == 0) { |
| kitten_puts(5, 0, "No package matched the search."); |
| return; |
| } |
| |
| /* iterate through all packages */ |
| for (x = 0; x < packagelist_len; x++) { |
| /* print the package/version couple on screen */ |
| printf("%s %s\n", packagelist[x], packagelist_ver[x]); |
| } |
| } |
| |
| |
| /* displays the list of available updates for local packages (or a single package if pkg is not NULL). Returns 0 if some updates are found, non zero otherwise. */ |
| int checkupdates(char *dosdir, struct pkgdb *pkgdb, char **repolist, char *pkg, char *tempdir, int flags, struct customdirs *dirlist, char *proxy, int proxyport, char *downloadingstring, char *mapdrv) { |
| struct pkgdb *curpkg; |
| struct pkgrepo *currepo; |
| char *packagelist[packagelist_maxlen]; |
| char *packagelist_ver[packagelist_maxlen]; |
| int packagelist_len, x, foundupdate = 0, totalupdatesfound = 0; |
| int packages_updated = 0, packages_updatefailed = 0; |
| packagelist_len = loadinstpkglist(packagelist, packagelist_ver, packagelist_maxlen, NULL, dosdir); |
| for (x = 0; x < packagelist_len; x++) { |
| if (pkg != NULL) { |
| if (strcasecmp(pkg, packagelist[x]) != 0) continue; /* if we got asked for a specific package, skip all other packages. */ |
| } else { /* else display a progress so slower PCs don't think we are freezed */ |
| long percprogress = x; /* long, just in case we have more than 3'200 packages installed... */ |
| percprogress *= 100; |
| percprogress /= packagelist_len; |
| kitten_printf(10, 7, "Looking for updates..."); |
| printf(" %ld%% (%s) \r", percprogress, packagelist[x]); /* empty spaces trailing for flushing the previous content on the line */ |
| } |
| for (curpkg = pkgdb; curpkg != NULL; curpkg = curpkg->nextpkg) { /* iterate through packages */ |
| if (strcasecmp(curpkg->name, packagelist[x]) == 0) { |
| foundupdate = 0; |
| for (currepo = curpkg->repolist; currepo != NULL; currepo = currepo->nextrepo) { /* check for possible newer version in every repo */ |
| if (isversionnewer(packagelist_ver[x], currepo->version) > 0) { /* isversionnewer() returns 1 if version is newer */ |
| if (foundupdate == 0) { |
| foundupdate = 1; |
| totalupdatesfound += 1; |
| if (pkg == NULL) { |
| clrline(); |
| kitten_printf(10, 0, "%s (local version: %s)", packagelist[x], packagelist_ver[x]); |
| puts(""); |
| } |
| } |
| if (pkg == NULL) { |
| clrline(); |
| printf(" "); |
| kitten_printf(10, 1, "version %s at %s", currepo->version, repolist[currepo->repo]); |
| puts(""); |
| } |
| } |
| } |
| /* actually upgrade the package, if requested so */ |
| if (foundupdate != 0) { |
| if (flags & PKGINST_UPDATE) { |
| FILE *zipfilefd; |
| struct ziplist *zipfileidx; |
| char buffmem1k[1024]; |
| clrline(); |
| kitten_printf(10, 3, "An update of '%s' has been found. Update in progress...", packagelist[x]); |
| puts(""); |
| packages_updatefailed += 1; /* increment the updatefailed counter - later we will decrement it if we're okay */ |
| zipfileidx = pkginstall_preparepackage(pkgdb, packagelist[x], tempdir, NULL, flags, repolist, &zipfilefd, proxy, proxyport, downloadingstring, dosdir, dirlist, buffmem1k, mapdrv); |
| if (zipfileidx != NULL) { |
| if (pkgrem(packagelist[x], dosdir, mapdrv) != 0) { |
| /* ooops, package removal failed... */ |
| zip_freelist(&zipfileidx); |
| } else { /* pkgrem == 0 */ |
| pkginstall_installpackage(packagelist[x], dosdir, dirlist, zipfileidx, zipfilefd, mapdrv); |
| packages_updated += 1; |
| packages_updatefailed -= 1; /* decrement the updatefailed counter to leverage the fact we incremented it without reason earlier */ |
| } |
| fclose(zipfilefd); |
| } |
| } |
| puts(""); /* add a line feed to visually separate packages */ |
| } |
| break; /* get out of the loop to get over the next local package */ |
| } |
| } |
| } |
| if (pkg == NULL) { |
| clrline(); |
| kitten_printf(10, 5, "%d package update(s) found.", totalupdatesfound); |
| puts(""); |
| if (flags & PKGINST_UPDATE) { |
| kitten_printf(10, 4, "%d package(s) updated, %d package(s) failed.", packages_updated, packages_updatefailed); |
| puts(""); |
| } |
| } |
| if (foundupdate != 0) { |
| return(0); |
| } else { |
| return(-1); |
| } |
| } |
| |
| |
| /* frees a linked list of filenames */ |
| void pkg_freeflist(struct flist_t *flist) { |
| while (flist != NULL) { |
| struct flist_t *victim = flist; |
| flist = flist->next; |
| free(victim); |
| } |
| } |
| |
| |
| /* returns a linked list of the files that belong to package pkgname */ |
| struct flist_t *pkg_loadflist(char *pkgname, char *dosdir) { |
| struct flist_t *res = NULL, *newnode; |
| FILE *fd; |
| char *lineptr; |
| char buff[512]; |
| int getdelimlen, fnamelen; |
| size_t getdelimcount = 0; |
| sprintf(buff, "%s\\packages\\%s.lst", dosdir, pkgname); |
| if (fileexists(buff) == 0) { /* file does not exist */ |
| kitten_printf(9, 1, "Error: Local package %s not found.", pkgname); |
| puts(""); |
| return(NULL); |
| } |
| fd = fopen(buff, "rb"); |
| if (fd == NULL) { |
| kitten_puts(4, 1, "Error opening lst file!"); |
| return(NULL); |
| } |
| /* iterate through all lines of the file */ |
| for (;;) { |
| lineptr = NULL; |
| getdelimlen = getdelim(&lineptr, &getdelimcount, '\n', fd); |
| if (getdelimlen < 0) { /* EOF */ |
| free(lineptr); |
| break; |
| } |
| rtrim(lineptr); /* right-trim the filename */ |
| slash2backslash(lineptr); /* change all / to \ */ |
| if ((lineptr[0] == 0) || (lineptr[0] == '\r') || (lineptr[0] == '\n')) continue; /* skip empty lines */ |
| if (lineptr[strlen(lineptr) - 1] == '\\') continue; /* skip directories */ |
| if ((lineptr[0] == '\\') || (lineptr[1] == ':')) { /* this is an absolute path */ |
| fnamelen = snprintf(buff, sizeof(buff), "%s", lineptr); |
| } else { /* else it's a relative path starting at %dosdir% */ |
| fnamelen = snprintf(buff, sizeof(buff), "%s\\%s\n", dosdir, lineptr); |
| } |
| free(lineptr); /* free the memory occupied by the line */ |
| /* add the new node to the result */ |
| newnode = malloc(sizeof(struct flist_t) + fnamelen); |
| if (newnode == NULL) { |
| kitten_printf(2, 14, "Out of memory! (%s)", "malloc failure"); |
| continue; |
| } |
| newnode->next = res; |
| strcpy(newnode->fname, buff); |
| res = newnode; |
| } |
| fclose(fd); |
| return(res); |
| } |
| |
| |
| /* Prints files owned by a package */ |
| void listfilesofpkg(char *pkgname, char *dosdir) { |
| struct flist_t *flist, *flist_ptr; |
| /* load the list of files belonging to pkgname */ |
| flist = pkg_loadflist(pkgname, dosdir); |
| /* display each filename on screen */ |
| for (flist_ptr = flist; flist_ptr != NULL; flist_ptr = flist_ptr->next) { |
| printf("%s\n", flist_ptr->fname); |
| } |
| /* free the list of files */ |
| pkg_freeflist(flist); |
| } |