[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] [0463] [0464] [0465] [0466] [0467] [0468] [0469] [0470] [0471] [0472] [0473] [0474] [0475] [0476] [0477] [0478] [0479] [0480] [0481] [0482] [0483] [0484] [0485] [0486] [0487] [0488] [0489] [0490] [0491] [0492] [0493] [0494] [0495] [0496] [0497] [0498] [0499] [0500] [0501] [0502] [0503] [0504] [0505] [0506] [0507] [0508] [0509] [0510] [0511] [0512] [0513] [0514] [0515] [0516] [0517] [0518] [0519] [0520] [0521] [0522] [0523] [0524] [0525] [0526] [0527] [0528] [0529] [0530] [0531] [0532] [0533] [0534] [0535] [0536] [0537] [0538] [0539] [0540] [0541] [0542] [0543] [0544] [0545] [0546] [0547] [0548] [0549] [0550] [0551] [0552] [0553] [0554] [0555] [0556] [0557] [0558] [0559] [0560] [0561] [0562] [0563] [0564] [0565] [0566] [0567] [0568] [0569] [0570] [0571] [0572] [0573] [0574] [0575] [0576] [0577] [0578] [0579] [0580] [0581] [0582] [0583] [0584] [0585] [0586] [0587] [0588] [0589] [0590] [0591] [0592] [0593] [0594] [0595] [0596] [0597] [0598] [0599] [0600] [0601] [0602] [0603] [0604] [0605] [0606] [0607] [0608] [0609] [0610] [0611] [0612] [0613] [0614] [0615] [0616] [0617] [0618] [0619] [0620] [0621] [0622] [0623] [0624] [0625] [0626] [0627] [0628] [0629] [0630] [0631] [0632] [0633] [0634] [0635] [0636] [0637] [0638] [0639] [0640] [0641] [0642] [0643] [0644] [0645] [0646] [0647] [0648] [0649] [0650] [0651] [0652] [0653] [0654] [0655] [0656] [0657] [0658] [0659] [0660] [0661] [0662] [0663] [0664] [0665] [0666] [0667] [0668] [0669] [0670] [0671] [0672] [0673] [0674] [0675] [0676] [0677] [0678] [0679] [0680] [0681] [0682] [0683] [0684] [0685] [0686] [0687] [0688] [0689] [0690] [0691] [0692] [0693] [0694] [0695] [0696] [0697] [0698] [0699] [0700] [0701] [0702] [0703] [0704] [0705] [0706] [0707] [0708] [0709] [0710] [0711] [0712] [0713] [0714] [0715] [0716] [0717] [0718] [0719] [0720] [0721] [0722] [0723] [0724] [0725] [0726] [0727] [0728] [0729] [0730] [0731] [0732] [0733] [0734] [0735] [0736] [0737] [0738] [0739] [0740] [0741] [0742] [0743] [0744] [0745] [0746] [0747] [0748] [0749] [0750] [0751] [0752] [0753] [0754] [0755] [0756] [0757] [0758] [0759] [0760] [0761] [0762] [0763] [0764] [0765] [0766] [0767] [0768] [0769] [0770] [0771] [0772] [0773] [0774] [0775] [0776] [0777] [0778] [0779] [0780] [0781] [0782] [0783] [0784] [0785] [0786] [0787] [0788] [0789] [0790] [0791] [0792] [0793] [0794] [0795] [0796] [0797] [0798] [0799] [0800] [0801] [0802] [0803] [0804] [0805] [0806] [0807] [0808] [0809] [0810] [0811] [0812] [0813] [0814] [0815] [0816] [0817] [0818] [0819] [0820] [0821] [0822] [0823] [0824] [0825] [0826] [0827] [0828] [0829] [0830] [0831] [0832] [0833] [0834] [0835] [0836] [0837] [0838] [0839] [0840] [0841] [0842] [0843] [0844] [0845] [0846] [0847] [0848] [0849] [0850] [0851] [0852] [0853] [0854] [0855] [0856] [0857] [0858] [0859] [0860] [0861] [0862] [0863] [0864] [0865] [0866] [0867] [0868] [0869] [0870] [0871] [0872] [0873] [0874] [0875] [0876] [0877] [0878] [0879] [0880] [0881] [0882] [0883] [0884] [0885] [0886] [0887] [0888] [0889] [0890] [0891] [0892] [0893] [0894] [0895] [0896] [0897] [0898] [0899] [0900] [0901] [0902] [0903] [0904] [0905] [0906] [0907] [0908] [0909] [0910] [0911] [0912] [0913] [0914] [0915] [0916] [0917] [0918] [0919] [0920] [0921] [0922] [0923] [0924] [0925] [0926] [0927] [0928] [0929] [0930] [0931] [0932] [0933] [0934] [0935] [0936] [0937] [0938] [0939] [0940] [0941] [0942] [0943] [0944] [0945] [0946] [0947] [0948] [0949] [0950] [0951] [0952] [0953] [0954] [0955] [0956] [0957] [0958] [0959] [0960] [0961] [0962] [0963] [0964] [0965] [0966] [0967] [0968] [0969] [0970] [0971] [0972] [0973] [0974] [0975] [0976] [0977] [0978] [0979] [0980] [0981] [0982] [0983] [0984] [0985] [0986] [0987] [0988] [0989] [0990] [0991] [0992] [0993] [0994] [0995] [0996] [0997] [0998] [0999] [1000] [1001] [1002] [1003] [1004] [1005] [1006] [1007] [1008] [1009] [1010] [1011] [1012] [1013] [1014] [1015] [1016] [1017] [1018] [1019] [1020] [1021] [1022] [1023] [1024] [1025] [1026] [1027] [1028] [1029] [1030] [1031] [1032] [1033] [1034] [1035] [1036] [1037] [1038] [1039] [1040] [1041] [1042] [1043] [1044] [1045] [1046] [1047] [1048] [1049] [1050] [1051] [1052] [1053] [1054] [1055] [1056] [1057] [1058] [1059] [1060] [1061] [1062] [1063] [1064] [1065] [1066] [1067] [1068] [1069] [1070] [1071] [1072] [1073] [1074] [1075] [1076] [1077] [1078] [1079] [1080] [1081] [1082] [1083] [1084] [1085] [1086] [1087] [1088] [1089] [1090] [1091] [1092] [1093] [1094] [1095] [1096] [1097] [1098] [1099] [1100] [1101] [1102] [1103] [1104] [1105] [1106] [1107] [1108] [1109] [1110] [1111] [1112] [1113] [1114] [1115] [1116] [1117] [1118] [1119] [1120] [1121] [1122] [1123] [1124] [1125] [1126] [1127] [1128] [1129] [1130] [1131] [1132] [1133] [1134] [1135] [1136] [1137] [1138] [1139] [1140] [1141] [1142] [1143] [1144] [1145] [1146] [1147] [1148] [1149] [1150] [1151] [1152] [1153] [1154] [1155] [1156] [1157] [1158] [1159] [1160] [1161] [1162] [1163] [1164] [1165] [1166] [1167] [1168] [1169] [1170] [1171] [1172] [1173] [1174] [1175] [1176] [1177] [1178] [1179] [1180] [1181] [1182] [1183] [1184] [1185] [1186] [1187] [1188] [1189] [1190] [1191] [1192] [1193] [1194] [1195] [1196] [1197] [1198] [1199] [1200] [1201] [1202] [1203] [1204] [1205] [1206] [1207] [1208] [1209] [1210] [1211] [1212] [1213] [1214] [1215] [1216] [1217] [1218] [1219] [1220] [1221] [1222] [1223] [1224] [1225] [1226] [1227] [1228] [1229] [1230] [1231] [1232] [1233] [1234] [1235] [1236] [1237] [1238] [1239] [1240] [1241] [1242] [1243] [1244] [1245] [1246] [1247] [1248] [1249] [1250] [1251] [1252] [1253] [1254] [1255] [1256] [1257] [1258] [1259] [1260] [1261] [1262] [1263] [1264] [1265] [1266] [1267] [1268] [1269] [1270] [1271] [1272] [1273] [1274] [1275] [1276] [1277] [1278] [1279] [1280] [1281] [1282] [1283] [1284] [1285] [1286] [1287] [1288] [1289] [1290] [1291] [1292] [1293] [1294] [1295] [1296] [1297] [1298] [1299] [1300] [1301] [1302] [1303] [1304] [1305] [1306] [1307] [1308] [1309] [1310] [1311] [1312] [1313] [1314] [1315] [1316] [1317] [1318] [1319] [1320] [1321] [1322] [1323] [1324] [1325] [1326] [1327] [1328] [1329] [1330] [1331] [1332] [1333] [1334] [1335] [1336] [1337] [1338] [1339] [1340] [1341] [1342] [1343] [1344] [1345] [1346] [1347] [1348] [1349] [1350] [1351] [1352] [1353] [1354] [1355] [1356] [1357] [1358] [1359] [1360] [1361] [1362] [1363] [1364] [1365] [1366] [1367] [1368] [1369] [1370] [1371] [1372] [1373] [1374] [1375] [1376] [1377] [1378] [1379] [1380] [1381] [1382]
/*****************************************************************************/ /* CGIsapi.c CGIplus-based ISAPI (Internet Server API; Microsoft/Process Software Purveyor joint specification) extensions (not filters) scripting environment. The CGIplus environment, due to it's ability to support persistant scripts, and basic similarities between ISAPI and CGI processing, can quite conveniently support an ISAPI scripting environment. This program essentially becomes a CGIplus wrapper around an ISAPI DLL (dynamic link library, or with VMS known as a sharable image). In this environment the ISAPI extension does NOT execute in the server process space, it executes in a separate subprocess. Unlike implementations where ISAPI extensions are loaded into the server space the WASD approach effectively insulates buggy ISAPI extensions from crashing the server. The worst they can do is crash the subprocess. The down side is the separate process context is more expensive and slower than the native loadable, but performance measurements indicate persistant CGISAPI is still approximately four to five times faster than an equivalent CGI script! This makes development for the environment worthwhile for those resource-hungry applications. Like CGIplus it's persistant. This means scripts that have high initialization overheads (such as opening large databases) have far less latency on subsequent uses. A distinct advantage is no multi-threading issues. There will only ever be the one thread being executed by CGISAPI! CGISAPI DLLs must be executed via a CGIplus-enabled path. CGISAPI successfully loads and executes the Process Software Corporation Purveyor VMS example extension, SAMPLE_DLL_AXP.DLL and SAMPLE_DLL_VAX.DLL. CONSIDERATIONS -------------- This application is designed to be ISAPI 1.0 compliant. It should also be vanilla ISAPI 2.0 compliant (not the Microsoft WIN32 variety, so don't think you'll necessarily be able to grab all those IIS extensions and just recompile and use ;^) For experimentation the compliance version check can be set to allow any version DLL using the /VERSION= qualifier (major digit only). With CGISAPI multiple instances of any one extension may be active on the one server (each in an autonomous subprocess, unlike a server-process-space loaded extension where only one would ever be active at any one time). Be aware this could present different concurrency issues than a single multi or single threaded instance. When CGIplus subprocesses are idle they can be sys$delprc()ed at any time by the server at expiry of lifetime or to free up required server resources. For this reason ISAPI extensions (scripts) should finalize the processing of transactions when finished, not leave anything in a state where it's unexpected demise might corrupt resources or otherwise cause problems (which is fairly good general advice anyway ;^) That is, when finished tidy up as much as is necessary. Obviously do not exit completely or a complete reactivation will be necessary (why would you be using something like ISAPI if you didn't know that?) CGISAPI is not thread-aware, it doesn't need to be due to the single context of the subprocess it executes within. As a consequence, HttpExtensionProc() cannot be returned from before all processing is complete. When this function returns CGISAPI considers the extension is finished and ready to process another request. Returning HSE_STATUS_PENDING or using ServerSupportFunction() with HSE_REQ_DONE_WITH_SESSION are reported as errors and CGISAPI exits. When CGISAPI invokes the HttpExtensionProc() with the EXTENSION_CONTROL_BLOCK initialized, any request body is immediately and completely available via the 'cbTotalBytes', 'cbAvailable' and 'lpbData' fields. No subsequent calls to ReadClient() are necessary (although can be made). Any WASD CGI variable can be requested via GetServerVariable(), as well as ISAPI-specific "ALL_HTTP" and the WASD-specific "*". Note that some will not be portable. If a variable name does not exist '*lpdwSize' is set to zero, 'lpvBuffer' has a null character set at [0] and FALSE is returned. If the supplied size overflows 'lpvBuffer' contains a null-terminated string of as much as would be contained, '*lpdwSize' is set to the required size (including terminating null) and false is returned. If found and no overflow '*lpdwSize' is set to the size of the string (including null) and TRUE is returned. Output is explicitly buffered for efficiency reasons. For occasions where small amounts of output need to be sent to the client periodically (perhaps as status information during a more extended period of processing) use WriteClient() with a zero-length 'lpdwBytes' parameter. This will flush the output buffer. The size of this buffer may be explicitly set using the command line qualifier /WBUFFER= or a WASD extension call of ServerSupportFunction() with HSE_REQ_DLL_WRITE_BUFFER_SIZE and 'lpdwSize' pointing to a word containing the required buffer size (although this should seldom, if ever, be necessary). Setting the buffer size to zero, *before any output*, disables the buffering, resulting in immediate writes. CGISAPI loaded extensions can exit at any time they wish. The subprocess context allows this. Of course, normally a server-process-space loaded instance would not be able to do so! Any status code and log message set in EXTENSION_CONTROL_BLOCK at return from HttpExtensionProc() are ignored. Normal request logging is performed by the server. DEBUGGING --------- The CGISAPI implementation of ISAPI includes a facility to assist with debugging DLLs. Basic information on function parameters is output to the client whenever a call is made to an ISAPI function. This debugging can be toggled on and off whenever desired using a call to ServerSupportFunction() with 'dwHSERRequest' parameter set to the WASD values of HSE_REQ_DLL_DEBUG_ON or HSE_REQ_DLL_DEBUG_OFF. Once enabled DLL debugging remains active through multiple uses of a CGISAPI instance, or until disabled, or until the particular CGISAPI subprocess' lifetime expires. SERVER CONFIGURATION -------------------- Ensure the following are in the appropriate sections of HTTPD$CONFIG. [DclScriptRunTime] .DLL $CGI-BIN:[000000]CGISAPI.EXE [AddType] .DLL application/octet-stream - ISAPI extension DLL Ensure this is in the scripting section of HTTPD$MAP. exec+ /isapi/* /cgi-bin/* DLLs may then be accessed with paths such as: http://host.name.domain/isapi/isapiexample.dll ISAPI RESOURCES --------------- The code in this application, data structures, etc., has been derived in part from information contained in the QUE book "Using ISAPI", Stephen Genusa, et.al., 1997. http://www.genusa.com/isapi/ http://www.microsoft.com/win32dev/apitext/isalegal.htm http://www.process.com/news/spec.htm http://vms.process.com/ There's not a lot obvious anywhere for anything but Microsoft platforms, let alone specifically for VMS :^( Still, the efficiencies of having persistant scripts, along with ISAPI being a well-documented interface (in contrast to CGIplus, though which is simpler and more efficient), will provide real benefits for some sites. PARAMETERS ---------- The full file specification of the DLL must be supplied. QUALIFIERS ---------- /CHARSET= "Content-Type: text/html; charset=..." /DBUG turns on all "if (Debug)" statements /VERSION= set the ISAPI major version digit to allow non-1.0 DLLs (this is for experimentation, it doesn't really change anything, just stops the version check error report) /WBUFFER= integer, write buffer size in bytes, zero to disable LOGICAL NAMES ------------- CGISAPI$DBUG turns on all "if (Debug)" statements CGISAPI$DBUG_DLL turns on DLL debug mode before an extension is loaded CGISAPI$PARAM equivalent to (overrides) the command line parameters/qualifiers (define as a system-wide logical) BUILD DETAILS ------------- See BUILD_CGISAPI.COM procedure. COPYRIGHT --------- Copyright (C) 1999-2020 Mark G.Daniel This program comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redistribute it under the conditions of the GNU GENERAL PUBLIC LICENSE, version 3, or any later version. http://www.gnu.org/licenses/gpl.txt VERSION HISTORY (update SOFTWAREVN as well!) --------------- 25-OCT-2009 MGD V1.3.2, use CGI response to allow HTTP/1.1 functionalities (e.g. GZIP response encoding, chunking, persistence) 23-DEC-2003 MGD v1.3.1, minor conditional mods to support IA64 28-OCT-2000 MGD v1.3.0, use CGILIB object module, modifications for RELAXED_ANSI compilation 16-SEP-2000 MGD v1.2.2, make DLL debug span whole requests only 12-APR-2000 MGD v1.2.1, minor changes for CGILIB 1.4 20-NOV-1999 MGD v1.2.0, write buffer to reduce script I/O, use more of the CGILIB functionality 11-JUN-1999 MGD v1.1.1, improve (DllDebug) output, bugfix; "#define CGILIB_NONE NULL" 24-APR-1999 MGD v1.1.0, use CGILIB.C 14-MAR-1999 MGD v1.0.0, initial development */ /*****************************************************************************/ #define SOFTWAREVN "1.3.2" #define SOFTWARENM "CGISAPI" #ifdef __ALPHA # define SOFTWAREID SOFTWARENM " AXP-" SOFTWAREVN #endif #ifdef __ia64 # define SOFTWAREID SOFTWARENM " IA64-" SOFTWAREVN #endif #ifdef __VAX # define SOFTWAREID SOFTWARENM " VAX-" SOFTWAREVN #endif #ifdef __x86_64 # define SOFTWAREID SOFTWARENM " X86-" SOFTWAREVN #endif /* standard C header files */ #include <ctype.h> #include <errno.h> #include <stdio.h> #include <stdlib.h> #include <string.h> /* VMS-related header files */ #include <descrip.h> #include <libdef.h> #include <ssdef.h> #include <stsdef.h> /* application header files */ #include "cgisapi.h" #include <cgilib.h> #define boolean int #define true 1 #define false 0 #define FI_LI __FILE__, __LINE__ #ifndef __VAX # pragma nomember_alignment #endif #define VMSok(x) ((x) & STS$M_SUCCESS) #define VMSnok(x) (!((x) & STS$M_SUCCESS)) #define WRITE_BUFFER_SIZE_DEFAULT 4096 #define WRITE_BUFFER_SIZE_MIN 256 #define WRITE_BUFFER_SIZE_MAX 32768 #define DEFAULT_CHARSET "ISO-8859-1" #define CGISAPI_MAJOR_VERSION 1 #define CGISAPI_MINOR_VERSION 0 #define HTTP_VARIABLE_PREFIX "HTTP_" #define HTTP_VARIABLE_PREFIX_LENGTH sizeof(HTTP_VARIABLE_PREFIX)-1 char Utility [] = "CGISAPI"; boolean AllowStandardCgi, Debug, DllDebug, DllDebugOn, IsCgiPlus; int DllActivatedCount, IsapiMajorVersion = CGISAPI_MAJOR_VERSION, WriteBufferSize = WRITE_BUFFER_SIZE_DEFAULT; char *CliCharsetPtr, *CliDllFileNamePtr; char SoftwareID [48]; /* required function prototypes */ int FindImageSymbolHandler (); BOOL IsapiServerSupportFunction (HCONN, DWORD, LPVOID, LPDWORD, LPDWORD); BOOL IsapiGetServerVariable (HCONN, LPSTR, LPVOID, LPDWORD); BOOL IsapiReadClient (HCONN, LPVOID, LPDWORD); BOOL IsapiWriteClient (HCONN, LPVOID, LPDWORD, DWORD); /*****************************************************************************/ /* */ main () { /*********/ /* begin */ /*********/ sprintf (SoftwareID, "%s (%s)", SOFTWAREID, CgiLibEnvironmentVersion()); if (getenv ("CGISAPI$DBUG") != NULL) Debug = true; if (getenv ("CGISAPI$DBUG_DLL") != NULL) DllDebug = true; /* only for testing certain behaviours! */ if (getenv ("CGISAPI$CGI") != NULL) AllowStandardCgi = true; GetParameters (); if (CliDllFileNamePtr == NULL) { fprintf (stdout, "%%%s-E-DLL, not specified\n", Utility); exit (STS$K_ERROR | STS$M_INHIB_MSG); } CgiLibEnvironmentInit (0, NULL, false); CgiLibEnvironmentSetDebug (Debug); /* if a CGILIB CGI variable does not exist then return a NULL pointer */ CgiLibEnvironmentSetVarNone (NULL); CgiLibResponseSetCharset (CliCharsetPtr); CgiLibResponseSetSoftwareID (SoftwareID); CgiLibResponseSetErrorMessage ("Reported by CGISAPI"); IsCgiPlus = CgiLibEnvironmentIsCgiPlus (); if (!IsCgiPlus && !AllowStandardCgi) { /* only allows standard CGI environment when debug switched on */ CgiLibResponseError (FI_LI, 0, "ISAPI scripts must be executed in CGIplus environment!"); exit (SS$_NORMAL); } /***********/ /* process */ /***********/ if (IsCgiPlus) { for (;;) { /* block waiting for next request */ CgiLibVar (""); IsapiMain (); CgiLibCgiPlusEOF (); } } else IsapiMain (); exit (SS$_NORMAL); } /*****************************************************************************/ /* This function gets called each time the CGISAPI script gets activated. The first call it must load the DLL (shareable image), ensure the two required entry-points are available and check the ISAPI version of the DLL. Subsequent calls it can just invoke the DLL procedure entry-point to execute it's functionality. */ IsapiMain () { static BOOL (*GetExtensionVersion)(LPHSE_VERSION_INFO); static DWORD (*HttpExtensionProc)(LPEXTENSION_CONTROL_BLOCK); static $DESCRIPTOR (FileNameDsc, ""); static $DESCRIPTOR (HttpExtensionProcDsc, "HttpExtensionProc"); static $DESCRIPTOR (ImageNameDsc, "CGI-BIN:[000000].DLL"); static $DESCRIPTOR (GetExtensionVersionDsc, "GetExtensionVersion"); register char *cptr, *sptr, *zptr; boolean ok; int status, MajorVersion, MinorVersion; char FileName [256], ImageName [256]; HSE_VERSION_INFO HseVersion; EXTENSION_CONTROL_BLOCK ExtensionControlBlock; /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "IsapiMain() %d\n", DllActivatedCount); if (DllActivatedCount++) { /********************/ /* subsequent calls */ /********************/ IsapiEcbInit (&ExtensionControlBlock); /* invoke the DLL main procedure entry-point */ ok = (*HttpExtensionProc)(&ExtensionControlBlock); if (Debug) fprintf (stdout, "(*HttpExtensionProc)() ok:%d\n", ok); IsapiEnd (&ExtensionControlBlock, ok); return; } /**************/ /* first call */ /**************/ cptr = CliDllFileNamePtr; zptr = (sptr = ImageName) + sizeof(ImageName)-1; while (*cptr && *cptr != ']' && sptr < zptr) *sptr++ = *cptr++; if (cptr[1] == '[') { if (sptr < zptr) *sptr++ = *cptr++; while (*cptr && *cptr != ']' && sptr < zptr) *sptr++ = *cptr++; } if (*cptr && sptr < zptr) *sptr++ = *cptr++; ImageNameDsc.dsc$a_pointer = sptr; zptr = (sptr = FileName) + sizeof(FileName)-1; while (*cptr && *cptr != '.' && sptr < zptr) *sptr++ = *cptr++; *sptr = '\0'; FileNameDsc.dsc$a_pointer = FileName; FileNameDsc.dsc$w_length = strlen(FileName); if (Debug) fprintf (stdout, "|%s|\n", FileName); zptr = ImageName + sizeof(ImageName)-1; sptr = ImageNameDsc.dsc$a_pointer; while (*cptr && *cptr != ';' && sptr < zptr) *sptr++ = *cptr++; *sptr = '\0'; ImageNameDsc.dsc$a_pointer = ImageName; ImageNameDsc.dsc$w_length = strlen(ImageName); if (Debug) fprintf (stdout, "|%s|\n", ImageName); lib$establish (FindImageSymbolHandler); status = lib$find_image_symbol (&FileNameDsc, &HttpExtensionProcDsc, &HttpExtensionProc, &ImageNameDsc); if (Debug) fprintf (stdout, "lib$find_image_symbol() %%X%08.08X\n", status); lib$revert (); if (VMSnok (status)) { /* could not locate the required entry-point in the DLL */ if (status == LIB$_KEYNOTFOU) CgiLibResponseError (FI_LI, 0, "DLL HttpExtensionProc() not found"); else CgiLibResponseError (FI_LI, status, CliDllFileNamePtr); exit (SS$_NORMAL); } status = lib$find_image_symbol (&FileNameDsc, &GetExtensionVersionDsc, &GetExtensionVersion, &ImageNameDsc); if (Debug) fprintf (stdout, "lib$find_image_symbol() %%X%08.08X\n", status); if (VMSnok (status)) { /* could not locate the required entry-point in the DLL */ if (status == LIB$_KEYNOTFOU) CgiLibResponseError (FI_LI, 0, "DLL GetExtensionVersion() not found"); else CgiLibResponseError (FI_LI, status, CliDllFileNamePtr); exit (SS$_NORMAL); } /* invoke the DLL version information entry-point */ ok = (*GetExtensionVersion)(&HseVersion); if (Debug) fprintf (stdout, "(*GetExtensionVersion)() ok:%d\n", ok); if (ok) { /* check version compatibility */ MajorVersion = HseVersion.dwExtensionVersion >> 16; MinorVersion = HseVersion.dwExtensionVersion & 0x0ffff; if (Debug) fprintf (stdout, "HseVersion: %d.%d |%s|\n", MajorVersion, MinorVersion, HseVersion.lpszExtensionDesc); if (MajorVersion > IsapiMajorVersion) { char String [256]; sprintf (String, "DLL version is %d.%d, %s script is %d.%d", MajorVersion, MinorVersion, Utility, IsapiMajorVersion, CGISAPI_MINOR_VERSION); CgiLibResponseError (FI_LI, 0, String); exit (SS$_NORMAL); } } else { CgiLibResponseError (FI_LI, 0, "DLL GetExtensionVersion() failed"); exit (SS$_NORMAL); } /********************************/ /* call the extension procedure */ /********************************/ IsapiEcbInit (&ExtensionControlBlock); /* invoke the DLL main procedure entry-point */ ok = (*HttpExtensionProc)(&ExtensionControlBlock); if (Debug) fprintf (stdout, "(*HttpExtensionProc)() ok:%d\n", ok); IsapiEnd (&ExtensionControlBlock, ok); } /*****************************************************************************/ /* Just continue, to report an error if the image couldn't be activated or the required symbol not found. */ FindImageSymbolHandler () { /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "FindImageSymbolHandler()\n"); return (SS$_CONTINUE); } /*****************************************************************************/ /* Executed after the DLL's main procedure entry-point has returned. */ IsapiEnd ( LPEXTENSION_CONTROL_BLOCK lpEcb, DWORD HttpExtensionProcReturn ) { /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "IsapiEnd()\n"); if (Debug) fprintf (stdout, "dwHttpStatusCode: %d\n\ lpszLogData |%s|\n", lpEcb->dwHttpStatusCode, lpEcb->lpszLogData); if (DllDebug) { fprintf (stdout, "[HttpExtensionProc() returned: %d\n\ dwHttpStatusCode: %d\n\ lpszLogData: |%s|]\n", HttpExtensionProcReturn, lpEcb->dwHttpStatusCode, lpEcb->lpszLogData); } if (lpEcb->dwHttpStatusCode == HSE_STATUS_PENDING) { /* we're not threaded here, so anything pending's not supported! */ CgiLibResponseError (FI_LI, 0, "HSE_STATUS_PENDING not supported!"); exit (SS$_NORMAL); } /* flush anything in the write buffer */ IsapiWriteClient (lpEcb, NULL, 0, 0); } /*****************************************************************************/ /* Initialize the extension control block, filling out the required fields. */ IsapiEcbInit (LPEXTENSION_CONTROL_BLOCK lpEcb) { char *cptr; /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "IsapiEcbInit()\n"); DllDebug = DllDebugOn; memset (lpEcb, 0, sizeof(EXTENSION_CONTROL_BLOCK)); lpEcb->cbSize = sizeof(EXTENSION_CONTROL_BLOCK); lpEcb->dwVersion = CGISAPI_MAJOR_VERSION << 16 | CGISAPI_MINOR_VERSION; lpEcb->ConnID = lpEcb; if ((lpEcb->lpszMethod = CgiLibVar("REQUEST_METHOD")) == NULL) lpEcb->lpszMethod = ""; if ((lpEcb->lpszQueryString = CgiLibVar("QUERY_STRING")) == NULL) lpEcb->lpszQueryString = ""; if ((lpEcb->lpszPathInfo = CgiLibVar("PATH_INFO")) == NULL) lpEcb->lpszPathInfo = ""; if ((lpEcb->lpszPathTranslated = CgiLibVar("PATH_TRANSLATED")) == NULL) lpEcb->lpszPathTranslated = ""; if ((lpEcb->lpszContentType = CgiLibVar("CONTENT_TYPE")) == NULL) lpEcb->lpszContentType = ""; /* initialize the request body procedure, indicated by a NULL 'lpdBuffer' */ IsapiReadClient (lpEcb, NULL, NULL); lpEcb->GetServerVariable = &IsapiGetServerVariable; lpEcb->ReadClient = &IsapiReadClient; lpEcb->WriteClient = &IsapiWriteClient; lpEcb->ServerSupportFunction = &IsapiServerSupportFunction; if (DllDebug) { CgiLibResponseHeader (200, "text/plain"); fprintf (stdout, "[%s %s activation: %d]\n", SoftwareID, CliDllFileNamePtr, DllActivatedCount); if ((cptr = CgiLibVar("*")) != NULL) { fprintf (stdout, "[%s", cptr); while ((cptr = CgiLibVar("*")) != NULL) fprintf (stdout, "\n %s", cptr); fputs ("]\n", stdout); } fprintf (stdout, "[HttpExtensionProc()\n\ ConnID: %d\n\ lpszMethod: |%s|\n\ lpszQueryString: |%s|\n\ lpszPathInfo: |%s|\n\ lpszPathTranslated: |%s|\n\ lpszContentType: |%s|\n\ cbTotalBytes: %d\n\ cbAvailable: %d\n\ lpbData: %d]\n", lpEcb->ConnID, lpEcb->lpszMethod, lpEcb->lpszQueryString, lpEcb->lpszPathInfo, lpEcb->lpszPathTranslated, lpEcb->lpszContentType, lpEcb->cbTotalBytes, lpEcb->cbAvailable, lpEcb->lpbData); } } /*****************************************************************************/ /* DLL callback that will return the requested CGI-like variable value. Returns TRUE if the variable exists, FALSE if it doesn't (sets 'lpvBuffer' to an empty string). Returns FALSE if the buffer overflows (puts as much as possible into it as a null-terminated stream, then sets 'lpdwSize' to what was actually required). Special case is "content-length", sets 'lpvBuffer' to a 4 byte binary value. */ BOOL IsapiGetServerVariable ( HCONN hConn, LPSTR lpszVariableName, LPVOID lpvBuffer, LPDWORD lpdwSize ) { register char *cptr, *sptr, *zptr; int len; char *CgiLibVarPtr; /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "IsapiGetServerVariable() |%s|\n", lpszVariableName); if (DllDebug) { fprintf (stdout, "[GetServerVariable()\n\ hConn: %d\n\ lpszVariableName: |%s|\n\ lpvBuffer: %d\n\ lpdwSize: %d %d\n", hConn, lpszVariableName, lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } if (lpszVariableName[0] == '*' || strsame (lpszVariableName, "ALL_HTTP", -1)) { /************************/ /* all, or all HTTP_... */ /************************/ zptr = (sptr = lpvBuffer) + *lpdwSize; while ((cptr = CgiLibVar("*")) != NULL) { if (lpszVariableName[0] == '*' || !memcmp (cptr, HTTP_VARIABLE_PREFIX, HTTP_VARIABLE_PREFIX_LENGTH)) { while (*cptr && *cptr != '=' && sptr < zptr) *sptr++ = *cptr++; if (*cptr) cptr++; if (sptr < zptr) *sptr++ = ':'; if (sptr < zptr) *sptr++ = ' '; while (*cptr && sptr < zptr) *sptr++ = *cptr++; if (sptr < zptr) *sptr++ = '\n'; if (sptr >= zptr) break; } } if (sptr >= zptr) { /* too small, suggest to double it's size */ *(char*)lpvBuffer = '\0'; *lpdwSize = *lpdwSize < 1; if (DllDebug) { fprintf (stdout, " BUFFER OVERFLOW\n\ lpvBuffer: |%s|\n\ lpdwsize: %d %d\n\ return: FALSE]\n", (char*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (FALSE); } *sptr = '\0'; *lpdwSize = sptr - (char*)lpvBuffer + 1; if (DllDebug) { fprintf (stdout, " FOUND\n\ lpvBuffer: |%s|\n\ lpdwsize: %d %d\n\ return: TRUE]\n", (char*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (TRUE); } /***********************/ /* single CGI variable */ /***********************/ /* fudge: Purveyor must use "user-agent" because it's example DLL does! */ if (strsame (lpszVariableName, "user-agent", -1)) lpszVariableName = "http_user_agent"; if ((cptr = CgiLibVarPtr = CgiLibVar (lpszVariableName)) == NULL) { *(char*)lpvBuffer = '\0'; *lpdwSize = 0; if (DllDebug) { fprintf (stdout, " NOT FOUND\n\ lpvBuffer: |%s|\n\ lpdwsize: %d %d\n\ return: FALSE]\n", (char*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (FALSE); } else { if (strsame (lpszVariableName, "content_length", -1)) { /* special case, return binary value */ if (*lpdwSize < sizeof(DWORD)) { *lpdwSize = sizeof(DWORD); if (DllDebug) { fprintf (stdout, " BUFFER OVERFLOW\n\ lpvBuffer: |%s|\n\ lpdwsize: %d %d\n\ return: FALSE]\n", (char*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (FALSE); } *(DWORD*)lpvBuffer = atoi(cptr); *lpdwSize = sizeof(DWORD); if (DllDebug) { fprintf (stdout, " FOUND\n\ lpvBuffer: %d %d\n\ lpdwsize: %d %d\n\ return: TRUE]\n", lpvBuffer, *(DWORD*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (TRUE); } zptr = (sptr = lpvBuffer) + *lpdwSize - 1; while (*cptr && sptr < zptr) *sptr++ = *cptr++; *sptr = '\0'; if (sptr < zptr) { *lpdwSize = sptr - (char*)lpvBuffer + 1; if (DllDebug) { fprintf (stdout, " FOUND\n\ lpvBuffer: |%s|\n\ lpdwsize: %d %d\n\ return: TRUE]\n", (char*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (TRUE); } else { while (*cptr) cptr++; *lpdwSize = cptr - CgiLibVarPtr + 1; if (DllDebug) { fprintf (stdout, " BUFFER OVERFLOW\n\ lpvBuffer: |%s|\n\ lpdwsize: %d %d\n\ return: FALSE]\n", (char*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (FALSE); } } } /*****************************************************************************/ /* DLL callback to read (further) request content (body) from the client. CGISAPI _always_ supplies all the request content with the initial ECB supplied to the HttpExtensionProc() entry-point, so this really never will need to be called. It it is it just indicates there is no more data available. IsapiEcbInit() calls this procedure with 'lpvBuffer' set to NULL to initially set the body content fields correctly whether there is content or not. */ BOOL IsapiReadClient ( HCONN ConnID, LPVOID lpvBuffer, LPDWORD lpdwSize ) { static int BufferCount; static char *BufferPtr; char *cptr; EXTENSION_CONTROL_BLOCK *lpEcb; /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "IsapiReadClient() %d\n", ConnID); lpEcb = (EXTENSION_CONTROL_BLOCK*)ConnID; if (lpvBuffer == NULL) { if ((cptr = CgiLibVar("CONTENT_LENGTH")) == NULL) { lpEcb->cbTotalBytes = lpEcb->cbAvailable = BufferCount = 0; lpEcb->lpbData = BufferPtr = ""; return (FALSE); } else { lpEcb->cbTotalBytes = atoi(cptr); if (Debug) fprintf (stdout, "lpEcb->cbTotalBytes: %d\n", lpEcb->cbTotalBytes); } if (CgiLibReadRequestBody (&BufferPtr, &BufferCount)) { if (Debug) fprintf (stdout, "BufferCount: %d\n", BufferCount); if (lpEcb->cbTotalBytes == BufferCount) { /* always return the entire body with the initial call! */ lpEcb->lpbData = BufferPtr; lpEcb->cbAvailable = BufferCount; return (TRUE); } else { lpEcb->cbTotalBytes = lpEcb->cbAvailable = BufferCount = 0; lpEcb->lpbData = BufferPtr = ""; return (FALSE); } } else { lpEcb->cbTotalBytes = lpEcb->cbAvailable = BufferCount = 0; lpEcb->lpbData = BufferPtr = ""; return (FALSE); } } if (DllDebug) { fprintf (stdout, "[ReadClient()\n\ ConnID: %d\n\ lpvBuffer: %d\n\ lpdwSize: %d %d\n", ConnID, lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } /* explicit calls to IsapiReadClient() always have nothing to return! */ *(char*)lpvBuffer = '\0'; *lpdwSize = 0; if (DllDebug) { fprintf (stdout, " lpvBuffer: |%s|\n\ lpdwsize: %d %d\n\ return: FALSE]\n", (char*)lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize); } return (FALSE); } /*****************************************************************************/ /* DLL callback, write the supplied buffer to the client. The efficiencies provided by buffering this data, reducing the number of I/Os between the script and the server, are worth explicitly buffering it here. To flush what is buffered at any time call this function with a zero-length 'lpdwBytes'. Why not use the C-RTL for this? Two reasons. The data given to this function is specified by pointer and a length, meaning an fwrite() needs to be used (which does an implicit flush). Why not then freopen(,,,"ctx=xplct")? This worked on Alpha VMS 7.1 but barfed on VAX VMS 6.2 (at least), hence this work around. This buffering reduced response time to 12.5% of what it was without it!! (as measured using the ISAPIEXAMPLE.C program outputing lines of 80 characters). */ BOOL IsapiWriteClient ( HCONN ConnID, LPVOID lpvBuffer, LPDWORD lpdwBytes, DWORD dwReserved ) { static int WriteBufferCapacity; static char *WriteBuffer = NULL, *WriteBufferPtr; int DataBytes, DataCount; /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "IsapiWriteClient()\n"); if (DllDebug) { fprintf (stdout, "[WriteClient()\n\ ConnID: %d\n\ lpvBuffer: %d\n\ lpdwSize: %d %d\n\ dwReserved: %d]\n", ConnID, lpvBuffer, lpdwBytes, lpdwBytes == NULL ? 0 : *lpdwBytes, dwReserved); } if (Debug) fprintf (stdout, "%d %d %d\n", WriteBuffer, WriteBufferPtr, WriteBufferCapacity); if (!WriteBufferSize || (DllDebug && lpdwBytes != NULL && (DataBytes = *lpdwBytes))) { /* if buffer size set zero, or when debugging the DLL, do not buffer */ fwrite (lpvBuffer, *lpdwBytes, 1, stdout); } else if (WriteBufferSize && lpdwBytes != NULL && (DataBytes = *lpdwBytes)) { if (WriteBuffer == NULL) if ((WriteBufferPtr = WriteBuffer = calloc (1, WriteBufferCapacity = WriteBufferSize)) == NULL) exit (vaxc$errno); if (DataBytes <= WriteBufferCapacity) { /* initial space in the buffer */ memcpy (WriteBufferPtr, lpvBuffer, DataBytes); WriteBufferPtr += DataBytes; WriteBufferCapacity -= DataBytes; } else { /* no initial space in the buffer */ DataCount = WriteBufferCapacity; DataBytes -= DataCount; for (;;) { memcpy (WriteBufferPtr, lpvBuffer, DataCount); fwrite (WriteBuffer, WriteBufferSize, 1, stdout); WriteBufferPtr = WriteBuffer; WriteBufferCapacity = WriteBufferSize; lpvBuffer = (void*)((int)lpvBuffer + DataCount); if (DataBytes <= WriteBufferCapacity) DataCount = DataBytes; else DataCount = WriteBufferCapacity; memcpy (WriteBufferPtr, lpvBuffer, DataCount); WriteBufferPtr += DataCount; WriteBufferCapacity -= DataCount; DataBytes -= DataCount; if (!DataBytes) break; } } } else if (WriteBufferSize && !DllDebug && WriteBuffer != NULL && WriteBufferPtr > WriteBuffer) { /* flush the write buffer */ fwrite (WriteBuffer, WriteBufferPtr-WriteBuffer, 1, stdout); WriteBufferPtr = WriteBuffer; WriteBufferCapacity = WriteBufferSize; } if (DllDebug) fprintf (stdout, "\n[return: TRUE]\n"); return (TRUE); } /*****************************************************************************/ /* DLL callback, provide support functions. */ BOOL IsapiServerSupportFunction ( HCONN hConn, DWORD dwHSERRequest, LPVOID lpvBuffer, LPDWORD lpdwSize, LPDWORD lpdwDataType ) { char *CharsetPtr; EXTENSION_CONTROL_BLOCK *lpEcb; /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "IsapiServerSupportFunction() %d %d %d\n", dwHSERRequest, lpdwSize == NULL ? 0 : *lpdwSize, lpdwDataType); lpEcb = (EXTENSION_CONTROL_BLOCK*)hConn; if (DllDebug) { fprintf (stdout, "[ServerSupportFunction()\n\ hConn: %d\n\ dwHSERRequest: %d\n\ lpvBuffer: %d\n\ lpdwSize: %d %d\n\ lpdwDataType: %d %d\n", hConn, dwHSERRequest, lpvBuffer, lpdwSize, lpdwSize == NULL ? 0 : *lpdwSize, lpdwDataType, lpdwDataType == NULL ? 0 : *lpdwDataType); } switch (dwHSERRequest) { case HSE_REQ_SEND_URL_REDIRECT_RESP : if (DllDebug || Debug) fprintf (stdout, " HSE_REQ_SEND_URL_REDIRECT_RESP]\n"); CgiLibResponseRedirect (lpvBuffer); fflush (stdout); if (DllDebug) fprintf (stdout, "[return: TRUE]\n"); return (TRUE); case HSE_REQ_SEND_URL : if (DllDebug || Debug) fprintf (stdout, " HSE_REQ_SEND_URL]\n"); /* this should be in effect a WASD CGI internal redirect */ CgiLibResponseRedirect (lpvBuffer); fflush (stdout); if (DllDebug) fprintf (stdout, "[return: TRUE]\n"); return (TRUE); case HSE_REQ_SEND_RESPONSE_HEADER : if (DllDebug || Debug) fprintf (stdout, " HSE_REQ_SEND_RESPONSE_HEADER]\n"); if (lpvBuffer == NULL) fputs ("Status: 200\r\n", stdout); else fputs (lpvBuffer, stdout); if (lpdwDataType == NULL) { if ((CharsetPtr = CliCharsetPtr) == NULL) { /* there is no script-enforced character set */ CharsetPtr = CgiLibVar ("REQUEST_CHARSET"); if (!CharsetPtr[0]) CharsetPtr = CgiLibVar ("SERVER_CHARSET"); if (!CharsetPtr[0]) CharsetPtr = DEFAULT_CHARSET; } fprintf (stdout, "Content-Type: text/plain; charset=%s\n\n", CharsetPtr); } else fputs ((char*)lpdwDataType, stdout); fflush (stdout); if (DllDebug) fprintf (stdout, "[return: TRUE]\n"); return (TRUE); case HSE_REQ_DONE_WITH_SESSION : if (DllDebug || Debug) fprintf (stdout, " HSE_REQ_DONE_WITH_SESSION]\n"); /* we're not threaded here, so anything pending's not supported! */ CgiLibResponseError (FI_LI, 0, "HSE_REQ_DONE_WITH_SESSION not supported!"); exit (SS$_NORMAL); case HSE_REQ_DLL_DEBUG_ON : if (DllDebug || Debug) fprintf (stdout, " HSE_REQ_DLL_DEBUG_ON\n return: TRUE]\n"); DllDebugOn = true; return (TRUE); case HSE_REQ_DLL_DEBUG_OFF : if (DllDebug || Debug) fprintf (stdout, " HSE_REQ_DLL_DEBUG_OFF\n return: TRUE]\n"); DllDebugOn = false; return (TRUE); case HSE_REQ_DLL_WRITE_BUFFER_SIZE : if (DllDebug || Debug) fprintf (stdout, " HSE_REQ_DLL_WRITE_BUFFER_SIZE\n return: TRUE]\n"); if (lpdwSize != NULL) { WriteBufferSize = *lpdwSize; /* zero disables output buffering */ if (WriteBufferSize) { /* make sure it's a sensible size */ if (WriteBufferSize < WRITE_BUFFER_SIZE_MIN) WriteBufferSize = WRITE_BUFFER_SIZE_MIN; else if (WriteBufferSize > WRITE_BUFFER_SIZE_MAX) WriteBufferSize = WRITE_BUFFER_SIZE_MAX; } } return (TRUE); default : if (DllDebug) fprintf (stdout, " return: FALSE]\n"); return (FALSE); } } /*****************************************************************************/ /* Get "command-line" parameters, whether from the command-line or from a configuration symbol or logical containing the equivalent. */ GetParameters () { static char CommandLine [256]; static unsigned long Flags = 0; register char *aptr, *cptr, *clptr, *sptr; int status; unsigned short Length; char ch; $DESCRIPTOR (CommandLineDsc, CommandLine); /*********/ /* begin */ /*********/ if (Debug) fprintf (stdout, "GetParameters()\n"); if ((clptr = getenv ("CGISAPI$PARAM")) == NULL) { /* get the entire command line following the verb */ if (VMSnok (status = lib$get_foreign (&CommandLineDsc, 0, &Length, &Flags))) exit (status); (clptr = CommandLine)[Length] = '\0'; } aptr = NULL; ch = *clptr; for (;;) { if (aptr != NULL && *aptr == '/') *aptr = '\0'; if (!ch) break; *clptr = ch; if (Debug) fprintf (stdout, "clptr |%s|\n", clptr); while (*clptr && isspace(*clptr)) *clptr++ = '\0'; aptr = clptr; if (*clptr == '/') clptr++; while (*clptr && !isspace (*clptr) && *clptr != '/') { if (*clptr != '\"') { clptr++; continue; } cptr = clptr; clptr++; while (*clptr) { if (*clptr == '\"') if (*(clptr+1) == '\"') clptr++; else break; *cptr++ = *clptr++; } *cptr = '\0'; if (*clptr) clptr++; } ch = *clptr; if (*clptr) *clptr = '\0'; if (Debug) fprintf (stdout, "aptr |%s|\n", aptr); if (!*aptr) continue; if (strsame (aptr, "/CHARSET=", 4)) { for (cptr = aptr; *cptr && *cptr != '='; cptr++); if (*cptr) cptr++; CliCharsetPtr = cptr; continue; } if (strsame (aptr, "/DBUG", -1)) { Debug = true; continue; } if (strsame (aptr, "/VERSION=", 4)) { for (cptr = aptr; *cptr && *cptr != '='; cptr++); if (*cptr) cptr++; IsapiMajorVersion = atoi(cptr); continue; } if (strsame (aptr, "/WBUFFER=", 4)) { for (cptr = aptr; *cptr && *cptr != '='; cptr++); if (*cptr) cptr++; WriteBufferSize = atoi(cptr); continue; } if (*aptr == '/') { fprintf (stdout, "%%%s-E-IVQUAL, unrecognized qualifier\n \\%s\\\n", Utility, aptr+1); exit (STS$K_ERROR | STS$M_INHIB_MSG); } if (CliDllFileNamePtr == NULL) { CliDllFileNamePtr = aptr; continue; } fprintf (stdout, "%%%s-E-MAXPARM, too many parameters\n \\%s\\\n", Utility, aptr); exit (STS$K_ERROR | STS$M_INHIB_MSG); } } /****************************************************************************/ /* Does a case-insensitive, character-by-character string compare and returns true if two strings are the same, or false if not. If a maximum number of characters are specified only those will be compared, if the entire strings should be compared then specify the number of characters as 0. */ boolean strsame ( register char *sptr1, register char *sptr2, register int count ) { while (*sptr1 && *sptr2) { if (toupper (*sptr1++) != toupper (*sptr2++)) return (false); if (count) if (!--count) return (true); } if (*sptr1 || *sptr2) return (false); else return (true); } /*****************************************************************************/