[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]
/*****************************************************************************/
/*
DAVcopy.c
Also see comments on MOVE in DAVWEB.C.
Implement the COPY method for single resources (files) and collections
(directory trees).
This module is also used by a MOVE of resources between different volumes.
For files a DLM is taken out on the source file specification and any
associated meta-data tested for. If not locked the file is copied.
For directories (collections) a DLM lock is taken out on the source directory
and target directory specifications, and then any associated META locking
tested. Locking permitting the source tree is then walked with corresponding
target directories being created and files copied from tree-to-tree. Source
files are deleted when closed (so the source tree shrinks as the target tree
grows). When concluded source directory files (.DIRs) remain in the source
tree and are explicitly removed using DELETE functionality.
VERSION HISTORY
---------------
17-OCT-2018 MGD bugfix; ensure meta directory exists
16-OCT-2018 MGD bugfix; DavCopyNext() copy meta for single file
13-APR-2018 MGD SS$_ABORT on ->RequestRundown
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 "DAVCOPY"
#define TEST_DEADLOCK_DETECT 0
/******************/
/* global storage */
/******************/
/********************/
/* external storage */
/********************/
extern char ErrorSanityCheck[];
extern unsigned long SysPrvMask[];
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
*/
DavCopyBegin (REQUEST_STRUCT *rqptr)
{
int status;
WEBDAV_COPY *cpyptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyBegin()");
tkptr = rqptr->WebDavTaskPtr;
cpyptr = &tkptr->CopyData;
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,
"COPY !AZ to !AZ overwrite:!&B depth:!UL path:!AZ",
rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName,
tkptr->CopyData.MoveOverwrite, tkptr->ToDepth,
DavWebPathAccess(rqptr));
if (strsame (rqptr->ParseOds.ExpFileName, tkptr->DestOds.ExpFileName, -1))
{
/* caseless compare because can't copy to the same underlying name! */
DavWebResponse (rqptr, 403, 0, "same underlying file name", FI_LI);
DavWebEnd (rqptr);
return;
}
if (rqptr->ParseOds.NamNameLength ||
rqptr->ParseOds.NamTypeLength)
{
/* copying a file */
if (tkptr->DestOds.NamNameLength ||
tkptr->DestOds.NamTypeLength)
{
/* to a file */
DavCopyFile (rqptr);
return;
}
DavWebResponse (rqptr, 400, 0, "file to directory", FI_LI);
}
else
{
/* copying a directory */
if (!tkptr->DestOds.NamNameLength &&
!tkptr->DestOds.NamTypeLength)
{
/* to a directory */
DavCopyDirectory (rqptr);
return;
}
DavWebResponse (rqptr, 400, 0, "directory to file", FI_LI);
}
/* file to a directory or directory to a file specification! */
DavWebEnd (rqptr);
}
/*****************************************************************************/
/*
*/
DavCopyEnd (WEBDAV_COPY *cpyptr)
{
int status;
REQUEST_STRUCT *rqptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
rqptr = cpyptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyEnd()");
tkptr = rqptr->WebDavTaskPtr;
if (cpyptr->CopyingDir)
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV,
"COPIED dirs:!UL fail:!UL files:!UL fail:!UL meta:!UL fail:!UL",
cpyptr->DirCount, cpyptr->DirFailCount,
cpyptr->FileCount, cpyptr->FileFailCount,
cpyptr->MetaCount, cpyptr->MetaFailCount);
if (rqptr->rqResponse.HttpStatus == 207)
FaoToNet (rqptr, "</D:multistatus>\n");
if (rqptr->rqHeader.Method == HTTP_METHOD_WEBDAV_MOVE)
{
/* move using copy */
DavMoveEnd (rqptr);
return;
}
if (!rqptr->rqResponse.HttpStatus)
{
/* in the absence of any other status */
if (tkptr->OverwriteOccurred)
DavWebResponse (rqptr, 204, 0, "success, overwrite", FI_LI);
else
{
DavWebHref (rqptr, tkptr->DestOds.ExpFileName, 0);
DavWebResponse201 (rqptr);
}
}
DavWebEnd (rqptr);
}
/*****************************************************************************/
/*
Copy a single file (depth:0).
*/
DavCopyFile (REQUEST_STRUCT *rqptr)
{
int status;
WEBDAV_COPY *cpyptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyFile()");
tkptr = rqptr->WebDavTaskPtr;
cpyptr = &tkptr->CopyData;
cpyptr->RequestPtr = rqptr;
if (!cpyptr->MoveOverwrite)
{
sys$setprv (1, &SysPrvMask, 0, 0);
status = OdsFileExists (tkptr->DestOds.ExpFileName, NULL);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSok(status))
{
DavWebResponse (rqptr, 412, 0,
"target file exists, no overwrite", FI_LI);
DavCopyEnd (cpyptr);
return;
}
}
DavCopyFile2 (cpyptr);
}
/*****************************************************************************/
/*
Test if the source or destination are locked and continue copy if not. This
function will be called multiple times as asynchronous testing of the DLM and
meta locking occurs.
*/
DavCopyFile2 (WEBDAV_COPY *cpyptr)
{
int status;
REQUEST_STRUCT *rqptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
rqptr = cpyptr->RequestPtr;
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavCopyFile2() !UL", tkptr->TestLockState);
/***********/
/* locking */
/***********/
/* if it's a move then locking has already been processed */
if (rqptr->rqHeader.Method == HTTP_METHOD_WEBDAV_MOVE)
tkptr->TestLockState = 999;
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, DavCopyFile2, cpyptr);
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);
DavCopyEnd (cpyptr);
return;
}
/* establish a request (overall) VMS DLM lock on destination */
tkptr->TestLockState++;
DavWebDlmEnqueue (rqptr, &tkptr->DlmDestin,
#if TEST_DEADLOCK_DETECT
rqptr->ParseOds.ExpFileName, NULL,
#else
tkptr->DestOds.ExpFileName, NULL,
#endif
true, false, DavCopyFile2, cpyptr);
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);
DavCopyEnd (cpyptr);
return;
}
/* check for meta-lock on existing source */
tkptr->TestLockState++;
DavLockTest (rqptr, rqptr->ParseOds.ExpFileName, false,
DavCopyFile2, cpyptr);
return;
case 3 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "source locked", FI_LI);
DavCopyEnd (cpyptr);
return;
}
/* check for meta-lock on existing destination */
tkptr->TestLockState++;
DavLockTest (rqptr, tkptr->DestOds.ExpFileName, false,
DavCopyFile2, cpyptr);
return;
case 4 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "destination locked", FI_LI);
DavCopyEnd (cpyptr);
return;
}
}
/**************/
/* not locked */
/**************/
StrDscText (rqptr, &cpyptr->ReadNameDsc,
rqptr->ParseOds.ExpFileName,
rqptr->ParseOds.ExpFileNameLength);
StrDscText (rqptr, &cpyptr->WriteNameDsc,
tkptr->DestOds.ExpFileName,
tkptr->DestOds.ExpFileNameLength);
cpyptr->ReadOdsPtr = (ODS_STRUCT*)VmGetHeap (rqptr, sizeof(ODS_STRUCT));
OdsStructInit (cpyptr->ReadOdsPtr, false);
cpyptr->WriteOdsPtr = (ODS_STRUCT*)VmGetHeap (rqptr, sizeof(ODS_STRUCT));
OdsStructInit (cpyptr->WriteOdsPtr, false);
DavCopyReadOpen (cpyptr);
}
/*****************************************************************************/
/*
Copy a directory tree (depth:infinity).
*/
DavCopyDirectory (REQUEST_STRUCT *rqptr)
{
int status;
WEBDAV_COPY *cpyptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyDirectory()");
tkptr = rqptr->WebDavTaskPtr;
cpyptr = &tkptr->CopyData;
cpyptr->RequestPtr = rqptr;
if (tkptr->ToDepth != WEBDAV_DEPTH_ZERO &&
tkptr->ToDepth != WEBDAV_DEPTH_INFINITY)
{
DavWebResponse (rqptr, 400, 0, "inappropriate depth", FI_LI);
DavCopyEnd (cpyptr);
return;
}
if (cpyptr->MoveOverwrite)
{
sys$setprv (1, &SysPrvMask, 0, 0);
status = OdsFileExists (tkptr->DestOds.ExpFileName, "*.*");
sys$setprv (0, &SysPrvMask, 0, 0);
if (status != RMS$_FNF && status != RMS$_DNF)
{
/* not completely accurate but will do in the interim */
DavWebResponse (rqptr, 409, 0,
"directory COPY does not support overwrite", FI_LI);
DavCopyEnd (cpyptr);
return;
}
}
else
{
sys$setprv (1, &SysPrvMask, 0, 0);
status = OdsFileExists (tkptr->DestOds.ExpFileName, NULL);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSok(status))
{
DavWebResponse (rqptr, 412, 0,
"target directory exists, overwrite not requested", FI_LI);
DavCopyEnd (cpyptr);
return;
}
}
if (VMSnok (DavWebParentExists (NULL, tkptr->DestOds.ExpFileName)))
{
DavWebResponse (rqptr, 412, 0, "parent does not exist", FI_LI);
DavCopyEnd (rqptr);
return;
}
DavCopyDirectory2 (rqptr);
}
/*****************************************************************************/
/*
Test if the source or destination are locked and continue copy if not. This
function will be called multiple times as asynchronous testing of the DLM and
meta locking occurs.
*/
DavCopyDirectory2 (REQUEST_STRUCT *rqptr)
{
int status,
ParentNameLength;
char *cptr, *sptr, *zptr;
char ParentName [ODS_MAX_FILE_NAME_LENGTH+1];
WEBDAV_COPY *cpyptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavCopyDirectory2() !UL", tkptr->TestLockState);
cpyptr = &tkptr->CopyData;
/***********/
/* locking */
/***********/
/* if it's a move then locking has already been processed */
if (rqptr->rqHeader.Method == HTTP_METHOD_WEBDAV_MOVE)
tkptr->TestLockState = 999;
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, DavCopyDirectory2, 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);
DavCopyEnd (cpyptr);
return;
}
/* establish a request (overall) VMS DLM lock on destination */
tkptr->TestLockState++;
DavWebDlmEnqueue (rqptr, &tkptr->DlmDestin,
#if TEST_DEADLOCK_DETECT
rqptr->ParseOds.ExpFileName, NULL,
#else
tkptr->DestOds.ExpFileName, NULL,
#endif
true, false, DavCopyDirectory2, 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);
DavCopyEnd (cpyptr);
return;
}
/* check for meta-lock on existing source */
tkptr->TestLockState++;
DavLockTest (rqptr, rqptr->ParseOds.ExpFileName, false,
DavCopyDirectory2, rqptr);
return;
case 3 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "source locked", FI_LI);
DavCopyEnd (cpyptr);
return;
}
/* check for meta-lock on existing destination */
tkptr->TestLockState++;
DavLockTest (rqptr, tkptr->DestOds.ExpFileName, false,
DavCopyDirectory2, rqptr);
return;
case 4 :
if (VMSnok (tkptr->TestLockStatus))
{
DavWebResponse (rqptr, 423, 0, "destination locked", FI_LI);
DavCopyEnd (cpyptr);
return;
}
/* now ready to copy */
}
/**************/
/* not locked */
/**************/
OdsNameOfDirectoryFile (tkptr->DestOds.ExpFileName,
tkptr->DestOds.ExpFileNameLength,
ParentName, &ParentNameLength);
sys$setprv (1, &SysPrvMask, 0, 0);
status = OdsFileExists (ParentName, NULL);
sys$setprv (0, &SysPrvMask, 0, 0);
if (status == RMS$_DNF)
{
/* parent or other ascendent directory does not exist */
DavWebResponse (rqptr, 409, status, "parent", FI_LI);
DavCopyEnd (cpyptr);
return;
}
/******************************/
/* create top-level directory */
/******************************/
status = DavWebCreateDir (rqptr, tkptr->DestOds.ExpFileName,
tkptr->DestOds.ExpFileNameLength);
if (VMSok(status))
cpyptr->DirCount++;
else
{
cpyptr->DirFailCount++;
DavWebResponse (rqptr, 0, status, NULL, FI_LI);
DavCopyEnd (cpyptr);
return;
}
if (tkptr->ToDepth == WEBDAV_DEPTH_ZERO)
{
/* depth of zero essentially only creates the directory */
DavWebHref (rqptr, tkptr->DestOds.ExpFileName, 0);
DavWebResponse201 (rqptr);
DavCopyEnd (cpyptr);
return;
}
/***********************/
/* directory tree spec */
/***********************/
cpyptr->CopyingDir = true;
zptr = (sptr = tkptr->SearchSpec) + sizeof(tkptr->SearchSpec)-1;
for (cptr = rqptr->ParseOds.NamDevicePtr;
cptr < rqptr->ParseOds.NamNamePtr-1 && sptr < zptr;
*sptr++ = *cptr++);
for (cptr = "...]*.*;"; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (sptr >= zptr)
{
ErrorNoticed (rqptr, SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
DavWebResponse (rqptr, 0, SS$_BUGCHECK, NULL, FI_LI);
return;
}
tkptr->SearchSpecLength = sptr - tkptr->SearchSpec;
*sptr = '\0';
/* suitable to search against (i.e. no NAM$_SYNCHK) */
OdsStructInit (&tkptr->SearchOds, false);
OdsParse (&tkptr->SearchOds, tkptr->SearchSpec, tkptr->SearchSpecLength,
NULL, 0, 0, NULL, 0);
if (VMSnok (status = tkptr->SearchOds.Fab.fab$l_sts))
{
ErrorNoticed (rqptr, status, NULL, FI_LI);
DavWebResponse (rqptr, 500, status, NULL, FI_LI);
return;
}
/****************/
/* some storage */
/****************/
StrDscText (rqptr, &cpyptr->ReadNameDsc,
rqptr->ParseOds.ExpFileName,
rqptr->ParseOds.ExpFileNameLength);
StrDscText (rqptr, &cpyptr->WriteNameDsc,
tkptr->DestOds.ExpFileName,
tkptr->DestOds.ExpFileNameLength);
cpyptr->ReadOdsPtr = (ODS_STRUCT*)VmGetHeap (rqptr, sizeof(ODS_STRUCT));
OdsStructInit (cpyptr->ReadOdsPtr, false);
cpyptr->WriteOdsPtr = (ODS_STRUCT*)VmGetHeap (rqptr, sizeof(ODS_STRUCT));
OdsStructInit (cpyptr->WriteOdsPtr, false);
DavCopyNext (cpyptr);
}
/*****************************************************************************/
/*
This function is a common target from the file copy functions when the copy
fails or completes. If a single file copy it just calls DavCopyEnd() and
that's that! For a directory (tree) copy, a search for the next file is
performed which ASTs to DavCopyNextAst().
*/
DavCopyNext (WEBDAV_COPY *cpyptr)
{
REQUEST_STRUCT *rqptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
rqptr = cpyptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyNext()");
tkptr = rqptr->WebDavTaskPtr;
if (!cpyptr->CopyingDir)
{
/* no next if we're copying the one file (depth:0) */
if (cpyptr->CopyingMeta)
DavCopyEnd (cpyptr);
else
DavCopyMeta (rqptr, rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName);
return;
}
AuthAccessEnable (rqptr, 0, AUTH_ACCESS_SYSPRV);
OdsSearch (&tkptr->SearchOds, &DavCopyNextAst, cpyptr);
AuthAccessEnable (rqptr, 0, 0);
}
/*****************************************************************************/
/*
Directry (tree) copy search has completed. If no more files are found then
it's the end of the tree copy. Otherwise initiate the copy of this file.
*/
DavCopyNextAst (WEBDAV_COPY *cpyptr)
{
BOOL IsDirectory;
int status,
FileNameLength;
char *cptr, *sptr, *zptr;
char DirName [ODS_MAX_FILE_NAME_LENGTH+1],
FileName [ODS_MAX_FILE_NAME_LENGTH+1],
FromDirName [ODS_MAX_FILE_NAME_LENGTH+1];
STR_DSC_AUTO (FromDsc);
STR_DSC_AUTO (ToDsc);
REQUEST_STRUCT *rqptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
rqptr = cpyptr->RequestPtr;
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavCopyNextAst() sts:!&S stv:!&S",
tkptr->SearchOds.Fab.fab$l_sts,
tkptr->SearchOds.Fab.fab$l_stv);
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
DavCopyEnd (cpyptr);
return;
}
if (VMSnok (status = tkptr->SearchOds.Fab.fab$l_sts))
{
if (status == RMS$_NMF || status == RMS$_FNF)
{
cpyptr->VmsStatus = SS$_NORMAL;
if (!cpyptr->CopyingMeta)
{
DavCopyMeta (rqptr, rqptr->ParseOds.ExpFileName,
tkptr->DestOds.ExpFileName);
return;
}
}
else
cpyptr->VmsStatus = status;
DavCopyEnd (cpyptr);
return;
}
IsDirectory = false;
if (tkptr->SearchOds.NamTypeLength == 4 &&
(MATCH5 (tkptr->SearchOds.NamTypePtr, ".DIR;") ||
MATCH5 (tkptr->SearchOds.NamTypePtr, ".dir;")))
{
status = OdsReallyADir (rqptr, &tkptr->SearchOds);
if (VMSok(status)) IsDirectory = true;
}
if (IsDirectory)
{
/*************/
/* directory */
/*************/
/* derived from the original plus the descendent tree */
zptr = (sptr = DirName) + sizeof(DirName)-1;
for (cptr = tkptr->DestOds.ExpFileName;
*cptr && sptr < zptr;
*sptr++ = *cptr++);
/* eliminate the trailing ']' */
sptr--;
if (sptr < zptr) *sptr++ = '.';
/* append (any) descendent tree from the search results */
cptr = tkptr->SearchOds.ResFileName +
rqptr->ParseOds.ExpFileNameLength - 1;
while (cptr < tkptr->SearchOds.NamTypePtr && sptr < zptr)
{
if (*cptr == ']')
*sptr++ = '.';
else
*sptr++ = *cptr;
cptr++;
}
if (sptr < zptr) *sptr++ = ']';
if (sptr >= zptr)
{
ErrorNoticed (rqptr, SS$_RESULTOVF, NULL, FI_LI);
DavCopyEnd (cpyptr);
return;
}
*sptr = '\0';
status = DavWebCreateDir (rqptr, DirName, sptr-DirName);
if (VMSok(status))
cpyptr->DirCount++;
else
{
cpyptr->DirFailCount++;
DavWebMultiStatus (rqptr, status, DirName);
}
DavCopyNext (cpyptr);
return;
}
/***************************/
/* source and target names */
/***************************/
/* the source file name comes directly from the search results */
StrDscText (rqptr, &cpyptr->ReadNameDsc,
tkptr->SearchOds.ResFileName,
tkptr->SearchOds.ResFileNameLength);
/* the target name is derived from the original plus the descendent tree */
zptr = (sptr = FileName) + ODS_MAX_FILE_NAME_LENGTH;
for (cptr = tkptr->DestOds.ExpFileName;
*cptr && sptr < zptr;
*sptr++ = *cptr++);
/* eliminate the trailing ']' */
sptr--;
/* append (any) descendent tree from the search results */
for (cptr = tkptr->SearchOds.ResFileName +
rqptr->ParseOds.ExpFileNameLength - 2;
*cptr && sptr < zptr;
*sptr++ = *cptr++);
if (sptr >= zptr)
{
ErrorNoticed (rqptr, SS$_RESULTOVF, NULL, FI_LI);
DavCopyEnd (cpyptr);
return;
}
*sptr = '\0';
FileNameLength = sptr - FileName;
StrDscText (rqptr, &cpyptr->WriteNameDsc, FileName, FileNameLength);
DavCopyReadOpen (cpyptr);
}
/*****************************************************************************/
/*
Open the source file.
*/
DavCopyReadOpen (WEBDAV_COPY *cpyptr)
{
int status;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = cpyptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyReadOpen()");
AuthAccessEnable (rqptr, STR_DSC_PTR(&cpyptr->ReadNameDsc),
AUTH_ACCESS_READ);
OdsOpen (cpyptr->ReadOdsPtr,
&cpyptr->ReadNameDsc, -1, NULL, 0,
FAB$M_GET + FAB$M_BIO, 0, FAB$M_SHRGET,
DavCopyReadOpenAst, cpyptr);
AuthAccessEnable (rqptr, 0, 0);
}
/*****************************************************************************/
/*
AST from source file open. Check status and abandon copy if it failed. If
successful connect a RAB and attempt to create the target file.
*/
DavCopyReadOpenAst (WEBDAV_COPY *cpyptr)
{
int status;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = cpyptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyReadOpenAst() !&S",
cpyptr->ReadOdsPtr->Fab.fab$l_sts);
cpyptr->VmsStatus = status = cpyptr->ReadOdsPtr->Fab.fab$l_sts;
if (VMSnok (status))
{
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "COPY read open !AZ !&S",
STR_DSC_PTR(&cpyptr->ReadNameDsc), status);
if (!cpyptr->CopyingMeta)
{
cpyptr->FileFailCount++;
if (VMSnok (status))
DavWebMultiStatus (rqptr, status, STR_DSC_PTR(&cpyptr->ReadNameDsc));
}
DavCopyNext (cpyptr);
return;
}
cpyptr->ReadOdsPtr->Rab = cc$rms_rab;
cpyptr->ReadOdsPtr->Rab.rab$l_ctx = cpyptr;
cpyptr->ReadOdsPtr->Rab.rab$l_fab = &cpyptr->ReadOdsPtr->Fab;
status = sys$connect (&cpyptr->ReadOdsPtr->Rab, 0, 0);
if (VMSnok (status))
{
cpyptr->VmsStatus = status;
OdsClose (cpyptr->ReadOdsPtr, NULL, NULL);
DavCopyNext (cpyptr);
return;
}
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"!&Z", STR_DSC_PTR(&cpyptr->WriteNameDsc));
AuthAccessEnable (rqptr, STR_DSC_PTR(&cpyptr->WriteNameDsc),
AUTH_ACCESS_WRITE);
OdsCreate (cpyptr->WriteOdsPtr,
&cpyptr->WriteNameDsc, -1, NULL, 0,
FAB$M_PUT + FAB$M_GET + FAB$M_BIO, FAB$M_CIF, FAB$M_NIL,
0, 0,
&cpyptr->ReadOdsPtr->Fab,
DavCopyWriteOpenAst, cpyptr);
AuthAccessEnable (rqptr, 0, 0);
}
/*****************************************************************************/
/*
AST from target file create. Check status and abandon copy if it failed. If
successful connect a RAB and populate the RABs ready for an asynchronous set of
reads and writes.
*/
DavCopyWriteOpenAst (WEBDAV_COPY *cpyptr)
{
int status;
ODS_STRUCT *rodsptr, *wodsptr;
REQUEST_STRUCT *rqptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
rqptr = cpyptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyWriteOpenAst() !&S",
cpyptr->WriteOdsPtr->Fab.fab$l_sts);
tkptr = rqptr->WebDavTaskPtr;
rodsptr = cpyptr->ReadOdsPtr;
wodsptr = cpyptr->WriteOdsPtr;
cpyptr->VmsStatus = status = wodsptr->Fab.fab$l_sts;
if (VMSnok (status))
{
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "COPY write open !AZ !&S",
STR_DSC_PTR(&cpyptr->WriteNameDsc), status);
cpyptr->FileFailCount++;
if (VMSnok (status))
DavWebMultiStatus (rqptr, status, STR_DSC_PTR(&cpyptr->WriteNameDsc));
OdsClose (rodsptr, NULL, NULL);
DavCopyNext (cpyptr);
return;
}
if (cpyptr->VmsStatus != RMS$_CREATED) tkptr->OverwriteOccurred = true;
/* unless the copy completes successfully */
wodsptr->DeleteOnClose = true;
wodsptr->Rab = cc$rms_rab;
wodsptr->Rab.rab$l_ctx = cpyptr;
wodsptr->Rab.rab$l_fab = &wodsptr->Fab;
status = sys$connect (&wodsptr->Rab, 0, 0);
if (VMSnok (status))
{
cpyptr->VmsStatus = status;
/* ensure delete-on-close (if required) */
AuthAccessEnable (rqptr, 0, AUTH_ACCESS_SYSPRV);
OdsClose (rodsptr, NULL, NULL);
OdsClose (wodsptr, NULL, NULL);
AuthAccessEnable (rqptr, 0, 0);
DavCopyNext (cpyptr);
return;
}
/* maximise block buffer size against file size */
if (rodsptr->XabFhc.xab$l_ebk < 127)
cpyptr->BucketSize = rodsptr->XabFhc.xab$l_ebk;
else
cpyptr->BucketSize = 127;
cpyptr->DataSize = cpyptr->BucketSize * 512;
cpyptr->DataPtr = VmGetHeap (rqptr, cpyptr->DataSize);
/* set up read RAB */
rodsptr->Rab.rab$l_ctx = cpyptr;
rodsptr->Rab.rab$l_rop = RAB$M_BIO | RAB$M_ASY;
rodsptr->Rab.rab$l_ubf = cpyptr->DataPtr;
rodsptr->Rab.rab$w_usz = cpyptr->DataSize;
rodsptr->Rab.rab$l_bkt = 1;
/* set up write RAB */
wodsptr->Rab.rab$l_ctx = cpyptr;
wodsptr->Rab.rab$l_rop = RAB$M_BIO | RAB$M_ASY;
sys$read (&rodsptr->Rab, &DavCopyReadAst, &DavCopyReadAst);
}
/*****************************************************************************/
/*
AST from source read. Check status and abandon copy if it failed. If
successful write the just-read buffer.
*/
DavCopyReadAst (struct RAB *RabPtr)
{
BOOL IsMetaFile;
int status;
char *cptr;
ODS_STRUCT *rodsptr, *wodsptr;
REQUEST_STRUCT *rqptr;
STR_DSC_AUTO (FromDsc);
STR_DSC_AUTO (ToDsc);
WEBDAV_COPY *cpyptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
cpyptr = RabPtr->rab$l_ctx;
rqptr = cpyptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV,
"DavCopyReadAst() read: !&S !UL write: !&S !UL",
cpyptr->ReadOdsPtr->Rab.rab$l_sts,
cpyptr->ReadOdsPtr->Rab.rab$w_rsz,
cpyptr->WriteOdsPtr->Rab.rab$l_sts,
cpyptr->WriteOdsPtr->Rab.rab$w_rsz);
tkptr = rqptr->WebDavTaskPtr;
rodsptr = cpyptr->ReadOdsPtr;
wodsptr = cpyptr->WriteOdsPtr;
status = rodsptr->Rab.rab$l_sts;
if (VMSnok (status))
{
if (status == RMS$_EOF)
{
/* successful copy */
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "COPIED !AZ",
STR_DSC_PTR(&cpyptr->ReadNameDsc));
/* delete original if moving using copy */
if (rqptr->rqHeader.Method == HTTP_METHOD_WEBDAV_MOVE)
rodsptr->DeleteOnClose = true;
/* undo delete unless successful */
wodsptr->DeleteOnClose = false;
cpyptr->VmsStatus = status = SS$_NORMAL;
}
else
cpyptr->VmsStatus = status;
/* only need this expense when WATCHing */
if (WATCHING (rqptr, WATCH_WEBDAV))
{
IsMetaFile = DavMetaFile (cpyptr->ReadOdsPtr);
if (VMSok(status))
if (IsMetaFile)
cpyptr->MetaCount++;
else
cpyptr->FileCount++;
else
if (IsMetaFile)
cpyptr->MetaFailCount++;
else
cpyptr->FileFailCount++;
}
if (VMSnok (status))
{
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "COPY read !AZ !&S",
STR_DSC_PTR(&cpyptr->ReadNameDsc), status);
DavWebMultiStatus (rqptr, status, STR_DSC_PTR(&cpyptr->ReadNameDsc));
}
/* ensure delete-on-close (if required) */
AuthAccessEnable (rqptr, 0, AUTH_ACCESS_SYSPRV);
OdsClose (rodsptr, NULL, NULL);
OdsClose (wodsptr, NULL, NULL);
AuthAccessEnable (rqptr, 0, 0);
DavCopyNext (cpyptr);
return;
}
wodsptr->Rab.rab$l_rbf = rodsptr->Rab.rab$l_ubf;
wodsptr->Rab.rab$w_rsz = rodsptr->Rab.rab$w_rsz;
wodsptr->Rab.rab$l_bkt = rodsptr->Rab.rab$l_bkt;
sys$write (&wodsptr->Rab, &DavCopyWriteAst, &DavCopyWriteAst);
}
/*****************************************************************************/
/*
AST from target write. Check status and abandon copy if it failed. If
successful queue another source read.
*/
DavCopyWriteAst (struct RAB *RabPtr)
{
int status;
ODS_STRUCT *rodsptr, *wodsptr;
REQUEST_STRUCT *rqptr;
WEBDAV_COPY *cpyptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
cpyptr = RabPtr->rab$l_ctx;
rqptr = cpyptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyWriteAst() !&S !UL",
cpyptr->WriteOdsPtr->Rab.rab$l_sts,
cpyptr->WriteOdsPtr->Rab.rab$w_rsz);
tkptr = rqptr->WebDavTaskPtr;
rodsptr = cpyptr->ReadOdsPtr;
wodsptr = cpyptr->WriteOdsPtr;
status = wodsptr->Rab.rab$l_sts;
if (VMSnok (status))
{
cpyptr->VmsStatus = status;
cpyptr->FileFailCount++;
if (WATCHING (rqptr, WATCH_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_WEBDAV, "COPY write !AZ !&S",
STR_DSC_PTR(&cpyptr->WriteNameDsc), status);
DavWebMultiStatus (rqptr, cpyptr->VmsStatus,
STR_DSC_PTR(&cpyptr->WriteNameDsc));
/* ensure delete-on-close (if required) */
AuthAccessEnable (rqptr, 0, AUTH_ACCESS_SYSPRV);
OdsClose (rodsptr, NULL, NULL);
OdsClose (wodsptr, NULL, NULL);
AuthAccessEnable (rqptr, 0, 0);
DavCopyNext (cpyptr);
return;
}
rodsptr->Rab.rab$l_bkt += cpyptr->BucketSize;
sys$read (&rodsptr->Rab, &DavCopyReadAst, &DavCopyReadAst);
}
/*****************************************************************************/
/*
Copy any meta file associated with the source to the destination.
Assumes everything's locked by the calling routine.
*/
DavCopyMeta
(
REQUEST_STRUCT *rqptr,
char *SrcFileName,
char *DstFileName
)
{
int status;
WEBDAV_COPY *cpyptr;
WEBDAV_META *mtaptr;
WEBDAV_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->WebDavTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_WEBDAV))
WatchThis (WATCHITM(rqptr), WATCH_MOD_WEBDAV, "DavCopyMeta() !AZ !AZ",
SrcFileName, DstFileName);
cpyptr = &tkptr->CopyData;
cpyptr->CopyingMeta = true;
mtaptr = &tkptr->MetaData;
mtaptr->TaskPtr = rqptr->WebDavTaskPtr;
DavMetaName (mtaptr, SrcFileName, 'r');
DavMetaName (mtaptr, DstFileName, 'w');
StrDscText (rqptr, &cpyptr->ReadNameDsc,
mtaptr->ReadMetaName,
mtaptr->ReadMetaNameLength);
StrDscText (rqptr, &cpyptr->WriteNameDsc,
mtaptr->WriteMetaName,
mtaptr->WriteMetaNameLength);
DavMetaCreateDir (mtaptr);
DavCopyReadOpen (cpyptr);
}
/*****************************************************************************/