[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
/*****************************************************************************/
/*
StmLf.c
This module implements a full multi-threaded, AST-driven, asynchronous file
conversion from variable to stream-LF record format, by copying it into a
next-highest version. When called it allocates a dynamic structure and creates
its own I/O-event-driven thread. Errors are reported to the HTTPd process log,
and do not affect any other activities (including request processing) within
the server. Will purge the pre-existing version, however if multiple versions
already existed only deletes the one copied from!
Why this module's functionality? The WASD VMS HTTPd is significantly more
efficient in transfering stream-format than variable-format files. The reason?
Stream files can be read using block I/O, variable must be processed
record-by-record and buffered into a larger block before network I/O, very much
more expensive. This module allows detected variable-format files to be
converted to stream-LF "on-the-fly". This happens in a thread separate to the
detecting and initiating request, so the original variable-format file is used
to concurrently supply that particular request, with the converted file
probably available by the time the next request for it occurs. In addition,
the WASD HTTPd can determine the "Content-Length:" of stream-LF files and hence
can not only supply this item to the client but as a consequence participate
in a persistent connection request.
VERSION HISTORY
---------------
13-MAR-2008 MGD StmLfLog() include timestamp
30-MAY-2006 MGD bugfix; StmLfLog() -E- to -I- for non-status-value call
27-APR-2002 MGD use sys$setprv()
04-AUG-2001 MGD support module WATCHing
27-DEC-1999 MGD support ODS-2 and ODS-5
28-JAN-1999 MGD ensure created files are truncated-on-close
07-OCT-1998 MGD change path specification to SET rule mapping
19-AUG-1998 MGD confine conversions to specified paths
17-AUG-1997 MGD SYSUAF-authenticated users security-profile
01-AUG-1996 MGD initial, v3.3
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
/* VMS related header files */
#include <descrip.h>
#include <rms.h>
#include <rmsdef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application header files */
#include "wasd.h"
#include "httpd.h"
#include "stmlf.h"
#define WASD_MODULE "STMLF"
/**
#define STMLF_NOPURGE 1
**/
#define MAX_PURGE_ATTEMPTS 30
/********************/
/* external storage */
/********************/
extern const int64 Delta01Sec;
extern unsigned long SysPrvMask[];
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
*/
StmLfBegin
(
char *FilePath,
char *FileName,
int FileNameLength,
BOOL OdsExtended,
BOOL VmsUserHasAccess
)
{
int status;
char *cptr, *sptr;
struct StreamLfStruct *stmptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StmLfBegin() !&Z !&Z !UL !UL",
FilePath, FileName, OdsExtended, VmsUserHasAccess);
/* allocate dynamic memory for the conversion thread */
stmptr = (struct StreamLfStruct*) VmGet (sizeof(struct StreamLfStruct));
/* reset this boolean so that anything but source EOF is not success */
stmptr->ConversionOk = stmptr->DstFileCreated = false;
/* copy the filename into thread-persistent storage */
memcpy (stmptr->FileName, FileName, FileNameLength+1);
/* set a limit on the number of attempts to purge the source file */
stmptr->PurgeAttemptCount = MAX_PURGE_ATTEMPTS;
stmptr->SrcFileFab = cc$rms_fab;
stmptr->SrcFileFab.fab$b_fac = FAB$M_GET;
stmptr->SrcFileFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
stmptr->SrcFileFab.fab$l_fna = -1;
stmptr->SrcFileFab.fab$b_fns = 0;
stmptr->SrcFileFab.fab$l_nam = &stmptr->SrcFileNaml;
ENAMEL_RMS_NAML(stmptr->SrcFileNaml)
stmptr->SrcFileNaml.naml$l_long_filename = stmptr->FileName;
stmptr->SrcFileNaml.naml$l_long_filename_size = FileNameLength;
stmptr->SrcFileNaml.naml$l_long_expand = stmptr->SrcExpFileName;
stmptr->SrcFileNaml.naml$l_long_expand_alloc =
sizeof(stmptr->SrcExpFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
stmptr->SrcFileFab.fab$l_fna = stmptr->FileName;
stmptr->SrcFileFab.fab$b_fns = FileNameLength;
stmptr->SrcFileFab.fab$l_nam = &stmptr->SrcFileNam;
stmptr->SrcFileNam = cc$rms_nam;
stmptr->SrcFileNam.nam$l_esa = stmptr->SrcExpFileName;
stmptr->SrcFileNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
}
if (VmsUserHasAccess) sys$setprv (1, &SysPrvMask, 0, 0);
status = sys$open (&stmptr->SrcFileFab, 0, 0);
if (VmsUserHasAccess) sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSnok (status))
{
StmLfLog (stmptr, "sys$open()", status);
StmLfEnd (stmptr);
return;
}
#ifdef ODS_EXTENDED
if (OdsExtended)
stmptr->SrcFileNaml.naml$l_long_ver[stmptr->SrcFileNaml.naml$l_long_ver_size] = '\0';
else
#endif /* ODS_EXTENDED */
stmptr->SrcFileNam.nam$l_ver[stmptr->SrcFileNam.nam$b_ver] = '\0';
stmptr->SrcFileRab = cc$rms_rab;
stmptr->SrcFileRab.rab$l_fab = &stmptr->SrcFileFab;
stmptr->SrcFileRab.rab$b_mbf = 2;
stmptr->SrcFileRab.rab$l_rop = RAB$M_RAH | RAB$M_ASY;
stmptr->SrcFileRab.rab$l_ubf = stmptr->Buffer;
stmptr->SrcFileRab.rab$w_usz = sizeof(stmptr->Buffer);
/* set the RAB context to contain the conversion thread pointer */
stmptr->SrcFileRab.rab$l_ctx = stmptr;
status = sys$connect (&stmptr->SrcFileRab, 0, 0);
if (VMSnok (status))
{
StmLfLog (stmptr, "sys$connect() src", status);
StmLfEnd (stmptr);
return;
}
stmptr->DstFileFab = cc$rms_fab;
stmptr->DstFileFab.fab$l_fop = FAB$M_SQO | FAB$M_TEF;
stmptr->DstFileFab.fab$b_rfm = FAB$C_STMLF;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
stmptr->DstFileFab.fab$l_fna = -1;
stmptr->DstFileFab.fab$b_fns = 0;
stmptr->DstFileFab.fab$l_nam = &stmptr->DstFileNaml;
ENAMEL_RMS_NAML(stmptr->DstFileNaml)
stmptr->DstFileNaml.naml$l_long_filename = stmptr->FileName;
for (cptr = stmptr->FileName; *cptr && *cptr != ';'; cptr++);
stmptr->DstFileNaml.naml$l_long_filename_size = cptr - stmptr->FileName;
stmptr->DstFileNaml.naml$l_long_expand = stmptr->DstExpFileName;
stmptr->DstFileNaml.naml$l_long_expand_alloc = sizeof(stmptr->DstExpFileName)-1;
stmptr->DstFileNaml.naml$l_long_result = stmptr->DstResFileName;
stmptr->DstFileNaml.naml$l_long_result_alloc = sizeof(stmptr->DstResFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
stmptr->DstFileFab.fab$l_fna = stmptr->FileName;
for (cptr = stmptr->FileName; *cptr && *cptr != ';'; cptr++);
stmptr->DstFileFab.fab$b_fns = cptr - stmptr->FileName;
stmptr->DstFileFab.fab$l_nam = &stmptr->DstFileNam;
stmptr->DstFileNam = cc$rms_nam;
stmptr->DstFileNam.nam$l_esa = stmptr->DstExpFileName;
stmptr->DstFileNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
stmptr->DstFileNam.nam$l_rsa = stmptr->DstResFileName;
stmptr->DstFileNam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
/* use SYSPRV to ensure creation of file (provided protection is S:RWED) */
sys$setprv (1, &SysPrvMask, 0, 0);
status = sys$create (&stmptr->DstFileFab, 0, 0);
sys$setprv (0, &SysPrvMask, 0, 0);
/* check the status of the file create */
if (VMSnok (status))
{
StmLfLog (stmptr, "sys$create()", status);
StmLfEnd (stmptr);
return;
}
stmptr->DstFileCreated = true;
#ifdef ODS_EXTENDED
if (OdsExtended)
stmptr->DstFileNaml.naml$l_long_ver[stmptr->DstFileNaml.naml$l_long_ver_size] = '\0';
else
#endif /* ODS_EXTENDED */
stmptr->DstFileNam.nam$l_ver[stmptr->DstFileNam.nam$b_ver] = '\0';
stmptr->DstFileRab = cc$rms_rab;
stmptr->DstFileRab.rab$l_fab = &stmptr->DstFileFab;
stmptr->DstFileRab.rab$b_mbf = 2;
stmptr->DstFileRab.rab$l_rop = RAB$M_WBH | RAB$M_ASY;
stmptr->DstFileRab.rab$l_rbf = stmptr->Buffer;
/* set the RAB context to contain the conversion thread pointer */
stmptr->DstFileRab.rab$l_ctx = stmptr;
status = sys$connect (&stmptr->DstFileRab, 0, 0);
if (VMSnok (status))
{
StmLfLog (stmptr, "sys$connect() dst", status);
StmLfEnd (stmptr);
return;
}
/* get the first reacord */
status = sys$get (&stmptr->SrcFileRab,
&StmLfNextRecordAst, &StmLfNextRecordAst);
}
/****************************************************************************/
/*
Close source and destination files. If successfully converted attempt to
purge the version it was copied from. If the file is still locked due to
a still continuing transfer to a (the) client then set a timer and try again
in one second. Do this a number of times before giving up! If not
successfully copied then delete any new version created in the attempt.
*/
StmLfEnd (struct StreamLfStruct *stmptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "StmLfEnd() !8XL", stmptr);
if (stmptr->SrcFileFab.fab$w_ifi) sys$close (&stmptr->SrcFileFab, 0, 0);
if (stmptr->ConversionOk)
{
InstanceGblSecIncrLong (&AccountingPtr->StreamLfConversionCount);
if (stmptr->DstFileFab.fab$w_ifi) sys$close (&stmptr->DstFileFab, 0, 0);
#ifndef STMLF_NOPURGE
stmptr->SrcFileFab.fab$l_fop = FAB$M_NAM;
/* use SYSPRV to ensure erasure of file */
sys$setprv (1, &SysPrvMask, 0, 0);
status = sys$erase (&stmptr->SrcFileFab, 0, 0);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSnok (status))
{
if (status == RMS$_FLK)
{
if (stmptr->PurgeAttemptCount--)
{
status = sys$setimr (0, &Delta01Sec,
&StmLfEnd, stmptr, 0);
if (VMSok (status)) return;
StmLfLog (stmptr, NULL, status);
}
else
StmLfLog (stmptr, "sys$erase()", status);
}
else
StmLfLog (stmptr, "sys$erase() src", status);
}
#endif
StmLfLog (stmptr, "converted", 0);
}
else
if (stmptr->DstFileCreated)
{
sys$close (&stmptr->DstFileFab, 0, 0);
stmptr->DstFileFab.fab$l_fop = FAB$M_NAM;
/* use SYSPRV to ensure erasure of file */
sys$setprv (1, &SysPrvMask, 0, 0);
status = sys$erase (&stmptr->DstFileFab, 0, 0);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSnok (status)) StmLfLog (stmptr, "sys$erase() dst", status);
}
VmFree (stmptr, FI_LI);
}
/****************************************************************************/
/*
*/
StmLfNextRecord (struct RAB *RabPtr)
{
int status;
struct StreamLfStruct *stmptr;
/*********/
/* begin */
/*********/
stmptr = RabPtr->rab$l_ctx;
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StmLfNextRecord() !&F !8XL sts:!&X stv:!&X\n",
&StmLfNextRecord, stmptr,
RabPtr->rab$l_sts, RabPtr->rab$l_stv);
if (VMSnok (stmptr->DstFileRab.rab$l_sts))
{
StmLfEnd (stmptr);
return;
}
status = sys$get (&stmptr->SrcFileRab,
&StmLfNextRecordAst, &StmLfNextRecordAst);
}
/****************************************************************************/
/*
*/
StmLfNextRecordAst (struct RAB *RabPtr)
{
int status;
struct StreamLfStruct *stmptr;
/*********/
/* begin */
/*********/
stmptr = RabPtr->rab$l_ctx;
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StmLfNextRecordAst() !&F !8XL sts:!&X stv:!&X\n",
&StmLfNextRecordAst, stmptr,
RabPtr->rab$l_sts, RabPtr->rab$l_stv, RabPtr->rab$w_rsz);
if (VMSnok (stmptr->SrcFileRab.rab$l_sts))
{
if (stmptr->SrcFileRab.rab$l_sts == RMS$_EOF)
{
/* only place this boolean gets set */
stmptr->ConversionOk = true;
StmLfEnd (stmptr);
return;
}
StmLfLog (stmptr, "sys$get()", stmptr->SrcFileRab.rab$l_sts);
StmLfEnd (stmptr);
return;
}
stmptr->DstFileRab.rab$l_rbf = stmptr->SrcFileRab.rab$l_ubf;
stmptr->DstFileRab.rab$w_rsz = stmptr->SrcFileRab.rab$w_rsz;
status = sys$put (&stmptr->DstFileRab,
&StmLfNextRecord, &StmLfNextRecord);
}
/****************************************************************************/
/*
*/
StmLfLog
(
struct StreamLfStruct *stmptr,
char *Explanation,
int StatusValue
)
{
int status;
char *FileNamePtr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "StmLfLog() !8XL", stmptr);
if (stmptr)
FileNamePtr = stmptr->FileName;
else
FileNamePtr = "";
if (StatusValue)
FaoToStdout ("%HTTPD-E-STREAMLF, !20%D, !&X !AZ !AZ\n",
0, StatusValue, Explanation, FileNamePtr);
else
FaoToStdout ("%HTTPD-I-STREAMLF, !20%D, !AZ !AZ\n",
0, Explanation, FileNamePtr);
}
/****************************************************************************/