[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]
/*****************************************************************************/
/*
DAVlock.c
WASD WebDAV locks are implemented as meta-data and stored along with properties
in the meta-data administered by the DAVMETA.C module.
VERSION HISTORY
---------------
19-OCT-2018 MGD bugfix; DavLockTest() munge the ]NAME.DIR into a directory
specification .NAME]
12-SEP-2018 MGD bugfix; significant refactor of locking
18-JUN-2014 MGD DavLockUrnUuidToken() move from opaque to uuid token
(from "opaquelocktoken:..." to "urn:uuid:...")
15-JUN-2014 MGD interim test of metadata directory
07-SEP-2013 MGD DavLockSetTimeout() BitKinex at least uses a timeout
of "infinity" rather than the RFC "infinite"
02-SEP-2009 MGD bugfix; scanning backwards through extended file spec
31-DEC-2006 MGD initial
*/
/*****************************************************************************/
#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
#include <stdio.h>
#include <ctype.h>
#include <libdef.h>
#include <rmsdef.h>
#include "wasd.h"
#include "davweb.h"
#define WASD_MODULE "DAVLOCK"
#ifndef WASD_WEBDAV
#define WASD_WEBDAV 1
#endif
/******************/
/* global storage */
/******************/
/********************/
/* external storage */
/********************/
extern BOOL WebDavEnabled,
WebDavLockingEnabled;
extern const int64 Delta01Sec;
extern int WebDavLockCollectionDepth;
WebDavLockTimeoutDefaultSeconds,
WebDavLockTimeoutMaxSeconds;
extern int64 HttpdTime64;
extern int ToLowerCase[],
ToUpperCase[];
extern unsigned long SysPrvMask[];
extern char ErrorSanityCheck[],
HttpdVersion[];
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Should be performed as soon as the metadata file XML has been parsed.
Scan all locks looking for any that may have timed-out. Simply remove them
from the in-memory lock list. If the metadata file is updated those lock(s)
will not be updated with it. If the file is not updated then they just sit
there harmlessly until it is. If a lock is being checked then timed-out locks
will be absent.
*/
DavLockPreProcess (REQUEST_STRUCT *rqptr)
{
int status;
int64 ScratchTime64;
WEBDAV_LOCK *lckptr, *nextptr;
WEBDAV_META *mtaptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockPreProcess()");
tkptr = rqptr->WebDavTaskPtr;
mtaptr = &tkptr->MetaData;
/* don't use LIST_ITERATE as we may need to manipulate the list itself */
for (lckptr = LIST_GET_HEAD(&mtaptr->LockList); lckptr; lckptr = nextptr)
{
/* get any next entry in case the current is removed */
nextptr = LIST_GET_NEXT (&lckptr->ListEntry);
if (lckptr->Timeout)
{
/* a negative time indicates the timeout has expired */
ScratchTime64 = lckptr->ExpiresTime64 - HttpdTime64;
if (ScratchTime64 < 0)
{
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV,
"LOCK timeout !20%D expired", lckptr->ExpiresTime64);
ListRemove (&mtaptr->LockList, lckptr);
}
}
}
}
/*****************************************************************************/
/*
No up-front VMS DLM lock required.
Just rely on the DLM lock acquired by the meta-data lock.
*/
DavLockBegin (REQUEST_STRUCT *rqptr)
{
WEBDAV_META *mtaptr;
/*********/
/* begin */
/*********/
if (!WebDavLockingEnabled)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockBegin()");
if (WATCHING (rqptr, WATCH_RESPONSE))
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE, "LOCK !AZ",
rqptr->ParseOds.ExpFileName);
mtaptr = &rqptr->WebDavTaskPtr->MetaData;
DavMetaLock (rqptr, mtaptr, rqptr->ParseOds.ExpFileName,
&DavLockUpdate, mtaptr);
}
/*****************************************************************************/
/*
If obtained the DLM and meta-data lock the update with new/refresh lock.
*/
DavLockUpdate (WEBDAV_META *mtaptr)
{
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = mtaptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockUpdate()");
if (VMSok (mtaptr->VmsStatus))
DavMetaUpdate (mtaptr, DavLockEnd, mtaptr);
else
DavLockEnd (mtaptr);
}
/*****************************************************************************/
/*
Results of the lock update.
*/
DavLockEnd (WEBDAV_META *mtaptr)
{
static char LockToken [64] = "Lock-Token: ";
int status;
char *ltptr;
REQUEST_STRUCT *rqptr;
WEBDAV_LOCK *lckptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
rqptr = mtaptr->RequestPtr;
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockEnd()");
if (tkptr->DestOds.Fab.fab$l_sts)
{
/* just created an unmapped URL empty resource */
mtaptr->VmsStatus = tkptr->DestOds.Fab.fab$l_sts;
if (WATCHING (rqptr, WATCH_WEBDAV))
if (VMSok (mtaptr->VmsStatus))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "LOCK unmapped URL");
else
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "LOCK !&S unmapped URL",
mtaptr->VmsStatus);
if (VMSok (mtaptr->VmsStatus))
{
tkptr->ResponseStatusCode = 201;
status = OdsClose (&tkptr->DestOds, NULL, NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
}
else
if (mtaptr->MetaCreated)
{
if (!mtaptr->MetaForDir)
{
/* not a directory meta, check if the resource exists */
sys$setprv (1, &SysPrvMask, 0, 0);
status = OdsFileExists (NULL, rqptr->ParseOds.ExpFileName);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSnok (status))
{
/* does not exists - create unmapped URL empty resource */
AuthAccessEnable (rqptr, rqptr->ParseOds.ExpFileName,
AUTH_ACCESS_WRITE);
OdsCreate (&tkptr->DestOds,
rqptr->ParseOds.ExpFileName,
rqptr->ParseOds.ExpFileNameLength,
NULL, 0,
FAB$M_PUT + FAB$M_GET + FAB$M_BIO + FAB$M_TRN,
FAB$M_CIF + FAB$M_TEF,
FAB$M_NIL, FAB$C_UDF, 0, NULL,
&DavLockEnd, mtaptr);
AuthAccessEnable (rqptr, 0, 0);
return;
}
}
}
if (VMSok (mtaptr->VmsStatus))
{
/* the list head will be the most recently added/refreshed lock */
if (!(lckptr = LIST_GET_HEAD(&mtaptr->LockList)))
{
ErrorNoticed (rqptr, SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
DavWebResponse (rqptr, 500, SS$_BUGCHECK, NULL, FI_LI);
DavWebEnd (rqptr);
return;
}
if (mtaptr->LockCreated)
{
/* lock-token response only supplied with new locks not refreshes */
strcpy (LockToken+12, lckptr->TokenString);
strcat (LockToken+12, "\r\n");
ltptr = LockToken;
}
else
ltptr = "";
}
else
{
/* blanket 412 for any locking failure */
DavWebResponse (rqptr, 412, mtaptr->VmsStatus, NULL, FI_LI);
DavWebEnd (rqptr);
return;
}
rqptr->rqResponse.NoGzip = true;
ResponseHeader (rqptr, tkptr->ResponseStatusCode,
"text/xml; charset=\"utf-8\"",
-1, NULL, ltptr);
FaoToNet (rqptr,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\
<D:prop xmlns:D=\"DAV:\">\n\
<D:lockdiscovery>\n\
<D:activelock>\n\
<D:locktype><D:!AZ/></D:locktype>\n\
<D:lockscope><D:!AZ!AZ/></D:lockscope>\n\
<D:locktoken><D:href>!AZ</D:href></D:locktoken>\n\
<D:depth>!AZ!AZ!AZ</D:depth>\n\
!AZ!AZ!AZ\
!AZ!AZ!AZ\
</D:activelock>\n\
</D:lockdiscovery>\n\
</D:prop>\n",
lckptr->Type == WEBDAV_LOCK_TYPE_WRITE ? "write" : "",
lckptr->Scope == WEBDAV_LOCK_SCOPE_EXCLUSIVE ? "exclusive" : "",
lckptr->Scope == WEBDAV_LOCK_SCOPE_SHARED ? "shared" : "",
lckptr->TokenString,
lckptr->Depth == WEBDAV_DEPTH_ZERO ? "0" : "",
lckptr->Depth == WEBDAV_DEPTH_ONE ? "1" : "",
lckptr->Depth == WEBDAV_DEPTH_INFINITY ? "infinity" : "",
lckptr->Timeout ? " <D:timeout>" : "",
lckptr->Timeout ? lckptr->TimeoutString : "",
lckptr->Timeout ? "</D:timeout>\n" : "",
STR_DSC_LEN(&lckptr->OwnerDsc) ? " <D:owner>" : "",
/* the owner string has already been HTML-sanitised */
STR_DSC_LEN(&lckptr->OwnerDsc) ? STR_DSC_PTR(&lckptr->OwnerDsc) : "",
STR_DSC_LEN(&lckptr->OwnerDsc) ? "</D:owner>\n" : "");
DavWebEnd (rqptr);
}
/*****************************************************************************/
/*
No up-front VMS DLM lock required.
Just rely on the DLM lock acquired by the meta-data lock.
*/
DavUnLockBegin (REQUEST_STRUCT *rqptr)
{
WEBDAV_META *mtaptr;
/*********/
/* begin */
/*********/
if (!WebDavLockingEnabled)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavUnLockBegin()");
if (WATCHING (rqptr, WATCH_RESPONSE))
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE, "UNLOCK !AZ !AZ",
rqptr->ParseOds.ExpFileName,
rqptr->rqHeader.WebDavLockTokenPtr);
mtaptr = &rqptr->WebDavTaskPtr->MetaData;
DavMetaLock (rqptr, mtaptr, rqptr->ParseOds.ExpFileName,
&DavUnLockUpdate, mtaptr);
}
/*****************************************************************************/
/*
If obtained the DLM and meta-data lock the update with no lock.
*/
DavUnLockUpdate (WEBDAV_META *mtaptr)
{
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = mtaptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavUnLockUpdate()");
if (VMSok (mtaptr->VmsStatus))
DavMetaUpdate (mtaptr, DavUnLockEnd, mtaptr);
else
DavUnLockEnd (mtaptr);
}
/*****************************************************************************/
/*
*/
DavUnLockEnd (WEBDAV_META *mtaptr)
{
REQUEST_STRUCT *rqptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
rqptr = mtaptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavUnLockEnd() !&S", mtaptr->VmsStatus);
tkptr = rqptr->WebDavTaskPtr;
if (VMSok (mtaptr->VmsStatus))
{
/* success status but with no content */
DavWebResponse (rqptr, 204, 0, "success", FI_LI);
}
else
{
/* unlock failed */
rqptr->rqResponse.HttpStatus = 412;
DavWebResponse (rqptr, 412, mtaptr->VmsStatus, NULL, FI_LI);
}
DavWebEnd (rqptr);
}
/*****************************************************************************/
/*
Build either a new or refreshed lock XML text into the supplied lock.
Return a zero to indicate success or an HTTP error status code.
*/
int DavLockSetTimeout
(
REQUEST_STRUCT *rqptr,
WEBDAV_LOCK *lckptr
)
{
int status, expsecs, tmosecs;
char ExpiresDateTime [32];
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockSetTimeout() !&Z",
rqptr->rqHeader.WebDavTimeoutPtr);
tkptr = rqptr->WebDavTaskPtr;
if (rqptr->rqHeader.WebDavTimeoutPtr)
{
/* from request header (both "infinite" and "infinity" seem in use) */
if (strsame (rqptr->rqHeader.WebDavTimeoutPtr, "Infinit", 7))
lckptr->Timeout = WEBDAV_TIMEOUT_INFINITE;
else
if (strsame (rqptr->rqHeader.WebDavTimeoutPtr, "Second-", 7))
lckptr->Timeout = atoi(rqptr->rqHeader.WebDavTimeoutPtr+7);
else
{
if (WATCHING (rqptr, WATCH_RESPONSE))
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE, "TIMEOUT? !AZ",
rqptr->rqHeader.WebDavTimeoutPtr);
/* default timeouts */
if (!(lckptr->Timeout = rqptr->rqPathSet.WebDavLockTimeoutDefault))
lckptr->Timeout = WebDavLockTimeoutDefaultSeconds;
}
}
else
{
/* default timeouts */
if (!(lckptr->Timeout = rqptr->rqPathSet.WebDavLockTimeoutDefault))
lckptr->Timeout = WebDavLockTimeoutDefaultSeconds;
}
/* limit to configured maximum */
if (rqptr->rqPathSet.WebDavLockTimeoutMax) {
if (lckptr->Timeout > rqptr->rqPathSet.WebDavLockTimeoutMax)
lckptr->Timeout = rqptr->rqPathSet.WebDavLockTimeoutMax;
}
else
if (WebDavLockTimeoutMaxSeconds) {
if (lckptr->Timeout > WebDavLockTimeoutMaxSeconds)
lckptr->Timeout = WebDavLockTimeoutMaxSeconds;
}
if (lckptr->Timeout)
{
/* current lock timeout */
expsecs = tmosecs = lckptr->Timeout;
}
else
{
/* default timeouts */
if (!(expsecs = tmosecs = rqptr->rqPathSet.WebDavLockTimeoutDefault))
expsecs = tmosecs = WebDavLockTimeoutDefaultSeconds;
}
/* limit to configured maximum */
if (rqptr->rqPathSet.WebDavLockTimeoutMax) {
if (expsecs > rqptr->rqPathSet.WebDavLockTimeoutMax)
expsecs = rqptr->rqPathSet.WebDavLockTimeoutMax;
}
else
if (WebDavLockTimeoutMaxSeconds) {
if (expsecs > WebDavLockTimeoutMaxSeconds)
expsecs = WebDavLockTimeoutMaxSeconds;
}
if (lckptr->Timeout == WEBDAV_TIMEOUT_INFINITE)
strcpy (lckptr->TimeoutString, "infinite");
else
if (lckptr->Timeout)
sprintf (lckptr->TimeoutString, "Second-%d", lckptr->Timeout);
else
lckptr->TimeoutString[0] = '\0';
lckptr->ExpiresTime64 = HttpdTime64 + (int64)expsecs * DELTA64_ONE_SEC;
if (lckptr->ExpiresTime64)
{
DavWebDateTimeTo3339 (ExpiresDateTime, &lckptr->ExpiresTime64);
FaoToBuffer (lckptr->ExpiresString, sizeof(lckptr->ExpiresString), NULL,
"!AZ !20%D", ExpiresDateTime, &lckptr->ExpiresTime64);
}
else
lckptr->ExpiresString[0] = '\0';
return (0);
}
/*****************************************************************************/
/*
Generate XML text equivalent to the lock data adding it to the supplied string
descriptor.
*/
DavLockXml
(
REQUEST_STRUCT *rqptr,
WEBDAV_LOCK *lckptr,
STR_DSC *wdptr
)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavLockXml() !8XL !8XL", lckptr, wdptr);
StrDscBuild (wdptr, NULL, "<WASDAV:lock\n");
StrDscBuild (wdptr, NULL, "token=\"");
StrDscBuild (wdptr, NULL, lckptr->TokenString);
StrDscBuild (wdptr, NULL, "\"\n");
if (lckptr->Depth == WEBDAV_DEPTH_ZERO)
StrDscBuild (wdptr, NULL, "depth=\"0\"\n");
else
if (lckptr->Depth == WEBDAV_DEPTH_ONE)
StrDscBuild (wdptr, NULL, "depth=\"1\"\n");
else
if (lckptr->Depth == WEBDAV_DEPTH_INFINITY)
StrDscBuild (wdptr, NULL, "depth=\"infinity\"\n");
if (lckptr->Type == WEBDAV_LOCK_TYPE_WRITE)
StrDscBuild (wdptr, NULL, "type=\"write\"\n");
if (lckptr->Scope == WEBDAV_LOCK_SCOPE_EXCLUSIVE)
StrDscBuild (wdptr, NULL, "scope=\"exclusive\"\n");
else
if (lckptr->Scope == WEBDAV_LOCK_SCOPE_SHARED)
StrDscBuild (wdptr, NULL, "scope=\"shared\"\n");
if (lckptr->Timeout == WEBDAV_TIMEOUT_INFINITE)
StrDscBuild (wdptr, NULL, "timeout=\"infinite\"");
else
if (lckptr->Timeout)
FaoToBuffer (wdptr, -1, NULL, "timeout=\"Second-!UL\"", lckptr->Timeout);
else
FaoToBuffer (wdptr, -1, NULL, "timeout=\"Second-!UL\"",
WebDavLockTimeoutDefaultSeconds);
if (lckptr->ExpiresTime64)
FaoToBuffer (wdptr, -1, NULL, "\nexpires=\"!AZ\">\n",
lckptr->ExpiresString);
else
FaoToBuffer (wdptr, -1, NULL, ">\n");
if (STR_DSC_LEN(&lckptr->OwnerDsc))
FaoToBuffer (wdptr, -1, NULL, "<WASDAV:owner>!&;AZ</WASDAV:owner>\n",
STR_DSC_PTR(&lckptr->OwnerDsc));
StrDscBuild (wdptr, NULL, "</WASDAV:lock>\n");
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "!AZ",
STR_DSC_PTR(wdptr));
}
/*****************************************************************************/
/*
From the meta-data.
*/
DavLockDiscovery (REQUEST_STRUCT *rqptr)
{
WEBDAV_LOCK *lckptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockDiscovery()");
/* step through each lock in the list generating an XML text equivalent */
LIST_ITERATE (lckptr, &rqptr->WebDavTaskPtr->MetaData.LockList)
{
FaoToNet (rqptr,
" <D:lockdiscovery>\n\
<D:activelock>\n\
<D:locktype><D:!AZ/></D:locktype>\n\
<D:lockscope><D:!AZ!AZ/></D:lockscope>\n\
<D:locktoken><D:href>!AZ</D:href></D:locktoken>\n\
<D:depth>!AZ!AZ!AZ</D:depth>\n\
!AZ!AZ!AZ\
!AZ!AZ!AZ\
</D:activelock>\n\
</D:lockdiscovery>\n",
lckptr->Type == WEBDAV_LOCK_TYPE_WRITE ? "write" : "",
lckptr->Scope == WEBDAV_LOCK_SCOPE_EXCLUSIVE ? "exclusive" : "",
lckptr->Scope == WEBDAV_LOCK_SCOPE_SHARED ? "shared" : "",
lckptr->TokenString,
lckptr->Depth == WEBDAV_DEPTH_ZERO ? "0" : "",
lckptr->Depth == WEBDAV_DEPTH_ONE ? "1" : "",
lckptr->Depth == WEBDAV_DEPTH_INFINITY ? "infinity" : "",
lckptr->Timeout ? " <D:timeout>" : "",
lckptr->Timeout ? lckptr->TimeoutString : "",
lckptr->Timeout ? "</D:timeout>\n" : "",
STR_DSC_LEN(&lckptr->OwnerDsc) ? " <D:owner>" : "",
/* the owner string has already been HTML-sanitised */
STR_DSC_LEN(&lckptr->OwnerDsc) ? STR_DSC_PTR(&lckptr->OwnerDsc) : "",
STR_DSC_LEN(&lckptr->OwnerDsc) ? "</D:owner>\n" : "");
}
}
/*****************************************************************************/
/*
Find a lock that matches the request header "Lock-token:". Return NULL if no
locks. Return NOTPTR if lock(s) exist but the header token did not match (any
one). Returns NOPTR if there is no Lock-Token: header. Returns the pointer to
any matching lock.
*/
WEBDAV_LOCK* DavLockFindToken (REQUEST_STRUCT *rqptr)
{
char *cptr, *sptr;
WEBDAV_META *mtaptr;
WEBDAV_LOCK *lckptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockFindToken() !AZ",
rqptr->rqHeader.WebDavLockTokenPtr ?
rqptr->rqHeader.WebDavLockTokenPtr : "NONE");
tkptr = rqptr->WebDavTaskPtr;
mtaptr = &tkptr->MetaData;
/* if no header token */
if (!rqptr->rqHeader.WebDavLockTokenPtr) return (NOTPTR);
/* if no locks */
if (!LIST_GET_HEAD(&mtaptr->LockList)) return (NULL);
LIST_ITERATE (lckptr, &mtaptr->LockList)
{
sptr = lckptr->TokenString;
cptr = rqptr->rqHeader.WebDavLockTokenPtr;
if (*cptr == '<') cptr++;
while (*cptr && *cptr != '>' && *sptr && *cptr == *sptr)
{
cptr++;
sptr++;
}
/* if a match return the lock pointer */
if (*cptr == '>' && !*sptr) break;
}
if (!lckptr) lckptr = NOTPTR;
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "TOKEN match !AZ",
lckptr && lckptr != NOTPTR ? lckptr->TokenString : "NONE");
return (lckptr);
}
/*****************************************************************************/
/*
Search through the lock list for any lock matching the supplied scope. If
found check the If: header data to determine whether the action is permitted.
Return a pointer to lock if permitted, a NOTPTR if not permitted, or a NULL if
no applicable lock.
*/
WEBDAV_LOCK* DavLockFindIf
(
REQUEST_STRUCT *rqptr,
int scope
)
{
char *cptr, *sptr;
WEBDAV_LOCK *lckptr, *notptr;
WEBDAV_META *mtaptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavLockFindIf() !UL", scope);
tkptr = rqptr->WebDavTaskPtr;
mtaptr = &tkptr->MetaData;
notptr = NULL;
LIST_ITERATE (lckptr, &mtaptr->LockList)
{
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "!AZ !UL !UL",
lckptr->TokenString, lckptr->Type, lckptr->Scope);
if (lckptr->Type == WEBDAV_LOCK_TYPE_WRITE && lckptr->Scope == scope)
{
if (DavLockIfToken (rqptr, lckptr)) break;
notptr = NOTPTR;
}
}
if (!lckptr) lckptr = notptr;
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "LOCK search !AZ match !AZ",
scope == WEBDAV_LOCK_SCOPE_EXCLUSIVE ? "EXCLUSIVE" :
"SHARED",
(!lckptr || lckptr == NOTPTR) ? "NONE" : lckptr->TokenString);
return (lckptr);
}
/*****************************************************************************/
/*
Asynchronously reads the meta-data (if any) and tests locking (if any) for
permission to modify resource. Return success VMS status for modify permission
or an error status to forbid. The meta-data read ASTs back this same function
which then dispatches another AST to the originally supplied routine (and of
course only the first argument is then valid). Performs this test for the
supplied file specification and any parent directory(ies) depending on
configuration. The configuration depth parameter is 0 (default) or 1 for files
only, 2 for the parent directory, 3 for the grandparent directory, etc. If the
resource is locked then 'TestLockedAt' is set to the collection level, where 1
is the resource itself, 2 is the parent, 3 the grandparent, etc., otherwise it
is zero.
*/
DavLockTest
(
REQUEST_STRUCT *rqptr,
char *FileName,
BOOL IsDirFile,
REQUEST_AST AstFunction,
unsigned long AstParam
)
{
char *cptr, *sptr, *zptr;
WEBDAV_LOCK *lckptr;
WEBDAV_META *mtaptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->WebDavTaskPtr;
mtaptr = &tkptr->MetaData;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockTest() !&Z !UL !&S",
tkptr->LockTestName, tkptr->TestLockDepth, mtaptr->VmsStatus);
if (tkptr->TestLockDepth)
{
/***************/
/* assess test */
/***************/
/* meta-data has been read, check it */
if (mtaptr->VmsStatus == RMS$_FNF ||
mtaptr->VmsStatus == RMS$_DNF)
tkptr->TestLockStatus = SS$_NORMAL;
else
if (VMSok (mtaptr->VmsStatus))
{
tkptr->TestLockStatus = SS$_NORMAL;
if (rqptr->rqHeader.WebDavIfPtr)
{
if (lckptr = DavLockFindIf (rqptr, WEBDAV_LOCK_SCOPE_EXCLUSIVE))
{
if (lckptr == NOTPTR)
{
tkptr->TestLockStatus = SS$_ACCONFLICT;
tkptr->TestLockedAt = tkptr->TestLockDepth;
}
}
}
else
if (rqptr->rqHeader.WebDavLockTokenPtr)
{
if (lckptr = DavLockFindToken (rqptr))
if (lckptr == NOTPTR)
tkptr->TestLockStatus = SS$_ACCONFLICT;
}
else
if (LIST_GET_HEAD(&mtaptr->LockList))
{
/* the metadata contains a lock and so a conflict */
tkptr->TestLockStatus = SS$_ACCONFLICT;
}
}
else
tkptr->TestLockStatus = mtaptr->VmsStatus;
if (VMSnok (tkptr->TestLockStatus) ||
tkptr->TestLockDepth > WebDavLockCollectionDepth)
{
/*********************/
/* testing concluded */
/*********************/
SysDclAst (tkptr->TestLockAstFunction, tkptr->TestLockAstParam);
tkptr->TestLockAstFunction = NULL;
tkptr->TestLockAstParam = tkptr->TestLockDepth = 0;
tkptr->LockTestName[0] = '\0';
return;
}
/******************************/
/* test parent directory(ies) */
/******************************/
/* create a parent directory out of the current file specification */
zptr = (sptr = tkptr->LockTestName) + sizeof(tkptr->LockTestName)-1;
while (*sptr) sptr++;
if (*(sptr-1) == ']')
while (sptr > tkptr->LockTestName &&
(*sptr != '.' || SAME2(sptr-1,'^.')) &&
(*sptr != '[' || SAME2(sptr-1,'^['))) sptr--;
else
while (sptr > tkptr->LockTestName &&
(*sptr != ']' || SAME2(sptr-1,'^]')) &&
(*sptr != '[' || SAME2(sptr-1,'^['))) sptr--;
if (*sptr == '[')
{
for (cptr = "[000000]"; *cptr && sptr < zptr; *sptr++ = *cptr++);
/* reached the MFD so this will be the final test */
tkptr->TestLockDepth = WebDavLockCollectionDepth;
}
else
*sptr++ = ']';
*sptr = '\0';
tkptr->TestLockDepth++;
DavMetaRead (rqptr, mtaptr, tkptr->LockTestName, &DavLockTest, rqptr);
return;
}
/****************/
/* initial call */
/****************/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "!&Z !&B",
FileName, IsDirFile);
zptr = (sptr = tkptr->LockTestName) + sizeof(tkptr->LockTestName)-1;
for (cptr = FileName; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
if (IsDirFile)
{
/* munge the ]NAME.DIR into a directory specification .NAME] */
while (sptr > tkptr->LockTestName &&
(*sptr != '.' || SAME2(sptr-1,'^.')) &&
(*sptr != ']' || SAME2(sptr-1,'^]'))) sptr--;
SET2(sptr,']\0');
if (sptr > tkptr->LockTestName) sptr--;
while (sptr > tkptr->LockTestName &&
(*sptr != ']' || SAME2(sptr-1,'^]'))) sptr--;
if (sptr > tkptr->LockTestName) *sptr = '.';
}
tkptr->TestLockAstFunction = AstFunction;
tkptr->TestLockAstParam = AstParam;
tkptr->TestLockedAt = 0;
tkptr->TestLockDepth++;
DavMetaRead (rqptr, mtaptr, tkptr->LockTestName, &DavLockTest, rqptr);
}
/*****************************************************************************/
/*
When looking for the lock's token in the request's if: header. If found and
not negated return true. If not found and negated returns true. Otherwise
returns false. The function does not fully implement RFC2518 section 9.4. As
WASD uses unqiue (UUID) lock tokens it should only have to check for the
presence of one of these, and not need to match on a tagged list or etag.
*/
BOOL DavLockIfToken
(
REQUEST_STRUCT *rqptr,
WEBDAV_LOCK *lckptr
)
{
BOOL hit, notif;
char *cptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavLockIfToken() !8XL !8XL",
rqptr->rqHeader.WebDavIfPtr, lckptr);
if (!lckptr) return (false);
if (!(cptr = rqptr->rqHeader.WebDavIfPtr))
{
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "IF: none");
return (false);
}
while (*cptr == ' ' || *cptr == '\t') cptr++;
if (*cptr == '(' && strsame (cptr, "(NOT ", 5))
notif = true;
else
notif = false;
while (*cptr)
{
if (*cptr == '<' &&
MATCH10 (cptr, "<urn:uuid:") &&
!memcmp (cptr+1, lckptr->TokenString, 45) &&
*(cptr+46) == '>') break;
cptr++;
}
hit = (*cptr && !notif) || (!*cptr && notif);
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "IF: !&B !AZ!AZ>",
hit, notif ? "(NOT <" : "<", lckptr->TokenString);
return (hit);
}
/*****************************************************************************/
/*
Generates a lock token UUID as described in RFC 2518, section 6.3.
This function (substantially and practically) meets this requirement by
combining a quadword time component, a function-internal counter, and the
file-system specification for the resource. The UUID is then just the MD5
hash transformed into the required "urn:uuid:..." format.
*/
DavLockSetUrnUuidToken
(
REQUEST_STRUCT *rqptr,
WEBDAV_LOCK *lckptr
)
{
static int64 TokenCounter;
static $DESCRIPTOR (TokenDsc, "");
static $DESCRIPTOR (TokenFaoDsc, "urn:uuid:!8XL-!4XL-!4XL-!4XL-!4XL!8XL\0");
ulong *qptr;
unsigned char Hash16 [16];
char *cptr, *sptr, *zptr;
char NameBuffer [1024];
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavLockSetUrnUuidToken()");
tkptr = rqptr->WebDavTaskPtr;
/* initialize to a quasi-indeterminate value */
if (!TokenCounter++) TokenCounter = rqptr->rqTime.BeginTime64;
zptr = (sptr = NameBuffer) + sizeof(NameBuffer)-1;
qptr = &rqptr->rqTime.BeginTime64;
*(ULONGPTR)sptr = qptr[0];
sptr += 4;
*(ULONGPTR)sptr = qptr[1];
sptr += 4;
*(INT64PTR)sptr = TokenCounter;
sptr += 8;
for (cptr = rqptr->ParseOds.ExpFileName;
*cptr && sptr < zptr;
*sptr++ = *cptr++);
Md5Digest (NameBuffer, sptr-NameBuffer, &Hash16);
TokenDsc.dsc$a_pointer = lckptr->TokenString;
TokenDsc.dsc$w_length = sizeof(lckptr->TokenString);
sys$fao (&TokenFaoDsc, 0, &TokenDsc, *(ULONGPTR)Hash16,
*(USHORTPTR)(Hash16+4),
*(USHORTPTR)(Hash16+6),
*(USHORTPTR)(Hash16+8),
*(USHORTPTR)(Hash16+10),
*(ULONGPTR)(Hash16+12));
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "TOKEN !AZ",
TokenDsc.dsc$a_pointer);
}
/*****************************************************************************/