diff options
Diffstat (limited to 'WWW/Library/Implementation/HTVMSUtils.c')
| -rw-r--r-- | WWW/Library/Implementation/HTVMSUtils.c | 1131 |
1 files changed, 1131 insertions, 0 deletions
diff --git a/WWW/Library/Implementation/HTVMSUtils.c b/WWW/Library/Implementation/HTVMSUtils.c new file mode 100644 index 0000000..38e583a --- /dev/null +++ b/WWW/Library/Implementation/HTVMSUtils.c @@ -0,0 +1,1131 @@ +/* + * $LynxId: HTVMSUtils.c,v 1.40 2020/01/21 21:58:29 tom Exp $ + * + * MODULE HTVMSUtil.c + * VMS Utility Routines + * + * AUTHORS: + * MD Mark Donszelmann duns@vxdeop.cern.ch + * + * HISTORY: + * 14 Nov 93 MD Written + * + * BUGS: + * + * + */ + +#include <HTUtils.h> +#ifdef VMS +#include <HTFormat.h> +#include <HTStream.h> +#include <UCDefs.h> +#include <UCMap.h> +#include <UCAux.h> +#include <HTFTP.h> +#include <HTTCP.h> +#include <HTVMSUtils.h> +#include <ssdef.h> +#include <jpidef.h> +#include <prvdef.h> +#include <acldef.h> +#include <chpdef.h> +#include <descrip.h> +#include <lib$routines.h> +#include <starlet.h> +#include <rmsdef.h> + +#include <LYGlobalDefs.h> +#include <LYUtils.h> +#include <LYLeaks.h> +#include <LYStrings.h> + +BOOL HTVMSFileVersions = FALSE; /* Include version numbers in listing? */ + +typedef struct { + unsigned long BufferLength:16; + unsigned long ItemCode:16; + unsigned long BufferAddress:32; + unsigned long ReturnLengthAddress:32; +} ItemStruct; + +/* PUBLIC HTVMS_authSysPrv() + * CHECKS IF THIS PROCESS IS AUTHORIZED TO ENABLE SYSPRV + * ON ENTRY: + * No arguments. + * + * ON EXIT: + * returns YES if SYSPRV is authorized + */ +BOOL HTVMS_authSysPrv(void) +{ + unsigned long Result; + ItemStruct ItemList[2]; + unsigned long Length; + unsigned long Buffer[2]; + + /* fill Item */ + ItemList[0].BufferLength = sizeof(Buffer); + ItemList[0].BufferAddress = (unsigned long) Buffer; + ItemList[0].ReturnLengthAddress = (unsigned long) &Length; + ItemList[0].ItemCode = JPI$_AUTHPRIV; + + /* terminate list */ + ItemList[1].ItemCode = 0; + ItemList[1].BufferLength = 0; + + /* call system */ + Result = sys$getjpiw(0, 0, 0, ItemList, 0, 0, 0); + + if (Result != SS$_NORMAL) + return (NO); + + if (Buffer[0] & PRV$M_SYSPRV) + return (YES); + + return (NO); +} + +/* PUBLIC HTVMS_enableSysPrv() + * ENABLES SYSPRV + * ON ENTRY: + * No arguments. + * + * ON EXIT: + * + */ +void HTVMS_enableSysPrv(void) +{ + unsigned long Result; + unsigned long Prv[2], PreviousPrv[2]; + + Prv[0] = PRV$M_SYSPRV; + Prv[1] = 0; + Result = sys$setprv(1, &Prv, 0, &PreviousPrv); + + if (Result == SS$_NORMAL) { + if (!(PreviousPrv[0] & PRV$M_SYSPRV)) { + CTRACE((tfp, "HTVMS_enableSysPrv: Enabled SYSPRV\n")); + } + } +} + +/* PUBLIC HTVMS_disableSysPrv() + * DISABLES SYSPRV + * ON ENTRY: + * No arguments. + * + * ON EXIT: + * + */ +void HTVMS_disableSysPrv(void) +{ + unsigned long Result; + unsigned long Prv[2], PreviousPrv[2]; + + Prv[0] = PRV$M_SYSPRV; + Prv[1] = 0; + Result = sys$setprv(0, &Prv, 0, &PreviousPrv); + + if (Result == SS$_NORMAL) { + if (PreviousPrv[0] & PRV$M_SYSPRV) { + CTRACE((tfp, "HTVMS_disableSysPrv: Disabled SYSPRV\n")); + } + } +} + +/* PUBLIC HTVMS_checkAccess() + * CHECKS ACCESS TO FILE FOR CERTAIN USER + * ON ENTRY: + * FileName The file to be accessed + * UserName Name of the user to check access for. + * User nobody, represented by "" is given NO for an answer + * Method Name of the method to be checked + * + * ON EXIT: + * returns YES if access is allowed + * + */ +BOOL HTVMS_checkAccess(const char *FileName, + const char *UserName, + const char *Method) +{ + unsigned long Result; + ItemStruct ItemList[2]; + unsigned long Length; + unsigned long Buffer; + unsigned long ObjType; + + char *VmsName; + + struct dsc$descriptor_s FileNameDesc; + struct dsc$descriptor_s UserNameDesc; + + char *colon; + + /* user nobody should access as from account under which server is running */ + if (0 == strcmp(UserName, "")) + return (NO); + + /* check Filename and convert */ + colon = StrChr(FileName, ':'); + if (colon) + VmsName = HTVMS_name("", colon + 1); + else + VmsName = HTVMS_name("", FileName); + + /* check for GET */ + if (0 == strcmp(Method, "GET")) { + /* fill Item */ + ItemList[0].BufferLength = sizeof(Buffer); + ItemList[0].BufferAddress = (unsigned long) &Buffer; + ItemList[0].ReturnLengthAddress = (unsigned long) &Length; + ItemList[0].ItemCode = CHP$_FLAGS; + + /* terminate list */ + ItemList[1].ItemCode = 0; + ItemList[1].BufferLength = 0; + + /* fill input */ + ObjType = ACL$C_FILE; + Buffer = CHP$M_READ; + UserNameDesc.dsc$w_length = strlen(UserName); + UserNameDesc.dsc$b_dtype = DSC$K_DTYPE_T; + UserNameDesc.dsc$b_class = DSC$K_CLASS_S; + UserNameDesc.dsc$a_pointer = (char *) UserName; + FileNameDesc.dsc$w_length = strlen(VmsName); + FileNameDesc.dsc$b_dtype = DSC$K_DTYPE_T; + FileNameDesc.dsc$b_class = DSC$K_CLASS_S; + FileNameDesc.dsc$a_pointer = VmsName; + + /* call system */ + Result = sys$check_access(&ObjType, &FileNameDesc, &UserNameDesc, ItemList); + + if (Result == SS$_NORMAL) + return (YES); + else + return (NO); + } + + return (NO); +} + +/* PUBLIC HTVMS_wwwName() + * CONVERTS VMS Name into WWW Name + * ON ENTRY: + * vmsname VMS file specification (NO NODE) + * + * ON EXIT: + * returns www file specification + * + * EXAMPLES: + * vmsname wwwname + * DISK$USER disk$user + * DISK$USER: /disk$user/ + * DISK$USER:[DUNS] /disk$user/duns + * DISK$USER:[DUNS.ECHO] /disk$user/duns/echo + * [DUNS] duns + * [DUNS.ECHO] duns/echo + * [DUNS.ECHO.-.TRANS] duns/echo/../trans + * [DUNS.ECHO.--.TRANS] duns/echo/../../trans + * [.DUNS] duns + * [.DUNS.ECHO] duns/echo + * [.DUNS.ECHO]TEST.COM duns/echo/test.com + * TEST.COM test.com + * + * + */ +const char *HTVMS_wwwName(const char *vmsname) +{ + static char wwwname[LY_MAXPATH]; + const char *src; + char *dst; + int dir; + + dst = wwwname; + src = vmsname; + dir = 0; + if (StrChr(src, ':')) + *(dst++) = '/'; + for (; *src != '\0'; src++) { + switch (*src) { + case ':': + *(dst++) = '/'; + break; + case '-': + if (dir) { + if ((*(src - 1) == '[' || + *(src - 1) == '.' || + *(src - 1) == '-') && + (*(src + 1) == '.' || + *(src + 1) == '-')) { + *(dst++) = '/'; + *(dst++) = '.'; + *(dst++) = '.'; + } else + *(dst++) = '-'; + } else { + if (*(src - 1) == ']') + *(dst++) = '/'; + *(dst++) = '-'; + } + break; + case '.': + if (dir) { + if (*(src - 1) != '[') + *(dst++) = '/'; + } else { + if (*(src - 1) == ']') + *(dst++) = '/'; + *(dst++) = '.'; + } + break; + case '[': + dir = 1; + break; + case ']': + dir = 0; + break; + default: + if (*(src - 1) == ']') + *(dst++) = '/'; + *(dst++) = *src; + break; + } + } + *(dst++) = '\0'; + return (wwwname); +} + +/* + * The code below is for directory browsing by VMS Curses clients. + * It is based on the newer WWWLib's HTDirBrw.c. - Foteos Macrides + */ +int HTStat(const char *filename, + struct stat *info) +{ + /* + the following stuff does not work in VMS with a normal stat... + --> /disk$user/duns/www if www is a directory + is statted like: /disk$user/duns/www.dir + after a normal stat has failed + --> /disk$user/duns if duns is a toplevel directory + is statted like: /disk$user/000000/duns.dir + --> /disk$user since disk$user is a device + is statted like: /disk$user/000000/000000.dir + --> / + searches all devices, no solution yet... + --> /vxcern!/disk$cr/wwwteam/login.com + is not statted but granted with fake information... + */ + int Result; + int Len; + char *Ptr, *Ptr2; + static char *Name; + + /* try normal stat... */ + Result = stat((char *) filename, info); + if (Result == 0) + return (Result); + + /* make local copy */ + StrAllocCopy(Name, filename); + + /* failed,so do device search in case root is requested */ + if (!strcmp(Name, "/")) { /* root requested */ + return (-1); + } + + /* failed so this might be a directory, add '.dir' */ + Len = strlen(Name); + if (Name[Len - 1] == '/') + Name[Len - 1] = '\0'; + + /* fail in case of device */ + Ptr = StrChr(Name + 1, '/'); + if ((Ptr == NULL) && (Name[0] == '/')) { /* device only... */ + StrAllocCat(Name, "/000000/000000"); + } + + if (Ptr != NULL) { /* correct filename in case of toplevel dir */ + Ptr2 = StrChr(Ptr + 1, '/'); + if ((Ptr2 == NULL) && (Name[0] == '/')) { + char End[256]; + + LYStrNCpy(End, Ptr, sizeof(End) - 1); + *(Ptr + 1) = '\0'; + StrAllocCat(Name, "000000"); + StrAllocCat(Name, End); + } + } + + /* try in case a file on toplevel directory or .DIR was already specified */ + Result = stat(Name, info); + if (Result == 0) + return (Result); + + /* add .DIR and try again */ + StrAllocCat(Name, ".dir"); + Result = stat(Name, info); + return (Result); +} + +#ifndef _POSIX_SOURCE +#define d_ino d_fileno /* compatibility */ +#ifndef NULL +#define NULL 0 +#endif +#endif /* !_POSIX_SOURCE */ + +typedef struct __dirdesc { + long context; /* context descriptor for LIB$FIND_FILE calls */ + char dirname[255 + 1]; /* keeps the directory name, including *.* */ + struct dsc$descriptor_s dirname_desc; /* descriptor of dirname */ +} DIR; + +static DIR *HTVMSopendir(char *dirname); +static struct dirent *HTVMSreaddir(DIR *dirp); +static int HTVMSclosedir(DIR *dirp); + +/*** #include <sys_dirent.h> ***/ +/*** "sys_dirent.h" ***/ +struct dirent { + unsigned long d_fileno; /* file number of entry */ + unsigned short d_namlen; /* length of string in d_name */ + char d_name[255 + 1]; /* name (up to MAXNAMLEN + 1) */ +}; + +#ifndef _POSIX_SOURCE +/* + * It's unlikely to change, but make sure that sizeof d_name above is + * at least MAXNAMLEN + 1 (more may be added for padding). + */ +#define MAXNAMLEN 255 +/* + * The macro DIRSIZ(dp) gives the minimum amount of space required to represent + * a directory entry. For any directory entry dp->d_reclen >= DIRSIZ(dp). + * Specific filesystem types may use this macro to construct the value + * for d_reclen. + */ +#undef DIRSIZ +#define DIRSIZ(dp) \ + (((sizeof(struct dirent) - (MAXNAMLEN+1) + ((dp)->d_namlen+1)) +3) & ~3) + +#endif /* !_POSIX_SOURCE */ + +static DIR *HTVMSopendir(char *dirname) +{ + static DIR dir; + char *closebracket; + long status; + struct dsc$descriptor_s entryname_desc; + struct dsc$descriptor_s dirname_desc; + static char *DirEntry; + char Actual[256]; + char VMSentry[256]; + char UnixEntry[256]; + int index; + char *dot; + + /* check if directory exists */ + /* dirname can look like /disk$user/duns/www/test/multi */ + /* or like /disk$user/duns/www/test/multi/ */ + /* DirEntry should look like disk$user:[duns.www.test]multi in both cases */ + /* dir.dirname should look like disk$user:[duns.www.test.multi] */ + sprintf(UnixEntry, "%.*s", sizeof(UnixEntry) - 2, dirname); + if (UnixEntry[strlen(UnixEntry) - 1] != '/') + strcat(UnixEntry, "/"); + + StrAllocCopy(DirEntry, HTVMS_name("", UnixEntry)); + if (strlen(DirEntry) > sizeof(dir.dirname) - 1) + return (NULL); + strcpy(dir.dirname, DirEntry); + index = strlen(DirEntry) - 1; + + if (DirEntry[index] == ']') + DirEntry[index] = '\0'; + + if ((dot = strrchr(DirEntry, '.')) == NULL) { /* convert disk$user:[duns] into disk$user:[000000]duns.dir */ + char *openbr = strrchr(DirEntry, '['); + + if (!openbr) { /* convert disk$user: into disk$user:[000000]000000.dir */ + if (strlen(dir.dirname) > sizeof(dir.dirname) - 10) + return (NULL); + sprintf(dir.dirname, "%.*s[000000]", sizeof(dir.dirname) - 9, DirEntry); + StrAllocCat(DirEntry, "[000000]000000.dir"); + } else { + char End[256]; + + strcpy(End, openbr + 1); + *(openbr + 1) = '\0'; + StrAllocCat(DirEntry, "000000]"); + StrAllocCat(DirEntry, End); + StrAllocCat(DirEntry, ".dir"); + } + } else { + *dot = ']'; + StrAllocCat(DirEntry, ".dir"); + } + /* lib$find_file needs a fixed-size buffer */ + LYStrNCpy(Actual, DirEntry, sizeof(Actual) - 1); + + dir.context = 0; + dirname_desc.dsc$w_length = strlen(Actual); + dirname_desc.dsc$b_dtype = DSC$K_DTYPE_T; + dirname_desc.dsc$b_class = DSC$K_CLASS_S; + dirname_desc.dsc$a_pointer = (char *) &(Actual); + + /* look for the directory */ + entryname_desc.dsc$w_length = 255; + entryname_desc.dsc$b_dtype = DSC$K_DTYPE_T; + entryname_desc.dsc$b_class = DSC$K_CLASS_S; + entryname_desc.dsc$a_pointer = VMSentry; + + status = lib$find_file(&(dirname_desc), + &entryname_desc, + &(dir.context), + 0, 0, 0, 0); + if (!(status & 0x01)) { /* directory not found */ + return (NULL); + } + + if (strlen(dir.dirname) > sizeof(dir.dirname) - 10) + return (NULL); + if (HTVMSFileVersions) + strcat(dir.dirname, "*.*;*"); + else + strcat(dir.dirname, "*.*"); + dir.context = 0; + dir.dirname_desc.dsc$w_length = strlen(dir.dirname); + dir.dirname_desc.dsc$b_dtype = DSC$K_DTYPE_T; + dir.dirname_desc.dsc$b_class = DSC$K_CLASS_S; + dir.dirname_desc.dsc$a_pointer = (char *) &(dir.dirname); + return (&dir); +} + +static struct dirent *HTVMSreaddir(DIR *dirp) +{ + static struct dirent entry; + long status; + struct dsc$descriptor_s entryname_desc; + char *space, *slash; + char VMSentry[256]; + const char *UnixEntry; + + entryname_desc.dsc$w_length = 255; + entryname_desc.dsc$b_dtype = DSC$K_DTYPE_T; + entryname_desc.dsc$b_class = DSC$K_CLASS_S; + entryname_desc.dsc$a_pointer = VMSentry; + + status = lib$find_file(&(dirp->dirname_desc), + &entryname_desc, + &(dirp->context), + 0, 0, 0, 0); + if (status == RMS$_NMF) { /* no more files */ + return (NULL); + } else { /* ok */ + if (!(status & 0x01)) + return (0); + if (HTVMSFileVersions) + space = StrChr(VMSentry, ' '); + else + space = StrChr(VMSentry, ';'); + if (space) + *space = '\0'; + + /* convert to unix style... */ + UnixEntry = HTVMS_wwwName(VMSentry); + slash = strrchr(UnixEntry, '/') + 1; + strcpy(entry.d_name, slash); + entry.d_namlen = strlen(entry.d_name); + entry.d_fileno = 1; + return (&entry); + } +} + +static int HTVMSclosedir(DIR *dirp) +{ + long status; + + status = lib$find_file_end(&(dirp->context)); + if (!(status & 0x01)) + exit_immediately(status); + dirp->context = 0; + return (0); +} + +#include <HTAnchor.h> +#include <HTParse.h> +#include <HTBTree.h> +#include <HTFile.h> /* For HTFileFormat() */ +#include <HTAlert.h> +/* + * Hypertext object building machinery. + */ +#include <HTML.h> +#define PUTC(c) (*targetClass.put_character)(target, c) +#define PUTS(s) (*targetClass.put_string)(target, s) +#define START(e) (*targetClass.start_element)(target, e, 0, 0, -1, 0) +#define END(e) (*targetClass.end_element)(target, e, 0) +#define FREE_TARGET (*targetClass._free)(target) +#define ABORT_TARGET (*targetClass._free)(target) +struct _HTStructured { + const HTStructuredClass *isa; + /* ... */ +}; + +#define STRUCT_DIRENT struct dirent + +static char *months[12] = +{ + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; + +typedef struct _VMSEntryInfo { + char *filename; + char *type; + char *date; + unsigned int size; + BOOLEAN display; /* show this entry? */ +} VMSEntryInfo; + +static void free_VMSEntryInfo_contents(VMSEntryInfo * entry_info) +{ + if (entry_info) { + FREE(entry_info->filename); + FREE(entry_info->type); + FREE(entry_info->date); + } + /* don't free the struct */ +} + +int compare_VMSEntryInfo_structs(VMSEntryInfo * entry1, VMSEntryInfo * entry2) +{ + int i, status; + char date1[16], date2[16], time1[8], time2[8], month[4]; + + switch (HTfileSortMethod) { + case FILE_BY_SIZE: + /* both equal or both 0 */ + if (entry1->size == entry2->size) + return (strcasecomp(entry1->filename, + entry2->filename)); + else if (entry1->size > entry2->size) + return (1); + else + return (-1); + case FILE_BY_TYPE: + if (entry1->type && entry2->type) { + status = strcasecomp(entry1->type, entry2->type); + if (status) + return (status); + /* else fall to filename comparison */ + } + return (strcasecomp(entry1->filename, + entry2->filename)); + case FILE_BY_DATE: + if (entry1->date && entry2->date) { + /* + * Make sure we have the correct length. - FM + */ + if (strlen(entry1->date) != 12 || + strlen(entry2->date) != 12) { + return (strcasecomp(entry1->filename, + entry2->filename)); + } + /* + * Set up for sorting in reverse + * chronological order. - FM + */ + if (entry1->date[7] != ' ') { + strcpy(date1, "9999"); + strcpy(time1, (char *) &entry1->date[7]); + } else { + strcpy(date1, (char *) &entry1->date[8]); + strcpy(time1, "00:00"); + } + LYStrNCpy(month, entry1->date, 3); + for (i = 0; i < 12; i++) { + if (!strcasecomp(month, months[i])) { + break; + } + } + i++; + sprintf(month, "%02d", i); + strcat(date1, month); + StrNCat(date1, (char *) &entry1->date[4], 2); + date1[8] = '\0'; + if (date1[6] == ' ') { + date1[6] = '0'; + } + strcat(date1, time1); + if (entry2->date[7] != ' ') { + strcpy(date2, "9999"); + strcpy(time2, (char *) &entry2->date[7]); + } else { + strcpy(date2, (char *) &entry2->date[8]); + strcpy(time2, "00:00"); + } + LYStrNCpy(month, entry2->date, 3); + for (i = 0; i < 12; i++) { + if (!strcasecomp(month, months[i])) { + break; + } + } + i++; + sprintf(month, "%02d", i); + strcat(date2, month); + StrNCat(date2, (char *) &entry2->date[4], 2); + date2[8] = '\0'; + if (date2[6] == ' ') { + date2[6] = '0'; + } + strcat(date2, time2); + /* + * Do the comparison. - FM + */ + status = strcasecomp(date2, date1); + if (status) + return (status); + /* else fall to filename comparison */ + } + return (strcasecomp(entry1->filename, + entry2->filename)); + case FILE_BY_NAME: + default: + return (strcmp(entry1->filename, + entry2->filename)); + } +} + +/* HTVMSBrowseDir() + * + * This function generates a directory listing as an HTML-object + * for local file URL's. It assumes the first two elements of + * of the path are a device followed by a directory: + * + * file://localhost/device/directory[/[foo]] + * + * Will not accept 000000 as a directory name. + * Will offer links to parent through the top directory, unless + * a terminal slash was included in the calling URL. + * + * Returns HT_LOADED on success, HTLoadError() messages on error. + * + * Developed for Lynx by Foteos Macrides (macrides@sci.wfeb.edu). + */ +int HTVMSBrowseDir(const char *address, + HTParentAnchor *anchor, + HTFormat format_out, + HTStream *sink) +{ + HTStructured *target; + HTStructuredClass targetClass; + char *pathname = HTParse(address, "", PARSE_PATH + PARSE_PUNCTUATION); + char *tail = NULL; + char *title = NULL; + char *header = NULL; + char *parent = NULL; + char *relative = NULL; + char *cp, *cp1; + int pathend, len; + DIR *dp; + struct stat file_info; + time_t NowTime; + static char ThisYear[8]; + VMSEntryInfo *entry_info = 0; + char string_buffer[64]; + + HTUnEscape(pathname); + CTRACE((tfp, "HTVMSBrowseDir: Browsing `%s\'\n", pathname)); + + /* + * Require at least two elements (presumably a device and directory) and + * disallow the device root (000000 directory). Symbolic paths (e.g., + * sys$help) should have been translated and expanded (e.g., to + * /sys$sysroot/syshlp) before calling this routine. + */ + if (((*pathname != '/') || + (cp = StrChr(pathname + 1, '/')) == NULL || + *(cp + 1) == '\0' || + 0 == StrNCmp((cp + 1), "000000", 6)) || + (dp = HTVMSopendir(pathname)) == NULL) { + FREE(pathname); + return HTLoadError(sink, 403, COULD_NOT_ACCESS_DIR); + } + + /* + * Set up the output stream. + */ + _HTProgress(BUILDING_DIR_LIST); + if (UCLYhndl_HTFile_for_unspec >= 0) { + HTAnchor_setUCInfoStage(anchor, + UCLYhndl_HTFile_for_unspec, + UCT_STAGE_PARSER, + UCT_SETBY_DEFAULT); + } + target = HTML_new(anchor, format_out, sink); + targetClass = *(target->isa); + + /* + * Set up the offset string of the anchor reference, and strings for the + * title and header. + */ + cp = strrchr(pathname, '/'); /* find lastslash */ + StrAllocCopy(tail, (cp + 1)); /* take slash off the beginning */ + if (*tail != '\0') { + StrAllocCopy(title, tail); + *cp = '\0'; + if ((cp1 = strrchr(pathname, '/')) != NULL && + cp1 != pathname && + StrNCmp((cp1 + 1), "000000", 6)) + StrAllocCopy(parent, (cp1 + 1)); + *cp = '/'; + } else { + pathname[strlen(pathname) - 1] = '\0'; + cp = strrchr(pathname, '/'); + StrAllocCopy(title, (cp + 1)); + pathname[strlen(pathname)] = '/'; + } + StrAllocCopy(header, pathname); + + /* + * Initialize path name for HTStat(). + */ + pathend = strlen(pathname); + if (*(pathname + pathend - 1) != '/') { + StrAllocCat(pathname, "/"); + pathend++; + } + + /* + * Output the title and header. + */ + START(HTML_HTML); + PUTC('\n'); + START(HTML_HEAD); + PUTC('\n'); + HTUnEscape(title); + START(HTML_TITLE); + PUTS(title); + PUTS(" directory"); + END(HTML_TITLE); + PUTC('\n'); + FREE(title); + END(HTML_HEAD); + PUTC('\n'); + START(HTML_BODY); + PUTC('\n'); + HTUnEscape(header); + START(HTML_H1); + PUTS(header); + END(HTML_H1); + PUTC('\n'); + if (HTDirReadme == HT_DIR_README_TOP) { + FILE *fp; + + if (header[strlen(header) - 1] != '/') + StrAllocCat(header, "/"); + StrAllocCat(header, HT_DIR_README_FILE); + if ((fp = fopen(header, "r")) != NULL) { + START(HTML_PRE); + for (;;) { + char c = fgetc(fp); + + if (c == (char) EOF) + break; +#ifdef NOTDEFINED + switch (c) { + case '&': + case '<': + case '>': + PUTC('&'); + PUTC('#'); + PUTC((char) (c / 10)); + PUTC((char) (c % 10)); + PUTC(';'); + break; + default: + PUTC(c); + } +#else + PUTC(c); +#endif /* NOTDEFINED */ + } + END(HTML_PRE); + fclose(fp); + } + } + FREE(header); + if (parent) { + HTSprintf0(&relative, "%s/..", tail); + HTStartAnchor(target, "", relative); + PUTS("Up to "); + HTUnEscape(parent); + PUTS(parent); + END(HTML_A); + START(HTML_P); + PUTC('\n'); + FREE(relative); + FREE(parent); + } + + /* + * Set up the date comparison. + */ + NowTime = time(NULL); + strcpy(ThisYear, (char *) ctime(&NowTime) + 20); + ThisYear[4] = '\0'; + + /* + * Now, generate the Btree and put it out to the output stream. + */ + { + char dottest = 2; /* To avoid two strcmp() each time */ + STRUCT_DIRENT *dirbuf; + HTBTree *bt; + + /* Set up sort key and initialize BTree */ + bt = HTBTree_new((HTComparer) compare_VMSEntryInfo_structs); + + /* Build tree */ + while ((dirbuf = HTVMSreaddir(dp))) { + HTAtom *encoding = NULL; + HTFormat format; + + /* Skip if not used */ + if (!dirbuf->d_ino) { + continue; + } + + /* Current and parent directories are never shown in list */ + if (dottest && (!strcmp(dirbuf->d_name, ".") || + !strcmp(dirbuf->d_name, ".."))) { + dottest--; + continue; + } + + /* Don't show the selective enabling file + * unless version numbers are included */ + if (!strcasecomp(dirbuf->d_name, HT_DIR_ENABLE_FILE)) { + continue; + } + + /* Skip files beginning with a dot? */ + if ((no_dotfiles || !show_dotfiles) && *dirbuf->d_name == '.') { + continue; + } + + /* OK, make an lstat() and get a key ready. */ + *(pathname + pathend) = '\0'; + StrAllocCat(pathname, dirbuf->d_name); + if (HTStat(pathname, &file_info)) { + /* for VMS the failure here means the file is not readable... + we however continue to browse through the directory... */ + continue; + } + entry_info = (VMSEntryInfo *) malloc(sizeof(VMSEntryInfo)); + if (entry_info == NULL) + outofmem(__FILE__, "HTVMSBrowseDir"); + entry_info->type = 0; + entry_info->size = 0; + entry_info->date = 0; + entry_info->filename = 0; + entry_info->display = TRUE; + + /* Get the type */ + format = HTFileFormat(dirbuf->d_name, &encoding, + (const char **) &cp); + if (!cp) { + if (!StrNCmp(HTAtom_name(format), "application", 11)) { + cp = HTAtom_name(format) + 12; + if (!StrNCmp(cp, "x-", 2)) + cp += 2; + } else + cp = HTAtom_name(format); + } + StrAllocCopy(entry_info->type, cp); + + StrAllocCopy(entry_info->filename, dirbuf->d_name); + if (S_ISDIR(file_info.st_mode)) { + /* strip .DIR part... */ + char *dot; + + dot = strstr(entry_info->filename, ".DIR"); + if (dot) + *dot = '\0'; + LYLowerCase(entry_info->filename); + StrAllocCopy(entry_info->type, "Directory"); + } else { + if ((cp = strstr(entry_info->filename, "READ")) == NULL) { + cp = entry_info->filename; + } else { + cp += 4; + if (!StrNCmp(cp, "ME", 2)) { + cp += 2; + while (cp && *cp && *cp != '.') { + cp++; + } + } else if (!StrNCmp(cp, ".ME", 3)) { + cp = (entry_info->filename + + strlen(entry_info->filename)); + } else { + cp = entry_info->filename; + } + } + LYLowerCase(cp); + if (((len = strlen(entry_info->filename)) > 2) && + entry_info->filename[len - 1] == 'z') { + if (entry_info->filename[len - 2] == '.' || + entry_info->filename[len - 2] == '_') + entry_info->filename[len - 1] = 'Z'; + } + } + + /* Get the date */ + { + char *t = (char *) ctime((const time_t *) &file_info.st_ctime); + + *(t + 24) = '\0'; + + StrAllocCopy(entry_info->date, (t + 4)); + *((entry_info->date) + 7) = '\0'; + if ((atoi((t + 19))) < atoi(ThisYear)) + StrAllocCat(entry_info->date, (t + 19)); + else { + StrAllocCat(entry_info->date, (t + 11)); + *((entry_info->date) + 12) = '\0'; + } + } + + /* Get the size */ + if (!S_ISDIR(file_info.st_mode)) + entry_info->size = (unsigned int) file_info.st_size; + else + entry_info->size = 0; + + /* Now, update the BTree etc. */ + if (entry_info->display) { + CTRACE((tfp, "Adding file to BTree: %s\n", + entry_info->filename)); + HTBTree_add(bt, entry_info); + } + + } /* End while HTVMSreaddir() */ + + FREE(pathname); + HTVMSclosedir(dp); + + START(HTML_PRE); + /* + * Run through the BTree printing out in order + */ + { + HTBTElement *ele; + int i; + + for (ele = HTBTree_next(bt, NULL); + ele != NULL; + ele = HTBTree_next(bt, ele)) { + entry_info = (VMSEntryInfo *) HTBTree_object(ele); + + /* Output the date */ + if (entry_info->date) { + PUTS(entry_info->date); + PUTS(" "); + } else + PUTS(" * "); + + /* Output the type */ + if (entry_info->type) { + for (i = 0; entry_info->type[i] != '\0' && i < 15; i++) + PUTC(entry_info->type[i]); + for (; i < 17; i++) + PUTC(' '); + + } + + /* Output the link for the name */ + HTDirEntry(target, tail, entry_info->filename); + PUTS(entry_info->filename); + END(HTML_A); + + /* Output the size */ + if (entry_info->size) { + if (entry_info->size < 1024) + sprintf(string_buffer, " %d bytes", + entry_info->size); + else + sprintf(string_buffer, " %dKb", + entry_info->size / 1024); + PUTS(string_buffer); + } + + PUTC('\n'); /* end of this entry */ + + free_VMSEntryInfo_contents(entry_info); + } + } + + HTBTreeAndObject_free(bt); + + } /* End of both BTree loops */ + + /* + * Complete the output stream. + */ + END(HTML_PRE); + PUTC('\n'); + END(HTML_BODY); + PUTC('\n'); + END(HTML_HTML); + PUTC('\n'); + FREE(tail); + FREE_TARGET; + + return HT_LOADED; + +} /* End of directory reading section */ + +/* + * Remove all versions of the given file. We assume there are no permissions + * problems, since we do this mainly for removing temporary files. + */ +int HTVMS_remove(char *filename) +{ + int code = remove(filename); /* return the first status code */ + + while (remove(filename) == 0) ; + return code; +} + +/* + * Remove all older versions of the given file. We may fail to remove some + * version due to permissions -- the loop stops either at that point, or when + * we run out of older versions to remove. + */ +void HTVMS_purge(char *filename) +{ + char *older_file = 0; + char *oldest_file = 0; + struct stat sb; + + StrAllocCopy(older_file, filename); + StrAllocCat(older_file, ";-1"); + + while (remove(older_file) == 0) ; + /* + * If we do not have any more older versions, it is safe to rename the + * current file to version #1. + */ + if (stat(older_file, &sb) != 0) { + StrAllocCopy(oldest_file, filename); + StrAllocCat(oldest_file, ";1"); + rename(older_file, oldest_file); + FREE(oldest_file); + } + + FREE(older_file); +} +#endif /* VMS */ |