5752 lines
179 KiB
C
5752 lines
179 KiB
C
/*
|
|
Copyright (c) 1990-2009 Info-ZIP. All rights reserved.
|
|
|
|
See the accompanying file LICENSE, version 2009-Jan-02 or later
|
|
(the contents of which are also included in unzip.h) for terms of use.
|
|
If, for some reason, all these files are missing, the Info-ZIP license
|
|
also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
|
|
*/
|
|
/*---------------------------------------------------------------------------
|
|
|
|
vms.c Igor Mandrichenko and others
|
|
|
|
This file contains routines to extract VMS file attributes from a zipfile
|
|
extra field and create a file with these attributes. The code was almost
|
|
entirely written by Igor, with a couple of routines by GRR and lots of
|
|
modifications and fixes by Christian Spieler.
|
|
|
|
Contains: check_format()
|
|
open_outfile()
|
|
find_vms_attrs()
|
|
flush()
|
|
close_outfile()
|
|
defer_dir_attribs()
|
|
set_direc_attribs()
|
|
dos_to_unix_time() (TIMESTAMP only)
|
|
stamp_file() (TIMESTAMP only)
|
|
vms_msg_text()
|
|
do_wild()
|
|
mapattr()
|
|
mapname()
|
|
checkdir()
|
|
check_for_newer()
|
|
return_VMS
|
|
screensize()
|
|
screenlinewrap()
|
|
version()
|
|
|
|
---------------------------------------------------------------------------*/
|
|
|
|
#ifdef VMS /* VMS only! */
|
|
|
|
#define UNZIP_INTERNAL
|
|
|
|
#include "unzip.h"
|
|
#include "crc32.h"
|
|
#include "vms.h"
|
|
#include "vmsdefs.h"
|
|
|
|
#ifdef MORE
|
|
# include <ttdef.h>
|
|
#endif
|
|
#include <unixlib.h>
|
|
|
|
#include <dvidef.h>
|
|
#include <ssdef.h>
|
|
#include <stsdef.h>
|
|
|
|
/* Workaround for broken header files of older DECC distributions
|
|
* that are incompatible with the /NAMES=AS_IS qualifier. */
|
|
#define lib$getdvi LIB$GETDVI
|
|
#define lib$getsyi LIB$GETSYI
|
|
#define lib$sys_getmsg LIB$SYS_GETMSG
|
|
#include <lib$routines.h>
|
|
|
|
#ifndef EEXIST
|
|
# include <errno.h> /* For mkdir() status codes */
|
|
#endif
|
|
|
|
/* On VAX, define Goofy VAX Type-Cast to obviate /standard = vaxc.
|
|
Otherwise, lame system headers on VAX cause compiler warnings.
|
|
(GNU C may define vax but not __VAX.)
|
|
*/
|
|
#ifdef vax
|
|
# define __VAX 1
|
|
#endif
|
|
|
|
#ifdef __VAX
|
|
# define GVTC (unsigned int)
|
|
#else
|
|
# define GVTC
|
|
#endif
|
|
|
|
/* With GNU C, some FAB bits may be declared only as masks, not as
|
|
* structure bits.
|
|
*/
|
|
#ifdef __GNUC__
|
|
# define OLD_FABDEF 1
|
|
#endif
|
|
|
|
#define ASYNCH_QIO /* Use asynchronous PK-style QIO writes */
|
|
|
|
/* buffer size for a single block write (using RMS or QIO WRITEVBLK),
|
|
must be less than 64k and a multiple of 512 ! */
|
|
#define BUFS512 (((OUTBUFSIZ>0xFFFF) ? 0xFFFF : OUTBUFSIZ) & (~511))
|
|
/* buffer size for record output (RMS limit for max. record size) */
|
|
#define BUFSMAXREC 32767
|
|
/* allocation size for RMS and QIO output buffers */
|
|
#define BUFSALLOC (BUFS512 * 2 > BUFSMAXREC ? BUFS512 * 2 : BUFSMAXREC)
|
|
/* locbuf size */
|
|
|
|
/* VMS success or warning status */
|
|
#define OK(s) (((s) & STS$M_SUCCESS) != 0)
|
|
#define STRICMP(s1, s2) STRNICMP(s1, s2, 2147483647)
|
|
|
|
/* Interactive inquiry response codes for replace(). */
|
|
|
|
#define REPL_NO_EXTRACT 0
|
|
#define REPL_NEW_VERSION 1
|
|
#define REPL_OVERWRITE 2
|
|
#define REPL_ERRLV_WARN 256
|
|
#define REPL_TASKMASK 255
|
|
|
|
/* 2008-09-13 CS.
|
|
* Note: In extract.c, there are similar strings "InvalidResponse" and
|
|
* "AssumeNone" defined. However, as the UI functionality of the VMS
|
|
* "version-aware" query is slightly different from the generic variant,
|
|
* these strings are kept separate for now to allow independent
|
|
* "fine tuning" without affecting the other variant of the
|
|
* "overwrite or ..." user query.
|
|
*/
|
|
ZCONST char Far InvalidResponse[] =
|
|
"error: invalid response [%.1s]\n";
|
|
ZCONST char Far AssumeNo[] =
|
|
"\n(EOF or read error, treating as \"[N]o extract (all)\" ...)\n";
|
|
|
|
|
|
#ifdef SET_DIR_ATTRIB
|
|
/* Structure for holding directory attribute data for final processing
|
|
* after all files are in place.
|
|
*/
|
|
typedef struct vmsdirattr {
|
|
struct vmsdirattr *next; /* link to next in (linked) list */
|
|
char *fn; /* file (directory) name */
|
|
|
|
/* Non-VMS attributes data */
|
|
ulg mod_dos_datetime; /* G.lrec.last_mod_dos_datetime */
|
|
unsigned perms; /* same as min_info.file_attr */
|
|
|
|
unsigned xlen; /* G.lrec.extra_field_length */
|
|
char buf[1]; /* data buffer (extra_field, fn) */
|
|
} vmsdirattr;
|
|
#define VmsAtt(d) ((vmsdirattr *)d) /* typecast shortcut */
|
|
#endif /* SET_DIR_ATTRIB */
|
|
|
|
/*
|
|
* Local static storage
|
|
*/
|
|
static struct FAB fileblk; /* File Access Block */
|
|
static struct XABDAT dattim; /* date-time XAB */
|
|
static struct XABRDT rdt; /* revision date-time XAB */
|
|
static struct RAB rab; /* Record Access Block */
|
|
static struct NAM_STRUCT nam; /* name block */
|
|
|
|
static struct FAB *outfab = NULL;
|
|
static struct RAB *outrab = NULL;
|
|
static struct XABFHC *xabfhc = NULL; /* file header characteristics */
|
|
static struct XABDAT *xabdat = NULL; /* date-time */
|
|
static struct XABRDT *xabrdt = NULL; /* revision date-time */
|
|
static struct XABPRO *xabpro = NULL; /* protection */
|
|
static struct XABKEY *xabkey = NULL; /* key (indexed) */
|
|
static struct XABALL *xaball = NULL; /* allocation */
|
|
static struct XAB *first_xab = NULL, *last_xab = NULL;
|
|
|
|
static int replace_code_all = -1; /* All-file response for replace(). */
|
|
|
|
static uch rfm;
|
|
|
|
static uch locbuf[BUFSALLOC]; /* Space for 2 buffers of BUFS512 */
|
|
static unsigned loccnt = 0;
|
|
static uch *locptr;
|
|
static char got_eol = 0;
|
|
|
|
struct bufdsc
|
|
{
|
|
struct bufdsc *next;
|
|
uch *buf;
|
|
unsigned bufcnt;
|
|
};
|
|
|
|
static struct bufdsc b1, b2, *curbuf; /* buffer ring for asynchronous I/O */
|
|
|
|
static int _flush_blocks(__GPRO__ uch *rawbuf, unsigned size, int final_flag);
|
|
static int _flush_stream(__GPRO__ uch *rawbuf, unsigned size, int final_flag);
|
|
static int _flush_varlen(__GPRO__ uch *rawbuf, unsigned size, int final_flag);
|
|
static int _flush_qio(__GPRO__ uch *rawbuf, unsigned size, int final_flag);
|
|
static int _close_rms(__GPRO);
|
|
static int _close_qio(__GPRO);
|
|
#ifdef ASYNCH_QIO
|
|
static int WriteQIO(__GPRO__ uch *buf, unsigned len);
|
|
#endif
|
|
static int WriteBuffer(__GPRO__ uch *buf, unsigned len);
|
|
static int WriteRecord(__GPRO__ uch *rec, unsigned len);
|
|
|
|
static int (*_flush_routine)(__GPRO__ uch *rawbuf, unsigned size,
|
|
int final_flag);
|
|
static int (*_close_routine)(__GPRO);
|
|
|
|
#ifdef SYMLINKS
|
|
static int _read_link_rms(__GPRO__ int byte_count, char *link_text_buf);
|
|
#endif /* SYMLINKS */
|
|
|
|
static void init_buf_ring(void);
|
|
static void set_default_datetime_XABs(__GPRO);
|
|
static int create_default_output(__GPRO);
|
|
static int create_rms_output(__GPRO);
|
|
static int create_qio_output(__GPRO);
|
|
static int replace(__GPRO);
|
|
static int replace_rms_newversion(__GPRO);
|
|
static int replace_rms_overwrite(__GPRO);
|
|
static int find_vms_attrs(__GPRO__ int set_date_time);
|
|
static void free_up(void);
|
|
#ifdef CHECK_VERSIONS
|
|
static int get_vms_version(char *verbuf, int len);
|
|
#endif /* CHECK_VERSIONS */
|
|
static unsigned find_eol(ZCONST uch *p, unsigned n, unsigned *l);
|
|
#ifdef SET_DIR_ATTRIB
|
|
static char *vms_path_fixdown(ZCONST char *dir_spec, char *dir_file);
|
|
#endif
|
|
#ifdef TIMESTAMP
|
|
static time_t mkgmtime(struct tm *tm);
|
|
static void uxtime2vmstime(time_t utimeval, long int binval[2]);
|
|
#endif /* TIMESTAMP */
|
|
static int vms_msg_fetch(int status);
|
|
static void vms_msg(__GPRO__ ZCONST char *string, int status);
|
|
|
|
|
|
/*
|
|
2005-02-14 SMS.
|
|
Added some ODS5 support:
|
|
Use longer name structures in NAML, where available.
|
|
Locate special characters mindful of "^" escapes.
|
|
*/
|
|
|
|
/* Hex digit table. */
|
|
|
|
char hex_digit[16] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7',
|
|
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
|
|
};
|
|
|
|
|
|
/* Character property table for converting Zip file names to
|
|
(simpler) ODS2 or (escaped) ODS5 extended file names.
|
|
|
|
ODS2 valid characters: 0-9 A-Z a-z $ - _
|
|
|
|
ODS5 Invalid characters:
|
|
C0 control codes (0x00 to 0x1F inclusive)
|
|
Asterisk (*)
|
|
Question mark (?)
|
|
|
|
ODS5 Invalid characters only in VMS V7.2 (which no one runs, right?):
|
|
Double quotation marks (")
|
|
Backslash (\)
|
|
Colon (:)
|
|
Left angle bracket (<)
|
|
Right angle bracket (>)
|
|
Slash (/)
|
|
Vertical bar (|)
|
|
|
|
Characters escaped by "^":
|
|
SP ! " # % & ' ( ) + , . : ; =
|
|
@ [ \ ] ^ ` { | } ~
|
|
|
|
Either "^_" or "^ " is accepted as a space. Period (.) is a special
|
|
case. Note that un-escaped < and > can also confuse a directory
|
|
spec.
|
|
|
|
Characters put out as ^xx:
|
|
7F (DEL)
|
|
80-9F (C1 control characters)
|
|
A0 (nonbreaking space)
|
|
FF (Latin small letter y diaeresis)
|
|
|
|
Other cases:
|
|
Unicode: "^Uxxxx", where "xxxx" is four hex digits.
|
|
|
|
Property table values:
|
|
Normal ODS2 1
|
|
Lower-case ODS2 2
|
|
Period 4
|
|
Space 8
|
|
ODS5 simple 16
|
|
ODS5 1-char escape 32
|
|
ODS5 hex-hex escape 64
|
|
*/
|
|
|
|
unsigned char char_prop[256] = {
|
|
|
|
/* NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI */
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
/* DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US */
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
/* SP ! " # $ % & ' ( ) * + , - . / */
|
|
8, 32, 32, 32, 17, 32, 32, 32, 32, 32, 0, 32, 32, 17, 4, 0,
|
|
|
|
/* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
|
|
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 32, 32, 32, 32, 32, 32,
|
|
|
|
/* @ A B C D E F G H I J K L M N O */
|
|
32, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
|
|
|
/* P Q R S T U V W X Y Z [ \ ] ^ _ */
|
|
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 32, 32, 32, 32, 17,
|
|
|
|
/* ` a b c d e f g h i j k l m n o */
|
|
32, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
|
|
|
|
/* p q r s t u v w x y z { | } ~ DEL */
|
|
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 32, 32, 32, 32, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
|
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
|
64, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 64
|
|
};
|
|
|
|
|
|
/* 2004-11-23 SMS.
|
|
*
|
|
* get_rms_defaults().
|
|
*
|
|
* Get user-specified values from (DCL) SET RMS_DEFAULT. FAB/RAB
|
|
* items of particular interest are:
|
|
*
|
|
* fab$w_deq default extension quantity (blocks) (write).
|
|
* rab$b_mbc multi-block count.
|
|
* rab$b_mbf multi-buffer count (used with rah and wbh).
|
|
*/
|
|
|
|
#define DIAG_FLAG (uO.vflag >= 3)
|
|
|
|
/* Default RMS parameter values.
|
|
* The default extend quantity (deq) should not matter much here, as the
|
|
* initial allocation should always be set according to the known file
|
|
* size, and no extension should be needed.
|
|
*/
|
|
|
|
#define RMS_DEQ_DEFAULT 16384 /* About 1/4 the max (65535 blocks). */
|
|
#define RMS_MBC_DEFAULT 127 /* The max, */
|
|
#define RMS_MBF_DEFAULT 2 /* Enough to enable rah and wbh. */
|
|
|
|
/* GETJPI item descriptor structure. */
|
|
typedef struct
|
|
{
|
|
short buf_len;
|
|
short itm_cod;
|
|
void *buf;
|
|
int *ret_len;
|
|
} jpi_item_t;
|
|
|
|
/* Durable storage */
|
|
static int rms_defaults_known = 0;
|
|
|
|
/* JPI item buffers. */
|
|
static unsigned short rms_ext;
|
|
static char rms_mbc;
|
|
static unsigned char rms_mbf;
|
|
|
|
/* Active RMS item values. */
|
|
unsigned short rms_ext_active;
|
|
char rms_mbc_active;
|
|
unsigned char rms_mbf_active;
|
|
|
|
/* GETJPI item lengths. */
|
|
static int rms_ext_len; /* Should come back 2. */
|
|
static int rms_mbc_len; /* Should come back 1. */
|
|
static int rms_mbf_len; /* Should come back 1. */
|
|
|
|
/* Desperation attempts to define unknown macros. Probably doomed.
|
|
* If these get used, expect sys$getjpiw() to return %x00000014 =
|
|
* %SYSTEM-F-BADPARAM, bad parameter value.
|
|
* They keep compilers with old header files quiet, though.
|
|
*/
|
|
#ifndef JPI$_RMS_EXTEND_SIZE
|
|
# define JPI$_RMS_EXTEND_SIZE 542
|
|
#endif /* ndef JPI$_RMS_EXTEND_SIZE */
|
|
|
|
#ifndef JPI$_RMS_DFMBC
|
|
# define JPI$_RMS_DFMBC 535
|
|
#endif /* ndef JPI$_RMS_DFMBC */
|
|
|
|
#ifndef JPI$_RMS_DFMBFSDK
|
|
# define JPI$_RMS_DFMBFSDK 536
|
|
#endif /* ndef JPI$_RMS_DFMBFSDK */
|
|
|
|
/* GETJPI item descriptor set. */
|
|
|
|
struct
|
|
{
|
|
jpi_item_t rms_ext_itm;
|
|
jpi_item_t rms_mbc_itm;
|
|
jpi_item_t rms_mbf_itm;
|
|
int term;
|
|
} jpi_itm_lst =
|
|
{ { 2, JPI$_RMS_EXTEND_SIZE, &rms_ext, &rms_ext_len },
|
|
{ 1, JPI$_RMS_DFMBC, &rms_mbc, &rms_mbc_len },
|
|
{ 1, JPI$_RMS_DFMBFSDK, &rms_mbf, &rms_mbf_len },
|
|
0
|
|
};
|
|
|
|
static int get_rms_defaults()
|
|
{
|
|
int sts;
|
|
|
|
/* Get process RMS_DEFAULT values. */
|
|
|
|
sts = sys$getjpiw(0, 0, 0, &jpi_itm_lst, 0, 0, 0);
|
|
if ((sts & STS$M_SEVERITY) != STS$K_SUCCESS)
|
|
{
|
|
/* Failed. Don't try again. */
|
|
rms_defaults_known = -1;
|
|
}
|
|
else
|
|
{
|
|
/* Fine, but don't come back. */
|
|
rms_defaults_known = 1;
|
|
}
|
|
|
|
/* Limit the active values according to the RMS_DEFAULT values. */
|
|
|
|
if (rms_defaults_known > 0)
|
|
{
|
|
/* Set the default values. */
|
|
rms_ext_active = RMS_DEQ_DEFAULT;
|
|
rms_mbc_active = RMS_MBC_DEFAULT;
|
|
rms_mbf_active = RMS_MBF_DEFAULT;
|
|
|
|
/* Default extend quantity. Use the user value, if set. */
|
|
if (rms_ext > 0)
|
|
{
|
|
rms_ext_active = rms_ext;
|
|
}
|
|
|
|
/* Default multi-block count. Use the user value, if set. */
|
|
if (rms_mbc > 0)
|
|
{
|
|
rms_mbc_active = rms_mbc;
|
|
}
|
|
|
|
/* Default multi-buffer count. Use the user value, if set. */
|
|
if (rms_mbf > 0)
|
|
{
|
|
rms_mbf_active = rms_mbf;
|
|
}
|
|
}
|
|
|
|
if (DIAG_FLAG)
|
|
{
|
|
fprintf(stderr, "Get RMS defaults. getjpi sts = %%x%08x.\n", sts);
|
|
|
|
if (rms_defaults_known > 0)
|
|
{
|
|
fprintf(stderr,
|
|
" Default: deq = %6d, mbc = %3d, mbf = %3d.\n",
|
|
rms_ext, rms_mbc, rms_mbf);
|
|
}
|
|
}
|
|
return sts;
|
|
}
|
|
|
|
|
|
int check_format(__G)
|
|
__GDEF
|
|
{
|
|
int rtype;
|
|
int sts;
|
|
struct FAB fab;
|
|
#ifdef NAML$C_MAXRSS
|
|
struct NAML nam;
|
|
#endif
|
|
|
|
fab = cc$rms_fab; /* Initialize FAB. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
nam = cc$rms_naml; /* Initialize NAML. */
|
|
fab.fab$l_naml = &nam; /* Point FAB to NAML. */
|
|
|
|
fab.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fab.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNA = G.zipfn;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNS = strlen(G.zipfn);
|
|
|
|
if (ERR(sts = sys$open(&fab)))
|
|
{
|
|
Info(slide, 1, ((char *)slide, "\n\
|
|
error: cannot open zipfile [ %s ].\n",
|
|
FnFilter1(G.zipfn)));
|
|
vms_msg(__G__ " sys$open() error: ", sts);
|
|
return PK_ERR;
|
|
}
|
|
rtype = fab.fab$b_rfm;
|
|
sys$close(&fab);
|
|
|
|
if (rtype == FAB$C_VAR || rtype == FAB$C_VFC)
|
|
{
|
|
Info(slide, 1, ((char *)slide, "\n\
|
|
Error: zipfile is in variable-length record format. Please\n\
|
|
run \"bilf l %s\" to convert the zipfile to stream-LF\n\
|
|
record format. (BILF is available at various VMS archives.)\n\n",
|
|
FnFilter1(G.zipfn)));
|
|
return PK_ERR;
|
|
}
|
|
|
|
return PK_COOL;
|
|
}
|
|
|
|
|
|
|
|
#define PRINTABLE_FORMAT(x) ( (x) == FAB$C_VAR \
|
|
|| (x) == FAB$C_STMLF \
|
|
|| (x) == FAB$C_STMCR \
|
|
|| (x) == FAB$C_STM )
|
|
|
|
/* VMS extra field types */
|
|
#define VAT_NONE 0
|
|
#define VAT_IZ 1 /* old Info-ZIP format */
|
|
#define VAT_PK 2 /* PKWARE format */
|
|
|
|
/*
|
|
* open_outfile() assignments:
|
|
*
|
|
* VMS attributes ? create_xxx _flush_xxx
|
|
* ---------------- ---------- ----------
|
|
* not found 'default' text mode ?
|
|
* yes -> 'stream'
|
|
* no -> 'block'
|
|
*
|
|
* yes, in IZ format 'rms' uO.cflag ?
|
|
* yes -> switch (fab.rfm)
|
|
* VAR -> 'varlen'
|
|
* STM* -> 'stream'
|
|
* default -> 'block'
|
|
* no -> 'block'
|
|
*
|
|
* yes, in PK format 'qio' uO.cflag ?
|
|
* yes -> switch (pka_rattr)
|
|
* VAR -> 'varlen'
|
|
* STM* -> 'stream'
|
|
* default -> 'block'
|
|
* no -> 'qio'
|
|
*
|
|
* "text mode" == G.pInfo->textmode || (uO.cflag && !uO.bflag)
|
|
* (simplified, for complete expression see create_default_output() code)
|
|
*/
|
|
|
|
/* The VMS version of open_outfile() supports special return codes:
|
|
* OPENOUT_OK a file has been opened normally
|
|
* OPENOUT_FAILED the file open process failed
|
|
* OPENOUT_SKIPOK file open skipped at user request, err level OK
|
|
* OPENOUT_SKIPWARN file open skipped at user request, err level WARN
|
|
*/
|
|
int open_outfile(__G)
|
|
__GDEF
|
|
{
|
|
/* Get process RMS_DEFAULT values, if not already done. */
|
|
if (rms_defaults_known == 0)
|
|
{
|
|
get_rms_defaults();
|
|
}
|
|
|
|
switch (find_vms_attrs(__G__ (uO.D_flag <= 1)))
|
|
{
|
|
case VAT_NONE:
|
|
default:
|
|
return create_default_output(__G);
|
|
case VAT_IZ:
|
|
return create_rms_output(__G);
|
|
case VAT_PK:
|
|
return create_qio_output(__G);
|
|
}
|
|
}
|
|
|
|
static void init_buf_ring()
|
|
{
|
|
locptr = &locbuf[0];
|
|
loccnt = 0;
|
|
|
|
b1.buf = &locbuf[0];
|
|
b1.bufcnt = 0;
|
|
b1.next = &b2;
|
|
b2.buf = &locbuf[BUFS512];
|
|
b2.bufcnt = 0;
|
|
b2.next = &b1;
|
|
curbuf = &b1;
|
|
}
|
|
|
|
|
|
/* Static data storage for time conversion: */
|
|
|
|
/* string constants for month names */
|
|
static ZCONST char *month[] =
|
|
{"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
|
|
"JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
|
|
|
|
/* buffer for time string */
|
|
static char timbuf[24]; /* length = first entry in "date_str" + 1 */
|
|
|
|
/* fixed-length string descriptor for timbuf: */
|
|
static ZCONST struct dsc$descriptor date_str =
|
|
{sizeof(timbuf)-1, DSC$K_DTYPE_T, DSC$K_CLASS_S, timbuf};
|
|
|
|
|
|
static void set_default_datetime_XABs(__GPRO)
|
|
{
|
|
unsigned yr, mo, dy, hh, mm, ss;
|
|
#ifdef USE_EF_UT_TIME
|
|
iztimes z_utime;
|
|
struct tm *t;
|
|
|
|
if (G.extra_field &&
|
|
#ifdef IZ_CHECK_TZ
|
|
G.tz_is_valid &&
|
|
#endif
|
|
(ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
|
|
G.lrec.last_mod_dos_datetime, &z_utime, NULL)
|
|
& EB_UT_FL_MTIME))
|
|
t = localtime(&(z_utime.mtime));
|
|
else
|
|
t = (struct tm *)NULL;
|
|
if (t != (struct tm *)NULL)
|
|
{
|
|
yr = t->tm_year + 1900;
|
|
mo = t->tm_mon;
|
|
dy = t->tm_mday;
|
|
hh = t->tm_hour;
|
|
mm = t->tm_min;
|
|
ss = t->tm_sec;
|
|
}
|
|
else
|
|
{
|
|
yr = ((G.lrec.last_mod_dos_datetime >> 25) & 0x7f) + 1980;
|
|
mo = ((G.lrec.last_mod_dos_datetime >> 21) & 0x0f) - 1;
|
|
dy = (G.lrec.last_mod_dos_datetime >> 16) & 0x1f;
|
|
hh = (G.lrec.last_mod_dos_datetime >> 11) & 0x1f;
|
|
mm = (G.lrec.last_mod_dos_datetime >> 5) & 0x3f;
|
|
ss = (G.lrec.last_mod_dos_datetime << 1) & 0x3e;
|
|
}
|
|
#else /* !USE_EF_UT_TIME */
|
|
|
|
yr = ((G.lrec.last_mod_dos_datetime >> 25) & 0x7f) + 1980;
|
|
mo = ((G.lrec.last_mod_dos_datetime >> 21) & 0x0f) - 1;
|
|
dy = (G.lrec.last_mod_dos_datetime >> 16) & 0x1f;
|
|
hh = (G.lrec.last_mod_dos_datetime >> 11) & 0x1f;
|
|
mm = (G.lrec.last_mod_dos_datetime >> 5) & 0x3f;
|
|
ss = (G.lrec.last_mod_dos_datetime << 1) & 0x1f;
|
|
#endif /* ?USE_EF_UT_TIME */
|
|
|
|
dattim = cc$rms_xabdat; /* fill XABs with default values */
|
|
rdt = cc$rms_xabrdt;
|
|
sprintf(timbuf, "%02u-%3s-%04u %02u:%02u:%02u.00",
|
|
dy, month[mo], yr, hh, mm, ss);
|
|
sys$bintim(&date_str, &dattim.xab$q_cdt);
|
|
memcpy(&rdt.xab$q_rdt, &dattim.xab$q_cdt, sizeof(rdt.xab$q_rdt));
|
|
}
|
|
|
|
|
|
/* The following return codes are supported:
|
|
* OPENOUT_OK a file has been opened normally
|
|
* OPENOUT_FAILED the file open process failed
|
|
* OPENOUT_SKIPOK file open skipped at user request, err level OK
|
|
* OPENOUT_SKIPWARN file open skipped at user request, err level WARN
|
|
*/
|
|
static int create_default_output(__GPRO)
|
|
{
|
|
int ierr;
|
|
int text_output, bin_fixed;
|
|
|
|
/* Extract the file in text format (Variable_length by default,
|
|
* Stream_LF with "-S" (/TEXT = STMLF), when
|
|
* a) explicitly requested by the user (through the -a option),
|
|
* and it is not a symbolic link,
|
|
* or
|
|
* b) piping to SYS$OUTPUT, unless "binary" piping was requested
|
|
* by the user (through the -b option).
|
|
*/
|
|
text_output = (G.pInfo->textmode
|
|
#ifdef SYMLINKS
|
|
&& !G.symlnk
|
|
#endif
|
|
) ||
|
|
(uO.cflag &&
|
|
(!uO.bflag || (!(uO.bflag - 1) && G.pInfo->textfile)));
|
|
/* Use fixed length 512 byte record format for disk file when
|
|
* a) explicitly requested by the user (-b option),
|
|
* and
|
|
* b) it is not a symbolic link,
|
|
* and
|
|
* c) it is not extracted in text mode.
|
|
*/
|
|
bin_fixed = !text_output &&
|
|
#ifdef SYMLINKS
|
|
!G.symlnk &&
|
|
#endif
|
|
(uO.bflag != 0) && ((uO.bflag != 1) || !G.pInfo->textfile);
|
|
|
|
rfm = FAB$C_STMLF; /* Default, stream-LF format from VMS or UNIX */
|
|
|
|
if (!uO.cflag) /* Redirect output */
|
|
{
|
|
rab = cc$rms_rab; /* Initialize RAB. */
|
|
fileblk = cc$rms_fab; /* Initialize FAB. */
|
|
|
|
fileblk.fab$l_xab = NULL; /* No XABs. */
|
|
rab.rab$l_fab = &fileblk; /* Point RAB to FAB. */
|
|
|
|
outfab = &fileblk; /* Set pointers used elsewhere. */
|
|
outrab = &rab;
|
|
|
|
if (text_output && (!uO.S_flag))
|
|
{ /* Default format for output `real' text file */
|
|
fileblk.fab$b_rfm = FAB$C_VAR; /* variable length records */
|
|
fileblk.fab$b_rat = FAB$M_CR; /* implied (CR) carriage ctrl */
|
|
}
|
|
else if (bin_fixed)
|
|
{ /* Default format for output `real' binary file */
|
|
fileblk.fab$b_rfm = FAB$C_FIX; /* fixed length records */
|
|
fileblk.fab$w_mrs = 512; /* record size 512 bytes */
|
|
fileblk.fab$b_rat = 0; /* no carriage ctrl */
|
|
}
|
|
else
|
|
{ /* Default format for output misc (bin or text) file */
|
|
fileblk.fab$b_rfm = FAB$C_STMLF; /* stream-LF record format */
|
|
fileblk.fab$b_rat = FAB$M_CR; /* implied (CR) carriage ctrl */
|
|
}
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
nam = CC_RMS_NAM; /* Initialize NAML. */
|
|
fileblk.FAB_NAM = &nam; /* Point FAB to NAML. */
|
|
|
|
fileblk.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fileblk.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(fileblk, nam).FAB_OR_NAML_FNA = G.filename;
|
|
FAB_OR_NAML(fileblk, nam).FAB_OR_NAML_FNS = strlen(G.filename);
|
|
|
|
/* Prepare date-time XABs, unless user requests not to. */
|
|
if (uO.D_flag <= 1) {
|
|
set_default_datetime_XABs(__G);
|
|
dattim.xab$l_nxt = fileblk.fab$l_xab;
|
|
fileblk.fab$l_xab = (void *) &dattim;
|
|
}
|
|
|
|
/* 2005-02-14 SMS. What does this mean? ----vvvvvvvvvvvvvvvvvvvvvvvvvvv */
|
|
fileblk.fab$w_ifi = 0; /* Clear IFI. It may be nonzero after ZIP */
|
|
fileblk.fab$b_fac = FAB$M_BRO | FAB$M_PUT; /* {block|record} output */
|
|
#ifdef SYMLINKS
|
|
if (G.symlnk)
|
|
/* Symlink file is read back to retrieve the link text. */
|
|
fileblk.fab$b_fac |= FAB$M_GET;
|
|
#endif
|
|
|
|
/* 2004-11-23 SMS.
|
|
* If RMS_DEFAULT values have been determined, and have not been
|
|
* set by the user, then set some FAB/RAB parameters for faster
|
|
* output. User-specified RMS_DEFAULT values override the
|
|
* built-in default values, so if the RMS_DEFAULT values could
|
|
* not be determined, then these (possibly unwise) values could
|
|
* not be overridden, and hence will not be set. Honestly,
|
|
* this seems to be excessively cautious, but only old VMS
|
|
* versions will be affected.
|
|
*/
|
|
|
|
/* If RMS_DEFAULT (and adjusted active) values are available,
|
|
* then set the FAB/RAB parameters. If RMS_DEFAULT values are
|
|
* not available, then suffer with the default behavior.
|
|
*/
|
|
if (rms_defaults_known > 0)
|
|
{
|
|
/* Set the FAB/RAB parameters accordingly. */
|
|
fileblk.fab$w_deq = rms_ext_active;
|
|
rab.rab$b_mbc = rms_mbc_active;
|
|
rab.rab$b_mbf = rms_mbf_active;
|
|
|
|
#ifdef OLD_FABDEF
|
|
|
|
/* Truncate at EOF on close, as we may over-extend. */
|
|
fileblk.fab$l_fop |= FAB$M_TEF ;
|
|
|
|
/* If using multiple buffers, enable write-behind. */
|
|
if (rms_mbf_active > 1)
|
|
{
|
|
rab.rab$l_rop |= RAB$M_WBH;
|
|
}
|
|
}
|
|
|
|
/* Set the initial file allocation according to the file
|
|
* size. Also set the "sequential access only" flag, as
|
|
* otherwise, on a file system with highwater marking
|
|
* enabled, allocating space for a large file may lock the
|
|
* disk for a long time (minutes).
|
|
*/
|
|
fileblk.fab$l_alq = (unsigned) (G.lrec.ucsize+ 511)/ 512;
|
|
fileblk.fab$l_fop |= FAB$M_SQO;
|
|
|
|
#else /* !OLD_FABDEF */
|
|
|
|
/* Truncate at EOF on close, as we may over-extend. */
|
|
fileblk.fab$v_tef = 1;
|
|
|
|
/* If using multiple buffers, enable write-behind. */
|
|
if (rms_mbf_active > 1)
|
|
{
|
|
rab.rab$v_wbh = 1;
|
|
}
|
|
}
|
|
|
|
/* Set the initial file allocation according to the file
|
|
* size. Also set the "sequential access only" flag, as
|
|
* otherwise, on a file system with highwater marking
|
|
* enabled, allocating space for a large file may lock the
|
|
* disk for a long time (minutes).
|
|
*/
|
|
fileblk.fab$l_alq = (unsigned) (G.lrec.ucsize+ 511)/ 512;
|
|
fileblk.fab$v_sqo = 1;
|
|
|
|
#endif /* ?OLD_FABDEF */
|
|
|
|
ierr = sys$create(outfab);
|
|
if (ierr == RMS$_FEX)
|
|
{
|
|
/* File exists.
|
|
* Consider command-line options, or ask the user what to do.
|
|
*/
|
|
ierr = replace(__G);
|
|
switch (ierr & REPL_TASKMASK)
|
|
{
|
|
case REPL_NO_EXTRACT: /* No extract. */
|
|
free_up();
|
|
return ((ierr & REPL_ERRLV_WARN)
|
|
? OPENOUT_SKIPWARN : OPENOUT_SKIPOK);
|
|
case REPL_NEW_VERSION: /* Create a new version. */
|
|
ierr = replace_rms_newversion(__G);
|
|
break;
|
|
case REPL_OVERWRITE: /* Overwrite the existing file. */
|
|
ierr = replace_rms_overwrite(__G);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ERR(ierr))
|
|
{
|
|
char buf[NAM_MAXRSS + 128]; /* Name length + message length. */
|
|
|
|
sprintf(buf, "[ Cannot create ($create) output file %s ]\n",
|
|
G.filename);
|
|
vms_msg(__G__ buf, ierr);
|
|
if (fileblk.fab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", fileblk.fab$l_stv);
|
|
}
|
|
free_up();
|
|
return OPENOUT_FAILED;
|
|
}
|
|
|
|
if (!text_output)
|
|
{
|
|
rab.rab$l_rop |= (RAB$M_BIO | RAB$M_ASY);
|
|
}
|
|
rab.rab$b_rac = RAB$C_SEQ;
|
|
|
|
if ((ierr = sys$connect(&rab)) != RMS$_NORMAL)
|
|
{
|
|
#ifdef DEBUG
|
|
vms_msg(__G__ "create_default_output: sys$connect failed.\n", ierr);
|
|
if (fileblk.fab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", fileblk.fab$l_stv);
|
|
}
|
|
#endif
|
|
Info(slide, 1, ((char *)slide,
|
|
"Cannot create ($connect) output file: %s\n",
|
|
FnFilter1(G.filename)));
|
|
free_up();
|
|
return OPENOUT_FAILED;
|
|
}
|
|
} /* end if (!uO.cflag) */
|
|
|
|
init_buf_ring();
|
|
|
|
_flush_routine = text_output ? got_eol=0,_flush_stream : _flush_blocks;
|
|
_close_routine = _close_rms;
|
|
return OPENOUT_OK;
|
|
}
|
|
|
|
|
|
|
|
/* The following return codes are supported:
|
|
* OPENOUT_OK a file has been opened normally
|
|
* OPENOUT_FAILED the file open process failed
|
|
* OPENOUT_SKIPOK file open skipped at user request, err level OK
|
|
* OPENOUT_SKIPWARN file open skipped at user request, err level WARN
|
|
*/
|
|
static int create_rms_output(__GPRO)
|
|
{
|
|
int ierr;
|
|
int text_output;
|
|
|
|
/* extract the file in text (variable-length) format, when
|
|
* piping to SYS$OUTPUT, unless "binary" piping was requested
|
|
* by the user (through the -b option); the "-a" option is
|
|
* ignored when extracting zip entries with VMS attributes saved
|
|
*/
|
|
text_output = uO.cflag &&
|
|
(!uO.bflag || (!(uO.bflag - 1) && G.pInfo->textfile));
|
|
|
|
rfm = outfab->fab$b_rfm; /* Use record format from VMS extra field */
|
|
|
|
if (uO.cflag) /* SYS$OUTPUT */
|
|
{
|
|
if (text_output && !PRINTABLE_FORMAT(rfm))
|
|
{
|
|
Info(slide, 1, ((char *)slide,
|
|
"[ File %s has illegal record format to put to screen ]\n",
|
|
FnFilter1(G.filename)));
|
|
free_up();
|
|
return OPENOUT_FAILED;
|
|
}
|
|
}
|
|
else /* File output */
|
|
{
|
|
rab = cc$rms_rab; /* Initialize RAB. */
|
|
|
|
/* The output FAB has already been initialized with the values
|
|
* found in the Zip file's "VMS attributes" extra field.
|
|
*/
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
nam = CC_RMS_NAM; /* Initialize NAML. */
|
|
outfab->FAB_NAM = &nam; /* Point FAB to NAML. */
|
|
|
|
outfab->fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
outfab->fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(*outfab, nam).FAB_OR_NAML_FNA = G.filename;
|
|
FAB_OR_NAML(*outfab, nam).FAB_OR_NAML_FNS = strlen(G.filename);
|
|
|
|
/* Prepare date-time XABs, unless user requests not to. */
|
|
if (uO.D_flag <= 1) {
|
|
/* If no XAB date/time, use attributes from non-VMS fields. */
|
|
if (!(xabdat && xabrdt))
|
|
{
|
|
set_default_datetime_XABs(__G);
|
|
|
|
if (xabdat == NULL)
|
|
{
|
|
dattim.xab$l_nxt = outfab->fab$l_xab;
|
|
outfab->fab$l_xab = (void *) &dattim;
|
|
}
|
|
}
|
|
}
|
|
/* 2005-02-14 SMS. What does this mean? ----vvvvvvvvvvvvvvvvvvvvvvvvvvv */
|
|
outfab->fab$w_ifi = 0; /* Clear IFI. It may be nonzero after ZIP */
|
|
outfab->fab$b_fac = FAB$M_BIO | FAB$M_PUT; /* block-mode output */
|
|
#ifdef SYMLINKS
|
|
/* 2007-02-28 SMS.
|
|
* VMS/RMS symlink properties will be restored naturally when
|
|
* the link file is recreated this way, so there's no need to do
|
|
* the deferred symlink post-processing step for this file.
|
|
* Therefore, clear the pInfo->symlink flag here, and the symlink
|
|
* "close file" processor will only display the link text.
|
|
*/
|
|
if (G.symlnk) {
|
|
G.pInfo->symlink = 0;
|
|
if (QCOND2) {
|
|
/* Symlink file is read back to display the link text. */
|
|
outfab->fab$b_fac |= FAB$M_GET;
|
|
}
|
|
}
|
|
#endif /* SYMLINKS */
|
|
|
|
/* 2004-11-23 SMS.
|
|
* Set the "sequential access only" flag, as otherwise, on a
|
|
* file system with highwater marking enabled, allocating space
|
|
* for a large file may lock the disk for a long time (minutes).
|
|
*/
|
|
#ifdef OLD_FABDEF
|
|
outfab-> fab$l_fop |= FAB$M_SQO;
|
|
#else /* !OLD_FABDEF */
|
|
outfab-> fab$v_sqo = 1;
|
|
#endif /* ?OLD_FABDEF */
|
|
|
|
ierr = sys$create(outfab);
|
|
if (ierr == RMS$_FEX)
|
|
{
|
|
/* File exists.
|
|
* Consider command-line options, or ask the user what to do.
|
|
*/
|
|
ierr = replace(__G);
|
|
switch (ierr & REPL_TASKMASK)
|
|
{
|
|
case REPL_NO_EXTRACT: /* No extract. */
|
|
free_up();
|
|
return ((ierr & REPL_ERRLV_WARN)
|
|
? OPENOUT_SKIPWARN : OPENOUT_SKIPOK);
|
|
case REPL_NEW_VERSION: /* Create a new version. */
|
|
ierr = replace_rms_newversion(__G);
|
|
break;
|
|
case REPL_OVERWRITE: /* Overwrite the existing file. */
|
|
ierr = replace_rms_overwrite(__G);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ERR(ierr))
|
|
{
|
|
char buf[NAM_MAXRSS + 128]; /* Name length + message length. */
|
|
|
|
sprintf(buf, "[ Cannot create ($create) output file %s ]\n",
|
|
G.filename);
|
|
vms_msg(__G__ buf, ierr);
|
|
if (outfab->fab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outfab->fab$l_stv);
|
|
}
|
|
free_up();
|
|
return OPENOUT_FAILED;
|
|
}
|
|
|
|
if (outfab->fab$b_org & (FAB$C_REL | FAB$C_IDX)) {
|
|
/* relative and indexed files require explicit allocation */
|
|
ierr = sys$extend(outfab);
|
|
if (ERR(ierr))
|
|
{
|
|
char buf[NAM_MAXRSS + 128]; /* Name length + msg length. */
|
|
|
|
sprintf(buf, "[ Cannot allocate space for %s ]\n", G.filename);
|
|
vms_msg(__G__ buf, ierr);
|
|
if (outfab->fab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outfab->fab$l_stv);
|
|
}
|
|
free_up();
|
|
return OPENOUT_FAILED;
|
|
}
|
|
}
|
|
|
|
outrab = &rab;
|
|
rab.rab$l_fab = outfab;
|
|
{
|
|
rab.rab$l_rop |= (RAB$M_BIO | RAB$M_ASY);
|
|
}
|
|
rab.rab$b_rac = RAB$C_SEQ;
|
|
|
|
if ((ierr = sys$connect(outrab)) != RMS$_NORMAL)
|
|
{
|
|
#ifdef DEBUG
|
|
vms_msg(__G__ "create_rms_output: sys$connect failed.\n", ierr);
|
|
if (outfab->fab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outfab->fab$l_stv);
|
|
}
|
|
#endif
|
|
Info(slide, 1, ((char *)slide,
|
|
"Cannot create ($connect) output file: %s\n",
|
|
FnFilter1(G.filename)));
|
|
free_up();
|
|
return OPENOUT_FAILED;
|
|
}
|
|
} /* end if (!uO.cflag) */
|
|
|
|
init_buf_ring();
|
|
|
|
if ( text_output )
|
|
switch (rfm)
|
|
{
|
|
case FAB$C_VAR:
|
|
_flush_routine = _flush_varlen;
|
|
break;
|
|
case FAB$C_STM:
|
|
case FAB$C_STMCR:
|
|
case FAB$C_STMLF:
|
|
_flush_routine = _flush_stream;
|
|
got_eol = 0;
|
|
break;
|
|
default:
|
|
_flush_routine = _flush_blocks;
|
|
break;
|
|
}
|
|
else
|
|
_flush_routine = _flush_blocks;
|
|
_close_routine = _close_rms;
|
|
return OPENOUT_OK;
|
|
}
|
|
|
|
|
|
|
|
static int pka_devchn;
|
|
static int pka_io_pending;
|
|
static unsigned pka_vbn;
|
|
|
|
/* IOSB for QIO[W] read and write operations. */
|
|
#if defined(__DECC) || defined(__DECCXX)
|
|
#pragma __member_alignment __save
|
|
#pragma __nomember_alignment
|
|
#endif /* __DECC || __DECCXX */
|
|
static struct
|
|
{
|
|
unsigned short status;
|
|
unsigned int count; /* Unaligned ! */
|
|
unsigned short dummy;
|
|
} pka_io_iosb;
|
|
#if defined(__DECC) || defined(__DECCXX)
|
|
#pragma __member_alignment __restore
|
|
#endif /* __DECC || __DECCXX */
|
|
|
|
/* IOSB for QIO[W] miscellaneous ACP operations. */
|
|
static struct
|
|
{
|
|
unsigned short status;
|
|
unsigned short dummy;
|
|
unsigned int count;
|
|
} pka_acp_iosb;
|
|
|
|
static struct fibdef pka_fib;
|
|
static struct atrdef pka_atr[VMS_MAX_ATRCNT];
|
|
static int pka_idx;
|
|
static ulg pka_uchar;
|
|
static struct fatdef pka_rattr;
|
|
|
|
/* Directory attribute storage, descriptor (list). */
|
|
static struct atrdef pka_recattr[2] =
|
|
{ { sizeof(pka_rattr), ATR$C_RECATTR, GVTC &pka_rattr}, /* RECATTR. */
|
|
{ 0, 0, 0 } /* List terminator. */
|
|
};
|
|
|
|
static struct dsc$descriptor pka_fibdsc =
|
|
{ sizeof(pka_fib), DSC$K_DTYPE_Z, DSC$K_CLASS_S, (void *) &pka_fib };
|
|
|
|
static struct dsc$descriptor_s pka_devdsc =
|
|
{ 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, &nam.NAM_DVI[1] };
|
|
|
|
static struct dsc$descriptor_s pka_fnam =
|
|
{ 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
|
|
|
|
/* Expanded and resultant name storage. */
|
|
static char exp_nam[NAM_MAXRSS];
|
|
static char res_nam[NAM_MAXRSS];
|
|
|
|
/* Special ODS5-QIO-compatible name storage. */
|
|
#ifdef NAML$C_MAXRSS
|
|
static char sys_nam[NAML$C_MAXRSS]; /* Probably need less here. */
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
#define PK_PRINTABLE_RECTYP(x) ( (x) == FAT$C_VARIABLE \
|
|
|| (x) == FAT$C_STREAMLF \
|
|
|| (x) == FAT$C_STREAMCR \
|
|
|| (x) == FAT$C_STREAM )
|
|
|
|
|
|
/* The following return codes are supported:
|
|
* OPENOUT_OK a file has been opened normally
|
|
* OPENOUT_FAILED the file open process failed
|
|
* OPENOUT_SKIPOK file open skipped at user request, err level OK
|
|
* OPENOUT_SKIPWARN file open skipped at user request, err level WARN
|
|
*/
|
|
static int create_qio_output(__GPRO)
|
|
{
|
|
int status;
|
|
int i;
|
|
int text_output;
|
|
|
|
/* extract the file in text (variable-length) format, when
|
|
* piping to SYS$OUTPUT, unless "binary" piping was requested
|
|
* by the user (through the -b option); the "-a" option is
|
|
* ignored when extracting zip entries with VMS attributes saved
|
|
*/
|
|
text_output = uO.cflag &&
|
|
(!uO.bflag || (!(uO.bflag - 1) && G.pInfo->textfile));
|
|
|
|
if ( uO.cflag )
|
|
{
|
|
int rtype;
|
|
|
|
if (text_output)
|
|
{
|
|
rtype = pka_rattr.fat$v_rtype;
|
|
if (!PK_PRINTABLE_RECTYP(rtype))
|
|
{
|
|
Info(slide, 1, ((char *)slide,
|
|
"[ File %s has illegal record format to put to screen ]\n",
|
|
FnFilter1(G.filename)));
|
|
return OPENOUT_FAILED;
|
|
}
|
|
}
|
|
else
|
|
/* force "block I/O" for binary piping mode */
|
|
rtype = FAT$C_UNDEFINED;
|
|
|
|
init_buf_ring();
|
|
|
|
switch (rtype)
|
|
{
|
|
case FAT$C_VARIABLE:
|
|
_flush_routine = _flush_varlen;
|
|
break;
|
|
case FAT$C_STREAM:
|
|
case FAT$C_STREAMCR:
|
|
case FAT$C_STREAMLF:
|
|
_flush_routine = _flush_stream;
|
|
got_eol = 0;
|
|
break;
|
|
default:
|
|
_flush_routine = _flush_blocks;
|
|
break;
|
|
}
|
|
_close_routine = _close_rms;
|
|
}
|
|
else /* !(uO.cflag) : redirect output */
|
|
{
|
|
fileblk = cc$rms_fab; /* Initialize FAB. */
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
fileblk.FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
fileblk.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fileblk.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
/* Special ODS5-QIO-compatible name storage. */
|
|
nam.naml$l_filesys_name = sys_nam;
|
|
nam.naml$l_filesys_name_alloc = sizeof(sys_nam);
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
/* VMS-format file name, derived from archive. */
|
|
FAB_OR_NAML(fileblk, nam).FAB_OR_NAML_FNA = G.filename;
|
|
FAB_OR_NAML(fileblk, nam).FAB_OR_NAML_FNS = strlen(G.filename);
|
|
|
|
/* Expanded and resultant name storage. */
|
|
nam.NAM_ESA = exp_nam;
|
|
nam.NAM_ESS = sizeof(exp_nam);
|
|
nam.NAM_RSA = res_nam;
|
|
nam.NAM_RSS = sizeof(res_nam);
|
|
|
|
if ( ERR(status = sys$parse(&fileblk)) )
|
|
{
|
|
vms_msg(__G__ "create_qio_output: sys$parse failed.\n", status);
|
|
return OPENOUT_FAILED;
|
|
}
|
|
|
|
pka_devdsc.dsc$w_length = (unsigned short)nam.NAM_DVI[0];
|
|
|
|
if ( ERR(status = sys$assign(&pka_devdsc, &pka_devchn, 0, 0)) )
|
|
{
|
|
vms_msg(__G__ "create_qio_output: sys$assign failed.\n", status);
|
|
return OPENOUT_FAILED;
|
|
}
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
/* Enable fancy name characters. Note that "fancy" here does
|
|
not include Unicode, for which there's no support elsewhere.
|
|
*/
|
|
pka_fib.fib$v_names_8bit = 1;
|
|
pka_fib.fib$b_name_format_in = FIB$C_ISL1;
|
|
|
|
/* ODS5 Extended names used as input to QIO have peculiar
|
|
encoding (perhaps to minimize storage?), so the special
|
|
filesys_name result (typically containing fewer carets) must
|
|
be used here.
|
|
*/
|
|
pka_fnam.dsc$a_pointer = nam.naml$l_filesys_name;
|
|
pka_fnam.dsc$w_length = nam.naml$l_filesys_name_size;
|
|
|
|
#else /* !NAML$C_MAXRSS */
|
|
|
|
/* Extract only the name.type;version.
|
|
2005-02-14 SMS.
|
|
Note: In old code, the version in the name here was retained
|
|
only if -V (uO.V_flag, so that there might be an explicit
|
|
version number in the archive (or perhaps not)), but the
|
|
version should already have been stripped before this in
|
|
adj_file_name_odsX(), and sys$parse() here should always
|
|
return a good version number which may be used as-is. If
|
|
not, here's where to fix the (new) problem. Note that the
|
|
ODS5-compatible code uses the whole thing in filesys_name,
|
|
too, and that's critical for proper interpretation of funny
|
|
names. (Omitting the ";" can cause trouble, so it should
|
|
certainly be kept, even if the version digits are removed
|
|
here.)
|
|
*/
|
|
|
|
pka_fnam.dsc$a_pointer = nam.NAM_L_NAME;
|
|
pka_fnam.dsc$w_length =
|
|
nam.NAM_B_NAME + nam.NAM_B_TYPE + nam.NAM_B_VER;
|
|
|
|
#if 0
|
|
pka_fnam.dsc$w_length = nam.NAM_B_NAME + nam.NAM_B_TYPE;
|
|
if ( uO.V_flag /* keep versions */ )
|
|
pka_fnam.dsc$w_length += nam.NAM_B_VER;
|
|
#endif /* 0 */
|
|
|
|
#endif /* ?NAML$C_MAXRSS */
|
|
|
|
/* Move the directory ID from the NAM[L] to the FIB.
|
|
Clear the FID in the FIB, as we're using the name.
|
|
*/
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
pka_fib.FIB$W_DID[i] = nam.NAM_DID[i];
|
|
pka_fib.FIB$W_FID[i] = 0;
|
|
}
|
|
|
|
/* 2004-11-23 SMS.
|
|
* Set the "sequential access only" flag, as otherwise, on a
|
|
* file system with highwater marking enabled, allocating space
|
|
* for a large file may lock the disk for a long time (minutes).
|
|
* (The "no other readers" flag is also required, if you want
|
|
* the "sequential access only" flag to have any effect.)
|
|
*/
|
|
pka_fib.FIB$L_ACCTL = FIB$M_WRITE | FIB$M_SEQONLY | FIB$M_NOREAD;
|
|
|
|
/* Allocate space for the file */
|
|
pka_fib.FIB$W_EXCTL = FIB$M_EXTEND;
|
|
if ( pka_uchar & FCH$M_CONTIG )
|
|
pka_fib.FIB$W_EXCTL |= FIB$M_ALCON | FIB$M_FILCON;
|
|
if ( pka_uchar & FCH$M_CONTIGB )
|
|
pka_fib.FIB$W_EXCTL |= FIB$M_ALCONB;
|
|
|
|
#define SWAPW(x) ( (((x)>>16)&0xFFFF) + ((x)<<16) )
|
|
|
|
pka_fib.fib$l_exsz = SWAPW(pka_rattr.fat$l_hiblk);
|
|
|
|
status = sys$qiow(0, /* event flag */
|
|
pka_devchn, /* channel */
|
|
IO$_CREATE|IO$M_CREATE|IO$M_ACCESS, /* funct */
|
|
&pka_acp_iosb, /* IOSB */
|
|
0, /* AST address */
|
|
0, /* AST parameter */
|
|
&pka_fibdsc, /* P1 = File Info Block */
|
|
&pka_fnam, /* P2 = File name (descr) */
|
|
0, /* P3 (= Resulting name len) */
|
|
0, /* P4 (= Resulting name descr) */
|
|
pka_atr, /* P5 = Attribute descr */
|
|
0); /* P6 (not used) */
|
|
|
|
if ( !ERR(status) )
|
|
status = pka_acp_iosb.status;
|
|
|
|
if ( status == SS$_DUPFILENAME )
|
|
{
|
|
/* File exists. Prepare to ask user what to do. */
|
|
|
|
/* Arrange to store the resultant file spec (with new
|
|
* version?) where the message code will find it.
|
|
*/
|
|
short res_nam_len;
|
|
struct dsc$descriptor_s res_nam_dscr =
|
|
{ 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
|
|
|
|
res_nam_dscr.dsc$a_pointer = G.filename;
|
|
res_nam_dscr.dsc$w_length = sizeof(G.filename);
|
|
|
|
/* File exists.
|
|
* Consider command-line options, or ask the user what to do.
|
|
*/
|
|
status = replace(__G);
|
|
switch (status & REPL_TASKMASK)
|
|
{
|
|
case REPL_NO_EXTRACT: /* No extract. */
|
|
free_up();
|
|
return ((status & REPL_ERRLV_WARN)
|
|
? OPENOUT_SKIPWARN : OPENOUT_SKIPOK);
|
|
case REPL_NEW_VERSION: /* Create a new version. */
|
|
pka_fib.FIB$W_NMCTL |= FIB$M_NEWVER;
|
|
break;
|
|
case REPL_OVERWRITE: /* Overwrite the existing file. */
|
|
pka_fib.FIB$W_NMCTL |= FIB$M_SUPERSEDE;
|
|
break;
|
|
}
|
|
|
|
/* Retry file creation with new (user-specified) policy. */
|
|
status = sys$qiow(0, /* event flag */
|
|
pka_devchn, /* channel */
|
|
IO$_CREATE|IO$M_CREATE|IO$M_ACCESS, /* funct */
|
|
&pka_acp_iosb, /* IOSB */
|
|
0, /* AST address */
|
|
0, /* AST parameter */
|
|
&pka_fibdsc, /* P1 = File Info Block */
|
|
&pka_fnam, /* P2 = File name (descr) */
|
|
&res_nam_len, /* P3 = Resulting name len */
|
|
&res_nam_dscr, /* P4 = Resulting name descr */
|
|
pka_atr, /* P5 = Attribute descr */
|
|
0); /* P6 (not used) */
|
|
|
|
if ( !ERR(status) )
|
|
status = pka_acp_iosb.status;
|
|
|
|
if (res_nam_len > 0)
|
|
{
|
|
/* NUL-terminate the resulting file spec. */
|
|
G.filename[res_nam_len] = '\0';
|
|
}
|
|
|
|
/* Clear any user-specified version policy flags
|
|
* (for the next file to be processed).
|
|
*/
|
|
pka_fib.FIB$W_NMCTL &= (~(FIB$M_NEWVER| FIB$M_SUPERSEDE));
|
|
}
|
|
|
|
if ( ERR(status) )
|
|
{
|
|
char buf[NAM_MAXRSS + 128]; /* Name length + message length. */
|
|
|
|
sprintf(buf, "[ Cannot create (QIO) output file %s ]\n",
|
|
G.filename);
|
|
vms_msg(__G__ buf, status);
|
|
sys$dassgn(pka_devchn);
|
|
return OPENOUT_FAILED;
|
|
}
|
|
|
|
#ifdef ASYNCH_QIO
|
|
init_buf_ring();
|
|
pka_io_pending = FALSE;
|
|
#else
|
|
locptr = locbuf;
|
|
loccnt = 0;
|
|
#endif
|
|
pka_vbn = 1;
|
|
_flush_routine = _flush_qio;
|
|
_close_routine = _close_qio;
|
|
} /* end if (!uO.cflag) */
|
|
return OPENOUT_OK;
|
|
}
|
|
|
|
|
|
/* 2008-07-23 SMS.
|
|
* Segregated user query function from file re-open functions/code.
|
|
*
|
|
* There was no code in create_qio_output() to deal with an
|
|
* SS$_DUPFILENAME condition, leading to ugly run-time failures, and its
|
|
* requirements differ from those of the RMS (non-QIO) functions,
|
|
* create_default_output() and create_rms_output().
|
|
*
|
|
* Whether it makes sense to have a second layer of VMS-specific
|
|
* querying after the generic UnZip query in extract.c:
|
|
* extract_or_test_entrylist() is another question, but changing that
|
|
* looks more scary than just getting the VMS-specific stuff to work
|
|
* right (better?).
|
|
*/
|
|
|
|
/* "File exists" handler(s). Ask user about further action. */
|
|
|
|
/* RMS create new version. */
|
|
static int replace_rms_newversion(__GPRO)
|
|
{
|
|
int ierr;
|
|
struct NAM_STRUCT nam;
|
|
|
|
nam = CC_RMS_NAM; /* Initialize local NAM[L] block. */
|
|
outfab->FAB_NAM = &nam; /* Point FAB to local NAM[L]. */
|
|
|
|
/* Arrange to store the resultant file spec (with new version), so
|
|
* that we can extract the actual file version from it, for later
|
|
* use in the "extracting:/inflating:/..." message (G.filename).
|
|
*/
|
|
nam.NAM_RSA = res_nam;
|
|
nam.NAM_RSS = sizeof(res_nam);
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
outfab->fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
outfab->fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(*outfab, nam).FAB_OR_NAML_FNA = G.filename;
|
|
FAB_OR_NAML(*outfab, nam).FAB_OR_NAML_FNS = strlen(G.filename);
|
|
|
|
/* Maximize version number. */
|
|
outfab->fab$l_fop |= FAB$M_MXV;
|
|
|
|
/* Create the new-version file. */
|
|
ierr = sys$create(outfab);
|
|
|
|
if (nam.NAM_RSL > 0)
|
|
{
|
|
/* File spec version pointers.
|
|
* Versions must exist, so a simple right-to-left search for ";"
|
|
* should work, even on ODS5 extended file specs.
|
|
*/
|
|
char *semi_col_orig;
|
|
char *semi_col_res;
|
|
|
|
/* NUL-terminate the (complete) resultant file spec. */
|
|
res_nam[nam.NAM_RSL] = '\0';
|
|
|
|
/* Find the versions (";") in the original and resultant file specs. */
|
|
semi_col_orig = strrchr(G.filename, ';');
|
|
semi_col_res = strrchr(res_nam, ';');
|
|
|
|
if ((semi_col_orig != NULL) && (semi_col_res != NULL))
|
|
{
|
|
/* Transfer the resultant version to the original file spec. */
|
|
strcpy((semi_col_orig + 1), (semi_col_res + 1));
|
|
}
|
|
}
|
|
return ierr;
|
|
}
|
|
|
|
|
|
/* RMS overwrite original version. */
|
|
static int replace_rms_overwrite(__GPRO)
|
|
{
|
|
/* Supersede existing file. */
|
|
outfab->fab$l_fop |= FAB$M_SUP;
|
|
/* Create (overwrite) the original-version file. */
|
|
return sys$create(outfab);
|
|
}
|
|
|
|
|
|
/* Main query function to ask user how to handle an existing file
|
|
* (unless command-line options already specify what to do).
|
|
*/
|
|
static int replace(__GPRO)
|
|
{
|
|
char answ[10];
|
|
int replace_code;
|
|
|
|
if (replace_code_all >= 0)
|
|
{
|
|
/* Use the previous all-file response. */
|
|
replace_code = replace_code_all;
|
|
}
|
|
else if (uO.overwrite_none)
|
|
{
|
|
/* "-n". Do not extract this (or any) file. */
|
|
replace_code = replace_code_all = REPL_NO_EXTRACT;
|
|
}
|
|
else if (uO.overwrite_all == 1)
|
|
{
|
|
/* "-o". Create a new version of this (or any) file. */
|
|
replace_code = replace_code_all = REPL_NEW_VERSION;
|
|
}
|
|
else if (uO.overwrite_all > 1)
|
|
{
|
|
/* "-oo". Overwrite (supersede) this (or any) existing file. */
|
|
replace_code = replace_code_all = REPL_OVERWRITE;
|
|
}
|
|
else
|
|
{
|
|
replace_code = -1;
|
|
do
|
|
{
|
|
/* Request, accept, and decode a response. */
|
|
Info(slide, 0x81, ((char *)slide,
|
|
"%s exists: new [v]ersion, [o]verwrite, or [n]o extract?\n\
|
|
(Uppercase response [V,O,N] => Do same for all files): ",
|
|
FnFilter1(G.filename)));
|
|
fflush(stderr);
|
|
|
|
if (fgets(answ, sizeof(answ), stdin) == (char *)NULL)
|
|
{
|
|
Info(slide, 1, ((char *)slide, AssumeNo));
|
|
/* Handle the NULL answer as "N",
|
|
* do not extract any existing files. */
|
|
replace_code_all = REPL_NO_EXTRACT;
|
|
/* Set a warning indicator. */
|
|
replace_code = REPL_NO_EXTRACT | REPL_ERRLV_WARN;
|
|
/* We are finished, break out of the query loop. */
|
|
break;
|
|
}
|
|
|
|
/* Strip off a trailing newline, to avoid corrupt
|
|
* complaints when displaying the answer.
|
|
*/
|
|
if (answ[strlen(answ) - 1] == '\n')
|
|
answ[strlen(answ) - 1] = '\0';
|
|
|
|
/* Extra newline to avoid having the extracting:/inflating:/...:
|
|
* message overwritten by the next query.
|
|
*/
|
|
Info(slide, 1, ((char *)slide, "\n"));
|
|
|
|
/* Interpret response. Store upper-case answer for future use. */
|
|
switch (answ[0])
|
|
{
|
|
case 'N':
|
|
replace_code_all = REPL_NO_EXTRACT;
|
|
case 'n':
|
|
/* Do not extract this file. */
|
|
replace_code = REPL_NO_EXTRACT;
|
|
break;
|
|
case 'O':
|
|
replace_code_all = REPL_OVERWRITE;
|
|
case 'o':
|
|
/* Overwrite (supersede) this existing file. */
|
|
replace_code = REPL_OVERWRITE;
|
|
break;
|
|
case 'V':
|
|
replace_code_all = REPL_NEW_VERSION;
|
|
case 'v':
|
|
/* Create a new version of this file. */
|
|
replace_code = REPL_NEW_VERSION;
|
|
break;
|
|
default:
|
|
/* Invalid response. Try again. */
|
|
Info(slide, 1, ((char *)slide, InvalidResponse, answ));
|
|
}
|
|
} while (replace_code < 0);
|
|
}
|
|
return replace_code;
|
|
}
|
|
|
|
|
|
|
|
#define W(p) (*(unsigned short*)(p))
|
|
#define L(p) (*(unsigned long*)(p))
|
|
#define EQL_L(a, b) ( L(a) == L(b) )
|
|
#define EQL_W(a, b) ( W(a) == W(b) )
|
|
|
|
/*
|
|
* Function find_vms_attrs() scans the ZIP entry extra field, if any,
|
|
* and looks for VMS attribute records. Various date-time attributes
|
|
* are ignored if set_date_time is FALSE (typically for a directory).
|
|
*
|
|
* For a set of IZ records, a FAB and various XABs are created and
|
|
* chained together.
|
|
*
|
|
* For a PK record, the pka_atr[] attribute descriptor array is
|
|
* populated.
|
|
*
|
|
* The return value is a VAT_* value, according to the type of extra
|
|
* field attribute data found.
|
|
*/
|
|
static int find_vms_attrs(__GPRO__ int set_date_time)
|
|
{
|
|
uch *scan = G.extra_field;
|
|
struct EB_header *hdr;
|
|
int len;
|
|
int type=VAT_NONE;
|
|
|
|
outfab = NULL;
|
|
xabfhc = NULL;
|
|
xabdat = NULL;
|
|
xabrdt = NULL;
|
|
xabpro = NULL;
|
|
first_xab = last_xab = NULL;
|
|
|
|
if (scan == NULL)
|
|
return VAT_NONE;
|
|
len = G.lrec.extra_field_length;
|
|
|
|
#define LINK(p) {/* Link xaballs and xabkeys into chain */ \
|
|
if ( first_xab == NULL ) \
|
|
first_xab = (void *) p; \
|
|
if ( last_xab != NULL ) \
|
|
last_xab->xab$l_nxt = (void *) p; \
|
|
last_xab = (void *) p; \
|
|
p->xab$l_nxt = NULL; \
|
|
}
|
|
/* End of macro LINK */
|
|
|
|
while (len > 0)
|
|
{
|
|
hdr = (struct EB_header *)scan;
|
|
if (EQL_W(&hdr->tag, IZ_SIGNATURE))
|
|
{
|
|
/*
|
|
* Info-ZIP-style extra block decoding.
|
|
*/
|
|
uch *blk;
|
|
unsigned siz;
|
|
uch *block_id;
|
|
|
|
type = VAT_IZ;
|
|
|
|
siz = hdr->size;
|
|
blk = (uch *)(&hdr->data[0]);
|
|
block_id = (uch *)(&((struct IZ_block *)hdr)->bid);
|
|
|
|
if (EQL_L(block_id, FABSIG)) {
|
|
outfab = (struct FAB *)extract_izvms_block(__G__ blk,
|
|
siz, NULL, (uch *)&cc$rms_fab, FABL);
|
|
} else if (EQL_L(block_id, XALLSIG)) {
|
|
xaball = (struct XABALL *)extract_izvms_block(__G__ blk,
|
|
siz, NULL, (uch *)&cc$rms_xaball, XALLL);
|
|
LINK(xaball);
|
|
} else if (EQL_L(block_id, XKEYSIG)) {
|
|
xabkey = (struct XABKEY *)extract_izvms_block(__G__ blk,
|
|
siz, NULL, (uch *)&cc$rms_xabkey, XKEYL);
|
|
LINK(xabkey);
|
|
} else if (EQL_L(block_id, XFHCSIG)) {
|
|
xabfhc = (struct XABFHC *) extract_izvms_block(__G__ blk,
|
|
siz, NULL, (uch *)&cc$rms_xabfhc, XFHCL);
|
|
} else if (EQL_L(block_id, XDATSIG)) {
|
|
if (set_date_time) {
|
|
xabdat = (struct XABDAT *) extract_izvms_block(__G__ blk,
|
|
siz, NULL, (uch *)&cc$rms_xabdat, XDATL);
|
|
}
|
|
} else if (EQL_L(block_id, XRDTSIG)) {
|
|
if (set_date_time) {
|
|
xabrdt = (struct XABRDT *) extract_izvms_block(__G__ blk,
|
|
siz, NULL, (uch *)&cc$rms_xabrdt, XRDTL);
|
|
}
|
|
} else if (EQL_L(block_id, XPROSIG)) {
|
|
xabpro = (struct XABPRO *) extract_izvms_block(__G__ blk,
|
|
siz, NULL, (uch *)&cc$rms_xabpro, XPROL);
|
|
} else if (EQL_L(block_id, VERSIG)) {
|
|
#ifdef CHECK_VERSIONS
|
|
char verbuf[80];
|
|
unsigned verlen = 0;
|
|
uch *vers;
|
|
char *m;
|
|
|
|
get_vms_version(verbuf, sizeof(verbuf));
|
|
vers = extract_izvms_block(__G__ blk, siz,
|
|
&verlen, NULL, 0);
|
|
if ((m = strrchr((char *) vers, '-')) != NULL)
|
|
*m = '\0'; /* Cut out release number */
|
|
if (strcmp(verbuf, (char *) vers) && uO.qflag < 2)
|
|
{
|
|
Info(slide, 0, ((char *)slide,
|
|
"[ Warning: VMS version mismatch."));
|
|
|
|
Info(slide, 0, ((char *)slide,
|
|
" This version %s --", verbuf));
|
|
strncpy(verbuf, (char *) vers, verlen);
|
|
verbuf[verlen] = '\0';
|
|
Info(slide, 0, ((char *)slide,
|
|
" version made by %s ]\n", verbuf));
|
|
}
|
|
free(vers);
|
|
#endif /* CHECK_VERSIONS */
|
|
} else {
|
|
Info(slide, 1, ((char *)slide,
|
|
"[ Warning: Unknown block signature %s ]\n",
|
|
block_id));
|
|
}
|
|
}
|
|
else if (hdr->tag == PK_SIGNATURE)
|
|
{
|
|
/*
|
|
* PKWARE-style extra block decoding.
|
|
*/
|
|
struct PK_header *blk;
|
|
register byte *scn;
|
|
register int len;
|
|
|
|
type = VAT_PK;
|
|
|
|
blk = (struct PK_header *)hdr;
|
|
len = blk->size - (PK_HEADER_SIZE - EB_HEADSIZE);
|
|
scn = (byte *)(&blk->data);
|
|
pka_idx = 0;
|
|
|
|
if (blk->crc32 != crc32(CRCVAL_INITIAL, scn, (extent)len))
|
|
{
|
|
Info(slide, 1, ((char *)slide,
|
|
"[ Warning: CRC error, discarding PKWARE extra field ]\n"));
|
|
len = 0;
|
|
type = VAT_NONE;
|
|
}
|
|
|
|
while (len > PK_FLDHDR_SIZE)
|
|
{
|
|
register struct PK_field *fld;
|
|
int skip=0;
|
|
|
|
fld = (struct PK_field *)scn;
|
|
switch(fld->tag)
|
|
{
|
|
case ATR$C_UCHAR:
|
|
pka_uchar = L(&fld->value);
|
|
break;
|
|
case ATR$C_RECATTR:
|
|
pka_rattr = *(struct fatdef *)(&fld->value);
|
|
break;
|
|
case ATR$C_UIC:
|
|
case ATR$C_ADDACLENT:
|
|
skip = !uO.X_flag;
|
|
break;
|
|
case ATR$C_CREDATE:
|
|
case ATR$C_REVDATE:
|
|
case ATR$C_EXPDATE:
|
|
case ATR$C_BAKDATE:
|
|
case ATR$C_ASCDATES:
|
|
skip = (set_date_time == FALSE);
|
|
break;
|
|
}
|
|
|
|
if ( !skip )
|
|
{
|
|
pka_atr[pka_idx].atr$w_size = fld->size;
|
|
pka_atr[pka_idx].atr$w_type = fld->tag;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &fld->value;
|
|
++pka_idx;
|
|
}
|
|
len -= fld->size + PK_FLDHDR_SIZE;
|
|
scn += fld->size + PK_FLDHDR_SIZE;
|
|
}
|
|
pka_atr[pka_idx].atr$w_size = 0; /* End of list */
|
|
pka_atr[pka_idx].atr$w_type = 0;
|
|
pka_atr[pka_idx].atr$l_addr = 0; /* NULL when DECC VAX gets fixed */
|
|
}
|
|
len -= hdr->size + EB_HEADSIZE;
|
|
scan += hdr->size + EB_HEADSIZE;
|
|
}
|
|
|
|
if ( type == VAT_IZ )
|
|
{
|
|
if (outfab != NULL)
|
|
{
|
|
/* Do not link XABPRO or XABRDT now.
|
|
* Leave them for sys$close() resp. set_direc_attribs().
|
|
*/
|
|
outfab->fab$l_xab = NULL;
|
|
if (xabfhc != NULL)
|
|
{
|
|
xabfhc->xab$l_nxt = outfab->fab$l_xab;
|
|
outfab->fab$l_xab = (void *) xabfhc;
|
|
}
|
|
if (xabdat != NULL)
|
|
{
|
|
xabdat->xab$l_nxt = outfab->fab$l_xab;
|
|
outfab->fab$l_xab = (void *) xabdat;
|
|
}
|
|
if (first_xab != NULL) /* Link xaball,xabkey subchain */
|
|
{
|
|
last_xab->xab$l_nxt = outfab->fab$l_xab;
|
|
outfab->fab$l_xab = (void *) first_xab;
|
|
}
|
|
}
|
|
else
|
|
type = VAT_NONE;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
|
|
|
|
static void free_up()
|
|
{
|
|
/*
|
|
* Free up all allocated XABs.
|
|
*/
|
|
if (xabdat != NULL) free(xabdat);
|
|
if (xabpro != NULL) free(xabpro);
|
|
if (xabrdt != NULL) free(xabrdt);
|
|
if (xabfhc != NULL) free(xabfhc);
|
|
while (first_xab != NULL)
|
|
{
|
|
struct XAB *x;
|
|
|
|
x = (struct XAB *) first_xab->xab$l_nxt;
|
|
free(first_xab);
|
|
first_xab = x;
|
|
}
|
|
/* Free FAB storage, if not the static one. */
|
|
if (outfab != NULL && outfab != &fileblk)
|
|
free(outfab);
|
|
}
|
|
|
|
|
|
|
|
#ifdef CHECK_VERSIONS
|
|
|
|
static int get_vms_version(verbuf, len)
|
|
char *verbuf;
|
|
int len;
|
|
{
|
|
int i = SYI$_VERSION;
|
|
int verlen = 0;
|
|
struct dsc$descriptor version;
|
|
char *m;
|
|
|
|
version.dsc$a_pointer = verbuf;
|
|
version.dsc$w_length = len - 1;
|
|
version.dsc$b_dtype = DSC$K_DTYPE_B;
|
|
version.dsc$b_class = DSC$K_CLASS_S;
|
|
|
|
if (ERR(lib$getsyi(&i, 0, &version, &verlen, 0, 0)) || verlen == 0)
|
|
return 0;
|
|
|
|
/* Cut out trailing spaces "V5.4-3 " -> "V5.4-3" */
|
|
for (m = verbuf + verlen, i = verlen - 1; i > 0 && verbuf[i] == ' '; --i)
|
|
--m;
|
|
*m = '\0';
|
|
|
|
/* Cut out release number "V5.4-3" -> "V5.4" */
|
|
if ((m = strrchr(verbuf, '-')) != NULL)
|
|
*m = '\0';
|
|
return strlen(verbuf) + 1; /* Transmit ending '\0' too */
|
|
}
|
|
|
|
#endif /* CHECK_VERSIONS */
|
|
|
|
|
|
|
|
/* flush contents of output buffer */
|
|
int flush(__G__ rawbuf, size, unshrink) /* return PK-type error code */
|
|
__GDEF
|
|
uch *rawbuf;
|
|
ulg size;
|
|
int unshrink;
|
|
{
|
|
G.crc32val = crc32(G.crc32val, rawbuf, (extent)size);
|
|
if (uO.tflag)
|
|
return PK_COOL; /* Do not output. Update CRC only */
|
|
else
|
|
return (*_flush_routine)(__G__ rawbuf, size, 0);
|
|
}
|
|
|
|
|
|
|
|
static int _flush_blocks(__G__ rawbuf, size, final_flag)
|
|
/* Asynchronous version */
|
|
__GDEF
|
|
uch *rawbuf;
|
|
unsigned size;
|
|
int final_flag; /* 1 if this is the final flushout */
|
|
{
|
|
int status;
|
|
unsigned off = 0;
|
|
|
|
while (size > 0)
|
|
{
|
|
if (curbuf->bufcnt < BUFS512)
|
|
{
|
|
unsigned ncpy;
|
|
|
|
ncpy = size > (BUFS512 - curbuf->bufcnt) ?
|
|
(BUFS512 - curbuf->bufcnt) : size;
|
|
memcpy(curbuf->buf + curbuf->bufcnt, rawbuf + off, ncpy);
|
|
size -= ncpy;
|
|
curbuf->bufcnt += ncpy;
|
|
off += ncpy;
|
|
}
|
|
if (curbuf->bufcnt == BUFS512)
|
|
{
|
|
status = WriteBuffer(__G__ curbuf->buf, curbuf->bufcnt);
|
|
if (status)
|
|
return status;
|
|
curbuf = curbuf->next;
|
|
curbuf->bufcnt = 0;
|
|
}
|
|
}
|
|
|
|
return (final_flag && (curbuf->bufcnt > 0)) ?
|
|
WriteBuffer(__G__ curbuf->buf, curbuf->bufcnt) :
|
|
PK_COOL;
|
|
}
|
|
|
|
|
|
|
|
#ifdef ASYNCH_QIO
|
|
static int WriteQIO(__G__ buf, len)
|
|
__GDEF
|
|
uch *buf;
|
|
unsigned len;
|
|
{
|
|
int status;
|
|
|
|
if (pka_io_pending) {
|
|
status = sys$synch(0, &pka_io_iosb);
|
|
if (!ERR(status))
|
|
status = pka_io_iosb.status;
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ WriteQIO: sys$synch found I/O failure ]\n",
|
|
status);
|
|
return PK_DISK;
|
|
}
|
|
pka_io_pending = FALSE;
|
|
}
|
|
/*
|
|
* Put content of buffer as a single VB
|
|
*/
|
|
status = sys$qio(0, pka_devchn, IO$_WRITEVBLK,
|
|
&pka_io_iosb, 0, 0,
|
|
buf, len, pka_vbn,
|
|
0, 0, 0);
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ WriteQIO: sys$qio failed ]\n", status);
|
|
return PK_DISK;
|
|
}
|
|
pka_io_pending = TRUE;
|
|
pka_vbn += (len>>9);
|
|
|
|
return PK_COOL;
|
|
}
|
|
|
|
/*
|
|
2004-10-01 SMS. Changed to clear the extra byte written out by qio()
|
|
and sys$write() when an odd byte count is incremented to the next
|
|
even value, either explicitly (qio), or implicitly (sys$write), on
|
|
the theory that a reliable NUL beats left-over garbage. Alpha and
|
|
VAX object files seem frequently to have even more than one byte of
|
|
extra junk past EOF, so this may not help them.
|
|
*/
|
|
|
|
static int _flush_qio(__G__ rawbuf, size, final_flag)
|
|
/* Asynchronous version */
|
|
__GDEF
|
|
uch *rawbuf;
|
|
unsigned size;
|
|
int final_flag; /* 1 if this is the final flushout */
|
|
{
|
|
int status;
|
|
unsigned off = 0;
|
|
|
|
while (size > 0)
|
|
{
|
|
if (curbuf->bufcnt < BUFS512)
|
|
{
|
|
unsigned ncpy;
|
|
|
|
ncpy = size > (BUFS512 - curbuf->bufcnt) ?
|
|
(BUFS512 - curbuf->bufcnt) : size;
|
|
memcpy(curbuf->buf + curbuf->bufcnt, rawbuf + off, ncpy);
|
|
size -= ncpy;
|
|
curbuf->bufcnt += ncpy;
|
|
off += ncpy;
|
|
}
|
|
if (curbuf->bufcnt == BUFS512)
|
|
{
|
|
status = WriteQIO(__G__ curbuf->buf, curbuf->bufcnt);
|
|
if (status)
|
|
return status;
|
|
curbuf = curbuf->next;
|
|
curbuf->bufcnt = 0;
|
|
}
|
|
}
|
|
|
|
if (final_flag && (curbuf->bufcnt > 0))
|
|
{
|
|
unsigned bufcnt_even;
|
|
|
|
/* Round up to an even byte count. */
|
|
bufcnt_even = (curbuf->bufcnt+1) & (~1);
|
|
/* If there is one, clear the extra byte. */
|
|
if (bufcnt_even > curbuf->bufcnt)
|
|
curbuf->buf[curbuf->bufcnt] = '\0';
|
|
|
|
return WriteQIO(curbuf->buf, bufcnt_even);
|
|
}
|
|
else
|
|
{
|
|
return PK_COOL;
|
|
}
|
|
}
|
|
|
|
#else /* !ASYNCH_QIO */
|
|
|
|
static int _flush_qio(__G__ rawbuf, size, final_flag)
|
|
__GDEF
|
|
uch *rawbuf;
|
|
unsigned size;
|
|
int final_flag; /* 1 if this is the final flushout */
|
|
{
|
|
int status;
|
|
uch *out_ptr=rawbuf;
|
|
|
|
if ( final_flag )
|
|
{
|
|
if ( loccnt > 0 )
|
|
{
|
|
unsigned loccnt_even;
|
|
|
|
/* Round up to an even byte count. */
|
|
loccnt_even = (loccnt+1) & (~1);
|
|
/* If there is one, clear the extra byte. */
|
|
if (loccnt_even > loccnt)
|
|
locbuf[loccnt] = '\0';
|
|
|
|
status = sys$qiow(0, pka_devchn, IO$_WRITEVBLK,
|
|
&pka_io_iosb, 0, 0,
|
|
locbuf,
|
|
loccnt_even,
|
|
pka_vbn,
|
|
0, 0, 0);
|
|
if (!ERR(status))
|
|
status = pka_io_iosb.status;
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ Write QIO failed ]\n", status);
|
|
return PK_DISK;
|
|
}
|
|
}
|
|
return PK_COOL;
|
|
}
|
|
|
|
if ( loccnt > 0 )
|
|
{
|
|
/*
|
|
* Fill local buffer upto 512 bytes then put it out
|
|
*/
|
|
unsigned ncpy;
|
|
|
|
ncpy = 512-loccnt;
|
|
if ( ncpy > size )
|
|
ncpy = size;
|
|
|
|
memcpy(locptr, out_ptr, ncpy);
|
|
locptr += ncpy;
|
|
loccnt += ncpy;
|
|
size -= ncpy;
|
|
out_ptr += ncpy;
|
|
if ( loccnt == 512 )
|
|
{
|
|
status = sys$qiow(0, pka_devchn, IO$_WRITEVBLK,
|
|
&pka_io_iosb, 0, 0,
|
|
locbuf, loccnt, pka_vbn,
|
|
0, 0, 0);
|
|
if (!ERR(status))
|
|
status = pka_io_iosb.status;
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ Write QIO failed ]\n", status);
|
|
return PK_DISK;
|
|
}
|
|
|
|
pka_vbn++;
|
|
loccnt = 0;
|
|
locptr = locbuf;
|
|
}
|
|
}
|
|
|
|
if ( size >= 512 )
|
|
{
|
|
unsigned nblk, put_cnt;
|
|
|
|
/*
|
|
* Put rest of buffer as a single VB
|
|
*/
|
|
put_cnt = (nblk = size>>9)<<9;
|
|
status = sys$qiow(0, pka_devchn, IO$_WRITEVBLK,
|
|
&pka_io_iosb, 0, 0,
|
|
out_ptr, put_cnt, pka_vbn,
|
|
0, 0, 0);
|
|
if (!ERR(status))
|
|
status = pka_io_iosb.status;
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ Write QIO failed ]\n", status);
|
|
return PK_DISK;
|
|
}
|
|
|
|
pka_vbn += nblk;
|
|
out_ptr += put_cnt;
|
|
size -= put_cnt;
|
|
}
|
|
|
|
if ( size > 0 )
|
|
{
|
|
memcpy(locptr, out_ptr, size);
|
|
loccnt += size;
|
|
locptr += size;
|
|
}
|
|
|
|
return PK_COOL;
|
|
}
|
|
#endif /* ?ASYNCH_QIO */
|
|
|
|
|
|
|
|
/*
|
|
* The routine _flush_varlen() requires: "(size & 1) == 0"
|
|
* (The variable-length record algorithm assumes an even byte-count!)
|
|
*/
|
|
static int _flush_varlen(__G__ rawbuf, size, final_flag)
|
|
__GDEF
|
|
uch *rawbuf;
|
|
unsigned size;
|
|
int final_flag;
|
|
{
|
|
unsigned nneed;
|
|
unsigned reclen;
|
|
uch *inptr=rawbuf;
|
|
|
|
/*
|
|
* Flush local buffer
|
|
*/
|
|
|
|
if ( loccnt > 0 ) /* incomplete record left from previous call */
|
|
{
|
|
reclen = *(ush*)locbuf;
|
|
nneed = reclen + 2 - loccnt;
|
|
if ( nneed > size )
|
|
{
|
|
if ( size+loccnt > BUFSMAXREC )
|
|
{
|
|
char buf[80];
|
|
Info(buf, 1, (buf,
|
|
"[ Record too long (%u bytes) ]\n", reclen));
|
|
return PK_DISK;
|
|
}
|
|
memcpy(locbuf+loccnt, inptr, size);
|
|
loccnt += size;
|
|
size = 0;
|
|
}
|
|
else
|
|
{
|
|
memcpy(locbuf+loccnt, inptr, nneed);
|
|
loccnt += nneed;
|
|
size -= nneed;
|
|
inptr += nneed;
|
|
if ( reclen & 1 )
|
|
{
|
|
size--;
|
|
inptr++;
|
|
}
|
|
if ( WriteRecord(__G__ locbuf+2, reclen) )
|
|
return PK_DISK;
|
|
loccnt = 0;
|
|
}
|
|
}
|
|
/*
|
|
* Flush incoming records
|
|
*/
|
|
while (size > 0)
|
|
{
|
|
reclen = *(ush*)inptr;
|
|
if ( reclen+2 <= size )
|
|
{
|
|
if (WriteRecord(__G__ inptr+2, reclen))
|
|
return PK_DISK;
|
|
size -= 2+reclen;
|
|
inptr += 2+reclen;
|
|
if ( reclen & 1 )
|
|
{
|
|
--size;
|
|
++inptr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memcpy(locbuf, inptr, size);
|
|
loccnt = size;
|
|
size = 0;
|
|
}
|
|
|
|
}
|
|
/*
|
|
* Final flush rest of local buffer
|
|
*/
|
|
if ( final_flag && loccnt > 0 )
|
|
{
|
|
char buf[80];
|
|
|
|
Info(buf, 1, (buf,
|
|
"[ Warning, incomplete record of length %u ]\n",
|
|
(unsigned)*(ush*)locbuf));
|
|
if ( WriteRecord(__G__ locbuf+2, loccnt-2) )
|
|
return PK_DISK;
|
|
}
|
|
return PK_COOL;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Routine _flush_stream breaks decompressed stream into records
|
|
* depending on format of the stream (fab->rfm, G.pInfo->textmode, etc.)
|
|
* and puts out these records. It also handles CR LF sequences.
|
|
* Should be used when extracting *text* files.
|
|
*/
|
|
|
|
#define VT 0x0B
|
|
#define FF 0x0C
|
|
|
|
/* The file is from MSDOS/OS2/NT -> handle CRLF as record end, throw out ^Z */
|
|
|
|
/* GRR NOTES: cannot depend on hostnum! May have "flip'd" file or re-zipped
|
|
* a Unix file, etc. */
|
|
|
|
#ifdef USE_ORIG_DOS
|
|
# define ORG_DOS \
|
|
(G.pInfo->hostnum==FS_FAT_ \
|
|
|| G.pInfo->hostnum==FS_HPFS_ \
|
|
|| G.pInfo->hostnum==FS_NTFS_)
|
|
#else
|
|
# define ORG_DOS 1
|
|
#endif
|
|
|
|
/* Record delimiters */
|
|
#ifdef undef
|
|
#define RECORD_END(c, f) \
|
|
( ( ORG_DOS || G.pInfo->textmode ) && c==CTRLZ \
|
|
|| ( f == FAB$C_STMLF && c==LF ) \
|
|
|| ( f == FAB$C_STMCR || ORG_DOS || G.pInfo->textmode ) && c==CR \
|
|
|| ( f == FAB$C_STM && (c==CR || c==LF || c==FF || c==VT) ) \
|
|
)
|
|
#else
|
|
# define RECORD_END(c, f) ((c) == LF || (c) == (CR))
|
|
#endif
|
|
|
|
static unsigned find_eol(p, n, l)
|
|
/*
|
|
* Find first CR, LF, CR/LF or LF/CR in string 'p' of length 'n'.
|
|
* Return offset of the sequence found or 'n' if not found.
|
|
* If found, return in '*l' length of the sequence (1 or 2) or
|
|
* zero if sequence end not seen, i.e. CR or LF is last char
|
|
* in the buffer.
|
|
*/
|
|
ZCONST uch *p;
|
|
unsigned n;
|
|
unsigned *l;
|
|
{
|
|
unsigned off = n;
|
|
ZCONST uch *q;
|
|
|
|
*l = 0;
|
|
|
|
for (q=p ; n > 0 ; --n, ++q)
|
|
if ( RECORD_END(*q, rfm) )
|
|
{
|
|
off = q-p;
|
|
break;
|
|
}
|
|
|
|
if ( n > 1 )
|
|
{
|
|
*l = 1;
|
|
if ( ( q[0] == CR && q[1] == LF ) || ( q[0] == LF && q[1] == CR ) )
|
|
*l = 2;
|
|
}
|
|
|
|
return off;
|
|
}
|
|
|
|
/* Record delimiters that must be put out */
|
|
#define PRINT_SPEC(c) ( (c)==FF || (c)==VT )
|
|
|
|
|
|
|
|
static int _flush_stream(__G__ rawbuf, size, final_flag)
|
|
__GDEF
|
|
uch *rawbuf;
|
|
unsigned size;
|
|
int final_flag; /* 1 if this is the final flushout */
|
|
{
|
|
int rest;
|
|
unsigned end = 0, start = 0;
|
|
|
|
if (size == 0 && loccnt == 0)
|
|
return PK_COOL; /* Nothing to do ... */
|
|
|
|
if ( final_flag )
|
|
{
|
|
unsigned recsize;
|
|
|
|
/*
|
|
* This is flush only call. size must be zero now.
|
|
* Just eject everything we have in locbuf.
|
|
*/
|
|
recsize = loccnt - (got_eol ? 1 : 0);
|
|
/*
|
|
* If the last char of file was ^Z ( end-of-file in MSDOS ),
|
|
* we will see it now.
|
|
*/
|
|
if ( recsize==1 && locbuf[0] == CTRLZ )
|
|
return PK_COOL;
|
|
|
|
return WriteRecord(__G__ locbuf, recsize);
|
|
}
|
|
|
|
|
|
if ( loccnt > 0 )
|
|
{
|
|
/* Find end of record partially saved in locbuf */
|
|
|
|
unsigned recsize;
|
|
int complete=0;
|
|
|
|
if ( got_eol )
|
|
{
|
|
recsize = loccnt - 1;
|
|
complete = 1;
|
|
|
|
if ( (got_eol == CR && rawbuf[0] == LF) ||
|
|
(got_eol == LF && rawbuf[0] == CR) )
|
|
end = 1;
|
|
|
|
got_eol = 0;
|
|
}
|
|
else
|
|
{
|
|
unsigned eol_len;
|
|
unsigned eol_off;
|
|
|
|
eol_off = find_eol(rawbuf, size, &eol_len);
|
|
|
|
if ( loccnt+eol_off > BUFSMAXREC )
|
|
{
|
|
/*
|
|
* No room in locbuf. Dump it and clear
|
|
*/
|
|
char buf[80]; /* CANNOT use slide for Info() */
|
|
|
|
recsize = loccnt;
|
|
start = 0;
|
|
Info(buf, 1, (buf,
|
|
"[ Warning: Record too long (%u) ]\n", loccnt+eol_off));
|
|
complete = 1;
|
|
end = 0;
|
|
}
|
|
else
|
|
{
|
|
if ( eol_off >= size )
|
|
{
|
|
end = size;
|
|
complete = 0;
|
|
}
|
|
else if ( eol_len == 0 )
|
|
{
|
|
got_eol = rawbuf[eol_off];
|
|
end = size;
|
|
complete = 0;
|
|
}
|
|
else
|
|
{
|
|
memcpy(locptr, rawbuf, eol_off);
|
|
recsize = loccnt + eol_off;
|
|
locptr += eol_off;
|
|
loccnt += eol_off;
|
|
end = eol_off + eol_len;
|
|
complete = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( complete )
|
|
{
|
|
if (WriteRecord(__G__ locbuf, recsize))
|
|
return PK_DISK;
|
|
loccnt = 0;
|
|
locptr = locbuf;
|
|
}
|
|
} /* end if ( loccnt ) */
|
|
|
|
for (start = end; start < size && end < size; )
|
|
{
|
|
unsigned eol_off, eol_len;
|
|
|
|
got_eol = 0;
|
|
|
|
#ifdef undef
|
|
if (uO.cflag)
|
|
/* skip CR's at the beginning of record */
|
|
while (start < size && rawbuf[start] == CR)
|
|
++start;
|
|
#endif
|
|
|
|
if ( start >= size )
|
|
continue;
|
|
|
|
/* Find record end */
|
|
end = start+(eol_off = find_eol(rawbuf+start, size-start, &eol_len));
|
|
|
|
if ( end >= size )
|
|
continue;
|
|
|
|
if ( eol_len > 0 )
|
|
{
|
|
if ( WriteRecord(__G__ rawbuf+start, end-start) )
|
|
return PK_DISK;
|
|
start = end + eol_len;
|
|
}
|
|
else
|
|
{
|
|
got_eol = rawbuf[end];
|
|
end = size;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
rest = size - start;
|
|
|
|
if (rest > 0)
|
|
{
|
|
if ( rest > BUFSMAXREC )
|
|
{
|
|
unsigned recsize;
|
|
char buf[80]; /* CANNOT use slide for Info() */
|
|
|
|
recsize = rest - (got_eol ? 1 : 0 );
|
|
Info(buf, 1, (buf,
|
|
"[ Warning: Record too long (%u) ]\n", recsize));
|
|
got_eol = 0;
|
|
return WriteRecord(__G__ rawbuf+start, recsize);
|
|
}
|
|
else
|
|
{
|
|
memcpy(locptr, rawbuf + start, rest);
|
|
locptr += rest;
|
|
loccnt += rest;
|
|
}
|
|
}
|
|
return PK_COOL;
|
|
}
|
|
|
|
|
|
|
|
static int WriteBuffer(__G__ buf, len)
|
|
__GDEF
|
|
uch *buf;
|
|
unsigned len;
|
|
{
|
|
int status;
|
|
|
|
if (uO.cflag)
|
|
{
|
|
(void)(*G.message)((zvoid *)&G, buf, len, 0);
|
|
}
|
|
else
|
|
{
|
|
status = sys$wait(outrab);
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ WriteBuffer: sys$wait failed ]\n", status);
|
|
if (outrab->rab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outrab->rab$l_stv);
|
|
}
|
|
}
|
|
|
|
/* If odd byte count, then this must be the final record.
|
|
Clear the extra byte past EOF to help keep the file clean.
|
|
*/
|
|
if (len & 1)
|
|
buf[len] = '\0';
|
|
|
|
outrab->rab$w_rsz = len;
|
|
outrab->rab$l_rbf = (char *) buf;
|
|
|
|
if (ERR(status = sys$write(outrab)))
|
|
{
|
|
vms_msg(__G__ "[ WriteBuffer: sys$write failed ]\n", status);
|
|
if (outrab->rab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outrab->rab$l_stv);
|
|
}
|
|
return PK_DISK;
|
|
}
|
|
}
|
|
return PK_COOL;
|
|
}
|
|
|
|
|
|
|
|
static int WriteRecord(__G__ rec, len)
|
|
__GDEF
|
|
uch *rec;
|
|
unsigned len;
|
|
{
|
|
int status;
|
|
|
|
if (uO.cflag)
|
|
{
|
|
(void)(*G.message)((zvoid *)&G, rec, len, 0);
|
|
(void)(*G.message)((zvoid *)&G, (uch *) ("\n"), 1, 0);
|
|
}
|
|
else
|
|
{
|
|
if (ERR(status = sys$wait(outrab)))
|
|
{
|
|
vms_msg(__G__ "[ WriteRecord: sys$wait failed ]\n", status);
|
|
if (outrab->rab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outrab->rab$l_stv);
|
|
}
|
|
}
|
|
outrab->rab$w_rsz = len;
|
|
outrab->rab$l_rbf = (char *) rec;
|
|
|
|
if (ERR(status = sys$put(outrab)))
|
|
{
|
|
vms_msg(__G__ "[ WriteRecord: sys$put failed ]\n", status);
|
|
if (outrab->rab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outrab->rab$l_stv);
|
|
}
|
|
return PK_DISK;
|
|
}
|
|
}
|
|
return PK_COOL;
|
|
}
|
|
|
|
|
|
|
|
#ifdef SYMLINKS
|
|
/* Read symlink text from a still-open rms file. */
|
|
|
|
static int _read_link_rms(int byte_count, char *link_text_buf)
|
|
{
|
|
/* Use RMS to read the link text into the user's buffer.
|
|
* Rewind, then read byte count = byte_count.
|
|
* NUL-terminate the link text.
|
|
*
|
|
* $WAIT may be pointless if not async, but $WAIT elsewhere seems
|
|
* to be used unconditionally, so what do I know?
|
|
*/
|
|
int sts;
|
|
int bytes_read;
|
|
|
|
/* Clear the bytes-read count. */
|
|
bytes_read = 0;
|
|
|
|
/* Wait for anything pending. */
|
|
sts = sys$wait(outrab);
|
|
{
|
|
/* Rewind. */
|
|
sts = sys$rewind(outrab);
|
|
if (!ERR(sts))
|
|
{
|
|
/* Wait for $REWIND. */
|
|
sts = sys$wait(outrab);
|
|
if (!ERR(sts))
|
|
{
|
|
/* Read the link text. */
|
|
outrab->rab$w_usz = byte_count;
|
|
outrab->rab$l_ubf = link_text_buf;
|
|
sts = sys$read(outrab);
|
|
if (!ERR(sts))
|
|
{
|
|
/* Wait for $READ. */
|
|
sts = sys$wait(outrab);
|
|
|
|
if (!ERR(sts))
|
|
/* Set the resultant byte count. */
|
|
bytes_read = outrab->rab$w_rsz;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* NUL-terminate the link text. */
|
|
link_text_buf[bytes_read] = '\0';
|
|
|
|
return sts;
|
|
}
|
|
|
|
#endif /* SYMLINKS */
|
|
|
|
|
|
|
|
void close_outfile(__G)
|
|
__GDEF
|
|
{
|
|
int status;
|
|
|
|
status = (*_flush_routine)(__G__ NULL, 0, 1);
|
|
if (status)
|
|
return /* PK_DISK */;
|
|
if (uO.cflag)
|
|
return /* PK_COOL */; /* Don't close stdout */
|
|
/* return */ (*_close_routine)(__G);
|
|
}
|
|
|
|
|
|
|
|
static int _close_rms(__GPRO)
|
|
{
|
|
int status;
|
|
struct XABPRO pro;
|
|
int retcode = PK_OK;
|
|
|
|
#ifdef SYMLINKS
|
|
|
|
/*----------------------------------------------------------------------
|
|
UNIX description:
|
|
If symbolic links are supported, allocate storage for a symlink
|
|
control structure, put the uncompressed "data" and other required
|
|
info in it, and add the structure to the "deferred symlinks" chain.
|
|
Since we know it's a symbolic link to start with, we shouldn't have
|
|
to worry about overflowing unsigned ints with unsigned longs.
|
|
----------------------------------------------------------------------*/
|
|
|
|
if (G.symlnk) {
|
|
extent ucsize = (extent)G.lrec.ucsize;
|
|
|
|
/* 2007-03-03 SMS.
|
|
* If the symlink is already a symlink (restored with VMS/RMS
|
|
* symlink attributes), then read the link text from the file,
|
|
* and close the file (using the appropriate methods), and then
|
|
* return.
|
|
*/
|
|
if (G.pInfo->symlink == 0)
|
|
{
|
|
if (QCOND2)
|
|
{
|
|
/* Link text storage. */
|
|
char* link_target = malloc(ucsize + 1);
|
|
|
|
if (link_target == NULL)
|
|
{
|
|
Info(slide, 0x201, ((char *)slide,
|
|
"warning: cannot show symlink (%s) target, no mem\n",
|
|
FnFilter1(G.filename)));
|
|
retcode = PK_MEM;
|
|
}
|
|
else
|
|
{
|
|
/* Read the link text. */
|
|
status = _read_link_rms(ucsize, link_target);
|
|
|
|
if (ERR(status))
|
|
{
|
|
Info(slide, 0x201, ((char *)slide,
|
|
"warning: error reading symlink text: %s\n",
|
|
strerror(EVMSERR, status)));
|
|
retcode = PK_DISK;
|
|
}
|
|
else
|
|
{
|
|
Info(slide, 0, ((char *)slide, "-> %s ",
|
|
FnFilter1(link_target)));
|
|
}
|
|
|
|
free(link_target);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
extent slnk_entrysize;
|
|
slinkentry *slnk_entry;
|
|
|
|
/* It's a symlink in need of post-processing. */
|
|
/* Size of the symlink entry is the sum of
|
|
* (struct size (includes 1st '\0') + 1 additional trailing '\0'),
|
|
* system specific attribute data size (might be 0),
|
|
* and the lengths of name and link target.
|
|
*/
|
|
slnk_entrysize = (sizeof(slinkentry) + 1) +
|
|
ucsize + strlen(G.filename);
|
|
|
|
if (slnk_entrysize < ucsize) {
|
|
Info(slide, 0x201, ((char *)slide,
|
|
"warning: symbolic link (%s) failed: mem alloc overflow\n",
|
|
FnFilter1(G.filename)));
|
|
retcode = PK_ERR;
|
|
}
|
|
else
|
|
{
|
|
if ((slnk_entry = (slinkentry *)malloc(slnk_entrysize))
|
|
== NULL) {
|
|
Info(slide, 0x201, ((char *)slide,
|
|
"warning: symbolic link (%s) failed, no mem\n",
|
|
FnFilter1(G.filename)));
|
|
retcode = PK_MEM;
|
|
}
|
|
else
|
|
{
|
|
slnk_entry->next = NULL;
|
|
slnk_entry->targetlen = ucsize;
|
|
/* don't set attributes for symlinks */
|
|
slnk_entry->attriblen = 0;
|
|
slnk_entry->target = slnk_entry->buf;
|
|
slnk_entry->fname = slnk_entry->target + ucsize + 1;
|
|
strcpy(slnk_entry->fname, G.filename);
|
|
|
|
/* Read the link text using the appropriate method. */
|
|
status = _read_link_rms(ucsize, slnk_entry->target);
|
|
|
|
if (ERR(status))
|
|
{
|
|
Info(slide, 0x201, ((char *)slide,
|
|
"warning: error reading symlink text (rms): %s\n",
|
|
strerror(EVMSERR, status)));
|
|
free(slnk_entry);
|
|
retcode = PK_DISK;
|
|
}
|
|
else
|
|
{
|
|
if (QCOND2)
|
|
Info(slide, 0, ((char *)slide, "-> %s ",
|
|
FnFilter1(slnk_entry->target)));
|
|
|
|
/* Add this symlink record to the list of
|
|
deferred symlinks. */
|
|
if (G.slink_last != NULL)
|
|
G.slink_last->next = slnk_entry;
|
|
else
|
|
G.slink_head = slnk_entry;
|
|
G.slink_last = slnk_entry;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif /* SYMLINKS */
|
|
|
|
/* Link XABRDT, XABDAT, and (optionally) XABPRO. */
|
|
if (xabrdt != NULL)
|
|
{
|
|
xabrdt->xab$l_nxt = NULL;
|
|
outfab->fab$l_xab = (void *) xabrdt;
|
|
}
|
|
else
|
|
{
|
|
rdt.xab$l_nxt = NULL;
|
|
outfab->fab$l_xab = (void *) &rdt;
|
|
}
|
|
if (xabdat != NULL)
|
|
{
|
|
xabdat->xab$l_nxt = outfab->fab$l_xab;
|
|
outfab->fab$l_xab = (void *)xabdat;
|
|
}
|
|
|
|
if (xabpro != NULL)
|
|
{
|
|
if ( !uO.X_flag )
|
|
xabpro->xab$l_uic = 0; /* Use default (user's) uic */
|
|
xabpro->xab$l_nxt = outfab->fab$l_xab;
|
|
outfab->fab$l_xab = (void *) xabpro;
|
|
}
|
|
else
|
|
{
|
|
pro = cc$rms_xabpro;
|
|
pro.xab$w_pro = G.pInfo->file_attr;
|
|
pro.xab$l_nxt = outfab->fab$l_xab;
|
|
outfab->fab$l_xab = (void *) &pro;
|
|
}
|
|
|
|
status = sys$wait(outrab);
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ _close_rms: sys$wait failed ]\n", status);
|
|
if (outrab->rab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outrab->rab$l_stv);
|
|
}
|
|
}
|
|
|
|
status = sys$close(outfab);
|
|
#ifdef DEBUG
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__
|
|
"\r[ Warning: cannot set owner/protection/time attributes ]\n",
|
|
status);
|
|
if (outfab->fab$l_stv != 0)
|
|
{
|
|
vms_msg(__G__ "", outfab->fab$l_stv);
|
|
}
|
|
retcode = PK_WARN;
|
|
}
|
|
#endif
|
|
free_up();
|
|
return retcode;
|
|
}
|
|
|
|
|
|
|
|
static int _close_qio(__GPRO)
|
|
{
|
|
int status;
|
|
|
|
pka_fib.FIB$L_ACCTL =
|
|
FIB$M_WRITE | FIB$M_NOTRUNC ;
|
|
pka_fib.FIB$W_EXCTL = 0;
|
|
|
|
pka_fib.FIB$W_FID[0] =
|
|
pka_fib.FIB$W_FID[1] =
|
|
pka_fib.FIB$W_FID[2] =
|
|
pka_fib.FIB$W_DID[0] =
|
|
pka_fib.FIB$W_DID[1] =
|
|
pka_fib.FIB$W_DID[2] = 0;
|
|
|
|
#ifdef ASYNCH_QIO
|
|
if (pka_io_pending) {
|
|
status = sys$synch(0, &pka_io_iosb);
|
|
if (!ERR(status))
|
|
status = pka_io_iosb.status;
|
|
if (ERR(status))
|
|
{
|
|
vms_msg(__G__ "[ _close_qio: sys$synch found I/O failure ]\n",
|
|
status);
|
|
}
|
|
pka_io_pending = FALSE;
|
|
}
|
|
#endif /* ASYNCH_QIO */
|
|
|
|
#ifdef SYMLINKS
|
|
if (G.symlnk && QCOND2)
|
|
{
|
|
/* Read back the symlink target specification for display purpose. */
|
|
extent ucsize = (extent)G.lrec.ucsize;
|
|
char *link_target; /* Link text storage. */
|
|
|
|
if ((link_target = malloc(ucsize + 1)) == NULL)
|
|
{
|
|
Info(slide, 0x201, ((char *)slide,
|
|
"warning: cannot show symlink (%s) target, no mem\n",
|
|
FnFilter1(G.filename)));
|
|
}
|
|
else
|
|
{
|
|
unsigned bytes_read = 0;
|
|
|
|
status = sys$qiow(0, /* event flag */
|
|
pka_devchn, /* channel */
|
|
IO$_READVBLK, /* function */
|
|
&pka_io_iosb, /* IOSB */
|
|
0, /* AST address */
|
|
0, /* AST parameter */
|
|
link_target, /* P1 = buffer address */
|
|
ucsize, /* P2 = requested byte count */
|
|
1, /* P3 = VBN (1 = first) */
|
|
0, /* P4 (not used) */
|
|
0, /* P5 (not used) */
|
|
0); /* P6 (not used) */
|
|
|
|
if (!ERR(status))
|
|
/* Final status. */
|
|
status = pka_io_iosb.status;
|
|
|
|
/* Set the resultant byte count. */
|
|
if (!ERR(status))
|
|
bytes_read = pka_io_iosb.count;
|
|
|
|
/* NUL-terminate the link text. */
|
|
link_target[bytes_read] = '\0';
|
|
|
|
if (ERR(status))
|
|
{
|
|
Info(slide, 0x201, ((char *)slide,
|
|
"warning: error reading symlink text (qio): %s\n",
|
|
strerror(EVMSERR, status)));
|
|
}
|
|
else
|
|
{
|
|
Info(slide, 0, ((char *)slide, "-> %s ",
|
|
FnFilter1(link_target)));
|
|
}
|
|
|
|
free(link_target);
|
|
|
|
}
|
|
}
|
|
#endif /* SYMLINKS */
|
|
|
|
status = sys$qiow(0, pka_devchn, IO$_DEACCESS, &pka_acp_iosb,
|
|
0, 0,
|
|
&pka_fibdsc, 0, 0, 0,
|
|
pka_atr, 0);
|
|
|
|
sys$dassgn(pka_devchn);
|
|
if ( !ERR(status) )
|
|
status = pka_acp_iosb.status;
|
|
if ( ERR(status) )
|
|
{
|
|
vms_msg(__G__ "[ Deaccess QIO failed ]\n", status);
|
|
return PK_DISK;
|
|
}
|
|
return PK_COOL;
|
|
}
|
|
|
|
|
|
|
|
#ifdef SET_DIR_ATTRIB
|
|
|
|
/*
|
|
* 2006-10-04 SMS.
|
|
* vms_path_fixdown().
|
|
*
|
|
* Convert VMS directory spec to VMS directory file name. That is,
|
|
* change "dev:[a.b.c.e]" to "dev:[a.b.c]e.DIR;1". The result (always
|
|
* larger than the source) is returned in the user's buffer.
|
|
*/
|
|
|
|
#define DIR_TYPE_VER ".DIR;1"
|
|
|
|
static char *vms_path_fixdown(ZCONST char *dir_spec, char *dir_file)
|
|
{
|
|
char dir_close;
|
|
char dir_open;
|
|
unsigned i;
|
|
unsigned dir_spec_len;
|
|
|
|
dir_spec_len = strlen(dir_spec);
|
|
if (dir_spec_len == 0) return NULL;
|
|
i = dir_spec_len - 1;
|
|
dir_close = dir_spec[i];
|
|
|
|
/* Identify the directory delimiters (which must exist). */
|
|
if (dir_close == ']')
|
|
{
|
|
dir_open = '[';
|
|
}
|
|
else if (dir_close == '>')
|
|
{
|
|
dir_open = '<';
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* Find the beginning of the last directory name segment. */
|
|
while ((i > 0) && ((dir_spec[i - 1] == '^') ||
|
|
((dir_spec[i] != '.') && (dir_spec[i] != dir_open))))
|
|
{
|
|
i--;
|
|
}
|
|
|
|
/* Form the directory file name from the pieces. */
|
|
if (dir_spec[i] == dir_open)
|
|
{
|
|
/* Top-level directory. */
|
|
sprintf(dir_file, "%.*s000000%c%.*s%s",
|
|
/* "dev:[" "000000" "]" */
|
|
(i + 1), dir_spec, dir_close,
|
|
/* "a" ".DIR;1" */
|
|
(dir_spec_len - i - 2), (dir_spec + i + 1), DIR_TYPE_VER);
|
|
}
|
|
else
|
|
{
|
|
/* Non-top-level directory. */
|
|
sprintf(dir_file, "%.*s%c%.*s%s",
|
|
/* "dev:[a.b.c" "]" */
|
|
i, dir_spec, dir_close,
|
|
/* "e" ".DIR;1" */
|
|
(dir_spec_len - i - 2), (dir_spec + i + 1), DIR_TYPE_VER);
|
|
}
|
|
return dir_file;
|
|
} /* end function vms_path_fixdown(). */
|
|
|
|
|
|
|
|
/* Save directory attributes (as the archive's extra field). */
|
|
|
|
/* 2006-12-13 SMS.
|
|
* This could probably be made more efficient by analyzing the data
|
|
* here, extracting the important data, and saving only what's needed.
|
|
* Given the existing code, it seemed simpler to save them all here, and
|
|
* deal with what's important in set_direc_attribs().
|
|
*/
|
|
|
|
int defer_dir_attribs(__G__ pd)
|
|
__GDEF
|
|
direntry **pd;
|
|
{
|
|
vmsdirattr *d_entry;
|
|
unsigned fnlen;
|
|
unsigned xlen;
|
|
|
|
/* Allocate space to save the file (directory) name, the extra
|
|
* block, and all the other data needed by the extra-block data
|
|
* scanner functions. If that works, save the data.
|
|
*/
|
|
fnlen = strlen(G.filename);
|
|
xlen = G.lrec.extra_field_length;
|
|
d_entry = (vmsdirattr *) malloc(sizeof(vmsdirattr) + fnlen + xlen);
|
|
*pd = (direntry *) d_entry;
|
|
if (d_entry == (vmsdirattr *) NULL)
|
|
{
|
|
return PK_MEM;
|
|
}
|
|
|
|
/* Save extra block length and data. */
|
|
d_entry->xlen = xlen;
|
|
memcpy(d_entry->buf, G.extra_field, xlen);
|
|
|
|
/* Set pointer to file (directory) name. */
|
|
d_entry->fn = d_entry->buf + xlen;
|
|
|
|
/* Save file (directory) name. */
|
|
strcpy(d_entry->fn, G.filename);
|
|
/* Strip the closing ']' char, to allow proper sorting. */
|
|
d_entry->fn[fnlen - 1] = '\0';
|
|
|
|
/* Save generic permission data from mapattr(). */
|
|
d_entry->perms = G.pInfo->file_attr;
|
|
|
|
/* Save G.lrec.last_mod_dos_datetime. */
|
|
d_entry->mod_dos_datetime = G.lrec.last_mod_dos_datetime;
|
|
|
|
return PK_OK;
|
|
} /* end function defer_dir_attribs() */
|
|
|
|
|
|
|
|
int set_direc_attribs(__G__ d)
|
|
__GDEF
|
|
direntry *d;
|
|
{
|
|
uch *sav_ef_ptr;
|
|
int i;
|
|
int status;
|
|
int type;
|
|
ush attr;
|
|
struct XABPRO pro;
|
|
char dir_name[NAM_MAXRSS + 1];
|
|
char warnmsg[NAM_MAXRSS + 128]; /* Name length + message length. */
|
|
int retcode = PK_OK;
|
|
|
|
/* Re-append the closing ']' character which has been stripped in
|
|
* defer_dir_attribs() for compatibility with generic sorting code.
|
|
*/
|
|
strcat(VmsAtt(d)->fn, "]");
|
|
|
|
/* Convert "[a.b.c]" form into "[a.b]c.DIR;1" */
|
|
vms_path_fixdown(VmsAtt(d)->fn, dir_name);
|
|
|
|
/* Dummy up critical global (G) data from the preserved directory
|
|
* attribute data.
|
|
*/
|
|
sav_ef_ptr = G.extra_field;
|
|
G.extra_field = (uch *)((VmsAtt(d)->xlen > 0) ? VmsAtt(d)->buf : NULL);
|
|
G.lrec.extra_field_length = VmsAtt(d)->xlen;
|
|
|
|
/* Extract the VMS file attributes from the preserved attribute
|
|
* data, if they exist, and restore the date-time stamps.
|
|
*/
|
|
type = find_vms_attrs(__G__ (uO.D_flag <= 0));
|
|
|
|
if (outfab == NULL)
|
|
{
|
|
/* Default and PK schemes need a FAB. (IZ supplies one.)
|
|
* In a degenerate case, this could be the first use of fileblk,
|
|
* so we assume that we need to initialize it.
|
|
*/
|
|
fileblk = cc$rms_fab; /* Initialize FAB. */
|
|
outfab = &fileblk; /* Set pointer used elsewhere. */
|
|
}
|
|
|
|
/* Arrange FAB-NAM[L] for file (directory) access. */
|
|
if (type != VAT_NONE)
|
|
{
|
|
if (type == VAT_IZ)
|
|
{
|
|
/* Make an attribute descriptor list for the VMS creation and
|
|
* revision dates (which were stored in the IZ XABs by
|
|
* find_vms_attrs()).
|
|
*/
|
|
pka_idx = 0;
|
|
|
|
if (xabrdt != NULL)
|
|
{
|
|
/* Revision date-time from XABRDT. */
|
|
pka_atr[pka_idx].atr$w_size = 8;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_REVDATE;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &xabrdt->xab$q_rdt;
|
|
++pka_idx;
|
|
}
|
|
if (xabdat != NULL)
|
|
{
|
|
/* Trust the XABRDT value for revision date. */
|
|
if (xabrdt == NULL)
|
|
{
|
|
/* Revision date-time from XABDAT. */
|
|
pka_atr[pka_idx].atr$w_size = 8;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_REVDATE;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &xabdat->xab$q_rdt;
|
|
++pka_idx;
|
|
}
|
|
/* Creation date-time from XABDAT. */
|
|
pka_atr[pka_idx].atr$w_size = 8;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_CREDATE;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &xabdat->xab$q_cdt;
|
|
++pka_idx;
|
|
}
|
|
if (xabpro != NULL)
|
|
{
|
|
if ( uO.X_flag ) {
|
|
pka_atr[pka_idx].atr$w_size = 4;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_UIC;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &xabpro->xab$l_uic;
|
|
++pka_idx;
|
|
}
|
|
attr = xabpro->xab$w_pro;
|
|
}
|
|
else
|
|
{
|
|
/* Revoke directory Delete permission for all. */
|
|
attr = VmsAtt(d)->perms
|
|
| (((1<< XAB$V_NODEL)<< XAB$V_SYS)|
|
|
((1<< XAB$V_NODEL)<< XAB$V_OWN)|
|
|
((1<< XAB$V_NODEL)<< XAB$V_GRP)|
|
|
((1<< XAB$V_NODEL)<< XAB$V_WLD));
|
|
}
|
|
pka_atr[pka_idx].atr$w_size = 2;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_FPRO;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &attr;
|
|
++pka_idx;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* No VMS attribute data were found. Prepare to assemble
|
|
* non-VMS attribute data.
|
|
*/
|
|
pka_idx = 0;
|
|
|
|
/* Get the (already converted) non-VMS permissions. */
|
|
attr = VmsAtt(d)->perms; /* Use right-sized prot storage. */
|
|
|
|
/* Revoke directory Delete permission for all. */
|
|
attr |= (((1<< XAB$V_NODEL)<< XAB$V_SYS)|
|
|
((1<< XAB$V_NODEL)<< XAB$V_OWN)|
|
|
((1<< XAB$V_NODEL)<< XAB$V_GRP)|
|
|
((1<< XAB$V_NODEL)<< XAB$V_WLD));
|
|
|
|
pka_atr[pka_idx].atr$w_size = 2;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_FPRO;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &attr;
|
|
++pka_idx;
|
|
|
|
/* Restore directory date-time if user requests it (-D). */
|
|
if (uO.D_flag <= 0)
|
|
{
|
|
/* Set the directory date-time from the non-VMS data.
|
|
* Dummy up the DOS-style modification date into global (G)
|
|
* data from the preserved directory attribute data.
|
|
*/
|
|
G.lrec.last_mod_dos_datetime = VmsAtt(d)->mod_dos_datetime;
|
|
|
|
/* Extract date-time data from the normal attribute data. */
|
|
set_default_datetime_XABs(__G);
|
|
|
|
/* Make an attribute descriptor list for the VMS creation
|
|
* and revision dates (which were stored in the XABs by
|
|
* set_default_datetime_XABs()).
|
|
*/
|
|
pka_atr[pka_idx].atr$w_size = 8;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_CREDATE;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &dattim.xab$q_cdt;
|
|
++pka_idx;
|
|
pka_atr[pka_idx].atr$w_size = 8;
|
|
pka_atr[pka_idx].atr$w_type = ATR$C_REVDATE;
|
|
pka_atr[pka_idx].atr$l_addr = GVTC &rdt.xab$q_rdt;
|
|
++pka_idx;
|
|
}
|
|
|
|
/* Set the directory protection from the non-VMS data. */
|
|
|
|
/* Terminate the attribute descriptor list. */
|
|
pka_atr[pka_idx].atr$w_size = 0; /* End of list */
|
|
pka_atr[pka_idx].atr$w_type = 0;
|
|
pka_atr[pka_idx].atr$l_addr = 0; /* NULL when DECC VAX gets fixed. */
|
|
}
|
|
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
outfab->FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
/* Point the FAB-NAM[L] to the VMS-format directory file name. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
outfab->fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
outfab->fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
/* Special ODS5-QIO-compatible name storage. */
|
|
nam.naml$l_filesys_name = sys_nam;
|
|
nam.naml$l_filesys_name_alloc = sizeof(sys_nam);
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(*outfab, nam).FAB_OR_NAML_FNA = dir_name;
|
|
FAB_OR_NAML(*outfab, nam).FAB_OR_NAML_FNS = strlen(dir_name);
|
|
|
|
/* Expanded and resultant name storage. */
|
|
nam.NAM_ESA = exp_nam;
|
|
nam.NAM_ESS = sizeof(exp_nam);
|
|
nam.NAM_RSA = res_nam;
|
|
nam.NAM_RSS = sizeof(res_nam);
|
|
|
|
status = sys$parse(outfab);
|
|
if ( ERR(status) )
|
|
{
|
|
sprintf(warnmsg,
|
|
"warning: set-dir-attributes failed ($parse) for %s.\n",
|
|
dir_name);
|
|
vms_msg(__G__ warnmsg, status);
|
|
retcode = PK_WARN;
|
|
goto cleanup_exit;
|
|
}
|
|
|
|
/* Set the length in the device name descriptor. */
|
|
pka_devdsc.dsc$w_length = (unsigned short) nam.NAM_DVI[0];
|
|
|
|
/* Open a channel to the disk device. */
|
|
status = sys$assign(&pka_devdsc, &pka_devchn, 0, 0);
|
|
if ( ERR(status) )
|
|
{
|
|
sprintf(warnmsg,
|
|
"warning: set-dir-attributes failed ($assign) for %s.\n",
|
|
dir_name);
|
|
vms_msg(__G__ warnmsg, status);
|
|
retcode = PK_WARN;
|
|
goto cleanup_exit;
|
|
}
|
|
|
|
/* Move the directory ID from the NAM[L] to the FIB.
|
|
Clear the FID in the FIB, as we're using the name.
|
|
*/
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
pka_fib.FIB$W_DID[i] = nam.NAM_DID[i];
|
|
pka_fib.FIB$W_FID[i] = 0;
|
|
}
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
/* Enable fancy name characters. Note that "fancy" here does
|
|
not include Unicode, for which there's no support elsewhere.
|
|
*/
|
|
pka_fib.fib$v_names_8bit = 1;
|
|
pka_fib.fib$b_name_format_in = FIB$C_ISL1;
|
|
|
|
/* ODS5 Extended names used as input to QIO have peculiar
|
|
encoding (perhaps to minimize storage?), so the special
|
|
filesys_name result (typically containing fewer carets) must
|
|
be used here.
|
|
*/
|
|
pka_fnam.dsc$a_pointer = nam.naml$l_filesys_name;
|
|
pka_fnam.dsc$w_length = nam.naml$l_filesys_name_size;
|
|
|
|
#else /* !NAML$C_MAXRSS */
|
|
|
|
/* ODS2-only: Use the whole name. */
|
|
pka_fnam.dsc$a_pointer = nam.NAM_L_NAME;
|
|
pka_fnam.dsc$w_length = nam.NAM_B_NAME + nam.NAM_B_TYPE + nam.NAM_B_VER;
|
|
|
|
#endif /* ?NAML$C_MAXRSS */
|
|
|
|
/* 2007-07-13 SMS.
|
|
* Our freshly created directory can easily contain fewer files than
|
|
* the original archived directory (for example, if not all the
|
|
* files in the original directory were included in the archive), so
|
|
* its size may differ from that of the archived directory. Thus,
|
|
* simply restoring the original RECATTR attributes structure, which
|
|
* includes EFBLK (and so on) can cause "SYSTEM-W-BADIRECTORY, bad
|
|
* directory file format" complaints. Instead, we overwrite
|
|
* selected archived attributes with current attributes, to avoid
|
|
* setting obsolete/inappropriate attributes on the newly created
|
|
* directory file.
|
|
*
|
|
* First, see if there is a RECATTR structure about which we need to
|
|
* worry.
|
|
*/
|
|
for (i = 0; pka_atr[i].atr$w_type != 0; i++)
|
|
{
|
|
if (pka_atr[i].atr$w_type == ATR$C_RECATTR)
|
|
{
|
|
/* We found a RECATTR structure which (we must assume) needs
|
|
* adjustment. Retrieve the RECATTR data for the existing
|
|
* (newly created) directory file.
|
|
*/
|
|
status = sys$qiow(0, /* event flag */
|
|
pka_devchn, /* channel */
|
|
IO$_ACCESS, /* function code */
|
|
&pka_acp_iosb, /* IOSB */
|
|
0, /* AST address */
|
|
0, /* AST parameter */
|
|
&pka_fibdsc, /* P1 = File Info Block */
|
|
&pka_fnam, /* P2 = File name */
|
|
0, /* P3 = Rslt nm len */
|
|
0, /* P4 = Rslt nm str */
|
|
pka_recattr, /* P5 = Attributes */
|
|
0); /* P6 (not used) */
|
|
|
|
/* If initial success, then get the final status from the IOSB. */
|
|
if ( !ERR(status) )
|
|
status = pka_acp_iosb.status;
|
|
|
|
if ( ERR(status) )
|
|
{
|
|
sprintf(warnmsg,
|
|
"warning: set-dir-attributes failed ($qiow acc) for %s.\n",
|
|
dir_name);
|
|
vms_msg(__G__ warnmsg, status);
|
|
retcode = PK_WARN;
|
|
}
|
|
else
|
|
{
|
|
/* We should have valid RECATTR data. Overwrite the
|
|
* critical bits of the archive RECATTR structure with
|
|
* the current bits. The book says that an attempt to
|
|
* modify HIBLK will be ignored, and FFBYTE should
|
|
* always be zero, but safety is cheap.
|
|
*/
|
|
struct fatdef *ptr_recattr;
|
|
|
|
ptr_recattr = (struct fatdef *) pka_atr[i].atr$l_addr;
|
|
ptr_recattr->fat$l_hiblk = pka_rattr.fat$l_hiblk;
|
|
ptr_recattr->fat$l_efblk = pka_rattr.fat$l_efblk;
|
|
ptr_recattr->fat$w_ffbyte = pka_rattr.fat$w_ffbyte;
|
|
}
|
|
/* There should be only one RECATTR structure in the list, so
|
|
* escape from the loop after the first/only one has been
|
|
* processed.
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Modify the file (directory) attributes. */
|
|
status = sys$qiow(0, /* event flag */
|
|
pka_devchn, /* channel */
|
|
IO$_MODIFY, /* function code */
|
|
&pka_acp_iosb, /* IOSB */
|
|
0, /* AST address */
|
|
0, /* AST parameter */
|
|
&pka_fibdsc, /* P1 = File Info Block */
|
|
&pka_fnam, /* P2 = File name */
|
|
0, /* P3 = Rslt nm len */
|
|
0, /* P4 = Rslt nm str */
|
|
pka_atr, /* P5 = Attributes */
|
|
0); /* P6 (not used) */
|
|
|
|
/* If initial success, then get the final status from the IOSB. */
|
|
if ( !ERR(status) )
|
|
status = pka_acp_iosb.status;
|
|
|
|
if ( ERR(status) )
|
|
{
|
|
sprintf(warnmsg,
|
|
"warning: set-dir-attributes failed ($qiow mod) for %s.\n",
|
|
dir_name);
|
|
vms_msg(__G__ warnmsg, status);
|
|
retcode = PK_WARN;
|
|
}
|
|
sys$dassgn(pka_devchn);
|
|
cleanup_exit:
|
|
free_up(); /* Free FAB, XAB storage. */
|
|
free(d); /* Free directory attribute storage. */
|
|
G.extra_field = sav_ef_ptr; /* Restore original pointer. */
|
|
return retcode;
|
|
} /* end function set_direc_attribs() */
|
|
|
|
#endif /* SET_DIR_ATTRIB */
|
|
|
|
|
|
|
|
#ifdef TIMESTAMP
|
|
|
|
/* Nonzero if `y' is a leap year, else zero. */
|
|
#define leap(y) (((y) % 4 == 0 && (y) % 100 != 0) || (y) % 400 == 0)
|
|
|
|
/* Number of leap years from 1970 to `y' (not including `y' itself). */
|
|
#define nleap(y) (((y) - 1969) / 4 - ((y) - 1901) / 100 + ((y) - 1601) / 400)
|
|
|
|
/* Accumulated number of days from 01-Jan up to start of current month. */
|
|
static ZCONST short ydays[] = {
|
|
0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
|
|
};
|
|
|
|
/***********************/
|
|
/* Function mkgmtime() */
|
|
/***********************/
|
|
|
|
static time_t mkgmtime(tm)
|
|
struct tm *tm;
|
|
{
|
|
time_t m_time;
|
|
int yr, mo, dy, hh, mm, ss;
|
|
unsigned days;
|
|
|
|
yr = tm->tm_year - 70;
|
|
mo = tm->tm_mon;
|
|
dy = tm->tm_mday - 1;
|
|
hh = tm->tm_hour;
|
|
mm = tm->tm_min;
|
|
ss = tm->tm_sec;
|
|
|
|
/* calculate days from BASE to this year and add expired days this year */
|
|
dy = (unsigned)dy + ((unsigned)yr * 365) + (unsigned)nleap(yr+1970) +
|
|
(unsigned)ydays[mo] + ((mo > 1) && leap(yr+1970));
|
|
|
|
/* convert date & time to seconds relative to 00:00:00, 01/01/1970 */
|
|
return (time_t)((unsigned long)(unsigned)dy * 86400L +
|
|
(unsigned long)hh * 3600L +
|
|
(unsigned long)(mm * 60 + ss));
|
|
|
|
} /* end function mkgmtime() */
|
|
|
|
|
|
|
|
/*******************************/
|
|
/* Function dos_to_unix_time() */ /* only used for timestamping of archives */
|
|
/*******************************/
|
|
|
|
time_t dos_to_unix_time(dosdatetime)
|
|
ulg dosdatetime;
|
|
{
|
|
struct tm *ltm; /* Local time. */
|
|
time_t loctime; /* The time_t value of local time. */
|
|
time_t then; /* The time to return. */
|
|
long tzoffset_adj; /* timezone-adjustment `remainder' */
|
|
int bailout_cnt; /* counter of tries for tz correction */
|
|
|
|
then = time(NULL);
|
|
ltm = localtime(&then);
|
|
|
|
/* dissect date */
|
|
ltm->tm_year = ((int)(dosdatetime >> 25) & 0x7f) + 80;
|
|
ltm->tm_mon = ((int)(dosdatetime >> 21) & 0x0f) - 1;
|
|
ltm->tm_mday = ((int)(dosdatetime >> 16) & 0x1f);
|
|
|
|
/* dissect time */
|
|
ltm->tm_hour = (int)(dosdatetime >> 11) & 0x1f;
|
|
ltm->tm_min = (int)(dosdatetime >> 5) & 0x3f;
|
|
ltm->tm_sec = (int)(dosdatetime << 1) & 0x3e;
|
|
|
|
loctime = mkgmtime(ltm);
|
|
|
|
/* Correct for the timezone and any daylight savings time.
|
|
The correction is verified and repeated when not correct, to
|
|
take into account the rare case that a change to or from daylight
|
|
savings time occurs between when it is the time in `tm' locally
|
|
and when it is that time in Greenwich. After the second correction,
|
|
the "timezone & daylight" offset should be correct in all cases. To
|
|
be sure, we allow a third try, but then the loop is stopped. */
|
|
bailout_cnt = 3;
|
|
then = loctime;
|
|
do {
|
|
ltm = localtime(&then);
|
|
tzoffset_adj = (ltm != NULL) ? (loctime - mkgmtime(ltm)) : 0L;
|
|
if (tzoffset_adj == 0L)
|
|
break;
|
|
then += tzoffset_adj;
|
|
} while (--bailout_cnt > 0);
|
|
|
|
if ( (dosdatetime >= DOSTIME_2038_01_18) &&
|
|
(then < (time_t)0x70000000L) )
|
|
then = U_TIME_T_MAX; /* saturate in case of (unsigned) overflow */
|
|
if (then < (time_t)0L) /* a converted DOS time cannot be negative */
|
|
then = S_TIME_T_MAX; /* -> saturate at max signed time_t value */
|
|
return then;
|
|
|
|
} /* end function dos_to_unix_time() */
|
|
|
|
|
|
|
|
/*******************************/
|
|
/* Function uxtime2vmstime() */
|
|
/*******************************/
|
|
|
|
static void uxtime2vmstime( /* convert time_t value into 64 bit VMS bintime */
|
|
time_t utimeval,
|
|
long int binval[2] )
|
|
{
|
|
time_t m_time = utimeval;
|
|
struct tm *t = localtime(&m_time);
|
|
|
|
if (t == (struct tm *)NULL) {
|
|
/* time conversion error; use current time instead, hoping
|
|
that localtime() does not reject it as well! */
|
|
m_time = time(NULL);
|
|
t = localtime(&m_time);
|
|
}
|
|
sprintf(timbuf, "%02d-%3s-%04d %02d:%02d:%02d.00",
|
|
t->tm_mday, month[t->tm_mon], t->tm_year + 1900,
|
|
t->tm_hour, t->tm_min, t->tm_sec);
|
|
sys$bintim(&date_str, binval);
|
|
} /* end function uxtime2vmstime() */
|
|
|
|
|
|
|
|
/***************************/
|
|
/* Function stamp_file() */ /* adapted from VMSmunch...it just won't die! */
|
|
/***************************/
|
|
|
|
int stamp_file(fname, modtime)
|
|
ZCONST char *fname;
|
|
time_t modtime;
|
|
{
|
|
int status;
|
|
int i;
|
|
static long int Cdate[2], Rdate[2], Edate[2], Bdate[2];
|
|
static short int revisions;
|
|
#if defined(__DECC) || defined(__DECCXX)
|
|
#pragma __member_alignment __save
|
|
#pragma __nomember_alignment
|
|
#endif /* __DECC || __DECCXX */
|
|
static union {
|
|
unsigned short int value;
|
|
struct {
|
|
unsigned system : 4;
|
|
unsigned owner : 4;
|
|
unsigned group : 4;
|
|
unsigned world : 4;
|
|
} bits;
|
|
} prot;
|
|
#if defined(__DECC) || defined(__DECCXX)
|
|
#pragma __member_alignment __restore
|
|
#endif /* __DECC || __DECCXX */
|
|
static unsigned long uic;
|
|
static struct fjndef jnl;
|
|
|
|
static struct atrdef Atr[] = {
|
|
{sizeof(pka_rattr), ATR$C_RECATTR, GVTC &pka_rattr},
|
|
{sizeof(pka_uchar), ATR$C_UCHAR, GVTC &pka_uchar},
|
|
{sizeof(Cdate), ATR$C_CREDATE, GVTC &Cdate[0]},
|
|
{sizeof(Rdate), ATR$C_REVDATE, GVTC &Rdate[0]},
|
|
{sizeof(Edate), ATR$C_EXPDATE, GVTC &Edate[0]},
|
|
{sizeof(Bdate), ATR$C_BAKDATE, GVTC &Bdate[0]},
|
|
{sizeof(revisions), ATR$C_ASCDATES, GVTC &revisions},
|
|
{sizeof(prot), ATR$C_FPRO, GVTC &prot},
|
|
{sizeof(uic), ATR$C_UIC, GVTC &uic},
|
|
{sizeof(jnl), ATR$C_JOURNAL, GVTC &jnl},
|
|
{0, 0, 0}
|
|
};
|
|
|
|
fileblk = cc$rms_fab; /* Initialize FAB. */
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
fileblk.FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
fileblk.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fileblk.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
/* Special ODS5-QIO-compatible name storage. */
|
|
nam.naml$l_filesys_name = sys_nam;
|
|
nam.naml$l_filesys_name_alloc = sizeof(sys_nam);
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(fileblk, nam).FAB_OR_NAML_FNA = (char *)fname;
|
|
FAB_OR_NAML(fileblk, nam).FAB_OR_NAML_FNS = strlen(fname);
|
|
|
|
nam.NAM_ESA = exp_nam;
|
|
nam.NAM_ESS = sizeof(exp_nam);
|
|
nam.NAM_RSA = res_nam;
|
|
nam.NAM_RSS = sizeof(res_nam);
|
|
|
|
if ( ERR(status = sys$parse(&fileblk)) )
|
|
{
|
|
vms_msg(__G__ "stamp_file: sys$parse failed.\n", status);
|
|
return -1;
|
|
}
|
|
|
|
pka_devdsc.dsc$w_length = (unsigned short)nam.NAM_DVI[0];
|
|
|
|
if ( ERR(status = sys$assign(&pka_devdsc, &pka_devchn, 0, 0)) )
|
|
{
|
|
vms_msg(__G__ "stamp_file: sys$assign failed.\n", status);
|
|
return -1;
|
|
}
|
|
|
|
/* Load the descriptor with the appropriate name data: */
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
/* Enable fancy name characters. Note that "fancy" here does
|
|
not include Unicode, for which there's no support elsewhere.
|
|
*/
|
|
pka_fib.fib$v_names_8bit = 1;
|
|
pka_fib.fib$b_name_format_in = FIB$C_ISL1;
|
|
|
|
/* ODS5 Extended names used as input to QIO have peculiar
|
|
encoding (perhaps to minimize storage?), so the special
|
|
filesys_name result (typically containing fewer carets) must
|
|
be used here.
|
|
*/
|
|
pka_fnam.dsc$a_pointer = nam.naml$l_filesys_name;
|
|
pka_fnam.dsc$w_length = nam.naml$l_filesys_name_size;
|
|
|
|
#else /* !NAML$C_MAXRSS */
|
|
|
|
/* Extract only the name.type;version. */
|
|
pka_fnam.dsc$a_pointer = nam.NAM_L_NAME;
|
|
pka_fnam.dsc$w_length = nam.NAM_B_NAME + nam.NAM_B_TYPE + nam.NAM_B_VER;
|
|
|
|
#endif /* ?NAML$C_MAXRSS */
|
|
|
|
/* Move the directory ID from the NAM[L] to the FIB.
|
|
Clear the FID in the FIB, as we're using the name.
|
|
*/
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
pka_fib.FIB$W_DID[i] = nam.NAM_DID[i];
|
|
pka_fib.FIB$W_FID[i] = 0;
|
|
}
|
|
|
|
/* Use the IO$_ACCESS function to return info about the file.
|
|
This way, the file is not opened, and the expiration and
|
|
revision dates are not modified.
|
|
*/
|
|
status = sys$qiow(0, pka_devchn, IO$_ACCESS,
|
|
&pka_acp_iosb, 0, 0,
|
|
&pka_fibdsc, &pka_fnam, 0, 0, Atr, 0);
|
|
|
|
if ( !ERR(status) )
|
|
status = pka_acp_iosb.status;
|
|
|
|
if ( ERR(status) )
|
|
{
|
|
vms_msg(__G__ "[ Access file QIO failed. ]\n", status);
|
|
sys$dassgn(pka_devchn);
|
|
return -1;
|
|
}
|
|
|
|
uxtime2vmstime(modtime, Cdate);
|
|
memcpy(Rdate, Cdate, sizeof(Cdate));
|
|
|
|
/* Note: Part of the FIB was cleared by earlier QIOW, so reset it. */
|
|
pka_fib.FIB$L_ACCTL = FIB$M_NORECORD;
|
|
|
|
/* Move the directory ID from the NAM[L] to the FIB.
|
|
Clear the FID in the FIB, as we're using the name.
|
|
*/
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
pka_fib.FIB$W_DID[i] = nam.NAM_DID[i];
|
|
pka_fib.FIB$W_FID[i] = 0;
|
|
}
|
|
|
|
/* Use the IO$_MODIFY function to change info about the file */
|
|
/* Note, used this way, the file is not opened, however this would */
|
|
/* normally cause the expiration and revision dates to be modified. */
|
|
/* Using FIB$M_NORECORD prohibits this from happening. */
|
|
status = sys$qiow(0, pka_devchn, IO$_MODIFY,
|
|
&pka_acp_iosb, 0, 0,
|
|
&pka_fibdsc, &pka_fnam, 0, 0, Atr, 0);
|
|
|
|
if ( !ERR(status) )
|
|
status = pka_acp_iosb.status;
|
|
|
|
if ( ERR(status) )
|
|
{
|
|
vms_msg(__G__ "[ Modify file QIO failed. ]\n", status);
|
|
sys$dassgn(pka_devchn);
|
|
return -1;
|
|
}
|
|
|
|
if ( ERR(status = sys$dassgn(pka_devchn)) )
|
|
{
|
|
vms_msg(__G__ "stamp_file: sys$dassgn failed.\n", status);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
|
|
} /* end function stamp_file() */
|
|
|
|
#endif /* TIMESTAMP */
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
#if 0 /* currently not used anywhere ! */
|
|
void dump_rms_block(p)
|
|
unsigned char *p;
|
|
{
|
|
unsigned char bid, len;
|
|
int err;
|
|
char *type;
|
|
char buf[132];
|
|
int i;
|
|
|
|
err = 0;
|
|
bid = p[0];
|
|
len = p[1];
|
|
switch (bid)
|
|
{
|
|
case FAB$C_BID:
|
|
type = "FAB";
|
|
break;
|
|
case XAB$C_ALL:
|
|
type = "xabALL";
|
|
break;
|
|
case XAB$C_KEY:
|
|
type = "xabKEY";
|
|
break;
|
|
case XAB$C_DAT:
|
|
type = "xabDAT";
|
|
break;
|
|
case XAB$C_RDT:
|
|
type = "xabRDT";
|
|
break;
|
|
case XAB$C_FHC:
|
|
type = "xabFHC";
|
|
break;
|
|
case XAB$C_PRO:
|
|
type = "xabPRO";
|
|
break;
|
|
default:
|
|
type = "Unknown";
|
|
err = 1;
|
|
break;
|
|
}
|
|
printf("Block @%08X of type %s (%d).", p, type, bid);
|
|
if (err)
|
|
{
|
|
printf("\n");
|
|
return;
|
|
}
|
|
printf(" Size = %d\n", len);
|
|
printf(" Offset - Hex - Dec\n");
|
|
for (i = 0; i < len; i += 8)
|
|
{
|
|
int j;
|
|
|
|
printf("%3d - ", i);
|
|
for (j = 0; j < 8; j++)
|
|
if (i + j < len)
|
|
printf("%02X ", p[i + j]);
|
|
else
|
|
printf(" ");
|
|
printf(" - ");
|
|
for (j = 0; j < 8; j++)
|
|
if (i + j < len)
|
|
printf("%03d ", p[i + j]);
|
|
else
|
|
printf(" ");
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
#endif /* never */
|
|
#endif /* DEBUG */
|
|
|
|
|
|
|
|
static char vms_msgbuf[256]; /* VMS-specific error message. */
|
|
static $DESCRIPTOR(vms_msgbuf_dscr, vms_msgbuf);
|
|
|
|
|
|
char *vms_msg_text(void)
|
|
{
|
|
return vms_msgbuf;
|
|
}
|
|
|
|
|
|
static int vms_msg_fetch(int status)
|
|
{
|
|
int msglen = 0;
|
|
int sts;
|
|
|
|
sts = lib$sys_getmsg(&status, &msglen, &vms_msgbuf_dscr, 0, 0);
|
|
|
|
vms_msgbuf[msglen] = '\0';
|
|
return sts;
|
|
}
|
|
|
|
|
|
static void vms_msg(__GPRO__ ZCONST char *string, int status)
|
|
{
|
|
if (ERR(vms_msg_fetch(status)))
|
|
Info(slide, 1, ((char *)slide,
|
|
"%s[ VMS status = %d ]\n", string, status));
|
|
else
|
|
Info(slide, 1, ((char *)slide,
|
|
"%s[ %s ]\n", string, vms_msgbuf));
|
|
}
|
|
|
|
|
|
|
|
#ifndef SFX
|
|
|
|
/* 2004-11-23 SMS.
|
|
* Changed to return the resulting file name even when sys$search()
|
|
* fails. Before, if the user specified "fred.zip;4" and there was
|
|
* none, the error message would complain:
|
|
* cannot find either fred.zip;4 or fred.zip;4.zip.
|
|
* when it wasn't really looking for "fred.zip;4.zip".
|
|
*/
|
|
/* 2005-08-11 SPC.
|
|
* The calling interface for the VMS version of do_wild() differs from all
|
|
* other implementations in the way it returns status info.
|
|
* There are three return states:
|
|
* a) pointer to buffer with non-zero-length string
|
|
* - canonical full filespec of existing file (search succeeded).
|
|
* b) pointer to buffer with zero-length string
|
|
* - initial file search has failed, extended VMS error info is available
|
|
* through call to vms_msg_text().
|
|
* c) NULL pointer
|
|
* - repeated file search has failed, because
|
|
* i) the list of matches for the pattern has been exhausted after at
|
|
* least one successful attempt.
|
|
* ii) a second attempt for a failed initial pattern (where do_wild()
|
|
* has returned a zero-length string) was tried and failed again.
|
|
*/
|
|
char *do_wild( __G__ wld )
|
|
__GDEF
|
|
ZCONST char *wld;
|
|
{
|
|
int status;
|
|
|
|
static char filenam[NAM_MAXRSS + 1];
|
|
static char efn[NAM_MAXRSS];
|
|
static char last_wild[NAM_MAXRSS + 1];
|
|
static struct FAB fab;
|
|
static struct NAM_STRUCT nam;
|
|
static int first_call = 1;
|
|
static ZCONST char deflt[] = "[]*.ZIP";
|
|
|
|
if ( first_call || strcmp(wld, last_wild) )
|
|
{ /* (Re)Initialize everything */
|
|
|
|
strcpy( last_wild, wld );
|
|
|
|
fab = cc$rms_fab; /* Initialize FAB. */
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
fab.FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
fab.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fab.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNA = (char *) deflt;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNS = sizeof(deflt) - 1;
|
|
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNA = last_wild;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNS = strlen(last_wild);
|
|
|
|
nam.NAM_ESA = efn;
|
|
nam.NAM_ESS = sizeof(efn)-1;
|
|
nam.NAM_RSA = filenam;
|
|
nam.NAM_RSS = sizeof(filenam)-1;
|
|
|
|
first_call = 0;
|
|
|
|
/* 2005-08-08 SMS.
|
|
* Parse the file spec. If sys$parse() fails, save the VMS
|
|
* error message for later use, and return an empty string.
|
|
*/
|
|
nam.NAM_NOP = NAM_M_SYNCHK; /* Syntax-only analysis. */
|
|
if ( !OK(status = sys$parse(&fab)) )
|
|
{
|
|
vms_msg_fetch(status);
|
|
filenam[0] = '\0'; /* Initialization failed */
|
|
return filenam;
|
|
}
|
|
|
|
/* 2005-11-16 SMS.
|
|
* If syntax-only parse worked, re-parse normally so that
|
|
* sys$search() will work properly. Regardless of parse error,
|
|
* leave filenam[] as-was.
|
|
*/
|
|
nam.NAM_NOP = 0; /* Normal analysis. */
|
|
if ( OK(status = sys$parse(&fab)) )
|
|
{
|
|
status = sys$search(&fab);
|
|
}
|
|
|
|
if ( !OK(status) )
|
|
{
|
|
/* Save the VMS error message for later use. */
|
|
vms_msg_fetch(status);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !OK(sys$search(&fab)) )
|
|
{
|
|
first_call = 1; /* Reinitialize next time */
|
|
return (char *)NULL;
|
|
}
|
|
}
|
|
filenam[nam.NAM_RSL] = '\0'; /* Add the NUL terminator. */
|
|
return filenam;
|
|
|
|
} /* end function do_wild() */
|
|
|
|
#endif /* !SFX */
|
|
|
|
|
|
|
|
static ulg unix_to_vms[8]={ /* Map from UNIX rwx to VMS rwed */
|
|
/* Note that unix w bit is mapped to VMS wd bits */
|
|
/* no access */
|
|
XAB$M_NOREAD | XAB$M_NOWRITE | XAB$M_NODEL | XAB$M_NOEXE, /* --- */
|
|
XAB$M_NOREAD | XAB$M_NOWRITE | XAB$M_NODEL, /* --x */
|
|
XAB$M_NOREAD | XAB$M_NOEXE, /* -w- */
|
|
XAB$M_NOREAD, /* -wx */
|
|
XAB$M_NOWRITE | XAB$M_NODEL | XAB$M_NOEXE, /* r-- */
|
|
XAB$M_NOWRITE | XAB$M_NODEL, /* r-x */
|
|
XAB$M_NOEXE, /* rw- */
|
|
0 /* rwx */
|
|
/* full access */
|
|
};
|
|
|
|
#define SETDFPROT /* We are using undocumented VMS System Service */
|
|
/* SYS$SETDFPROT here. If your version of VMS does */
|
|
/* not have that service, undef SETDFPROT. */
|
|
/* IM: Maybe it's better to put this to Makefile */
|
|
/* and DESCRIP.MMS */
|
|
#ifdef SETDFPROT
|
|
extern int sys$setdfprot();
|
|
#endif
|
|
|
|
int mapattr(__G)
|
|
__GDEF
|
|
{
|
|
ulg tmp = G.crec.external_file_attributes;
|
|
ulg theprot;
|
|
static ulg defprot = (ulg)-1L,
|
|
sysdef, owndef, grpdef, wlddef; /* Default protection fields */
|
|
|
|
/* IM: The only field of XABPRO we need to set here is */
|
|
/* file protection, so we need not to change type */
|
|
/* of G.pInfo->file_attr. WORD is quite enough. */
|
|
|
|
if ( defprot == (ulg)-1L )
|
|
{
|
|
/*
|
|
* First time here -- Get user default settings
|
|
*/
|
|
|
|
#ifdef SETDFPROT /* Undef this if linker cat't resolve SYS$SETDFPROT */
|
|
defprot = (ulg)0L;
|
|
if ( !ERR(sys$setdfprot(0, &defprot)) )
|
|
{
|
|
sysdef = defprot & ( (1L<<XAB$S_SYS)-1 ) << XAB$V_SYS;
|
|
owndef = defprot & ( (1L<<XAB$S_OWN)-1 ) << XAB$V_OWN;
|
|
grpdef = defprot & ( (1L<<XAB$S_GRP)-1 ) << XAB$V_GRP;
|
|
wlddef = defprot & ( (1L<<XAB$S_WLD)-1 ) << XAB$V_WLD;
|
|
}
|
|
else
|
|
#endif /* SETDFPROT */
|
|
{
|
|
umask(defprot = umask(0));
|
|
defprot = ~defprot;
|
|
wlddef = unix_to_vms[defprot & 07] << XAB$V_WLD;
|
|
grpdef = unix_to_vms[(defprot>>3) & 07] << XAB$V_GRP;
|
|
owndef = unix_to_vms[(defprot>>6) & 07] << XAB$V_OWN;
|
|
sysdef = owndef >> (XAB$V_OWN - XAB$V_SYS);
|
|
defprot = sysdef | owndef | grpdef | wlddef;
|
|
}
|
|
}
|
|
|
|
switch (G.pInfo->hostnum) {
|
|
case AMIGA_:
|
|
tmp = (unsigned)(tmp>>16 & 0x0f); /* Amiga RWED bits */
|
|
G.pInfo->file_attr = (tmp << XAB$V_OWN) |
|
|
grpdef | sysdef | wlddef;
|
|
break;
|
|
|
|
case THEOS_:
|
|
tmp &= 0xF1FFFFFFL;
|
|
if ((tmp & 0xF0000000L) != 0x40000000L)
|
|
tmp &= 0x01FFFFFFL; /* not a dir, mask all ftype bits */
|
|
else
|
|
tmp &= 0x41FFFFFFL; /* leave directory bit as set */
|
|
/* fall through! */
|
|
|
|
case UNIX_:
|
|
case VMS_: /*IM: ??? Does VMS Zip store protection in UNIX format ?*/
|
|
/* GRR: Yup. Bad decision on my part... */
|
|
case ACORN_:
|
|
case ATARI_:
|
|
case ATHEOS_:
|
|
case BEOS_:
|
|
case QDOS_:
|
|
case TANDEM_:
|
|
{
|
|
int r = FALSE;
|
|
unsigned uxattr = (unsigned)(tmp >> 16); /* drwxrwxrwx */
|
|
|
|
if (uxattr == 0 && G.extra_field) {
|
|
/* Some (non-Info-ZIP) implementations of Zip for Unix and
|
|
* VMS (and probably others ??) leave 0 in the upper 16-bit
|
|
* part of the external_file_attributes field. Instead, they
|
|
* store file permission attributes in some e.f. block.
|
|
* As a work-around, we search for the presence of one of
|
|
* these extra fields and fall back to the MSDOS compatible
|
|
* part of external_file_attributes if one of the known
|
|
* e.f. types has been detected.
|
|
* Later, we might implement extraction of the permission
|
|
* bits from the VMS extra field. But for now, the work-around
|
|
* should be sufficient to provide "readable" extracted files.
|
|
* (For ASI Unix e.f., an experimental remap of the e.f.
|
|
* mode value IS already provided!)
|
|
*/
|
|
ush ebID;
|
|
unsigned ebLen;
|
|
uch *ef = G.extra_field;
|
|
unsigned ef_len = G.crec.extra_field_length;
|
|
|
|
while (!r && ef_len >= EB_HEADSIZE) {
|
|
ebID = makeword(ef);
|
|
ebLen = (unsigned)makeword(ef+EB_LEN);
|
|
if (ebLen > (ef_len - EB_HEADSIZE))
|
|
/* discoverd some e.f. inconsistency! */
|
|
break;
|
|
switch (ebID) {
|
|
case EF_ASIUNIX:
|
|
if (ebLen >= (EB_ASI_MODE+2)) {
|
|
uxattr =
|
|
(unsigned)makeword(ef+(EB_HEADSIZE+EB_ASI_MODE));
|
|
/* force stop of loop: */
|
|
ef_len = (ebLen + EB_HEADSIZE);
|
|
break;
|
|
}
|
|
/* else: fall through! */
|
|
case EF_PKVMS:
|
|
/* "found nondecypherable e.f. with perm. attr" */
|
|
r = TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
ef_len -= (ebLen + EB_HEADSIZE);
|
|
ef += (ebLen + EB_HEADSIZE);
|
|
}
|
|
}
|
|
if (!r) {
|
|
#ifdef SYMLINKS
|
|
/* Check if the file is a (POSIX-compatible) symbolic link.
|
|
* We restrict symlink support to those "made-by" hosts that
|
|
* are known to support symbolic links.
|
|
*/
|
|
G.pInfo->symlink = S_ISLNK(uxattr) &&
|
|
SYMLINK_HOST(G.pInfo->hostnum);
|
|
#endif
|
|
theprot = (unix_to_vms[uxattr & 07] << XAB$V_WLD)
|
|
| (unix_to_vms[(uxattr>>3) & 07] << XAB$V_GRP)
|
|
| (unix_to_vms[(uxattr>>6) & 07] << XAB$V_OWN);
|
|
if ( uxattr & 0x4000 )
|
|
/* Directory -- set D bits */
|
|
theprot |= (XAB$M_NODEL << XAB$V_SYS)
|
|
| (XAB$M_NODEL << XAB$V_OWN)
|
|
| (XAB$M_NODEL << XAB$V_GRP)
|
|
| (XAB$M_NODEL << XAB$V_WLD);
|
|
G.pInfo->file_attr = theprot;
|
|
break;
|
|
}
|
|
}
|
|
/* fall through! */
|
|
|
|
/* all remaining cases: expand MSDOS read-only bit into write perms */
|
|
case FS_FAT_:
|
|
case FS_HPFS_:
|
|
case FS_NTFS_:
|
|
case MAC_:
|
|
case TOPS20_:
|
|
default:
|
|
theprot = defprot;
|
|
if ( tmp & 1 ) /* Test read-only bit */
|
|
{ /* Bit is set -- set bits in all fields */
|
|
tmp = XAB$M_NOWRITE | XAB$M_NODEL;
|
|
theprot |= (tmp << XAB$V_SYS) | (tmp << XAB$V_OWN) |
|
|
(tmp << XAB$V_GRP) | (tmp << XAB$V_WLD);
|
|
}
|
|
G.pInfo->file_attr = theprot;
|
|
break;
|
|
} /* end switch (host-OS-created-by) */
|
|
|
|
return 0;
|
|
|
|
} /* end function mapattr() */
|
|
|
|
|
|
#define PATH_DEFAULT "SYS$DISK:[]"
|
|
|
|
/* dest_struct_level()
|
|
|
|
Returns file system structure level for argument, negative on
|
|
error.
|
|
*/
|
|
|
|
int dest_struct_level(char *path)
|
|
{
|
|
int acp_code;
|
|
|
|
#ifdef DVI$C_ACP_F11V5
|
|
|
|
/* Should know about ODS5 file system. Do actual check.
|
|
(This should be non-VAX with __CRTL_VER >= 70200000.)
|
|
*/
|
|
|
|
int sts;
|
|
|
|
struct FAB fab;
|
|
struct NAM_STRUCT nam;
|
|
char e_name[NAM_MAXRSS + 1];
|
|
|
|
struct dsc$descriptor_s dev_descr =
|
|
{ 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0 };
|
|
|
|
fab = cc$rms_fab; /* Initialize FAB. */
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
fab.FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
fab.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fab.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNA = PATH_DEFAULT;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNS = strlen(PATH_DEFAULT);
|
|
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNA = path;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNS = strlen(path);
|
|
|
|
nam.NAM_ESA = e_name;
|
|
nam.NAM_ESS = sizeof(e_name) - 1;
|
|
|
|
nam.NAM_NOP = NAM_M_SYNCHK; /* Syntax-only analysis. */
|
|
sts = sys$parse(&fab);
|
|
|
|
if ((sts & STS$M_SUCCESS) == STS$K_SUCCESS)
|
|
{
|
|
/* Load resultant device name into device descriptor. */
|
|
dev_descr.dsc$a_pointer = nam.NAM_L_DEV;
|
|
dev_descr.dsc$w_length = nam.NAM_B_DEV;
|
|
|
|
/* Get filesystem type code.
|
|
(Text results for this item code have been unreliable.)
|
|
*/
|
|
sts = lib$getdvi(&((int) DVI$_ACPTYPE),
|
|
0,
|
|
&dev_descr,
|
|
&acp_code,
|
|
0,
|
|
0);
|
|
|
|
if ((sts & STS$M_SUCCESS) != STS$K_SUCCESS)
|
|
{
|
|
acp_code = -2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
acp_code = -1;
|
|
}
|
|
|
|
#else /* !DVI$C_ACP_F11V5 */
|
|
|
|
/* Too old for ODS5 file system. Return level 2. */
|
|
|
|
acp_code = DVI$C_ACP_F11V2;
|
|
|
|
#endif /* ?DVI$C_ACP_F11V5 */
|
|
|
|
return acp_code;
|
|
}
|
|
|
|
/* 2005-02-12 SMS.
|
|
Note that these name conversion functions do no length checking.
|
|
Buffer overflows are possible.
|
|
*/
|
|
|
|
static void adj_dir_name_ods2(char *dest, char *src, int src_len)
|
|
{
|
|
/* The source string (src) typically extends beyond the directory
|
|
segment of interest, hence the confining src_len argument.
|
|
*/
|
|
unsigned char uchr;
|
|
unsigned char prop;
|
|
char * src_last;
|
|
|
|
for (src_last = src + src_len; src < src_last; src++)
|
|
{
|
|
prop = char_prop[uchr = *src]; /* Get source char, properties. */
|
|
if ((prop & 2) != 0) /* Up-case lower case. */
|
|
{
|
|
uchr -= ('a' - 'A'); /* (Simple-fast is adequate.) */
|
|
}
|
|
else if ((prop & 1) == 0) /* Replace invalid char */
|
|
{
|
|
uchr = '_'; /* with "_". */
|
|
}
|
|
*dest++ = uchr; /* Store good char. */
|
|
}
|
|
*dest = '\0'; /* Terminate destination. */
|
|
}
|
|
|
|
|
|
static void adj_dir_name_ods5(char *dest, char *src, int src_len)
|
|
{
|
|
/* The source string (src) typically extends beyond the directory
|
|
segment of interest, hence the confining src_len argument.
|
|
*/
|
|
unsigned char uchr;
|
|
unsigned char prop;
|
|
char * src_last;
|
|
|
|
for (src_last = src + src_len; src < src_last; src++)
|
|
{
|
|
prop = char_prop[uchr = *src]; /* Get source char, props. */
|
|
prop = char_prop[uchr]; /* Get source char props. */
|
|
if ((prop & (32+8+4)) != 0) /* Escape 1-char, including */
|
|
{ /* SP and dot. */
|
|
*dest++ = '^'; /* Insert caret. */
|
|
if ((prop & 8) != 0) /* Replace SP with "_". */
|
|
{
|
|
uchr = '_';
|
|
}
|
|
else if (uchr == '?')
|
|
{
|
|
uchr = '/'; /* Replace "?" with "/". */
|
|
}
|
|
}
|
|
else if ((prop & 64) != 0) /* Escape hex-hex. */
|
|
{
|
|
*dest++ = '^'; /* Insert caret. */
|
|
*dest++ = hex_digit[uchr >> 4]; /* First hex digit. */
|
|
uchr = hex_digit[uchr & 15]; /* Second hex digit. */
|
|
}
|
|
else if ((prop & 16) == 0) /* Replace invalid with "_". */
|
|
{
|
|
uchr = '_';
|
|
}
|
|
*dest++ = uchr; /* Put good (or last) char. */
|
|
}
|
|
*dest = '\0'; /* Terminate destination. */
|
|
}
|
|
|
|
|
|
static void adj_file_name_ods2(char *dest, char *src)
|
|
{
|
|
unsigned char uchr;
|
|
unsigned char prop;
|
|
char *endp;
|
|
char *versionp;
|
|
char *last_dot;
|
|
|
|
endp = src + strlen(src); /* Pointer to the NUL-terminator of src. */
|
|
/* Starting at the end, find the last non-decimal-digit. */
|
|
versionp = endp;
|
|
while ((--versionp >= src) && isdigit(*versionp));
|
|
|
|
/* Left-most non-digit of a valid version is ";" (or perhaps "."). */
|
|
if ((*versionp != ';') && ((uO.Y_flag == 0) || (*versionp != '.')))
|
|
{
|
|
/* No valid version. The last dot is the last dot. */
|
|
versionp = endp;
|
|
}
|
|
else
|
|
{ /* Some kind of valid version. */
|
|
if (!uO.V_flag) /* Not -V, so cut off version. */
|
|
{
|
|
*versionp = '\0';
|
|
}
|
|
else if (*versionp == '.')
|
|
{
|
|
*versionp = ';'; /* Replace version dot with ";". */
|
|
}
|
|
}
|
|
|
|
/* 2008-11-04 SMS.
|
|
* Simplified the scheme here to escape all non-last dots. This
|
|
* should work when Zip works correctly (Zip 3.1).
|
|
* Note that if no last dot is found, the non-last-dot test below
|
|
* will always fail, but that's not a problem.
|
|
*/
|
|
|
|
/* Find the last dot (if any). */
|
|
last_dot = versionp;
|
|
while ((--last_dot >= src) && (*last_dot != '.'));
|
|
|
|
/* Critical features having been located, transform the name. */
|
|
while ((uchr = *src++) != '\0') /* Get source character. */
|
|
{
|
|
/* Note that "src" has been incremented, affecting "src <=". */
|
|
prop = char_prop[uchr]; /* Get source char properties. */
|
|
if ((prop & 2) != 0) /* Up-case lower case. */
|
|
{
|
|
uchr -= ('a' - 'A'); /* (Simple-fast is adequate.) */
|
|
}
|
|
else if ((prop & 4) != 0) /* Dot. */
|
|
{
|
|
if (src <= last_dot) /* Replace non-last dot */
|
|
{
|
|
uchr = '_'; /* with "_". */
|
|
}
|
|
}
|
|
else if ((prop & 1) == 0) /* Replace SP or invalid char, */
|
|
{
|
|
if (src <= versionp) /* if not in version, */
|
|
{
|
|
uchr = '_'; /* with "_". */
|
|
}
|
|
}
|
|
*dest++ = uchr; /* Store good char. */
|
|
}
|
|
*dest = '\0'; /* Terminate destination. */
|
|
}
|
|
|
|
|
|
static void adj_file_name_ods5(char *dest, char *src)
|
|
{
|
|
unsigned char uchr;
|
|
unsigned char prop;
|
|
char *endp;
|
|
char *versionp;
|
|
char *last_dot;
|
|
|
|
endp = src + strlen(src); /* Pointer to the NUL-terminator of src. */
|
|
/* Starting at the end, find the last non-decimal-digit. */
|
|
versionp = endp;
|
|
while ((--versionp >= src) && isdigit(*versionp));
|
|
|
|
/* Left-most non-digit of a valid version is ";" (or perhaps "."). */
|
|
if ((*versionp != ';') && ((uO.Y_flag == 0) || (*versionp != '.')))
|
|
{
|
|
/* No valid version. The last dot is the last dot. */
|
|
versionp = endp;
|
|
}
|
|
else
|
|
{ /* Some kind of valid version. */
|
|
if (!uO.V_flag) /* Not -V, so cut off version. */
|
|
{
|
|
*versionp = '\0';
|
|
}
|
|
else if (*versionp == '.')
|
|
{
|
|
*versionp = ';'; /* Replace version dot with ";". */
|
|
}
|
|
}
|
|
|
|
/* 2008-11-04 SMS.
|
|
* Simplified the scheme here to escape all non-last dots. This
|
|
* should work when Zip works correctly (Zip 3.1).
|
|
* Note that if no last dot is found, the non-last-dot test below
|
|
* will always fail, but that's not a problem.
|
|
*/
|
|
|
|
/* Find the last dot (if any). */
|
|
last_dot = versionp;
|
|
while ((--last_dot >= src) && (*last_dot != '.'));
|
|
|
|
/* Critical features having been located, transform the name. */
|
|
while ((uchr = *src++) != '\0') /* Get source character. */
|
|
{
|
|
/* Note that "src" has been incremented, affecting "src <=". */
|
|
prop = char_prop[uchr]; /* Get source char props. */
|
|
if ((prop & (32+8)) != 0) /* Escape 1-char, including */
|
|
{ /* SP (but not dot). */
|
|
if (src <= versionp) /* No escapes for version. */
|
|
{
|
|
*dest++ = '^'; /* Insert caret. */
|
|
if ((prop & 8) != 0) /* Replace SP with "_". */
|
|
{
|
|
uchr = '_';
|
|
}
|
|
else if (uchr == '?')
|
|
{
|
|
uchr = '/'; /* Replace "?" with "/". */
|
|
}
|
|
}
|
|
}
|
|
else if ((prop & 4) != 0) /* Dot. */
|
|
{
|
|
if (src <= last_dot) /* Escape non-last dot */
|
|
{
|
|
*dest++ = '^'; /* Insert caret. */
|
|
}
|
|
}
|
|
else if ((prop & 64) != 0) /* Escape hex-hex. */
|
|
{
|
|
*dest++ = '^'; /* Insert caret. */
|
|
*dest++ = hex_digit[uchr >> 4]; /* First hex digit. */
|
|
uchr = hex_digit[uchr & 15]; /* Second hex digit. */
|
|
}
|
|
else if ((prop & 16) == 0) /* Replace invalid with "_". */
|
|
{
|
|
uchr = '_';
|
|
}
|
|
*dest++ = uchr; /* Put good (or last) char. */
|
|
}
|
|
*dest = '\0'; /* Terminate destination. */
|
|
}
|
|
|
|
|
|
|
|
# define FN_MASK 7
|
|
# define USE_DEFAULT (FN_MASK+1)
|
|
|
|
/*
|
|
* Checkdir function codes:
|
|
* ROOT - set root path from unzip qq d:[dir]
|
|
* INIT - get ready for "filename"
|
|
* APPEND_DIR - append pathcomp
|
|
* APPEND_NAME - append filename
|
|
* APPEND_NAME | USE_DEFAULT - expand filename using collected path
|
|
* GETPATH - return resulting filespec
|
|
* END - free dynamically allocated space prior to program exit
|
|
*/
|
|
|
|
static int created_dir;
|
|
static int dest_file_sys_level;
|
|
static int ods2_names = -1;
|
|
|
|
int mapname(__G__ renamed)
|
|
/* returns: */
|
|
/* MPN_OK if no error, */
|
|
/* MPN_INF_TRUNC if caution (filename trunc), */
|
|
/* MPN_INF_SKIP if warning (skip file, dir doesn't exist), */
|
|
/* MPN_ERR_SKIP if error (skip file), */
|
|
/* MPN_CREATED_DIR if has created directory, */
|
|
/* MPN_VOL_LABEL if path was volume label (skip it) */
|
|
/* MPN_NOMEM if no memory (skip file) */
|
|
__GDEF
|
|
int renamed;
|
|
{
|
|
char pathcomp[FILNAMSIZ]; /* Path-component buffer. */
|
|
char *last_slash; /* Last slash in path. */
|
|
char *next_slash; /* Next slash in path. */
|
|
int dir_len; /* Length of a directory segment. */
|
|
|
|
char *cp = (char *)NULL; /* character pointer */
|
|
int killed_ddot = FALSE; /* Set when skipping "../" pathcomp. */
|
|
int error = MPN_OK;
|
|
|
|
if ( renamed )
|
|
{
|
|
if ( !(error = checkdir(__G__ pathcomp, APPEND_NAME | USE_DEFAULT)) )
|
|
strcpy(G.filename, pathcomp);
|
|
return error;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Initialize various pointers and counters and stuff.
|
|
---------------------------------------------------------------------------*/
|
|
|
|
if (G.pInfo->vollabel)
|
|
return MPN_VOL_LABEL; /* can't set disk volume labels on VMS */
|
|
|
|
/* can create path as long as not just freshening, or if user told us */
|
|
G.create_dirs = !uO.fflag;
|
|
|
|
created_dir = FALSE; /* not yet */
|
|
|
|
/* If not yet known, determine the destination file system type
|
|
(ODS2 or ODS5). (If the user specified a destination, we should
|
|
already have this, so use the default destination.)
|
|
*/
|
|
if (ods2_names < 0)
|
|
{
|
|
/* If user doesn't force ODS2, set flag according to destination. */
|
|
if (uO.ods2_flag == 0)
|
|
{
|
|
ods2_names =
|
|
(dest_struct_level(PATH_DEFAULT) <= DVI$C_ACP_F11V2);
|
|
}
|
|
else
|
|
{
|
|
ods2_names = 1; /* User demands ODS2 names. */
|
|
}
|
|
}
|
|
|
|
/* GRR: for VMS, convert to internal format now or later? or never? */
|
|
if (checkdir(__G__ pathcomp, INIT) == 10)
|
|
return MPN_NOMEM; /* Initialize path buffer, unless no memory. */
|
|
|
|
/* Locate and treat directory segments one at a time.
|
|
When pointer exceeds last_slash, then directory segments are
|
|
done, and only the name (with version?) remains.
|
|
*/
|
|
|
|
*pathcomp = '\0'; /* Initialize translation buffer. */
|
|
last_slash = strrchr(G.filename, '/'); /* Find last slash. */
|
|
|
|
if (uO.jflag) /* If junking directories, */
|
|
cp = last_slash; /* start at (will be after) the last slash. */
|
|
|
|
if (cp == NULL) /* If no '/', or keeping directories, */
|
|
cp = G.filename; /* start at the front of the pathname. */
|
|
else /* Else, with directories to junk, */
|
|
++cp; /* start after the last slash. */
|
|
|
|
/* Loop through the directory segments. */
|
|
while (cp < last_slash)
|
|
{
|
|
next_slash = strchr(cp, '/'); /* Find the next slash. */
|
|
dir_len = next_slash- cp;
|
|
|
|
/* Filter out unacceptable directories. */
|
|
if ((dir_len == 2) && (strncmp(cp, "..", 2) == 0))
|
|
{ /* Double dot. */
|
|
if (!uO.ddotflag) /* Not allowed. Skip it. */
|
|
{
|
|
dir_len = 0;
|
|
killed_ddot = TRUE; /* Record skipping double-dot. */
|
|
}
|
|
}
|
|
else if ((dir_len == 1) && (strncmp(cp, ".", 1) == 0))
|
|
{ /* Single dot. No-op. Skip it. */
|
|
dir_len = 0;
|
|
}
|
|
|
|
/* If non-null, acceptable directory, then process it. */
|
|
if (dir_len > 0)
|
|
{
|
|
if (ods2_names) /* Make directory name ODS2-compliant. */
|
|
{
|
|
adj_dir_name_ods2(pathcomp, cp, dir_len);
|
|
}
|
|
else /* Make directory name ODS5-compliant. */
|
|
{
|
|
adj_dir_name_ods5(pathcomp, cp, dir_len);
|
|
}
|
|
if (((error = checkdir(__G__ pathcomp, APPEND_DIR))
|
|
& MPN_MASK) > MPN_INF_TRUNC)
|
|
return error;
|
|
}
|
|
cp = next_slash+ 1; /* Continue at the next name segment. */
|
|
} /* end while loop */
|
|
|
|
/* Show warning when stripping insecure "parent dir" path components */
|
|
if (killed_ddot && QCOND2) {
|
|
Info(slide, 0, ((char *)slide,
|
|
"warning: skipped \"../\" path component(s) in %s\n",
|
|
FnFilter1(G.filename)));
|
|
if (!(error & ~MPN_MASK))
|
|
error = (error & MPN_MASK) | PK_WARN;
|
|
}
|
|
|
|
/* If there is one, adjust the name.type;version segment. */
|
|
if (strlen(cp) == 0)
|
|
{
|
|
/* Directory only, no file name. Create the directory, as needed.
|
|
Report directory creation to user.
|
|
*/
|
|
checkdir(__G__ "", APPEND_NAME); /* create directory, if not found */
|
|
checkdir(__G__ G.filename, GETPATH);
|
|
if (created_dir) {
|
|
if (QCOND2) {
|
|
Info(slide, 0, ((char *)slide, " creating: %s\n",
|
|
FnFilter1(G.filename)));
|
|
}
|
|
/* set dir time (note trailing '/') */
|
|
return (error & ~MPN_MASK) | MPN_CREATED_DIR;
|
|
}
|
|
/* dir existed already; don't look for data to extract */
|
|
return (error & ~MPN_MASK) | MPN_INF_SKIP;
|
|
}
|
|
|
|
/* Process the file name. */
|
|
if (ods2_names) /* Make file name ODS2-compliant. */
|
|
{
|
|
adj_file_name_ods2(pathcomp, cp);
|
|
}
|
|
else /* Make file name ODS5-compliant. */
|
|
{
|
|
adj_file_name_ods5(pathcomp, cp);
|
|
}
|
|
|
|
checkdir(__G__ pathcomp, APPEND_NAME); /* returns 1 if truncated: care? */
|
|
checkdir(__G__ G.filename, GETPATH);
|
|
|
|
return error;
|
|
|
|
} /* end function mapname() */
|
|
|
|
|
|
|
|
int checkdir(__G__ pathcomp, fcn)
|
|
/*
|
|
* returns:
|
|
* MPN_OK - no problem detected
|
|
* MPN_INF_TRUNC - (on APPEND_NAME) truncated filename
|
|
* MPN_INF_SKIP - path doesn't exist, not allowed to create
|
|
* MPN_ERR_SKIP - path doesn't exist, tried to create and failed; or path
|
|
* exists and is not a directory, but is supposed to be
|
|
* MPN_ERR_TOOLONG - path is too long
|
|
* MPN_NOMEM - can't allocate memory for filename buffers
|
|
*/
|
|
__GDEF
|
|
char *pathcomp;
|
|
int fcn;
|
|
{
|
|
int function=fcn & FN_MASK;
|
|
static char pathbuf[FILNAMSIZ];
|
|
|
|
/* previously created directory (initialized to impossible dir. spec.) */
|
|
static char lastdir[FILNAMSIZ] = "\t";
|
|
|
|
static char *pathptr = pathbuf; /* For debugger */
|
|
static char *devptr, *dirptr;
|
|
static int devlen, dirlen;
|
|
static int root_dirlen;
|
|
static char *end;
|
|
static int first_comp, root_has_dir;
|
|
static int rootlen=0;
|
|
static char *rootend;
|
|
static int mkdir_failed=0;
|
|
int status;
|
|
struct FAB fab;
|
|
struct NAM_STRUCT nam;
|
|
|
|
|
|
/************
|
|
*** ROOT ***
|
|
************/
|
|
|
|
#if (!defined(SFX) || defined(SFX_EXDIR))
|
|
if (function == ROOT)
|
|
{ /* Assume VMS root spec */
|
|
/* 2006-01-20 SMS.
|
|
Changed to use sys$parse() instead of sys$filescan() for analysis
|
|
of the user-specified destination directory. Previously, various
|
|
values behaved badly, without complaint, e.g. "-d sys$scratch".
|
|
*/
|
|
char *root_dest;
|
|
|
|
/* If the root path has already been set, return immediately. */
|
|
if (rootlen > 0)
|
|
return MPN_OK;
|
|
|
|
/* Initialization. */
|
|
root_dest = PATH_DEFAULT; /* Default destination for ODSx sensing. */
|
|
root_has_dir = 0; /* Root includes a directory. */
|
|
fab = cc$rms_fab; /* Initialize FAB. */
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
fab.FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
fab.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fab.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
/* Specified file spec. */
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNA = pathcomp;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNS = strlen(pathcomp);
|
|
|
|
/* Default file spec. */
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNA = PATH_DEFAULT;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNS = strlen(PATH_DEFAULT);
|
|
|
|
/* Expanded file spec. */
|
|
nam.NAM_ESA = pathbuf;
|
|
nam.NAM_ESS = NAM_MAXRSS;
|
|
|
|
status = sys$parse(&fab);
|
|
|
|
/* OK so far, if OK or if directory not found. */
|
|
if (((status & STS$M_SEVERITY) != STS$K_SUCCESS) &&
|
|
(status != RMS$_DNF))
|
|
{
|
|
/* Invalid destination directory specified. */
|
|
Info(slide, 1, ((char *)slide,
|
|
"Invalid destination directory (parse error): %s\n",
|
|
FnFilter1(pathcomp)));
|
|
return MPN_ERR_SKIP;
|
|
}
|
|
|
|
/* Should be only a device:[directory], so name+type+version
|
|
should have length 2 (".;").
|
|
*/
|
|
if (nam.NAM_B_NAME + nam.NAM_B_TYPE + nam.NAM_B_VER > 2)
|
|
{
|
|
Info(slide, 1, ((char *)slide,
|
|
"Invalid destination directory (includes file name): %s\n",
|
|
FnFilter1(nam.NAM_ESA)));
|
|
return MPN_ERR_SKIP;
|
|
}
|
|
|
|
/* Truncate at name, leaving only "dev:[dir]". */
|
|
*nam.NAM_L_NAME = '\0';
|
|
rootlen = nam.NAM_L_NAME - nam.NAM_ESA;
|
|
|
|
/* Remove any trailing dots in directory. */
|
|
if ((nam.NAM_ESA[rootlen-1] == ']') &&
|
|
(nam.NAM_ESA[rootlen-2] != '^'))
|
|
{
|
|
root_has_dir = 1;
|
|
rootlen -= 2;
|
|
while ((nam.NAM_ESA[rootlen] == '.') &&
|
|
(nam.NAM_ESA[rootlen-1] != '^'))
|
|
{
|
|
rootlen--;
|
|
}
|
|
nam.NAM_ESA[++rootlen] = ']';
|
|
nam.NAM_ESA[++rootlen] = '\0';
|
|
}
|
|
|
|
devlen = nam.NAM_L_DIR - nam.NAM_ESA;
|
|
|
|
/* If directory not found, then create it. */
|
|
if (status == RMS$_DNF)
|
|
{
|
|
if (status = mkdir(nam.NAM_ESA, 0))
|
|
{
|
|
Info(slide, 1, ((char *)slide,
|
|
"Can not create destination directory: %s\n",
|
|
FnFilter1(nam.NAM_ESA)));
|
|
|
|
/* path didn't exist, tried to create, and failed. */
|
|
return MPN_ERR_SKIP;
|
|
}
|
|
}
|
|
|
|
/* Save the (valid) device:[directory] spec. */
|
|
strcpy(pathbuf, nam.NAM_ESA);
|
|
root_dest = pathbuf;
|
|
|
|
/* At this point, the true destination is known. If the user
|
|
supplied an invalid destination directory, the default
|
|
directory will be used. (This may be pointless, but should
|
|
be safe.)
|
|
*/
|
|
|
|
/* If not yet known, determine the destination (root_dest) file
|
|
system type (ODS2 or ODS5).
|
|
*/
|
|
if (ods2_names < 0)
|
|
{
|
|
/* If user doesn't force ODS2, set flag according to dest. */
|
|
if (uO.ods2_flag == 0)
|
|
{
|
|
ods2_names = (dest_struct_level(root_dest) <= DVI$C_ACP_F11V2);
|
|
}
|
|
else
|
|
{
|
|
ods2_names = 1; /* User demands ODS2 names. */
|
|
}
|
|
}
|
|
|
|
/* Replace trailing "]" with ".", for later appending. */
|
|
if ((pathbuf[rootlen-1] == ']') || (pathbuf[rootlen-1] == '>'))
|
|
{
|
|
pathbuf[rootlen-1] = '.';
|
|
}
|
|
|
|
/* Set various pointers and lengths. */
|
|
devptr = pathbuf;
|
|
dirptr = pathbuf + (nam.NAM_L_DIR - nam.NAM_ESA);
|
|
rootend = pathbuf + rootlen;
|
|
*(end = rootend) = '\0';
|
|
root_dirlen = dirlen = rootlen - devlen;
|
|
first_comp = !root_has_dir;
|
|
return MPN_OK;
|
|
}
|
|
#endif /* !SFX || SFX_EXDIR */
|
|
|
|
|
|
/************
|
|
*** INIT ***
|
|
************/
|
|
|
|
if ( function == INIT )
|
|
{
|
|
if ( strlen(G.filename) + rootlen + 13 > NAM_MAXRSS )
|
|
return MPN_ERR_TOOLONG;
|
|
|
|
if ( rootlen == 0 ) /* No root given, reset everything. */
|
|
{
|
|
devptr = dirptr = rootend = pathbuf;
|
|
devlen = dirlen = 0;
|
|
}
|
|
end = rootend;
|
|
first_comp = !root_has_dir;
|
|
if ( dirlen = root_dirlen )
|
|
end[-1] = '.';
|
|
*end = '\0';
|
|
return MPN_OK;
|
|
}
|
|
|
|
|
|
/******************
|
|
*** APPEND_DIR ***
|
|
******************/
|
|
if ( function == APPEND_DIR )
|
|
{
|
|
int cmplen;
|
|
|
|
cmplen = strlen(pathcomp);
|
|
|
|
if ( first_comp )
|
|
{
|
|
*end++ = '[';
|
|
if ( cmplen )
|
|
*end++ = '.'; /* "dir/..." --> "[.dir...]" */
|
|
/* else "/dir..." --> "[dir...]" */
|
|
first_comp = 0;
|
|
}
|
|
|
|
if ( cmplen == 1 && *pathcomp == '.' )
|
|
; /* "..././..." -- ignore */
|
|
|
|
else if ( cmplen == 2 && pathcomp[0] == '.' && pathcomp[1] == '.' )
|
|
{ /* ".../../..." -- convert to "...-..." */
|
|
*end++ = '-';
|
|
*end++ = '.';
|
|
}
|
|
|
|
else if ( cmplen + (end-pathptr) > NAM_MAXRSS )
|
|
return MPN_ERR_TOOLONG;
|
|
|
|
else
|
|
{
|
|
strcpy(end, pathcomp);
|
|
*(end+=cmplen) = '.';
|
|
++end;
|
|
}
|
|
dirlen = end - dirptr;
|
|
*end = '\0';
|
|
return MPN_OK;
|
|
}
|
|
|
|
|
|
/*******************
|
|
*** APPEND_NAME ***
|
|
*******************/
|
|
if ( function == APPEND_NAME )
|
|
{
|
|
if ( fcn & USE_DEFAULT )
|
|
{ /* Expand renamed filename using collected path, return
|
|
* at pathcomp */
|
|
fab = cc$rms_fab; /* Initialize FAB. */
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
fab.FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
fab.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fab.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNA = pathptr;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNS = end - pathptr;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNA = G.filename;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNS = strlen(G.filename);
|
|
|
|
nam.NAM_ESA = pathcomp; /* (Great design. ---v. SMS.) */
|
|
nam.NAM_ESS = NAM_MAXRSS; /* Assume large enough. */
|
|
|
|
if (!OK(status = sys$parse(&fab)) && status == RMS$_DNF )
|
|
/* Directory not found: */
|
|
{ /* ... try to create it */
|
|
char save;
|
|
char *dirend;
|
|
int mkdir_failed;
|
|
|
|
dirend = (char*)nam.NAM_L_DIR + nam.NAM_B_DIR;
|
|
save = *dirend;
|
|
*dirend = '\0';
|
|
if ( (mkdir_failed = mkdir(nam.NAM_L_DEV, 0)) &&
|
|
errno == EEXIST )
|
|
mkdir_failed = 0;
|
|
*dirend = save;
|
|
if ( mkdir_failed )
|
|
return 3;
|
|
created_dir = TRUE;
|
|
} /* if (sys$parse... */
|
|
pathcomp[nam.NAM_ESL] = '\0';
|
|
return MPN_OK;
|
|
} /* if (USE_DEFAULT) */
|
|
else
|
|
{
|
|
*end = '\0';
|
|
if ( dirlen )
|
|
{
|
|
dirptr[dirlen-1] = ']'; /* Close directory */
|
|
|
|
/*
|
|
* Try to create the target directory.
|
|
* Don't waste time creating directory that was created
|
|
* last time.
|
|
*/
|
|
if ( STRICMP(lastdir, pathbuf) )
|
|
{
|
|
mkdir_failed = 0;
|
|
if ( mkdir(pathbuf, 0) )
|
|
{
|
|
if ( errno != EEXIST )
|
|
mkdir_failed = 1; /* Mine for GETPATH */
|
|
}
|
|
else
|
|
created_dir = TRUE;
|
|
strcpy(lastdir, pathbuf);
|
|
}
|
|
}
|
|
else
|
|
{ /*
|
|
* Target directory unspecified.
|
|
* Try to create "SYS$DISK:[]"
|
|
*/
|
|
if ( strcmp(lastdir, PATH_DEFAULT) )
|
|
{
|
|
strcpy(lastdir, PATH_DEFAULT);
|
|
mkdir_failed = 0;
|
|
if ( mkdir(lastdir, 0) && errno != EEXIST )
|
|
mkdir_failed = 1; /* Mine for GETPATH */
|
|
}
|
|
}
|
|
if ( strlen(pathcomp) + (end-pathbuf) > 255 )
|
|
return MPN_INF_TRUNC;
|
|
strcpy(end, pathcomp);
|
|
end += strlen(pathcomp);
|
|
return MPN_OK;
|
|
}
|
|
}
|
|
|
|
|
|
/***************
|
|
*** GETPATH ***
|
|
***************/
|
|
if ( function == GETPATH )
|
|
{
|
|
if ( mkdir_failed )
|
|
return MPN_ERR_SKIP;
|
|
*end = '\0'; /* To be safe */
|
|
strcpy( pathcomp, pathbuf );
|
|
return MPN_OK;
|
|
}
|
|
|
|
|
|
/***********
|
|
*** END ***
|
|
***********/
|
|
if ( function == END )
|
|
{
|
|
Trace((stderr, "checkdir(): nothing to free...\n"));
|
|
rootlen = 0;
|
|
return MPN_OK;
|
|
}
|
|
|
|
return MPN_INVALID; /* should never reach */
|
|
|
|
}
|
|
|
|
|
|
|
|
int check_for_newer(__G__ filenam) /* return 1 if existing file newer or */
|
|
__GDEF /* equal; 0 if older; -1 if doesn't */
|
|
char *filenam; /* exist yet */
|
|
{
|
|
#ifdef USE_EF_UT_TIME
|
|
iztimes z_utime;
|
|
struct tm *t;
|
|
#endif
|
|
char *filenam_stat;
|
|
unsigned short timbuf[7];
|
|
unsigned dy, mo, yr, hh, mm, ss, dy2, mo2, yr2, hh2, mm2, ss2;
|
|
struct FAB fab;
|
|
struct XABDAT xdat;
|
|
#ifdef NAML$C_MAXRSS
|
|
struct NAM_STRUCT nam;
|
|
#endif
|
|
|
|
/* 2008-07-12 SMS.
|
|
* Special case for "." as a file name, not as the current directory.
|
|
* Substitute ".;" to keep stat() from seeing a plain ".".
|
|
*/
|
|
if (strcmp(filenam, ".") == 0)
|
|
filenam_stat = ".;";
|
|
else
|
|
filenam_stat = filenam;
|
|
|
|
if (stat(filenam_stat, &G.statbuf))
|
|
return DOES_NOT_EXIST;
|
|
|
|
fab = cc$rms_fab; /* Initialize FAB. */
|
|
xdat = cc$rms_xabdat; /* Initialize XAB. */
|
|
|
|
#ifdef NAML$C_MAXRSS
|
|
|
|
nam = CC_RMS_NAM; /* Initialize NAM[L]. */
|
|
fab.FAB_NAM = &nam; /* Point FAB to NAM[L]. */
|
|
|
|
fab.fab$l_dna = (char *) -1; /* Using NAML for default name. */
|
|
fab.fab$l_fna = (char *) -1; /* Using NAML for file name. */
|
|
|
|
#endif /* NAML$C_MAXRSS */
|
|
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNA = filenam;
|
|
FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNS = strlen(filenam);
|
|
|
|
fab.fab$l_xab = (char *) &xdat;
|
|
fab.fab$l_fop = FAB$M_GET | FAB$M_UFO;
|
|
|
|
if (ERR(sys$open(&fab))) /* open failure: report exists and */
|
|
return EXISTS_AND_OLDER; /* older so new copy will be made */
|
|
sys$numtim(&timbuf, &xdat.xab$q_cdt);
|
|
fab.fab$l_xab = NULL;
|
|
|
|
sys$dassgn(fab.fab$l_stv);
|
|
sys$close(&fab); /* be sure file is closed and RMS knows about it */
|
|
|
|
#ifdef USE_EF_UT_TIME
|
|
if (G.extra_field &&
|
|
#ifdef IZ_CHECK_TZ
|
|
G.tz_is_valid &&
|
|
#endif
|
|
(ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
|
|
G.lrec.last_mod_dos_datetime, &z_utime, NULL)
|
|
& EB_UT_FL_MTIME))
|
|
t = localtime(&(z_utime.mtime));
|
|
else
|
|
t = (struct tm *)NULL;
|
|
|
|
if (t != (struct tm *)NULL)
|
|
{
|
|
yr2 = (unsigned)(t->tm_year) + 1900;
|
|
mo2 = (unsigned)(t->tm_mon) + 1;
|
|
dy2 = (unsigned)(t->tm_mday);
|
|
hh2 = (unsigned)(t->tm_hour);
|
|
mm2 = (unsigned)(t->tm_min);
|
|
ss2 = (unsigned)(t->tm_sec);
|
|
|
|
/* round to nearest sec--may become 60,
|
|
but doesn't matter for compare */
|
|
ss = (unsigned)((float)timbuf[5] + (float)timbuf[6]*.01 + 0.5);
|
|
TTrace((stderr, "check_for_newer: using Unix extra field mtime\n"));
|
|
}
|
|
else
|
|
#endif /* USE_EF_UT_TIME */
|
|
{
|
|
yr2 = ((G.lrec.last_mod_dos_datetime >> 25) & 0x7f) + 1980;
|
|
mo2 = (G.lrec.last_mod_dos_datetime >> 21) & 0x0f;
|
|
dy2 = (G.lrec.last_mod_dos_datetime >> 16) & 0x1f;
|
|
hh2 = (G.lrec.last_mod_dos_datetime >> 11) & 0x1f;
|
|
mm2 = (G.lrec.last_mod_dos_datetime >> 5) & 0x3f;
|
|
ss2 = (G.lrec.last_mod_dos_datetime << 1) & 0x1f;
|
|
|
|
/* round to nearest 2 secs--may become 60,
|
|
but doesn't matter for compare */
|
|
ss = (unsigned)((float)timbuf[5] + (float)timbuf[6]*.01 + 1.) & (~1);
|
|
}
|
|
yr = timbuf[0];
|
|
mo = timbuf[1];
|
|
dy = timbuf[2];
|
|
hh = timbuf[3];
|
|
mm = timbuf[4];
|
|
|
|
if (yr > yr2)
|
|
return EXISTS_AND_NEWER;
|
|
else if (yr < yr2)
|
|
return EXISTS_AND_OLDER;
|
|
|
|
if (mo > mo2)
|
|
return EXISTS_AND_NEWER;
|
|
else if (mo < mo2)
|
|
return EXISTS_AND_OLDER;
|
|
|
|
if (dy > dy2)
|
|
return EXISTS_AND_NEWER;
|
|
else if (dy < dy2)
|
|
return EXISTS_AND_OLDER;
|
|
|
|
if (hh > hh2)
|
|
return EXISTS_AND_NEWER;
|
|
else if (hh < hh2)
|
|
return EXISTS_AND_OLDER;
|
|
|
|
if (mm > mm2)
|
|
return EXISTS_AND_NEWER;
|
|
else if (mm < mm2)
|
|
return EXISTS_AND_OLDER;
|
|
|
|
if (ss >= ss2)
|
|
return EXISTS_AND_NEWER;
|
|
|
|
return EXISTS_AND_OLDER;
|
|
}
|
|
|
|
|
|
|
|
#ifdef RETURN_CODES
|
|
void return_VMS(__G__ err)
|
|
__GDEF
|
|
#else
|
|
void return_VMS(err)
|
|
#endif
|
|
int err;
|
|
{
|
|
int severity;
|
|
|
|
#ifdef RETURN_CODES
|
|
/*---------------------------------------------------------------------------
|
|
Do our own, explicit processing of error codes and print message, since
|
|
VMS misinterprets return codes as rather obnoxious system errors ("access
|
|
violation," for example).
|
|
---------------------------------------------------------------------------*/
|
|
|
|
switch (err) {
|
|
case PK_COOL:
|
|
break; /* life is fine... */
|
|
case PK_WARN:
|
|
Info(slide, 1, ((char *)slide, "\n\
|
|
[return-code %d: warning error \
|
|
(e.g., failed CRC or unknown compression method)]\n", err));
|
|
break;
|
|
case PK_ERR:
|
|
case PK_BADERR:
|
|
Info(slide, 1, ((char *)slide, "\n\
|
|
[return-code %d: error in zipfile \
|
|
(e.g., cannot find local file header sig)]\n", err));
|
|
break;
|
|
case PK_MEM:
|
|
case PK_MEM2:
|
|
case PK_MEM3:
|
|
case PK_MEM4:
|
|
case PK_MEM5:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: insufficient memory]\n", err));
|
|
break;
|
|
case PK_NOZIP:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: zipfile not found]\n", err));
|
|
break;
|
|
case PK_PARAM: /* exit(PK_PARAM); gives "access violation" */
|
|
Info(slide, 1, ((char *)slide, "\n\
|
|
[return-code %d: bad or illegal parameters specified on command line]\n",
|
|
err));
|
|
break;
|
|
case PK_FIND:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: no files found to extract/view/etc.]\n",
|
|
err));
|
|
break;
|
|
case PK_DISK:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: disk full or other I/O error]\n", err));
|
|
break;
|
|
case PK_EOF:
|
|
Info(slide, 1, ((char *)slide, "\n\
|
|
[return-code %d: unexpected EOF in zipfile (i.e., truncated)]\n", err));
|
|
break;
|
|
case IZ_CTRLC:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: you hit ctrl-C to terminate]\n", err));
|
|
break;
|
|
case IZ_UNSUP:
|
|
Info(slide, 1, ((char *)slide, "\n\
|
|
[return-code %d: unsupported compression or encryption for all files]\n",
|
|
err));
|
|
break;
|
|
case IZ_BADPWD:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: bad decryption password for all files]\n",
|
|
err));
|
|
break;
|
|
#ifdef DO_SAFECHECK_2GB
|
|
case IZ_ERRBF:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: big-file archive, small-file program]\n",
|
|
err));
|
|
break;
|
|
#endif /* DO_SAFECHECK_2GB */
|
|
default:
|
|
Info(slide, 1, ((char *)slide,
|
|
"\n[return-code %d: unknown return-code (screw-up)]\n", err));
|
|
break;
|
|
}
|
|
#endif /* RETURN_CODES */
|
|
|
|
/*---------------------------------------------------------------------------
|
|
* Return an intelligent status/severity level:
|
|
*
|
|
* 2007-01-29 SMS.
|
|
*
|
|
* VMS Status Code Summary (See STSDEF.H for details.)
|
|
*
|
|
* Bits: 31:28 27:16 15:3 2 1 0
|
|
* Field: Control Facility Message Severity
|
|
* -----
|
|
* 0 0 0 0 Warning
|
|
* 0 0 1 1 Success
|
|
* 0 1 0 2 Error
|
|
* 0 1 1 3 Information
|
|
* 1 0 0 4 Severe (fatal) error
|
|
*
|
|
* In the Control field, bits 31:29 are reserved. Bit 28 inhibits
|
|
* printing the message. In the Facility field, bit 27 means
|
|
* customer-defined (not HP-assigned, like us). In the Message field,
|
|
* bit 15 means facility-specific (which our messages are).
|
|
*
|
|
* Note that the C library translates exit(0) to a $STATUS value of 1
|
|
* (i.e., exit is both silent and has a $SEVERITY of "success").
|
|
*
|
|
* Previous versions of Info-ZIP programs used a generic ("chosen (by
|
|
* experimentation)") Control+Facility code of 0x7FFF, which included
|
|
* some reserved control bits, the inhibit-printing bit, and the
|
|
* customer-defined bit.
|
|
*
|
|
* HP has now assigned official Facility names and corresponding
|
|
* Facility codes for the Info-ZIP products:
|
|
*
|
|
* Facility Name Facility Code
|
|
* IZ_UNZIP 1954 = 0x7A2
|
|
* IZ_ZIP 1955 = 0x7A3
|
|
*
|
|
* Now, unless the CTL_FAC_IZ_UZP macro is defined at build-time, we
|
|
* will use the official Facility code.
|
|
*
|
|
---------------------------------------------------------------------------*/
|
|
|
|
/* Official HP-assigned Info-ZIP UnZip Facility code. */
|
|
#define FAC_IZ_UZP 1954 /* 0x7A2 */
|
|
|
|
#ifndef CTL_FAC_IZ_UZP
|
|
/*
|
|
* Default is inhibit-printing with the official Facility code.
|
|
*/
|
|
# define CTL_FAC_IZ_UZP ((0x1 << 12) | FAC_IZ_UZP)
|
|
# define MSG_FAC_SPEC 0x8000 /* Facility-specific code. */
|
|
#else /* CTL_FAC_IZ_UZP */
|
|
/* Use the user-supplied Control+Facility code for err or warn. */
|
|
# ifndef MSG_FAC_SPEC /* Old default is not Facility-specific. */
|
|
# define MSG_FAC_SPEC 0x0 /* Facility-specific code. Or 0x8000. */
|
|
# endif /* !MSG_FAC_SPEC */
|
|
#endif /* ?CTL_FAC_IZ_ZIP */
|
|
#define VMS_UZ_FAC_BITS ((CTL_FAC_IZ_UZP << 16) | MSG_FAC_SPEC)
|
|
|
|
severity = (err == PK_WARN) ? 0 : /* warn */
|
|
(err == PK_ERR || /* error */
|
|
(err >= PK_NOZIP && err <= PK_FIND) || /* ... */
|
|
(err >= IZ_CTRLC && err <= IZ_BADPWD)) ? 2 : /* ... */
|
|
4; /* fatal */
|
|
|
|
exit( /* $SEVERITY: */
|
|
(err == PK_COOL) ? SS$_NORMAL : /* success */
|
|
(VMS_UZ_FAC_BITS | (err << 4) | severity) /* warning, error, fatal */
|
|
);
|
|
|
|
} /* end function return_VMS() */
|
|
|
|
|
|
#ifdef MORE
|
|
static int scrnlines = -1;
|
|
static int scrncolumns = -1;
|
|
static int scrnwrap = -1;
|
|
|
|
|
|
static int getscreeninfo(int *tt_rows, int *tt_cols, int *tt_wrap)
|
|
{
|
|
/*
|
|
* For VMS v5.x:
|
|
* IO$_SENSEMODE/SETMODE info: Programming, Vol. 7A, System Programming,
|
|
* I/O User's: Part I, sec. 8.4.1.1, 8.4.3, 8.4.5, 8.6
|
|
* sys$assign(), sys$qio() info: Programming, Vol. 4B, System Services,
|
|
* System Services Reference Manual, pp. sys-23, sys-379
|
|
* fixed-length descriptor info: Programming, Vol. 3, System Services,
|
|
* Intro to System Routines, sec. 2.9.2
|
|
* GRR, 15 Aug 91 / SPC, 07 Aug 1995, 14 Nov 1999
|
|
*/
|
|
|
|
#ifndef OUTDEVICE_NAME
|
|
#define OUTDEVICE_NAME "SYS$OUTPUT"
|
|
#endif
|
|
|
|
static ZCONST struct dsc$descriptor_s OutDevDesc =
|
|
{(sizeof(OUTDEVICE_NAME) - 1), DSC$K_DTYPE_T, DSC$K_CLASS_S,
|
|
OUTDEVICE_NAME};
|
|
/* {dsc$w_length, dsc$b_dtype, dsc$b_class, dsc$a_pointer}; */
|
|
|
|
short OutDevChan, iosb[4];
|
|
long status;
|
|
struct tt_characts
|
|
{
|
|
uch class, type;
|
|
ush pagewidth;
|
|
union {
|
|
struct {
|
|
uch ttcharsbits[3];
|
|
uch pagelength;
|
|
} ttdef_bits;
|
|
unsigned ttcharflags;
|
|
} ttdef_area;
|
|
} ttmode; /* total length = 8 bytes */
|
|
|
|
|
|
/* assign a channel to standard output */
|
|
status = sys$assign(&OutDevDesc, &OutDevChan, 0, 0);
|
|
if (OK(status))
|
|
{
|
|
/* use sys$qiow and the IO$_SENSEMODE function to determine
|
|
* the current tty status.
|
|
*/
|
|
status = sys$qiow(0, OutDevChan, IO$_SENSEMODE, &iosb, 0, 0,
|
|
&ttmode, sizeof(ttmode), 0, 0, 0, 0);
|
|
/* deassign the output channel by way of clean-up */
|
|
(void) sys$dassgn(OutDevChan);
|
|
}
|
|
|
|
if ( OK(status) && OK(status = iosb[0]) ) {
|
|
if (tt_rows != NULL)
|
|
*tt_rows = ( (ttmode.ttdef_area.ttdef_bits.pagelength >= 5)
|
|
? (int) (ttmode.ttdef_area.ttdef_bits.pagelength)
|
|
/* TT device value */
|
|
: (24) ); /* VT 100 default */
|
|
if (tt_cols != NULL)
|
|
*tt_cols = ( (ttmode.pagewidth >= 10)
|
|
? (int) (ttmode.pagewidth) /* TT device value */
|
|
: (80) ); /* VT 100 default */
|
|
if (tt_wrap != NULL)
|
|
*tt_wrap = ((ttmode.ttdef_area.ttcharflags & TT$M_WRAP) != 0);
|
|
} else {
|
|
/* VT 100 defaults */
|
|
if (tt_rows != NULL)
|
|
*tt_rows = 24;
|
|
if (tt_cols != NULL)
|
|
*tt_cols = 80;
|
|
if (tt_wrap != NULL)
|
|
*tt_wrap = FALSE;
|
|
}
|
|
|
|
return (OK(status));
|
|
}
|
|
|
|
int screensize(int *tt_rows, int *tt_cols)
|
|
{
|
|
if (scrnlines < 0 || scrncolumns < 0)
|
|
getscreeninfo(&scrnlines, &scrncolumns, &scrnwrap);
|
|
if (tt_rows != NULL) *tt_rows = scrnlines;
|
|
if (tt_cols != NULL) *tt_cols = scrncolumns;
|
|
return !(scrnlines > 0 && scrncolumns > 0);
|
|
}
|
|
|
|
int screenlinewrap()
|
|
{
|
|
if (scrnwrap == -1)
|
|
getscreeninfo(&scrnlines, &scrncolumns, &scrnwrap);
|
|
return (scrnwrap);
|
|
}
|
|
#endif /* MORE */
|
|
|
|
|
|
#ifndef SFX
|
|
|
|
/************************/
|
|
/* Function version() */
|
|
/************************/
|
|
|
|
/* 2004-11-23 SMS.
|
|
* Changed to include the "-x" part of the VMS version.
|
|
* Added the IA64 system type name.
|
|
* Prepared for VMS versions after 9. (We should live so long.)
|
|
*/
|
|
|
|
void version(__G)
|
|
__GDEF
|
|
{
|
|
int len;
|
|
#ifdef VMS_VERSION
|
|
char *chrp1;
|
|
char *chrp2;
|
|
char buf[40];
|
|
char vms_vers[16];
|
|
int ver_maj;
|
|
#endif
|
|
#ifdef __DECC_VER
|
|
char buf2[40];
|
|
int vtyp;
|
|
#endif
|
|
|
|
#ifdef VMS_VERSION
|
|
/* Truncate the version string at the first (trailing) space. */
|
|
strncpy(vms_vers, VMS_VERSION, sizeof(vms_vers));
|
|
vms_vers[sizeof(vms_vers)-1] = '\0';
|
|
chrp1 = strchr(vms_vers, ' ');
|
|
if (chrp1 != NULL)
|
|
*chrp1 = '\0';
|
|
|
|
/* Determine the major version number. */
|
|
ver_maj = 0;
|
|
chrp1 = strchr(&vms_vers[1], '.');
|
|
for (chrp2 = &vms_vers[1];
|
|
chrp2 < chrp1;
|
|
ver_maj = ver_maj * 10 + *(chrp2++) - '0');
|
|
#endif /* VMS_VERSION */
|
|
|
|
/* DEC C in ANSI mode does not like "#ifdef MACRO" inside another
|
|
macro when MACRO is equated to a value (by "#define MACRO 1"). */
|
|
|
|
len = sprintf((char *)slide, LoadFarString(CompiledWith),
|
|
|
|
#ifdef __GNUC__
|
|
"gcc ", __VERSION__,
|
|
#else
|
|
# if defined(DECC) || defined(__DECC) || defined (__DECC__)
|
|
"DEC C",
|
|
# ifdef __DECC_VER
|
|
(sprintf(buf2, " %c%d.%d-%03d",
|
|
((vtyp = (__DECC_VER / 10000) % 10) == 6 ? 'T' :
|
|
(vtyp == 8 ? 'S' : 'V')),
|
|
__DECC_VER / 10000000,
|
|
(__DECC_VER % 10000000) / 100000, __DECC_VER % 1000), buf2),
|
|
# else
|
|
"",
|
|
# endif
|
|
# else
|
|
# ifdef VAXC
|
|
"VAX C", "",
|
|
# else
|
|
"unknown compiler", "",
|
|
# endif
|
|
# endif
|
|
#endif
|
|
|
|
#ifdef VMS_VERSION
|
|
# if defined(__alpha)
|
|
"OpenVMS",
|
|
(sprintf(buf, " (%s Alpha)", vms_vers), buf),
|
|
# elif defined(__ia64)
|
|
"OpenVMS",
|
|
(sprintf(buf, " (%s IA64)", vms_vers), buf),
|
|
# else /* VAX */
|
|
(ver_maj >= 6) ? "OpenVMS" : "VMS",
|
|
(sprintf(buf, " (%s VAX)", vms_vers), buf),
|
|
# endif
|
|
#else
|
|
"VMS",
|
|
"",
|
|
#endif /* ?VMS_VERSION */
|
|
|
|
#ifdef __DATE__
|
|
" on ", __DATE__
|
|
#else
|
|
"", ""
|
|
#endif
|
|
);
|
|
|
|
(*G.message)((zvoid *)&G, slide, (ulg)len, 0);
|
|
|
|
} /* end function version() */
|
|
|
|
#endif /* !SFX */
|
|
|
|
|
|
|
|
#ifdef __DECC
|
|
|
|
/* 2004-11-20 SMS.
|
|
*
|
|
* acc_cb(), access callback function for DEC C open().
|
|
*
|
|
* Set some RMS FAB/RAB items, with consideration of user-specified
|
|
* values from (DCL) SET RMS_DEFAULT. Items of particular interest are:
|
|
*
|
|
* fab$w_deq default extension quantity (blocks) (write).
|
|
* rab$b_mbc multi-block count.
|
|
* rab$b_mbf multi-buffer count (used with rah and wbh).
|
|
*
|
|
* See also the OPEN* macros in VMSCFG.H. Currently, no notice is
|
|
* taken of the caller-ID value, but options could be set differently
|
|
* for read versus write access. (I assume that specifying fab$w_deq,
|
|
* for example, for a read-only file has no ill effects.)
|
|
*/
|
|
|
|
/* Global storage. */
|
|
|
|
int openr_id = OPENR_ID; /* Callback id storage, read. */
|
|
|
|
/* acc_cb() */
|
|
|
|
int acc_cb(int *id_arg, struct FAB *fab, struct RAB *rab)
|
|
{
|
|
int sts;
|
|
|
|
/* Get process RMS_DEFAULT values, if not already done. */
|
|
if (rms_defaults_known == 0)
|
|
{
|
|
get_rms_defaults();
|
|
}
|
|
|
|
/* If RMS_DEFAULT (and adjusted active) values are available, then set
|
|
* the FAB/RAB parameters. If RMS_DEFAULT values are not available,
|
|
* suffer with the default parameters.
|
|
*/
|
|
if (rms_defaults_known > 0)
|
|
{
|
|
/* Set the FAB/RAB parameters accordingly. */
|
|
fab-> fab$w_deq = rms_ext_active;
|
|
rab-> rab$b_mbc = rms_mbc_active;
|
|
rab-> rab$b_mbf = rms_mbf_active;
|
|
|
|
/* Truncate at EOF on close, as we'll probably over-extend. */
|
|
fab-> fab$v_tef = 1;
|
|
|
|
/* If using multiple buffers, enable read-ahead and write-behind. */
|
|
if (rms_mbf_active > 1)
|
|
{
|
|
rab-> rab$v_rah = 1;
|
|
rab-> rab$v_wbh = 1;
|
|
}
|
|
|
|
if (DIAG_FLAG)
|
|
{
|
|
fprintf(stderr,
|
|
"Open callback. ID = %d, deq = %6d, mbc = %3d, mbf = %3d.\n",
|
|
*id_arg, fab-> fab$w_deq, rab-> rab$b_mbc, rab-> rab$b_mbf);
|
|
}
|
|
}
|
|
|
|
/* Declare success. */
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* 2004-09-19 SMS.
|
|
*
|
|
*----------------------------------------------------------------------
|
|
*
|
|
* decc_init()
|
|
*
|
|
* On non-VAX systems, uses LIB$INITIALIZE to set a collection of C
|
|
* RTL features without using the DECC$* logical name method.
|
|
*
|
|
*----------------------------------------------------------------------
|
|
*/
|
|
|
|
#ifdef __CRTL_VER
|
|
#if !defined(__VAX) && (__CRTL_VER >= 70301000)
|
|
|
|
#include <unixlib.h>
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
|
|
/* Global storage. */
|
|
|
|
/* Flag to sense if decc_init() was called. */
|
|
|
|
static int decc_init_done = -1;
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
|
|
/* decc_init()
|
|
|
|
Uses LIB$INITIALIZE to set a collection of C RTL features without
|
|
requiring the user to define the corresponding logical names.
|
|
*/
|
|
|
|
/* Structure to hold a DECC$* feature name and its desired value. */
|
|
|
|
typedef struct
|
|
{
|
|
char *name;
|
|
int value;
|
|
} decc_feat_t;
|
|
|
|
/* Array of DECC$* feature names and their desired values. */
|
|
|
|
decc_feat_t decc_feat_array[] = {
|
|
|
|
/* Preserve command-line case with SET PROCESS/PARSE_STYLE=EXTENDED */
|
|
{ "DECC$ARGV_PARSE_STYLE", 1 },
|
|
|
|
/* Preserve case for file names on ODS5 disks. */
|
|
{ "DECC$EFS_CASE_PRESERVE", 1 },
|
|
|
|
/* Enable multiple dots (and most characters) in ODS5 file names,
|
|
while preserving VMS-ness of ";version". */
|
|
{ "DECC$EFS_CHARSET", 1 },
|
|
|
|
/* List terminator. */
|
|
{ (char *)NULL, 0 } };
|
|
|
|
|
|
/* LIB$INITIALIZE initialization function. */
|
|
|
|
static void decc_init(void)
|
|
{
|
|
int feat_index;
|
|
int feat_value;
|
|
int feat_value_max;
|
|
int feat_value_min;
|
|
int i;
|
|
int sts;
|
|
|
|
/* Set the global flag to indicate that LIB$INITIALIZE worked. */
|
|
|
|
decc_init_done = 1;
|
|
|
|
/* Loop through all items in the decc_feat_array[]. */
|
|
|
|
for (i = 0; decc_feat_array[i].name != NULL; i++)
|
|
{
|
|
/* Get the feature index. */
|
|
feat_index = decc$feature_get_index(decc_feat_array[i].name);
|
|
if (feat_index >= 0)
|
|
{
|
|
/* Valid item. Collect its properties. */
|
|
feat_value = decc$feature_get_value(feat_index, 1);
|
|
feat_value_min = decc$feature_get_value(feat_index, 2);
|
|
feat_value_max = decc$feature_get_value(feat_index, 3);
|
|
|
|
if ((decc_feat_array[i].value >= feat_value_min) &&
|
|
(decc_feat_array[i].value <= feat_value_max))
|
|
{
|
|
/* Valid value. Set it if necessary. */
|
|
if (feat_value != decc_feat_array[i].value)
|
|
{
|
|
sts = decc$feature_set_value(
|
|
feat_index,
|
|
1,
|
|
decc_feat_array[i].value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Invalid DECC feature value. */
|
|
printf(" INVALID DECC FEATURE VALUE, %d: %d <= %s <= %d.\n",
|
|
feat_value,
|
|
feat_value_min, decc_feat_array[i].name, feat_value_max);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Invalid DECC feature name. */
|
|
printf(" UNKNOWN DECC FEATURE: %s.\n", decc_feat_array[i].name);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Get "decc_init()" into a valid, loaded LIB$INITIALIZE PSECT. */
|
|
|
|
#pragma nostandard
|
|
|
|
/* Establish the LIB$INITIALIZE PSECT, with proper alignment and
|
|
attributes.
|
|
*/
|
|
globaldef {"LIB$INITIALIZ"} readonly _align (LONGWORD)
|
|
int spare[8] = { 0 };
|
|
globaldef {"LIB$INITIALIZE"} readonly _align (LONGWORD)
|
|
void (*x_decc_init)() = decc_init;
|
|
|
|
/* Fake reference to ensure loading the LIB$INITIALIZE PSECT. */
|
|
|
|
#pragma extern_model save
|
|
/* The declaration for LIB$INITIALIZE() is missing in the VMS system header
|
|
files. Addionally, the lowercase name "lib$initialize" is defined as a
|
|
macro, so that this system routine can be reference in code using the
|
|
traditional C-style lowercase convention of function names for readability.
|
|
(VMS system functions declared in the VMS system headers are defined in a
|
|
similar way to allow using lowercase names within the C code, whereas the
|
|
"externally" visible names in the created object files are uppercase.)
|
|
*/
|
|
#ifndef lib$initialize
|
|
# define lib$initialize LIB$INITIALIZE
|
|
#endif
|
|
int lib$initialize(void);
|
|
#pragma extern_model strict_refdef
|
|
int dmy_lib$initialize = (int)lib$initialize;
|
|
#pragma extern_model restore
|
|
|
|
#pragma standard
|
|
|
|
#endif /* !defined(__VAX) && (__CRTL_VER >= 70301000) */
|
|
#endif /* __CRTL_VER */
|
|
#endif /* __DECC */
|
|
|
|
#endif /* VMS */
|