/*

* vms2unix.c

*

* Miscellaneous routines for UNIX/VMS compatibility.

*

* $Id: vms2unix.c,v 1.43 2005/06/03 00:03:29 tom Exp $

*

*/

#include "estruct.h"

#include "edef.h"

#include "dirstuff.h"

#define PERIOD '.'

#define COLON ':'

#define SEMICOLON ';'

static const char RootDir[] = "000000";

static const char DirType[] = ".DIR";

#if SYS_VMS

#include <starlet.h>

#include <unixio.h>

#include <ssdef.h>

#include <fab.h>

#define zfab dirp->dd_fab

#define znam dirp->dd_nam

#define zrsa dirp->dd_ret.d_name

#define zrsl dirp->dd_ret.d_namlen

#define zesa dirp->dd_esa

DIR *

opendir(char *filename)

{

DIR *dirp = typecalloc(DIR);

long status;

if (dirp == 0)

return (0);

zfab = cc$rms_fab;

zfab.fab$l_fop = FAB$M_NAM;

zfab.fab$l_nam = &znam; /* FAB => NAM block */

zfab.fab$l_dna = (global_g_val(GMDALL_VERSIONS)

? "*.*;*"

: "*.*;");

zfab.fab$b_dns = strlen(zfab.fab$l_dna);

zfab.fab$l_fna = filename;

zfab.fab$b_fns = strlen(filename);

znam = cc$rms_nam;

znam.nam$b_ess = NAM$C_MAXRSS;

znam.nam$l_esa = zesa;

znam.nam$b_rss = NAM$C_MAXRSS;

znam.nam$l_rsa = zrsa;

if (sys$parse(&zfab) != RMS$_NORMAL) {

(void) closedir(dirp);

dirp = 0;

}

return (dirp);

}

DIRENT *

readdir(DIR * dirp)

{

if (sys$search(&zfab) == RMS$_NORMAL) {

zrsl = znam.nam$b_rsl;

return (&(dirp->dd_ret));

}

return (0);

}

int

closedir(DIR * dirp)

{

cfree(dirp);

return 0;

}

char *

tempnam(const char *head, const char *tail)

{

char temp[NFILEN];

char leaf[NFILEN];

return mktemp(strmalloc(pathcat(temp,

head,

strcat(strcpy(leaf, tail),

"XXXXXX"))));

}

/*

* Check if the given file exists. If so, try to reuse its record-format when

* creating a new version.

*

* Note: using a '0' protection on VMS C 'open()' tells it to use an existing

* file's protection, or (if the file doesn't exist) the user's default

* protection.

*/

int

vms_creat(char *filename)

{

char rfm_option[80];

char rat_option[80];

char len_option[80];

struct stat sb;

int my_rfm = b_val(curbp, VAL_RECORD_FORMAT);

int my_rat = b_val(curbp, VAL_RECORD_ATTRS);

int my_len = b_val(curbp, VAL_RECORD_LENGTH);

int fd;

/*

* Only check for the previous file's record-format if the mode has not

* been specified.

*/

if (my_rfm == FAB$C_UDF) {

if (file_stat(filename, &sb) == 0) {

my_rfm = sb.st_fab_rfm;

my_rat = sb.st_fab_rat;

my_len = sb.st_fab_mrs;

/* Ignore the old record attributes, since 'cr' is the

* only one we know anything about.

*/

}

if (my_rfm == FAB$C_UDF)

my_rfm = FAB$C_STMLF;

}

lsprintf(rfm_option, "rfm=%s", vms_record_format(my_rfm));

lsprintf(rat_option, "rat=%s", vms_record_attrs(my_rat));

lsprintf(len_option, "mrs=%d", my_len);

switch (my_rfm) {

case FAB$C_FIX:

fd = creat(filename, 0, rfm_option, len_option, rat_option);

break;

case FAB$C_VFC:

/*

* FIXME: Must specify the fixed-length control field size

* (there's no interface for that at the moment, so I

* hardwired it at two bytes. Tom, I'm punting this one

* back to you.

*

* C. Morgan 11/29/1998.

*

* VFC files can only up to 32768 bytes/record, so the control

* field size is "always" 2 bytes -TD

*/

fd = creat(filename,

0,

rfm_option,

len_option,

"fsz=2", /* Fixed-length control field size */

rat_option);

break;

default:

/*

* The stmlf and var record-formats are really all that is

* required. Other combinations are experimental.

*/

fd = creat(filename, 0, rfm_option, "rat=cr");

break;

}

return fd;

}

/*

* Does "filename" exist? Can't use stat(), fstat(), or access() because

* they return incorrect results for DECNET-based files.

*

* Note 1: This routine will handle wildcarded filenames, but that's not it's

* purpose. Think of this routine as a replacement for

* "access(file, F_OK)".

*

* Note 2: This routine returns TRUE for "some.dir" (assuming it exists),

* but not "[.some]" .

*/

int

vms_ffexists(char *filename)

{

struct FAB fab;

struct NAM nam;

char expnd_file_buffer[NAM$C_MAXRSS + 1];

char rslt_file_buffer[NAM$C_MAXRSS + 1];

fab = cc$rms_fab;

nam = cc$rms_nam;

fab.fab$l_fna = filename;

fab.fab$b_fns = strlen(filename);

fab.fab$l_nam = &nam;

nam.nam$l_esa = expnd_file_buffer;

nam.nam$b_ess = NAM$C_MAXRSS;

nam.nam$l_rsa = rslt_file_buffer;

nam.nam$b_rss = NAM$C_MAXRSS;

return (sys$parse(&fab) == RMS$_NORMAL && sys$search(&fab) == RMS$_NORMAL);

}

#endif

#if OPT_VMS_PATH

/*

* These functions are adapted from my port2vms library -- T.Dickey

*/

/******************************************************************************

* Translate a UNIX-style name into a VMS-style name. *

******************************************************************************/

static int DotPrefix(char *s);

static char CharToVms(int c);

static int leading_uc(char *dst, char *src);

static int is_version(char *s);

static int leaf_dot; /* counts dots found in a particular leaf */

static int leaf_ver; /* set if we found a DECshell version */

/*

* If we have a dot in the second character position, force that to a dollar

* sign. Otherwise, keep the first dot in each unix leaf as a dot in the

* resulting vms name.

*/

static int

DotPrefix(char *s)

{

if (s[0] != EOS

&& s[1] == PERIOD

&& s[2] != EOS

&& strchr("sp", s[0])) /* hack for SCCS */

return (-1);

return (0);

}

static char

CharToVms(int c)

{

if (c == PERIOD) {

if (leaf_dot++)

c = '$';

} else if (!isAlnum(c) && !strchr("_-", c)) {

c = '$';

}

return (c);

}

static int

leading_uc(char *dst, char *src)

{

char *base = dst;

int c;

while ((c = *src) != EOS && c != SLASHC) {

if (isAlpha(c)) {

if (isLower(c))

return (0);

} else if (!strchr("0123456789$_", c))

return (0);

*dst++ = c;

*dst = EOS;

src++;

}

*dst = EOS;

if ((*base) && (dst = getenv(base)) != 0) {

c = strlen(base);

dst = skip_blanks(dst);

(void) strcpy(base, dst);

return (c);

}

return (0);

}

/*

* Returns true if the string points to a valid VMS version indicator, which

* may begin with a '.' or ';', e.g.,

* ;1

* ;*

* ;-1

*/

static int

is_version(char *s)

{

char *t;

if (*s == PERIOD

|| *s == SEMICOLON) {

if (*++s == EOS

|| !strcmp(s, "*")

|| !strcmp(s, "0")

|| (strtol(s, &t, 10) && *t == EOS))

return TRUE;

}

return FALSE;

}

static char *

path_suffix(char *path)

{

char *leaf = pathleaf(path);

char *type = strchr(leaf, '.');

if (type == 0)

type = skip_string(leaf);

return type;

}

static char *

path_version(char *path)

{

char *vers = strchr(path, SEMICOLON);

if (vers == 0)

vers = skip_string(path);

return vers;

}

char *

unix2vms_path(char *dst, const char *src)

{

#if !SYS_VMS

char tmp2[NFILEN];

#endif

char tmp[NFILEN];

char leading[NFILEN];

char *t;

char *s = strcpy(tmp, src); /* ... to permit src == dst */

char *d = dst;

char c = '?';

int bracket = FALSE; /* true when "[" passed. */

int on_top = FALSE; /* true when no "[." lead */

int node = FALSE; /* true when node found */

int device = FALSE; /* true when device found */

int len;

/*

* If VMS 'getenv()' is given an upper-case name, it assumes that it

* corresponds to a logical device assignment. As a special case, if

* we have a leading token of this form, translate it.

*/

if ((len = leading_uc(leading, s)) != 0) {

s += len;

len = strlen(strcpy(d, leading));

while (len > 1 && d[len - 1] == ' ')

len--;

if (*s) { /* text follows leading token */

s++; /* skip (assumed) SLASHC */

if ((len > 1)

&& (d[len - 1] == COLON)) {

on_top = TRUE;

} else if (strchr(s, SLASHC)) { /* must do a splice */

if ((len > 2)

&& (d[len - 1] == R_BLOCK)) {

bracket++;

if (d[len - 2] == PERIOD)

/* rooted-device ? */

len -= 2;

else

len--;

}

}

}

d[len] = EOS;

if ((t = strchr(d, COLON)) != NULL) {

if (t[1] == COLON) {

node = TRUE;

if ((t = strchr(t + 2, COLON)) != NULL)

device = TRUE;

} else

device = TRUE;

}

d += len;

} else if (*s == CH_TILDE) { /* process home-directory reference */

char *home = getenv("SYS$LOGIN");

#if !SYS_VMS

if (home == 0)

home = unix2vms_path(tmp2, getenv("HOME"));

#endif

node =

device = TRUE;

s++;

len = strlen(strcpy(d, home));

if (d[len - 1] == R_BLOCK) {

bracket++;

if (strcmp(s, "/")) { /* strip right-bracket to allow new levels */

if (d[len - 2] == PERIOD)

len--;

d[len - 1] = PERIOD;

} else {

s++;

len--;

}

}

d += len;

}

/* look for node-name in VMS-format */

if (!node

&& (t = strchr(s, '!')) != 0

&& (t[1] == SLASHC || t[1] == EOS)) {

leaf_dot = DotPrefix(s);

while (s < t)

*d++ = CharToVms(*s++);

*d++ = COLON;

*d++ = COLON;

s++; /* skip over '!' */

}

/* look for device-name, indicated by a leading SLASHC */

if (!device

&& (*s == SLASHC)) {

leaf_dot = DotPrefix(++s);

if ((t = strchr(s, SLASHC)) == 0)

t = skip_string(s);

else if (t[1] == EOS)

on_top = TRUE;

while (s < t)

*d++ = CharToVms(*s++);

if (d != dst)

*d++ = COLON;

}

/* permit leading "./" to simplify cases in which we concatenate */

if (!strncmp(s, "./", 2))

s += 2;

/* translate repeated leading "../" */

while (!strncmp(s, "../", 3)) {

s += 3;

if (!bracket++)

*d++ = L_BLOCK;

*d++ = '-';

}

if (!strcmp(s, "..")) {

s += 2;

if (!bracket++)

*d++ = L_BLOCK;

*d++ = '-';

}

if (strchr(s, SLASHC)) {

if (!bracket++)

*d++ = L_BLOCK;

if (*s == SLASHC) {

s++;

} else if (!on_top) {

*d++ = PERIOD;

}

while ((c = *s++) != EOS) {

if (c == PERIOD) {

c = '$';

if (*s == SLASHC) /* ignore "./" */

continue;

}

if (c == SLASHC) {

leaf_dot = DotPrefix(s);

if (strchr(s, SLASHC))

*d++ = PERIOD;

else {

break;

}

} else {

*d++ = CharToVms(c);

}

}

}

if (bracket) {

if (on_top && d[-1] == L_BLOCK) {

(void) strcpy(d, RootDir);

d += strlen(d);

}

*d++ = R_BLOCK;

}

if (c != EOS && *s) {

leaf_dot = DotPrefix(s);

while ((c = *s) != EOS) {

if ((leaf_ver = is_version(s)) == TRUE) {

leaf_dot = TRUE; /* no longer pertinent */

(void) strcpy(d, s);

*d = SEMICOLON; /* make this unambiguous */

d += strlen(d);

break;

} else {

*d++ = CharToVms(c);

}

s++;

}

if (!leaf_dot)

*d++ = PERIOD;

if (!leaf_ver)

*d++ = SEMICOLON;

}

*d = EOS;

return mkupper(dst);

}

/******************************************************************************

* Returns a pointer to a pathname's suffix iff it is likely a directory's *

******************************************************************************/

char *

is_vms_dirtype(char *path)

{

char *t = path_suffix(path);

char *v = path_version(t);

size_t len = (v - t);

if (len == sizeof(DirType) - 1

&& !strncmp(t, DirType, len)

&& (!*v || !strcmp(v, ";1"))) {

return t;

}

return 0;

}

/******************************************************************************

* Returns a pointer to a pathname's leaf iff it is the root directory *

******************************************************************************/

char *

is_vms_rootdir(char *path)

{

char *type;

if ((type = is_vms_dirtype(path)) != 0) {

char *leaf = pathleaf(path);

size_t len = (type - leaf);

if (len == sizeof(RootDir) - 1

&& !strncmp(leaf, RootDir, len))

return leaf;

}

return 0;

}

/******************************************************************************

* Convert a VMS directory-filename into the corresponding pathname *

******************************************************************************/

void

vms_dir2path(char *path)

{

char *s;

if ((s = is_vms_rootdir(path)) != 0) {

*s = EOS;

} else {

if ((s = strrchr(path, R_BLOCK)) != 0

&& (s[1] != EOS)) {

char *t;

if ((t = is_vms_dirtype(s)) != 0) {

*s = '.';

*t++ = R_BLOCK;

*t = EOS;

}

}

}

}

/******************************************************************************

* Convert a VMS pathname into the name of the corresponding directory-file. *

* *

* Note that this returns a pointer to a static buffer which is overwritten *

* by each call. *

******************************************************************************/

char *

vms_path2dir(const char *src)

{

static char buffer[NFILEN];

char *s = skip_string(strcpy(buffer, src));

if (s != buffer && *(--s) == R_BLOCK) {

(void) strcpy(s, DirType);

while (--s >= buffer) {

if (*s == PERIOD) {

*s = R_BLOCK;

if (s == buffer + 1) { /* absorb "]" */

char *t = s + 1;

s = buffer;

while ((*s++ = *t++) != EOS)

/*EMPTY */ ;

}

break;

}

if (*s == L_BLOCK) { /* absorb "[" */

char *t = s + 1;

if (is_vms_rootdir(t)

&& (s == buffer || s[-1] == COLON)) {

(void) lsprintf(t, "%s%c%s%s",

RootDir,

R_BLOCK,

RootDir,

DirType);

} else {

while ((*s++ = *t++) != EOS)

/*EMPTY */ ;

}

break;

}

}

}

return (buffer);

}

/******************************************************************************

* Translate a VMS-style pathname to a UNIX-style pathname *

******************************************************************************/

char *

vms2unix_path(char *dst, const char *src)

{

char current[NFILEN];

int need_dev = FALSE;

int have_dev = FALSE;

char tmp[NFILEN];

char *output = dst;

char *base = tmp;

char *s = strcpy(tmp, src); /* ... to permit src == dst */

char *d;

strip_version(s);

/* look for node specification */

if ((s = strchr(base, COLON)) != 0

&& (s[1] == COLON)) {

while (base < s) {

*dst++ = *base++;

}

*dst++ = '!';

base += 2;

need_dev = TRUE;

}

/*

* Look for device specification. If not found, see if the path must

* begin at the top of the device. In this case, it would be ambiguous

* if no device is supplied.

*/

if ((s = strchr(base, COLON)) != NULL) {

*dst++ = SLASHC;

while (base < s) {

*dst++ = *base++;

}

base++; /* skip over ":" */

have_dev = TRUE;

} else if (need_dev

|| ((base[0] == L_BLOCK)

&& (base[1] != '-')

&& (base[1] != PERIOD)

&& (base[1] != R_BLOCK))) { /* must supply a device */

char *a = getcwd(current, NFILEN);

char *b = strchr(a ? a : "?", COLON);

if ((b != 0)

&& (b[1] == COLON)) { /* skip over node specification */

a = b + 2;

b = strchr(a, COLON);

}

if (b != 0) {

*dst++ = SLASHC; /* begin the device */

while (a < b) {

*dst++ = *a++;

}

have_dev = TRUE;

} /* else, no device in getcwd! */

}

/* translate directory-syntax */

if ((s = strchr(base, L_BLOCK)) != NULL) {

int bracketed = TRUE;

if (s[1] == R_BLOCK) {

if (dst != output && *dst != SLASHC)

*dst++ = SLASHC;

*dst++ = PERIOD;

if (s[2] != EOS)

*dst++ = SLASHC;

s += 2;

d = s;

bracketed = FALSE;

} else if (s[1] == PERIOD) {

if (have_dev && dst[-1] != SLASHC)

*dst++ = SLASHC;

s += 2;

d = s;

} else if (s[1] == '-' && strchr("-.]", s[2])) {

s++;

while (*s == '-') {

s++;

*dst++ = PERIOD;

*dst++ = PERIOD;

if (*s == PERIOD

&& (s[1] == '-' || s[1] == R_BLOCK))

/* allow "-.-" */

s++;

if (*s == '-')

*dst++ = SLASHC;

}

d = s;

} else if (!strncmp(s + 1, RootDir, sizeof(RootDir) - 1)

&& strchr(".]", s[sizeof(RootDir)])) {

s += sizeof(RootDir);

d = s;

} else {

d = s;

*s++ = SLASHC;

}

/* expect s points to the last token before right-bracket */

if (bracketed) {

while (*s && *s != R_BLOCK) {

if (*s == PERIOD)

*s = SLASHC;

s++;

}

if (*s)

*s = s[1] ? SLASHC : EOS;

}

} else {

if (have_dev && dst[-1] != SLASHC)

*dst++ = SLASHC;

d = base;

}

/*

* Copy the remainder of the string, trimming trailing "."

*/

for (s = dst; *d; s++, d++) {

*s = *d;

if (*s == PERIOD && d[1] == EOS)

*s = EOS;

}

*s = EOS;

s = vms_pathleaf(dst);

/* SCCS hack */

if (*s == '$') {

*s++ = PERIOD;

} else if (s[0] == 's' && s[1] == '$') {

s[1] = PERIOD;

s += 2;

}

return mklower(output);

}

#endif /* OPT_VMS_PATH */