[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]
/*****************************************************************************/
/*
DAVmove.c
Also see comments on MOVE in DAVWEB.C.
Implement the MOVE method for single resources (files) and collections
(directory trees). Moves behave the same for for single resources (files) and
collections (directories). Both are renamed (if possible), with the directory
file itself being renamed in the case of a collection. Should the rename fail
due to the target being on another volume the move is done via a copy and
delete using the respective DAV code modules.
VERSION HISTORY
---------------
17-OCT-2018 MGD bugfix; ensure meta directory exists
07-JUL-2018 MGD bugfix; DavMoveMeta() OdsParseRelease() as final action
05-JUL-2018 MGD bugfix; flawed use of lib$rename_file() using DEFAULT_ZONE
memory without free (context not exhausted) - use
DavMoveRename() instead (which should be more efficient)
bugfix; remove context from lib$rename_file()
28-APR-2015 MGD bugfix; DavMoveMeta() do not report RMS$_DNF
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 <ctype.h>
#include <errno.h>
#include <stdio.h>
#include "wasd.h"
#include "davweb.h"
#define WASD_MODULE "DAVMOVE"
#define TEST_DEADLOCK_DETECT 0
#define TEST_BETWEEN_DEVICES 0
/* use RMS $RENAME by default but allow older LIB$RENAME_FILE as option */
#define DAV_MOVE_USING_ODS 1
/******************/
/* global storage */
/******************/
/********************/
/* external storage */
/********************/
extern int ToLowerCase[],
ToUpperCase[];
extern unsigned long SysPrvMask[];
extern char ErrorSanityCheck[];
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
*/
DavMoveBegin (REQUEST_STRUCT *rqptr)
{
int status;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavMoveBegin()");
tkptr = rqptr->WebDavTaskPtr;
tkptr->TestLockState = 0;
status = DavWebDestination (rqptr);
if (VMSnok (status))
{
DavWebResponse (rqptr, 0, status, NULL, FI_LI);
DavWebEnd (rqptr);
return;
}
if (WATCHING (rqptr, WATCH_RESPONSE))
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE,
"MOVE !AZ to !AZ overwrite:!&B depth:!UL path:!AZ",
rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName,
tkptr->CopyData.MoveOverwrite, tkptr->ToDepth,
DavWebPathAccess(rqptr));
if (!strcmp (rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName))
{
/* case-sensitive because the client might just be changing case! */
DavWebResponse (rqptr, 403, 0, "identical", FI_LI);
DavWebEnd (rqptr);
return;
}
if (rqptr->ParseOds.NamNameLength ||
rqptr->ParseOds.NamTypeLength)
{
/********/
/* file */
/********/
if (tkptr->DestOds.NamNameLength ||
tkptr->DestOds.NamTypeLength)
{
/* to a file */
DavMoveFile (rqptr);
return;
}
DavWebResponse (rqptr, 400, 0, "file to directory", FI_LI);
}
else
{
/*************/
/* directory */
/*************/
if (!tkptr->DestOds.NamNameLength &&
!tkptr->DestOds.NamTypeLength)
{
/* to a directory */
DavMoveDirectory (rqptr);
return;
}
DavWebResponse (rqptr, 400, 0, "directory to file", FI_LI);
}
DavWebEnd (rqptr);
}
/*****************************************************************************/
/*
*/
DavMoveEnd (REQUEST_STRUCT *rqptr)
{
int status;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavMoveEnd()");
tkptr = rqptr->WebDavTaskPtr;
if (tkptr->MoveUsingCopy)
{
/* delete directories left over from move using copy */
tkptr->MoveUsingCopy = false;
status = DavDeleteParse (rqptr, true, "...]*.DIR;*");
if (VMSnok (status))
{
DavWebResponse (rqptr, 0, status, NULL, FI_LI);
DavWebEnd (rqptr);
return;
}
tkptr->DeleteData.DelPhase = WEBDAV_DELETE_TREE_FILES;
DavDeleteSearch (rqptr);
return;
}
if (!rqptr->rqResponse.HttpStatus)
{
/* in the absence of any other (207 perhaps) status */
if (tkptr->OverwriteOccurred)
DavWebResponse (rqptr, 204, 0, "success, overwrite", FI_LI);
else
{
DavWebHref (rqptr, tkptr->DestOds.ExpFileName, 0);
DavWebResponse201 (rqptr);
}
}
DavWebEnd (rqptr);
}
/*****************************************************************************/
/*
Move a single (non-.DIR) file. This function will be called multiple times as
asynchronous testing of the DLM and meta locking occurs.
*/
DavMoveFile (REQUEST_STRUCT *rqptr)
{
static $DESCRIPTOR (DstNameDsc, "");
static $DESCRIPTOR (SrcNameDsc, "");
BOOL CanDoIt;
int status;
unsigned long RenameFlags;
ODS_STRUCT DeleteOds;
WEBDAV_DLM *dlmptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavMoveFile() !UL", tkptr->TestLockState);
/***********/
/* locking */
/***********/
switch (tkptr->TestLockState)
{
case 0 :
/* establish a request (overall) VMS DLM lock on source */
tkptr->TestLockState++;
DavWebDlmEnqueue (rqptr, &tkptr->DlmSource,
rqptr->ParseOds.ExpFileName, NULL,
true, false, DavMoveFile, rqptr);
return;
case 1 :
if (VMSnok (status = tkptr->DlmSource.LockSb.lksb$w_status))
{
/* ordinarily shouldn't return any errors */
DavWebResponse (rqptr, 500, status, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
/* establish a request (overall) VMS DLM lock on destination */
tkptr->TestLockState++;
/* we can rename the case of the same underlying name! */
if (strsame (rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName, -1))
{
/* do NOT take up a DLM lock on the same target - deadlock!! */
tkptr->DlmDestin.LockSb.lksb$w_status = SS$_NORMAL;
DavMoveFile (rqptr);
}
else
{
DavWebDlmEnqueue (rqptr, &tkptr->DlmDestin,
#if TEST_DEADLOCK_DETECT
rqptr->ParseOds.ExpFileName, NULL,
#else
tkptr->DestOds.ExpFileName, NULL,
#endif
true, false, DavMoveFile, rqptr);
}
return;
case 2 :
if (VMSnok (status = tkptr->DlmDestin.LockSb.lksb$w_status))
{
/* ordinarily shouldn't return any errors */
DavWebResponse (rqptr, 500, status, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
/* check for meta-lock on existing source */
tkptr->TestLockState++;
DavLockTest (rqptr, rqptr->ParseOds.ExpFileName, false,
DavMoveFile, rqptr);
return;
case 3 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "source locked", FI_LI);
DavMoveEnd (rqptr);
return;
}
/* check for meta-lock on existing destination */
tkptr->TestLockState++;
DavLockTest (rqptr, tkptr->DestOds.ExpFileName, false,
DavMoveFile, rqptr);
return;
case 4 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "destination locked", FI_LI);
DavMoveEnd (rqptr);
return;
}
}
/*****************/
/* ready to move */
/*****************/
if (DavMetaFile (&tkptr->DestOds) ||
DavMetaDir (rqptr, &tkptr->DestOds))
{
/* this is a metadata file or contains a metadata (sub)directory */
DavWebResponse (rqptr, 404, 0, "directory not found", FI_LI);
DavMoveEnd (rqptr);
return;
}
if (!tkptr->CopyData.MoveOverwrite)
{
sys$setprv (1, &SysPrvMask, 0, 0);
status = OdsFileExists (tkptr->DestOds.ExpFileName, NULL);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSok(status))
{
/* if really different and not just a case change (for instance) */
if (!strsame (rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName, -1))
{
DavWebResponse (rqptr, 412, 0,
"target file exists, no overwrite", FI_LI);
DavMoveEnd (rqptr);
return;
}
}
}
if (!rqptr->ParseOds.ExpFileNameLength ||
!tkptr->DestOds.ExpFileNameLength)
{
ErrorNoticed (rqptr, SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
DavWebResponse (rqptr, 0, SS$_BUGCHECK, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
#if TEST_BETWEEN_DEVICES
status = RMS$_DEV;
#else
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "!AZ to !AZ",
rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName);
SrcNameDsc.dsc$a_pointer = rqptr->ParseOds.ExpFileName;
SrcNameDsc.dsc$w_length = rqptr->ParseOds.ExpFileNameLength;
DstNameDsc.dsc$a_pointer = tkptr->DestOds.ExpFileName;
DstNameDsc.dsc$w_length = tkptr->DestOds.ExpFileNameLength;
CanDoIt = AuthAccessEnable (rqptr, tkptr->DestOds.ExpFileName,
AUTH_ACCESS_WRITE);
#if DAV_MOVE_USING_ODS
status = DavMoveRename (rqptr, &SrcNameDsc, &DstNameDsc);
#else /* DAV_MOVE_USING_ODS */
RenameFlags = 0x1;
#ifdef ODS_EXTENDED
if (rqptr->PathOdsExtended) RenameFlags += 0x4;
#endif /* ODS_EXTENDED */
status = lib$rename_file (&SrcNameDsc, &DstNameDsc,
0, 0, &RenameFlags, 0, 0, 0, 0, 0, 0, 0);
#endif /* DAV_MOVE_USING_ODS */
#endif /* TEST_BETWEEN_DEVICES */
AuthAccessEnable (rqptr, 0, 0);
if (WATCHING (rqptr, WATCH_WEBDAV))
{
if (VMSok(status))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "RENAMED !AZ to !AZ",
rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName);
else
if (status != RMS$_DEV)
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "RENAME !&S !AZ to !AZ",
status, rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName);
}
if (VMSnok(status))
{
if (status == RMS$_DEV)
{
/*********************/
/* to another device */
/*********************/
if (!CanDoIt)
{
DavWebResponse (rqptr, 403, 0,
"uncertain permission to delete source file", FI_LI);
DavMoveEnd (rqptr);
return;
}
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV,
"MOVE to another device - using COPY with DELETE");
tkptr->MoveUsingCopy = true;
DavCopyFile (rqptr);
return;
}
if (status == RMS$_RMV)
DavWebResponse (rqptr, 403, status, "protection", FI_LI);
else
if (status == RMS$_DNF)
DavWebResponse (rqptr, 409, status, "parent", FI_LI);
else
DavWebResponse (rqptr, 0, status, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
/* if not just a change of case */
if (!strsame (rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName, -1))
{
/**********************************/
/* delete any previous version(s) */
/**********************************/
OdsStructInit (&DeleteOds, true);
OdsParse (&DeleteOds,
rqptr->ParseOds.ExpFileName,
rqptr->ParseOds.ExpFileNameLength,
NULL, 0, NAM$M_SYNCHK, NULL, rqptr);
if (VMSnok (status = DeleteOds.Fab.fab$l_sts))
ErrorNoticed (rqptr, status, NULL, FI_LI);
else
{
AuthAccessEnable (rqptr, 0, AUTH_ACCESS_SYSPRV);
while (VMSok (status = sys$erase (&DeleteOds.Fab, 0, 0)));
AuthAccessEnable (rqptr, 0, 0);
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"sys$erase() !&S !AZ", status, DeleteOds.ExpFileName);
if (VMSnok (status) && DeleteOds.Fab.fab$l_stv)
status = DeleteOds.Fab.fab$l_stv;
if (VMSok (status)) tkptr->OverwriteOccurred = true;
if (status == SS$_NOSUCHFILE) status = SS$_NORMAL;
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
OdsParseRelease (&DeleteOds);
/*****************/
/* move any meta */
/*****************/
DavMoveMeta (rqptr, rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName);
}
DavMoveEnd (rqptr);
}
/*****************************************************************************/
/*
Move a directory (tree). This function will be called multiple times as
asynchronous testing of the DLM and meta locking occurs.
*/
DavMoveDirectory (REQUEST_STRUCT *rqptr)
{
static $DESCRIPTOR (DstNameDsc, "");
static $DESCRIPTOR (SrcNameDsc, "");
BOOL CanDoIt;
int status,
DstNameLength,
SrcNameLength;
unsigned long RenameFlags;
char *cptr, *sptr, *zptr;
char DstName [ODS_MAX_FILE_NAME_LENGTH+1],
SrcName [ODS_MAX_FILE_NAME_LENGTH+1];
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavMoveDirectory() !UL", tkptr->TestLockState);
if (VMSnok (DavWebParentExists (NULL, tkptr->DestOds.ExpFileName)))
{
DavWebResponse (rqptr, 412, 0, "parent does not exist", FI_LI);
DavMoveEnd (rqptr);
return;
}
/***********/
/* locking */
/***********/
switch (tkptr->TestLockState)
{
case 0 :
/* establish a request (overall) VMS DLM lock on source */
tkptr->TestLockState++;
DavWebDlmEnqueue (rqptr, &tkptr->DlmSource,
rqptr->ParseOds.ExpFileName, NULL,
true, false, DavMoveDirectory, rqptr);
return;
case 1 :
if (VMSnok (status = tkptr->DlmSource.LockSb.lksb$w_status))
{
/* ordinarily shouldn't return any errors */
DavWebResponse (rqptr, 500, status, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
/* establish a request (overall) VMS DLM lock on destination */
tkptr->TestLockState++;
/* we can rename the case of the same underlying name! */
if (strsame (rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName, -1))
{
/* do NOT take up a DLM lock on the same target - deadlock!! */
tkptr->DlmDestin.LockSb.lksb$w_status = SS$_NORMAL;
DavMoveDirectory (rqptr);
}
else
{
DavWebDlmEnqueue (rqptr, &tkptr->DlmDestin,
#if TEST_DEADLOCK_DETECT
rqptr->ParseOds.ExpFileName, NULL,
#else
tkptr->DestOds.ExpFileName, NULL,
#endif
true, false, DavMoveDirectory, rqptr);
}
return;
case 2 :
if (VMSnok (status = tkptr->DlmDestin.LockSb.lksb$w_status))
{
/* ordinarily shouldn't return any errors */
DavWebResponse (rqptr, 500, status, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
/* check for meta-lock on existing source */
tkptr->TestLockState++;
DavLockTest (rqptr, rqptr->ParseOds.ExpFileName, false,
DavMoveDirectory, rqptr);
return;
case 3 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "source locked", FI_LI);
DavMoveEnd (rqptr);
return;
}
/* check for meta-lock on existing destination */
tkptr->TestLockState++;
DavLockTest (rqptr, tkptr->DestOds.ExpFileName, false,
DavMoveDirectory, rqptr);
return;
case 4 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "destination locked", FI_LI);
DavMoveEnd (rqptr);
return;
}
}
/*****************/
/* ready to move */
/*****************/
if (DavMetaFile (&tkptr->DestOds) ||
DavMetaDir (rqptr, &tkptr->DestOds))
{
/* this is a metadata file or contains a metadata (sub)directory */
DavWebResponse (rqptr, 404, 0, "directory not found", FI_LI);
DavMoveEnd (rqptr);
return;
}
/* all collection moves must act as if the depth is infinity */
tkptr->ToDepth = WEBDAV_DEPTH_INFINITY;
OdsNameOfDirectoryFile (tkptr->DestOds.ExpFileName,
tkptr->DestOds.ExpFileNameLength,
DstName, &DstNameLength);
sys$setprv (1, &SysPrvMask, 0, 0);
status = OdsFileExists (DstName, NULL);
sys$setprv (0, &SysPrvMask, 0, 0);
if (tkptr->CopyData.MoveOverwrite)
{
/* collection COPY does not (yet) support overwrite */
if (status != RMS$_FNF && status != RMS$_DNF)
{
/* not completely accurate but will do in the interim */
DavWebResponse (rqptr, 409, 0,
"directory MOVE does not support overwrite", FI_LI);
DavMoveEnd (rqptr);
return;
}
}
else
{
if (VMSok(status))
{
/* if really different and not just a case change (for instance) */
if (!strsame (rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName, -1))
{
DavWebResponse (rqptr, 412, 0,
"target directory exists, overwrite not requested", FI_LI);
DavMoveEnd (rqptr);
return;
}
}
}
OdsNameOfDirectoryFile (rqptr->ParseOds.ExpFileName,
rqptr->ParseOds.ExpFileNameLength,
SrcName, &SrcNameLength);
if (!rqptr->ParseOds.ExpFileNameLength ||
!tkptr->DestOds.ExpFileNameLength)
{
ErrorNoticed (rqptr, SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
DavWebResponse (rqptr, 0, SS$_BUGCHECK, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"!AZ to !AZ", SrcName, DstName);
SrcNameDsc.dsc$a_pointer = SrcName;
SrcNameDsc.dsc$w_length = SrcNameLength;
DstNameDsc.dsc$a_pointer = DstName;
DstNameDsc.dsc$w_length = DstNameLength;
CanDoIt = AuthAccessEnable (rqptr, tkptr->DestOds.ExpFileName,
AUTH_ACCESS_WRITE);
#if TEST_BETWEEN_DEVICES
status = RMS$_DEV;
#else
#if DAV_MOVE_USING_ODS
status = DavMoveRename (rqptr, &SrcNameDsc, &DstNameDsc);
#else /* DAV_MOVE_USING_ODS */
RenameFlags = 0x1;
#ifdef ODS_EXTENDED
if (rqptr->PathOdsExtended) RenameFlags += 0x4;
#endif /* ODS_EXTENDED */
status = lib$rename_file (&SrcNameDsc, &DstNameDsc,
0, 0, &RenameFlags, 0, 0, 0, 0,
0, 0, 0);
#endif /* DAV_MOVE_USING_ODS */
#endif /* TEST_BETWEEN_DEVICES */
AuthAccessEnable (rqptr, 0, 0);
if (WATCHING (rqptr, WATCH_WEBDAV))
{
if (VMSok(status))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "RENAMED !AZ to !AZ",
SrcName, DstName);
else
if (status != RMS$_DEV)
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "RENAME !&S !AZ to !AZ",
status, SrcName, DstName);
}
if (VMSnok (status))
{
if (status == RMS$_DEV)
{
/*********************/
/* to another device */
/*********************/
if (!CanDoIt)
{
DavWebResponse (rqptr, 403, 0,
"uncertain permission to delete source directory", FI_LI);
DavMoveEnd (rqptr);
return;
}
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV,
"MOVE to another device - using COPY with DELETE");
tkptr->MoveUsingCopy = true;
DavCopyDirectory (rqptr);
return;
}
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV,
"MOVE rename !AZ to !AZ !&S",
SrcNameDsc.dsc$a_pointer,
DstNameDsc.dsc$a_pointer,
status);
if (status == RMS$_RMV)
DavWebResponse (rqptr, 403, status, "protection", FI_LI);
else
if (status == RMS$_IDR)
DavWebResponse (rqptr, 403, status, "dependency", FI_LI);
else
if (status == RMS$_DNF)
DavWebResponse (rqptr, 409, status, "parent", FI_LI);
else
DavWebResponse (rqptr, 0, status, NULL, FI_LI);
DavMoveEnd (rqptr);
return;
}
/* if not just a change of case */
if (!strsame (rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName, -1))
{
/*****************/
/* move any meta */
/*****************/
DavMoveMeta (rqptr, rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName);
}
DavMoveEnd (rqptr);
}
/*****************************************************************************/
/*
Move any meta file associated with the source to the destination. If there
were multiple versions of the that meta file (because of gerfingerpokin) then
delete remaining version. Assumes everything's locked by the calling routine.
*/
int DavMoveMeta
(
REQUEST_STRUCT *rqptr,
char *SrcFileName,
char *DstFileName
)
{
static $DESCRIPTOR (DstNameDsc, "");
static $DESCRIPTOR (SrcNameDsc, "");
int status;
unsigned long RenameFlags;
char *cptr, *sptr, *zptr;
ODS_STRUCT DeleteOds;
WEBDAV_META *mtaptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavMoveMeta() !AZ !AZ",
SrcFileName, DstFileName);
mtaptr = &tkptr->MetaData;
mtaptr->TaskPtr = rqptr->WebDavTaskPtr;
DavMetaName (mtaptr, SrcFileName, 'r');
DavMetaName (mtaptr, DstFileName, 'w');
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"!AZ to !AZ", SrcFileName, DstFileName);
SrcNameDsc.dsc$a_pointer = mtaptr->ReadMetaName;
SrcNameDsc.dsc$w_length = mtaptr->ReadMetaNameLength;
DstNameDsc.dsc$a_pointer = mtaptr->WriteMetaName;
DstNameDsc.dsc$w_length = mtaptr->WriteMetaNameLength;
DavMetaCreateDir (mtaptr);
sys$setprv (1, &SysPrvMask, 0, 0);
#if DAV_MOVE_USING_ODS
status = DavMoveRename (rqptr, &SrcNameDsc, &DstNameDsc);
#else /* DAV_MOVE_USING_ODS */
RenameFlags = 0x1;
#ifdef ODS_EXTENDED
if (rqptr->PathOdsExtended) RenameFlags += 0x4;
#endif /* ODS_EXTENDED */
status = lib$rename_file (&SrcNameDsc, &DstNameDsc,
0, 0, &RenameFlags, 0, 0, 0, 0, 0, 0, 0);
#endif /* DAV_MOVE_USING_ODS */
sys$setprv (0, &SysPrvMask, 0, 0);
if (WATCHING (rqptr, WATCH_WEBDAV))
{
if (VMSok(status))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "RENAMED !AZ to !AZ",
mtaptr->ReadMetaName, mtaptr->WriteMetaName);
else
if (status != RMS$_FNF && status != RMS$_DNF)
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "RENAME !&S !AZ to !AZ",
status, mtaptr->ReadMetaName, mtaptr->WriteMetaName);
}
if (VMSnok (status) && status != RMS$_DNF && status != RMS$_FNF)
{
ErrorNoticed (rqptr, status, NULL, FI_LI);
return (status);
}
/* purge all (remaining) previous meta version(s) */
OdsStructInit (&DeleteOds, true);
OdsParse (&DeleteOds,
mtaptr->ReadMetaName,
mtaptr->ReadMetaNameLength,
NULL, 0, NAM$M_SYNCHK, NULL, rqptr);
if (VMSnok (status = DeleteOds.Fab.fab$l_sts))
{
ErrorNoticed (rqptr, status, NULL, FI_LI);
return (status);
}
sys$setprv (1, &SysPrvMask, 0, 0);
while (VMSok (status = sys$erase (&DeleteOds.Fab, 0, 0)));
sys$setprv (0, &SysPrvMask, 0, 0);
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"sys$erase() !&S !AZ", status, DeleteOds.ExpFileName);
if (VMSnok (status) && DeleteOds.Fab.fab$l_stv)
status = DeleteOds.Fab.fab$l_stv;
if (status == SS$_NOSUCHFILE) status = SS$_NORMAL;
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
OdsParseRelease (&DeleteOds);
return (status);
}
/*****************************************************************************/
/*
Rename a single version of a single file.
*/
#if DAV_MOVE_USING_ODS
int DavMoveRename
(
REQUEST_STRUCT *rqptr,
struct dsc$descriptor *SrcDscPtr,
struct dsc$descriptor *DstDscPtr
)
{
int status;
ODS_STRUCT DstOds,
SrcOds;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavMoveRename() !AZ !AZ",
SrcDscPtr->dsc$a_pointer, DstDscPtr->dsc$a_pointer);
OdsStructInit (&SrcOds, true);
status = OdsParse (&SrcOds, SrcDscPtr->dsc$a_pointer,
SrcDscPtr->dsc$w_length,
NULL, 0, NAM$M_NOCONCEAL, NULL, rqptr);
if (VMSok (status))
{
OdsStructInit (&DstOds, true);
status = OdsParse (&DstOds, DstDscPtr->dsc$a_pointer,
DstDscPtr->dsc$w_length,
NULL, 0, NAM$M_NOCONCEAL, NULL, rqptr);
}
if (VMSok (status))
{
status = sys$rename (&SrcOds.Fab, 0, 0, &DstOds.Fab);
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "$rename() !&S", status);
}
return (status);
}
#endif /* !DAV_MOVE_USING_ODS */
/*****************************************************************************/