rainlance
/
unzip
mirror of https://frontier.innolan.net/rainlance/unzip.git
1
0
Fork 0
Code Releases Activity
unzip/vms/vms.c

5752 lines
179 KiB
C
Raw Permalink Blame History

/*
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 */
View Git Blame Copy Permalink