[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]
/*****************************************************************************
/*
CLI.c
Module to process (interpret) the HTTPD command line. Allows images activated
by a "foreign verb" to behave in a way that approximates the CLI$ (Command
Line Interpreter) utility calls.
VERSION HISTORY
---------------
12-JUL-2019 MGD add /SYSPLUS, /OUTPUT=
19-OCT-2017 MGD add /NOTE=<string> annotate server process log
21-JUN-2017 MGD add /INSTANCE=CONFIG ensure config file values used
07-JUL-2016 MGD ParseCommandInteger() accept just an integer
24-JUL-2015 MGD bugfix; ParseCommand() parenthesis parsing
05-OCT-2009 MGD remove /FILBUF
11-JUL-2009 MGD add /ENV=<integer>
25-MAY-2005 MGD add /VALBLK[=16|64]
15-APR-2004 MGD obsolete /LOCK
19-JUL-2003 MGD add /[NO]NETWORK
03-MAY-2003 MGD add /SYSUAF=VMS keyword
30-JAN-2003 MGD add /PROFILE=NORULE keyword
23-SEP-2002 MGD add /SCRIPT=AS=
16-SEP-2002 MGD add /PERSONA[=RELAXED|AUTHORIZED|RELAXED=AUTHORIZED],
rework qualifier keyword parsing
05-MAY-2002 MGD add /DEMO catch-all for freeware demo use, etc.,
/GBLSEC=NOPERM for no permanent global section
29-SEP-2001 MGD add /[NO]INSTANCE[=integer] number of per-node instances,
/CLUSTER[=integer] grouping (changed from [=resname])
20-MAY-2001 MGD add /GBLSEC=DELETE=<integer>
23-FEB-2001 MGD add /SYSUAF=PROXY
20-DEC-2000 MGD add /PROXY=
02-OCT-2000 MGD add /DETACH, /IDENT=, /PERSONA=, /USER=
18-JUN-2000 MGD add /ALL[=resname]
02-JAN-2000 MGD add /[NO]ODS5, ability to use HTTPD$PARAM
30-OCT-1999 MGD add /SYSPRV
29-SEP-1999 MGD change /SYSUAF= ALL to RELAXED (backward-compatible)
30-JUL-1999 MGD bugfix; /SYSUAF does not need a parameter!
26-MAY-1999 MGD /SSL= now takes a string parameter
24-FEB-1998 MGD /AUTH=ALL, /AUTH=(SSL,ALL), /SYSUAF=WASD_ID
07-NOV-1998 MGD /[NO]WATCH=
07-AUG-1998 MGD /PROMISCUOUS[=password]
06-JUL-1998 MGD v5.1, /SYSUAF=ID
11-MAR-1998 MGD /SYSUAF=(SSL,ALL)
04-FEB-1998 MGD v5.0, /SSL, /SYSUAF=SSL
11-OCT-1997 MGD v4.5, /CACHE, /VERSION
06-SEP-1997 MGD v4.4, /FORMAT, /PROFILE, /SYSUAF, /SOFTWAREID
01-FEB-1997 MGD HTTPd version 4
01-DEC-1995 MGD HTTPd version 3
20-DEC-1994 MGD multi-threaded daemon
20-JUN-1994 MGD single-threaded daemon
*/
/*****************************************************************************/
#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 header files */
#include <descrip.h>
#include <stsdef.h>
#include <ssdef.h>
#include <stsdef.h>
#include "wasd.h"
#define WASD_MODULE "CLI"
/******************/
/* global storage */
/******************/
BOOL CliCacheDisabled,
CliCacheEnabled,
CliDemo,
CliDetach,
CliGblSecDelete,
CliGblSecNoPerm,
CliInstanceConfig,
CliInstanceNoCrePrc,
CliInstancePassive,
CliLoggingDisabled,
CliLoggingEnabled,
CliMonitorDisabled,
CliMonitorEnabled,
CliNetworkMode,
CliNoNetworkMode,
CliOdsExtendedDisabled,
CliOdsExtendedEnabled,
CliPersonaAuthorized,
CliPersonaEnabled,
CliPersonaRelaxed,
CliPersonaRelaxedAuthorized,
CliSoftwareID,
CliSysPlus,
CliTests,
CliVersion;
int CliInstanceMax,
CliLockValueBlockSize,
CliServerPort;
char CommandLine [256],
CliParameter [256],
CliProcessIdentName [64],
CliProxyMaint [128],
CliServices [256],
CliScriptAs [64],
CliUserName [64];
char *CliAcceptHostsPtr = NULL,
*CliOutputPtr = NULL,
*CliRejectHostsPtr = NULL;
/********************/
/* external storage */
/********************/
#ifdef DBUG
extern BOOL Debug;
#else
#define Debug 0
#endif
extern BOOL AccountingZeroOnStartup,
AuthPromiscuous,
AuthPolicyAuthorizedOnly,
AuthPolicySslOnly,
AuthPolicySysUafProxy,
AuthPolicySysUafSslOnly,
AuthPolicySysUafRelaxed,
AuthPolicySysUafIdentifiers,
AuthPolicySysUafVms,
AuthPolicySysUafWasdIdentifiers,
AuthSysUafEnabled,
AuthSysUafPromiscuous,
AuthVmsUserProfileNoRule,
AuthVmsUserProfileEnabled,
ControlDoAllHttpd,
NoSwapOut,
OperateWithSysPrv;
extern int DclCgiPlusInSize,
DclSysCommandSize,
DclSysOutputSize,
DclCgiVariablePrefixLength,
InstanceEnvNumber,
NetReadBufferSize,
OutputBufferSize,
ProcessPriority,
ServerPort;
extern int ToLowerCase[],
ToUpperCase[];
extern char *AuthPromiscuousPwdPtr;
extern char ControlBuffer[],
DclCgiVariablePrefix[],
HttpdServerNote[],
LoggingFileName[],
LoggingFormatUser[],
LoggingPeriodName[],
PersonaIdentName[],
SesolaParams[],
SoftwareID[];
extern HTTPD_PROCESS HttpdProcess;
/****************************************************************************/
/*
This function allows images activated by a "foreign verb" to behave in a way
that approximates the CLI$ (Command Line Interpreter) utility calls. Get the
entire command line following the verb that activated the image. The command
line is returned in uppercase, space compressed (i.e. maximum of one space
between text elements, trimmed of leading and trailing spaces). Returns a
warning status if there were no parameters/qualifiers on the command line.
The variable CommandLine is global.
*/
int ParseCommandLine ()
{
int status;
unsigned short Length;
unsigned long Flags = 0;
char *cptr;
$DESCRIPTOR (CommandLineDsc, CommandLine);
if (!(cptr = getenv ("WASD_HTTPD_PARAM")) &&
!(cptr = getenv ("HTTPD$PARAM")))
{
/* get the entire command line following the verb */
if (VMSnok (status =
lib$get_foreign (&CommandLineDsc, 0, &Length, &Flags)))
return (status);
CommandLine[Length] = '\0';
}
else
{
strncpy (CommandLine, cptr, sizeof(CommandLine));
CommandLine[sizeof(CommandLine)-1] = '\0';
}
if (ParseCommand (CommandLine))
return (SS$_NORMAL);
else
return (STS$K_ERROR | STS$M_INHIB_MSG);
}
/****************************************************************************/
/*
This function allows images activated by a "foreign verb" to behave in a way
that approximates the CLI$ (Command Line Interpreter) utility calls. Quoted
strings are always indicated by being parsed to include a single leading
quote.
*/
BOOL ParseCommand (char *CommandLine)
{
BOOL CommandLineOK = true;
int ParenCount = 0,
QuoteCount = 0;
char *cptr, *eptr, *zptr;
char Entity [1024] = "";
/* set up any argument defaults */
ParseCommandEntity (NULL);
cptr = CommandLine;
zptr = (eptr = Entity) + sizeof(Entity)-1;
for (;;)
{
if (eptr >= zptr) exit (SS$_RESULTOVF);
if (*cptr == '\"')
{
QuoteCount++;
*eptr++ = *cptr++;
continue;
}
if (QuoteCount & 1 && *cptr)
{
/* inside quoted text, copy all characters as literals */
*eptr++ = *cptr++;
continue;
}
if (*cptr == '(')
{
ParenCount++;
*eptr++ = *cptr++;
continue;
}
if (ParenCount && *cptr)
{
if (*cptr == ')') ParenCount--;
*eptr++ = *cptr++;
continue;
}
if ((Entity[0] && *cptr == '/') || ISLWS (*cptr) || !*cptr)
{
if (eptr >= zptr) exit (SS$_RESULTOVF);
while (*cptr && ISLWS (*cptr)) cptr++;
*eptr = '\0';
if (Entity[0])
if (!ParseCommandEntity (Entity))
CommandLineOK = false;
if (!*cptr) break;
/* start of new entity */
eptr = Entity;
continue;
}
/* just copy any other character */
*eptr++ = *cptr++;
}
if (QuoteCount & 1)
{
FaoToStdout ("%HTTPD-E-QUOTES, unbalanced quotes\n");
return (false);
}
if (ParenCount)
{
FaoToStdout ("%HTTPD-E-PARENS, unbalanced parentheses\n");
return (false);
}
return (CommandLineOK);
}
/*****************************************************************************/
/*
Get a string value from a qualifier, e.g. '/EXAMPLE=TEST'.
*/
BOOL ParseCommandString
(
char *Entity,
char *String,
BOOL Qualifier,
BOOL ReportErrors,
BOOL EnsureUpperCase
)
{
int QuoteCount = 0;
char *eptr, *sptr;
eptr = Entity;
if (Qualifier)
{
/* scan down to equate symbol */
while (*eptr && *eptr != '=') eptr++;
if (*eptr) eptr++;
if (!*eptr)
{
if (ReportErrors)
FaoToStdout ("%HTTPD-E-VALREQ, \
missing qualifier or keyword value\n \\!AZ\\\n",
Entity+1);
return (false);
}
}
sptr = String;
while (*eptr)
{
if (*eptr == '\"')
{
if (QuoteCount & 1)
{
/* are inside quotes, check for escaped quotes ("") */
if (*++eptr != '\"')
{
/* now outside quotes */
QuoteCount++;
}
/* drop thru to character copy */
}
else
{
/* now inside quotes */
QuoteCount++;
eptr++;
continue;
}
}
if (ISLWS(*eptr) && !(QuoteCount & 1))
eptr++;
else
if (EnsureUpperCase)
*sptr++ = TOUP(*eptr++);
else
*sptr++ = *eptr++;
}
*sptr = '\0';
return (true);
}
/*****************************************************************************/
/*
Get an integer value from a qualifier, e.g. '/EXAMPLE=99'.
*/
BOOL ParseCommandInteger
(
char *Entity,
int *IntegerPtr,
int Base,
BOOL ReportErrors
)
{
char *eptr, *sptr;
/* if not in the form /<string>=<integer> assume just an integer */
if (*(eptr = Entity) == '/')
{
while (*eptr && *eptr != '=') eptr++;
if (*eptr) eptr++;
}
if (*eptr)
{
*IntegerPtr = strtol (eptr, &sptr, Base);
if (sptr > eptr && !*sptr)
return (true);
else
{
if (ReportErrors)
FaoToStdout ("%HTTPD-E-BADVALUE, \
'!AZ' is an invalid keyword value\n",
eptr);
return (false);
}
}
else
{
if (ReportErrors)
{
FaoToStdout ("%HTTPD-E-VALREQ, \
missing qualifier or keyword value\n \\!AZ\\\n",
Entity+1);
}
return (false);
}
}
/*****************************************************************************/
/*
A single command line "entity" has been parsed, check if its recognised. This
function is the one modified for the individual requirements of each program.
*/
BOOL ParseCommandEntity (char *Entity)
{
BOOL ok;
int Length;
char Scratch [256];
char *cptr, *sptr, *tptr, *zptr;
if (!Entity)
{
/* set up any argument defaults */
return (true);
}
ok = false;
if (Entity[0] == '/')
{
if (strsame (Entity, "/ACCEPT=", 4))
{
ok = ParseCommandString (Entity, Scratch, true, true, true);
for (cptr = Scratch; *cptr && ISLWS(*cptr); cptr++);
if (!*cptr) return (ok);
CliAcceptHostsPtr = VmGet (Length = strlen(Scratch)+1);
memcpy (CliAcceptHostsPtr, Scratch, Length);
return (ok);
}
if (strsame (Entity, "/AUTHORIZE=", 4))
{
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
while (*cptr)
{
while (*cptr == '(' || *cptr == ',' || *cptr == ')') cptr++;
zptr = (sptr = Scratch) + sizeof(Scratch)-1;
while (*cptr && *cptr != ',' && *cptr != ')' && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
if (!Scratch[0]) continue;
if (strsame (Scratch, "ALL", -1))
AuthPolicyAuthorizedOnly = ok = true;
else
if (strsame (Scratch, "SSL", -1))
AuthPolicySslOnly = ok = true;
else
{
CliIVKEYW (Scratch);
return (false);
}
}
if (!ok)
CliVALREQ (Entity);
return (true);
}
if (strsame (Entity, "/CACHE", 4))
{
CliCacheEnabled = true;
CliCacheDisabled = false;
return (true);
}
if (strsame (Entity, "/NOCACHE", 6))
{
CliCacheEnabled = false;
CliCacheDisabled = true;
return (true);
}
if (strsame (Entity, "/CGI_PREFIX=", 4))
{
ok = ParseCommandString (Entity, DclCgiVariablePrefix,
true, true, true);
DclCgiVariablePrefixLength = strlen(DclCgiVariablePrefix);
return (ok);
}
if (strsame (Entity, "/CLUSTER=", 4) ||
strsame (Entity, "/ALL=", 4))
{
ControlDoAllHttpd = true;
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (!*cptr) return (true);
/* optional grouping number */
return (ParseCommandInteger (Entity, &InstanceEnvNumber, 10, true));
}
if (strsame (Entity, "/DCLCGIPLUSIN=", 6))
return (ParseCommandInteger (Entity, &DclCgiPlusInSize, 10, true));
if (strsame (Entity, "/DETACH", 4)) return (CliDetach = true);
if (strsame (Entity, "/DO=", 4))
return (ParseCommandString (Entity, ControlBuffer, true, true, false));
#ifdef DBUG
/* turns on all "if (Debug)" statements */
if (strsame (Entity, "/DBUG", -1))
return (Debug = true);
#endif
if (strsame (Entity, "/DEMO", -1))
return (CliDemo = true);
if (strsame (Entity, "/ENV=", 4))
return (ParseCommandInteger (Entity, &InstanceEnvNumber, 10, true));
if (strsame (Entity, "/FORMAT=", 4))
return (ParseCommandString (Entity, LoggingFormatUser,
true, true, false));
if (strsame (Entity, "/GBLSEC=DELETE", 15))
{
CliGblSecDelete = true;
return (true);
}
if (strsame (Entity, "/GBLSEC=NOPERM", 15))
{
CliGblSecNoPerm = true;
return (true);
}
if (strsame (Entity, "/IDENT=", 4))
return (ParseCommandString (Entity, CliProcessIdentName,
true, true, true));
if (strsame (Entity, "/NOINSTANCE", 6))
return (CliInstanceNoCrePrc = true);
if (strsame (Entity, "/INSTANCE=", 4))
{
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
while (*cptr)
{
while (*cptr == '(' || *cptr == ',' || *cptr == ')') cptr++;
zptr = (sptr = Scratch) + sizeof(Scratch)-1;
while (*cptr && *cptr != ',' && *cptr != ')' && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
if (!Scratch[0]) continue;
if (ok = strsame (Scratch, "CONFIG", 3))
CliInstanceConfig = true;
else
if (ok = strsame (Scratch, "CPU", 3))
CliInstanceMax = INSTANCE_PER_CPU;
else
if (ok = strsame (Scratch, "PASSIVE", 3))
CliInstancePassive = true;
else
if (isdigit(Scratch[0]) || Scratch[0] == '-')
{
ok = ParseCommandInteger (Scratch, &CliInstanceMax, 10, true);
if (ok && CliInstanceMax == 0) CliInstanceMax = -999;
}
else
{
CliIVKEYW (Scratch);
return (false);
}
}
if (!ok)
{
CliVALREQ (Entity);
return (false);
}
return (true);
}
if (strsame (Entity, "/LOG=", 4))
{
CliLoggingEnabled = true;
CliLoggingDisabled = false;
if (Entity[4] == '=')
return (ParseCommandString (Entity, LoggingFileName,
true, true, true));
else
return (true);
}
if (strsame (Entity, "/NOLOG", 6))
{
CliLoggingEnabled = false;
CliLoggingDisabled = true;
return (true);
}
if (strsame (Entity, "/MONITOR", 4))
{
CliMonitorEnabled = true;
CliMonitorDisabled = false;
return (true);
}
if (strsame (Entity, "/NOMONITOR", 6))
{
CliMonitorEnabled = false;
CliMonitorDisabled = true;
return (true);
}
if (strsame (Entity, "/NETWORK", 5))
{
CliNetworkMode = true;
CliNoNetworkMode = false;
return (true);
}
if (strsame (Entity, "/NONETWORK", 5))
{
CliNetworkMode = false;
CliNoNetworkMode = true;
return (true);
}
if (strsame (Entity, "/NETBUF=", 5))
return (ParseCommandInteger (Entity, &NetReadBufferSize, 10, true));
if (strsame (Entity, "/NOTE=", 6))
{
strcpy (HttpdServerNote, "/NOTE=");
return (ParseCommandString (Entity, HttpdServerNote+6,
true, true, false));
}
if (strsame (Entity, "/ODS5", -1))
{
CliOdsExtendedEnabled = true;
CliOdsExtendedDisabled = false;
return (true);
}
if (strsame (Entity, "/NOODS5", -1))
{
CliOdsExtendedEnabled = false;
CliOdsExtendedDisabled = true;
return (true);
}
if (strsame (Entity, "/OUTBUF=", 5))
return (ParseCommandInteger (Entity, &OutputBufferSize, 10, true));
if (strsame (Entity, "/OUTPUT=", 4))
{
ok = ParseCommandString (Entity, Scratch, true, true, true);
for (cptr = Scratch; *cptr && ISLWS(*cptr); cptr++);
if (!*cptr) return (ok);
CliOutputPtr = VmGet (Length = strlen(Scratch)+1);
memcpy (CliOutputPtr, Scratch, Length);
return (ok);
}
if (strsame (Entity, "/PERIOD=", 5))
return (ParseCommandString (Entity, LoggingPeriodName,
true, true, false));
if (strsame (Entity, "/PERSONA=", 5))
{
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (!*cptr) return (CliPersonaEnabled = true);
cptr++;
while (*cptr)
{
while (*cptr == '(' || *cptr == ',' || *cptr == ')') cptr++;
zptr = (sptr = Scratch) + sizeof(Scratch)-1;
while (*cptr && *cptr != ',' && *cptr != ')' && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
if (!Scratch[0]) continue;
if (strsame (Scratch, "AUTHORIZED", 4))
CliPersonaAuthorized = true;
else
if (strsame (Scratch, "RELAXED", 5))
{
CliPersonaRelaxed = true;
for (sptr = Scratch; *sptr && *sptr != '='; sptr++);
if (strsame (sptr, "=AUTHORIZED", 5))
CliPersonaRelaxedAuthorized = true;
}
else
if (strsame (Scratch, "IDENT=", 6))
{
strcpy (PersonaIdentName, Scratch+6);
for (sptr = PersonaIdentName; *sptr; sptr++)
*sptr = TOUP(*sptr);
}
else
{
strcpy (PersonaIdentName, Scratch);
for (sptr = PersonaIdentName; *sptr; sptr++)
*sptr = TOUP(*sptr);
}
}
return (CliPersonaEnabled = true);
}
if (strsame (Entity, "/NOPERSONA", 5))
{
CliPersonaAuthorized = CliPersonaEnabled =
CliPersonaRelaxed = CliPersonaRelaxedAuthorized = false;
return (true);
}
if (strsame (Entity, "/PORT=", 4))
return (ParseCommandInteger (Entity, &CliServerPort, 10, true));
if (strsame (Entity, "/PRIORITY=", 4))
return (ParseCommandInteger (Entity, &ProcessPriority, 10, true));
if (strsame (Entity, "/PROFILE=", 5))
{
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (*cptr)
{
cptr++;
if (strsame (cptr, "NORULE", -1))
AuthVmsUserProfileNoRule = true;
else
{
CliIVKEYW (cptr);
return (AuthVmsUserProfileEnabled = false);
}
}
return (AuthVmsUserProfileEnabled = true);
}
if (strsame (Entity, "/NOPROFILE", 6))
{
AuthVmsUserProfileEnabled = false;
return (true);
}
/* for testing only, also needs /SYSUAF=PROMSICUOUS if using SYSUAF! */
if (strsame (Entity, "/PROMISCUOUS=", 5))
{
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (*cptr)
{
cptr++;
AuthPromiscuousPwdPtr = VmGet (Length = strlen(cptr)+1);
memcpy (AuthPromiscuousPwdPtr, cptr, Length);
}
return (AuthPromiscuous = true);
}
if (strsame (Entity, "/NOPROMISCUOUS", 7))
{
AuthPromiscuous = false;
return (true);
}
if (strsame (Entity, "/PROXY=", 5))
{
ok = ParseCommandString (Entity, CliProxyMaint, true, true, true);
if (CliProxyMaint[0]) return (ok);
CliVALREQ (Entity);
return (false);
}
if (strsame (Entity, "/REJECT=", 4))
{
ok = ParseCommandString (Entity, Scratch, true, true, true);
for (cptr = Scratch; *cptr && ISLWS(*cptr); cptr++);
if (!*cptr) return (ok);
CliRejectHostsPtr = VmGet (Length = strlen(Scratch)+1);
memcpy (CliRejectHostsPtr, Scratch, Length);
return (ok);
}
if (strsame (Entity, "/SCRIPT=AS=", 4))
{
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
while (*cptr && *cptr != '=') cptr++;
if (*cptr)
{
cptr++;
zptr = (sptr = CliScriptAs) + sizeof(CliScriptAs)-1;
while (*cptr && sptr < zptr) *sptr++ = TOUP(*cptr++);
*sptr = '\0';
if (CliScriptAs[0]) return (true);
}
CliVALREQ (Entity);
return (false);
}
if (strsame (Entity, "/SERVICES=", 4))
return (ParseCommandString (Entity, CliServices, true, true, false));
/*
This qualifier may come in handy if having to use VMS or WASD
causes embarressment :^) Seriously, if you consider providing
the server identification a security issue use this qualifier
to set it to something like "Mine", "Unknown", "?", etc.
*/
if (strsame (Entity, "/SOFTWAREID=", 4))
{
CliSoftwareID = true;
return (ParseCommandString (Entity, SoftwareID, true, true, false));
}
if (strsame (Entity, "/SSL=", 4))
return (ParseCommandString (Entity, SesolaParams, true, true, false));
if (strsame (Entity, "/NOSSL", 6))
{
strcpy (SesolaParams, "/NOSSL");
return (true);
}
if (strsame (Entity, "/SUBBUF=", 5))
return (ParseCommandInteger (Entity, &DclSysOutputSize, 10, true));
if (strsame (Entity, "/SWAP", -1))
{
NoSwapOut = false;
return (true);
}
if (strsame (Entity, "/NOSWAP", -1))
return (NoSwapOut = true);
if (strsame (Entity, "/SYSPLUS", -1))
return (CliSysPlus = true);
if (strsame (Entity, "/SYSPRV", -1))
return (OperateWithSysPrv = true);
if (strsame (Entity, "/NOSYSPRV", -1))
{
OperateWithSysPrv = false;
return (true);
}
if (strsame (Entity, "/SYSUAF=", 4))
{
AuthSysUafEnabled = true;
for (cptr = Entity; *cptr && *cptr != '='; cptr++);
if (!*cptr) return (true);
cptr++;
while (*cptr)
{
while (*cptr == '(' || *cptr == ',' || *cptr == ')') cptr++;
zptr = (sptr = Scratch) + sizeof(Scratch)-1;
while (*cptr && *cptr != ',' && *cptr != ')' && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
if (!Scratch[0]) continue;
if (strsame (Scratch, "ALL", -1) ||
strsame (Scratch, "RELAXED", -1))
AuthPolicySysUafRelaxed = true;
else
if (strsame (Scratch, "ID", -1))
AuthPolicySysUafIdentifiers = true;
else
if (strsame (Scratch, "PROXY", -1))
AuthPolicySysUafProxy = true;
else
if (strsame (Scratch, "SSL", -1))
AuthPolicySysUafSslOnly = true;
else
if (strsame (Scratch, "VMS", -1))
AuthPolicySysUafVms = true;
else
if (strsame (Scratch, "WASD", -1) ||
strsame (Scratch, "WASD_ID", -1))
AuthPolicySysUafWasdIdentifiers = true;
else
{
CliIVKEYW (Scratch);
return (AuthSysUafEnabled = false);
}
}
return (true);
}
if (strsame (Entity, "/NOSYSUAF", 6))
{
AuthSysUafEnabled = false;
return (true);
}
/* for testing SYSUAF-authenticated security profiles purposes only */
if (strsame (Entity, "/SYSUAF=PROMISCUOUS", -1))
return (AuthSysUafEnabled = AuthSysUafPromiscuous = true);
if (strsame (Entity, "/TESTS", 4))
return (CliTests = true);
if (strsame (Entity, "/USER=", 4))
return (ParseCommandString (Entity, CliUserName, true, true, true));
if (strsame (Entity, "/VALBLK=", 5))
{
/* used without a value set to the default value block size */
CliLockValueBlockSize = -1;
ParseCommandInteger (Entity, &CliLockValueBlockSize, 10, false);
if (CliLockValueBlockSize == -1 ||
CliLockValueBlockSize == 16 ||
CliLockValueBlockSize == 64) return (true);
CliIVKEYW (Entity);
CliLockValueBlockSize = 0;
return (false);
}
if (strsame (Entity, "/VERSION", 4))
return (CliVersion = true);
if (strsame (Entity, "/WATCH=", 4) ||
strsame (Entity, "/NOWATCH", 6))
return (WatchCliParse (Entity));
if (strsame (Entity, "/ZERO", -1))
return (AccountingZeroOnStartup = true);
if (strsame (Entity, "/NOZERO", -1))
{
AccountingZeroOnStartup = false;
return (true);
}
for (sptr = Entity; *sptr && *sptr != '='; sptr++);
*sptr = '\0';
CliIVQUAL (Entity+1);
return (false);
}
if (!CliParameter[0])
return (ParseCommandString (Entity, CliParameter, false, true, false));
FaoToStdout ("%HTTPD-E-MAXPARM, too many parameters\n \\!AZ\\\n", Entity);
return (false);
}
/*****************************************************************************/
/*
*/
BOOL CliIVQUAL (char *qual)
{
FaoToStdout ("%HTTPD-E-IVQUAL, unrecognised qualifier\n \\!AZ\\\n", qual);
return (false);
}
/*****************************************************************************/
/*
*/
BOOL CliIVKEYW (char *keyw)
{
FaoToStdout ("%HTTPD-E-IVKEYW, unrecognized keyword\n \\!AZ\\\n", keyw);
return (false);
}
/*****************************************************************************/
/*
*/
BOOL CliVALREQ (char *qual)
{
FaoToStdout ("%HTTPD-E-VALREQ, missing qualifier or keyword value\n \
\\!AZ\\\n", qual);
return (false);
}
/*****************************************************************************/