[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); } /****************************************************************************/