[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]
/***************************************************************************** /* StrDsc.c One of the basic constraints with standard VMS string descriptors is the limited size - 65535 characters max (ignoring 64 bit descriptors which are not supported on all platforms WASD can be built upon). While 65k might seem an awful lot there are circumstances where using a standard descriptor might be a limitation. WASD descriptors use 32 bit pointers and counters. They also include pointers to allow the creation of a linked list of them. Where data does not need to be contiguous (as with output) this makes it possible to build large buffers of data without memory reallocation (and the expensive memory copying associated). Where data does need to be contiguous the WASD descriptor buffer can be grown through reallocating memory (and transparently moving content to the new location as necessary - a'la the C-RTL realloc()). The pointed-to strings are always null-terminated and so non-linked descriptors are amenable to processing with C-RTL functions, etc. A number of functions below allow these descriptors to be easily created, built (filled with data), and disposed of. In addition FaolSAK() understands the structure and can write formatted data into a descriptor, linking descriptors or growing the buffer as required over multiple formatted writes. Even more usefully, NetWriteStrDsc() will write one or a linked list of these descriptors to the client. The 'itself' member of the structure is used to both detect whether a structure has been initialised and also as a subsequent sanity check where functions expect an initialised structure. It does this by being set to the bit-wise negation of address of itself (to avoid an random stack content pointer match) and reset when disposed of. A sanity check of this and the flags field helps ensure integrity of descriptor usage during run-time. Allocated storage using VmGet() and VmGetHeap() returns zeroed storage so initialised descriptors are not a problem. On the stack with function automatic storage is a different situation and descriptors should be explicitly zeroed during declaration using the STR_DSC_AUTO macro. VERSION HISTORY --------------- 09-JUN-2007 MGD a long, long time coming but WASD string descriptors (and the associated functions) have finally arrived! */ /*****************************************************************************/ #ifdef WASD_VMS_V7 #undef _VMS__V6__SOURCE #define _VMS__V6__SOURCE #undef __VMS_VER #undef __VMS_VER #undef __CRTL_VER #define __CRTL_VER 70000000 #endif /* standard C header files */ #include <ctype.h> #include <stdarg.h> #include <stdio.h> #include <stdlib.h> #include <string.h> /* VMS related header files */ #include <ssdef.h> #include <stsdef.h> /* application related header files */ #include "wasd.h" #define WASD_MODULE "STRDSC" /* obviously low-level debug can't use StrDsc..() functions - aka WATCH! */ #define DEBUG_STRDSC 0 #define ITSELF(ptr) ((STR_DSC*)~(unsigned long)ptr) /********************/ /* external storage */ /********************/ #ifdef DBUG extern BOOL Debug; #else #define Debug 0 #endif extern int ToLowerCase[], ToUpperCase[]; extern char ErrorSanityCheck[]; extern WATCH_STRUCT Watch; /*****************************************************************************/ /* Initialise (or reinitialise) a descriptor ready for use. If 'sdptr' is NULL create a dynamically allocated descriptor otherwise use the supplied pointer. If 'size' is -1 allocate the default quantity of storage; if 0 allocate no storage; or allocate the indicated quantity. */ STR_DSC* StrDscBegin ( REQUEST_STRUCT *rqptr, STR_DSC *sdptr, int size ) { unsigned long flags = 0; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscBegin()\n"); if (size < 0) size = STR_DSC_DEFAULT_SIZE; if (sdptr) { if (STR_DSC_SANITY(sdptr)) { flags = sdptr->flags; StrDscEnd (sdptr, FI_LI); } else memset (sdptr, 0, sizeof(STR_DSC)); } if (!sdptr || (flags & STR_DSC_FLAG_DYNAMIC)) { if (rqptr) { sdptr = VmGetHeap (rqptr, sizeof(STR_DSC)); if (sdptr->size = size) sdptr->pointer = VmGetHeap (rqptr, size); } else { sdptr = VmGet (sizeof(STR_DSC)); if (sdptr->size = size) sdptr->pointer = VmGet (size); #if WATCH_MOD if (size) StrDscWatchNotHeap (FI_LI); #endif } sdptr->flags = STR_DSC_FLAG_FLAG | STR_DSC_FLAG_DYNAMIC | STR_DSC_FLAG_STORAGE; } else { if (rqptr) { if (sdptr->size = size) sdptr->pointer = VmGetHeap (rqptr, size); } else { if (sdptr->size = size) sdptr->pointer = VmGet (size); #if WATCH_MOD if (size) StrDscWatchNotHeap (FI_LI); #endif } sdptr->flags = STR_DSC_FLAG_FLAG | STR_DSC_FLAG_STORAGE; } sdptr->itself = ITSELF(sdptr); sdptr->rqptr = rqptr; return (sdptr); } /*****************************************************************************/ /* Free this fixed or dynamically allocated WASD string descriptor. */ StrDscEnd ( STR_DSC *sdptr, char *SourceModuleName, int SourceLineNumber ) { STR_DSC *flink; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscEnd()\n"); /* just consider it to have been unused */ if (!STR_DSC_SANITY(sdptr)) return; while (sdptr) { if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, SourceModuleName, SourceLineNumber); flink = sdptr->flink; if (sdptr->rqptr) { if (sdptr->pointer && (sdptr->flags & STR_DSC_FLAG_STORAGE)) VmFreeFromHeap (sdptr->rqptr, sdptr->pointer, SourceModuleName, SourceLineNumber); if (sdptr->flags & STR_DSC_FLAG_DYNAMIC) VmFreeFromHeap (sdptr->rqptr, sdptr, SourceModuleName, SourceLineNumber); else memset (sdptr, 0, sizeof(STR_DSC)); } else { if (sdptr->pointer && (sdptr->flags & STR_DSC_FLAG_STORAGE)) VmFree (sdptr->pointer, SourceModuleName, SourceLineNumber); if (sdptr->flags & STR_DSC_FLAG_DYNAMIC) VmFree (sdptr, SourceModuleName, SourceLineNumber); else memset (sdptr, 0, sizeof(STR_DSC)); } sdptr = flink; } } /*****************************************************************************/ /* Ensure that a descriptor has been initialised. This is different to StrDscBegin() in that it doesn't re-initialise. */ STR_DSC* StrDscIfNotBegin ( REQUEST_STRUCT *rqptr, STR_DSC *sdptr, int BufferSize ) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscIfNotBegin()\n"); if (!sdptr || !STR_DSC_SANITY(sdptr)) sdptr = StrDscBegin (rqptr, sdptr, BufferSize); return (sdptr); } /*****************************************************************************/ /* Ensure that a collection descriptor has been initialised. */ STR_DSC* StrDscColIfNotBegin ( REQUEST_STRUCT *rqptr, STR_DSC *sdptr, int BufferSize ) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscColIfNotBegin()\n"); if (!sdptr || !STR_DSC_SANITY(sdptr)) { sdptr = StrDscBegin (rqptr, sdptr, BufferSize); sdptr->flags |= STR_DSC_FLAG_COLLECTION; } return (sdptr); } /*****************************************************************************/ /* Reallocate memory to the descriptor. In this case a non-zero 'grow' parameter is the *additional* memory to allocate, otherwise '->realloc' will be used. */ int StrDscRealloc ( REQUEST_STRUCT *rqptr, STR_DSC *sdptr, int grow, char *SourceModuleName, int SourceLineNumber ) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscRealloc()\n"); if (!grow) grow = sdptr->realloc; if (!grow) grow = STR_DSC_DEFAULT_SIZE; if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (sdptr->rqptr) sdptr->pointer = VmReallocHeap (sdptr->rqptr, sdptr->pointer, sdptr->size += grow, SourceModuleName, SourceLineNumber); else { #if WATCH_MOD StrDscWatchNotHeap (FI_LI); #endif sdptr->pointer = VmRealloc (sdptr->pointer, sdptr->size += grow, SourceModuleName, SourceLineNumber); } return (sdptr->size); } /*****************************************************************************/ /* Set the descriptor so it points at some external (array of char) buffer. */ STR_DSC* StrDscExternal ( REQUEST_STRUCT *rqptr, STR_DSC *sdptr, char *BufferPtr, int BufferSize ) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscExternal()\n"); sdptr = StrDscBegin (rqptr, sdptr, 0); sdptr->flags &= ~STR_DSC_FLAG_STORAGE; sdptr->flags |= STR_DSC_FLAG_EXTERNAL; sdptr->pointer = BufferPtr; sdptr->size = BufferSize; return (sdptr); } /*****************************************************************************/ /* Set the descriptor so it points at some external, null-terminated text. Intended for constants or other text requiring a descriptor but be careful not to otherwise pull the text out from under it! NOTE: this seems to have an issue with the likes of StrDscThis(..,"\n",1) and I haven't been able to determined why. */ STR_DSC* StrDscThis ( REQUEST_STRUCT *rqptr, STR_DSC *sdptr, char *TextPtr, int TextLength ) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscThis()\n"); if (TextLength <= 0 && TextPtr) TextLength = strlen(TextPtr); sdptr = StrDscBegin (rqptr, sdptr, 0); sdptr->flags &= ~STR_DSC_FLAG_STORAGE; sdptr->flags |= STR_DSC_FLAG_EXTERNAL; sdptr->pointer = TextPtr; sdptr->size = (sdptr->length = TextLength) + 1; return (sdptr); } /*****************************************************************************/ /* This function is intended for quick, ad hoc, string descriptor variables, often on automatic storage, or where the text must persist. */ STR_DSC* StrDscText ( REQUEST_STRUCT *rqptr, STR_DSC *sdptr, char *TextPtr, int TextLength ) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscText()\n"); if (TextLength <= 0) TextLength = strlen(TextPtr); sdptr = StrDscBegin (rqptr, sdptr, TextLength+1); memcpy (sdptr->pointer, TextPtr, TextLength); sdptr->length = TextLength; return (sdptr); } /*****************************************************************************/ /* Given a pointer to a (potential) list of descriptors, find the first one with space remaining and return a pointer to that. The exact byte within that descriptor can then be calculated using its pointer and length. If there is no descriptor with space remaining then either reallocate extra space for the current descriptor, or create another one and add it to the list. Request and non-request related descriptors are distinguished by the presence or absence of a request pointer in the structure. */ STR_DSC* StrDscBuffer (STR_DSC *sd1ptr) { REQUEST_STRUCT *rqptr; STR_DSC *sd2ptr; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscBuffer()\n"); if (!STR_DSC_SANITY(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (sd1ptr->flags & STR_DSC_FLAG_EXTERNAL) return (sd1ptr); if (!(sd1ptr->flags & STR_DSC_FLAG_FROZEN)) if (sd1ptr->pointer && sd1ptr->length < sd1ptr->size) return (sd1ptr); rqptr = sd1ptr->rqptr; /* find the next descriptor with available storage space (if any) */ for (sd2ptr = sd1ptr; sd2ptr; sd2ptr = sd2ptr->flink) { if (!STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (sd2ptr->flags & STR_DSC_FLAG_FROZEN) continue; if (sd2ptr->pointer && sd2ptr->length < sd2ptr->size) return (sd2ptr); } if (!sd1ptr->size) sd1ptr->size = STR_DSC_DEFAULT_SIZE; if (rqptr) { /* request storage */ if (sd1ptr->pointer) { if (sd1ptr->realloc && !(sd1ptr->flags & STR_DSC_FLAG_FROZEN)) { StrDscRealloc (rqptr, sd1ptr, sd1ptr->realloc, FI_LI); return (sd1ptr); } else { /* subsequent allocation of buffer */ sd2ptr = VmGetHeap (rqptr, sizeof(STR_DSC)); sd2ptr->itself = ITSELF(sd2ptr); sd2ptr->pointer = VmGetHeap (rqptr, sd2ptr->size = sd1ptr->size); sd2ptr->flags = STR_DSC_FLAG_FLAG | STR_DSC_FLAG_DYNAMIC | STR_DSC_FLAG_STORAGE; sd2ptr->rqptr = rqptr; /* append it to the end of the list */ while (sd1ptr->flink) sd1ptr = sd1ptr->flink; sd1ptr->flink = sd2ptr; sd2ptr->blink = sd1ptr; return (sd2ptr); } } else { /* initial allocation of buffer */ sd1ptr->itself = ITSELF(sd1ptr); sd1ptr->pointer = VmGetHeap (rqptr, sd1ptr->size); sd1ptr->flags |= STR_DSC_FLAG_STORAGE; sd1ptr->length = 0; return (sd1ptr); } } else { /* non-request storage */ #if WATCH_MOD StrDscWatchNotHeap (FI_LI); #endif if (sd1ptr->pointer) { if (sd1ptr->realloc && !(sd1ptr->flags & STR_DSC_FLAG_FROZEN)) { StrDscRealloc (NULL, sd1ptr, sd1ptr->realloc, FI_LI); return (sd1ptr); } else { /* subsequent allocation of buffer */ sd2ptr = VmGet (sizeof(STR_DSC)); sd2ptr->itself = ITSELF(sd2ptr); sd2ptr->pointer = VmGet (sd2ptr->size = sd1ptr->size); sd2ptr->flags = STR_DSC_FLAG_FLAG | STR_DSC_FLAG_DYNAMIC | STR_DSC_FLAG_STORAGE; sd1ptr->flink = sd2ptr; sd2ptr->blink = sd1ptr; return (sd2ptr); } } else { /* initial allocation of buffer */ sd1ptr->itself = ITSELF(sd1ptr); sd1ptr->pointer = VmGet (sd1ptr->size); sd1ptr->flags |= STR_DSC_FLAG_STORAGE; sd1ptr->length = 0; return (sd1ptr); } } } /*****************************************************************************/ /* Return the text length of a (potentially) list of descriptors. */ int StrDscLength (STR_DSC *sdptr) { int len; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscLength()\n"); len = 0; while (sdptr) { if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); len += sdptr->length; sdptr = sdptr->flink; } return (len); } /*****************************************************************************/ /* Return a pointer to the final entry in a list of descriptors. */ STR_DSC* StrDscTail (STR_DSC *sdptr) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscTail()\n"); if (!sdptr) return (NULL); if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); while (sdptr->flink) { sdptr = sdptr->flink; if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); } return (sdptr); } /*****************************************************************************/ /* Freeze the contents of the final entry in a list of descriptors. */ STR_DSC* StrDscTailFrozen (STR_DSC *sdptr) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscTailFrozen()\n"); if (!sdptr) return (NULL); if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); while (sdptr->flink) { sdptr = sdptr->flink; if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); } sdptr->flags |= STR_DSC_FLAG_FROZEN; return (sdptr); } /*****************************************************************************/ /* Effectively move the sd2ptr (head-of-list) descriptor to sd1ptr overwriting and losing it's contents including orphaning any memory it points to. This is intended for a fixed descriptor rather than a pointer to descriptor which can of course be merely assigned. */ StrDscMove ( STR_DSC *sd1ptr, STR_DSC *sd2ptr ) { unsigned long flags; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscMove()\n"); /* sd1ptr does not need to be sanity checked */ if (!STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); /* there is no back-link for head-of-list descriptors */ if (sd2ptr->flink) sd2ptr->flink->blink = sd1ptr; flags = sd1ptr->flags; memcpy (sd1ptr, sd2ptr, sizeof(STR_DSC)); sd1ptr->itself = ITSELF(sd1ptr); memset (sd2ptr, 0, sizeof(STR_DSC)); /* ensure the dynamic flag is propgated */ if (flags & STR_DSC_FLAG_DYNAMIC) sd1ptr->flags |= STR_DSC_FLAG_DYNAMIC; else sd1ptr->flags &= ~STR_DSC_FLAG_DYNAMIC; } /*****************************************************************************/ /* Effectively swap these two (head-of-list) descriptors (which may be fixed rather than allocated descriptors and therefore not amenable to mere pointer swapping). */ StrDscSwap ( STR_DSC *sd1ptr, STR_DSC *sd2ptr ) { STR_DSC TmpDsc; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscSwap()\n"); if (!STR_DSC_SANITY(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (!STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); /* must be head of list descriptors */ if (sd1ptr->blink || sd2ptr->blink) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (sd1ptr->flink) sd1ptr->flink->blink = sd2ptr; if (sd2ptr->flink) sd2ptr->flink->blink = sd1ptr; memcpy (&TmpDsc, sd1ptr, sizeof(STR_DSC)); memcpy (sd1ptr, sd2ptr, sizeof(STR_DSC)); sd1ptr->itself = ITSELF(sd1ptr); memcpy (sd2ptr, &TmpDsc, sizeof(STR_DSC)); sd2ptr->itself = ITSELF(sd2ptr); } /*****************************************************************************/ /* Swap the storage of these two descriptors (CAREFUL!). */ StrDscStorageSwap ( STR_DSC *sd1ptr, STR_DSC *sd2ptr ) { STR_DSC TmpDsc; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscStroageSwap()\n"); if (!STR_DSC_SANITY(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (!STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); TmpDsc.pointer = sd1ptr->pointer; sd1ptr->pointer = sd2ptr->pointer; sd2ptr->pointer = TmpDsc.pointer; TmpDsc.length = sd1ptr->length; sd1ptr->length = sd2ptr->length; sd2ptr->length = TmpDsc.length; TmpDsc.size = sd1ptr->size; sd1ptr->size = sd2ptr->size; sd2ptr->size = TmpDsc.size; } /*****************************************************************************/ /* Duplicate the descriptor (potentially a list of) provided by 'sd2ptr' in the descriptor 'sd1ptr'. If 'sd1ptr' is NULL a new dynamic descriptor is allocated. A pointer to 'sd1ptr' (existing or new) is returned. */ STR_DSC* StrDscDup ( STR_DSC *sd1ptr, STR_DSC *sd2ptr ) { REQUEST_STRUCT *rqptr; STR_DSC *sdptr; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscDup()\n"); /* sd1ptr does not need to be sanity checked */ if (!STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); rqptr = sd2ptr->rqptr; sd1ptr = StrDscBegin (rqptr, sd1ptr, sd2ptr->size); /* initial descriptor */ if (sd1ptr->length = sd2ptr->length) { /* including the terminating null */ memcpy (sd1ptr->pointer, sd2ptr->pointer, sd2ptr->length+1); } /* subsequent descriptors */ sdptr = sd1ptr; for (sd2ptr = sd2ptr->flink; sd2ptr; sd2ptr = sd2ptr->flink) { if (rqptr) sdptr->flink = VmGetHeap (rqptr, sizeof(STR_DSC)); else { #if WATCH_MOD StrDscWatchNotHeap (FI_LI); #endif sdptr->flink = VmGet (sizeof(STR_DSC)); } /* careful! */ sdptr->flink->blink = sdptr; sdptr = sdptr->flink; sdptr->itself = ITSELF(sdptr); sdptr->rqptr = rqptr; sdptr->size = sd2ptr->size; sdptr->flags = STR_DSC_FLAG_FLAG | STR_DSC_FLAG_DYNAMIC | STR_DSC_FLAG_STORAGE; if (rqptr) sdptr->pointer = VmGetHeap (rqptr, sdptr->size); else sdptr->pointer = VmGet (sdptr->size); /* including the terminating null */ if (sd1ptr->length = sd2ptr->length) { /* including the terminating null */ memcpy (sd1ptr->pointer, sd2ptr->pointer, sd2ptr->length+1); } } return (sd1ptr); } /*****************************************************************************/ /* Comparison of the descriptor content. */ BOOL StrDscSame ( STR_DSC *sd1ptr, STR_DSC *sd2ptr, BOOL CaseLess ) { int len1, len2; char *cptr, *sptr; STR_DSC *sdptr; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscSame()\n"); if (!sd1ptr->pointer || !sd2ptr->pointer) return (false); if (!STR_DSC_SANITY(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (!STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); len1 = len2 = 0; for (sdptr = sd1ptr; sdptr; sdptr = sdptr->flink) len1 += sdptr->length; for (sdptr = sd2ptr; sdptr; sdptr = sdptr->flink) len2 += sdptr->length; if (len1 != len2) return (false); if (!len1 && !len2) return (true); cptr = sd1ptr->pointer; len1 = sd1ptr->length; sptr = sd2ptr->pointer; len2 = sd2ptr->length; for (;;) { if (!len1) { if (!(sd1ptr = sd1ptr->flink)) break; cptr = sd1ptr->pointer; len1 = sd1ptr->length; } if (!len2) { if (!(sd2ptr = sd2ptr->flink)) break; sptr = sd2ptr->pointer; len2 = sd2ptr->length; } if (CaseLess && TOLO(*cptr) != TOLO(*sptr)) break; if (!CaseLess && *cptr != *sptr) break; cptr++; sptr++; len1--; len2--; } if (len1 || len2) return (false); return (true); } /*****************************************************************************/ /* Reset a (potentially linked list of) descriptor buffer(s) to no content. */ StrDscNoContent (STR_DSC *sdptr) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscNoContent()\n"); while (sdptr) { if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); sdptr->length = 0; sdptr = sdptr->flink; } } /*****************************************************************************/ /* Ensure the descriptor has a trailing newline. Returns a pointer to the current descriptor. */ STR_DSC* StrDscNewLine (STR_DSC *sdptr) { /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscNewLine()\n"); if (!STR_DSC_SANITY(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); /* find the latest descriptor */ if (!sdptr->pointer || sdptr->flags & STR_DSC_FLAG_FROZEN) sdptr = StrDscBuffer (sdptr); else { while (sdptr->length >= sdptr->size) { if (sdptr->itself != ITSELF(sdptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (!sdptr->flink) break; sdptr = sdptr->flink; } } if (sdptr->length && sdptr->pointer[sdptr->length-1] == '\n') return (sdptr); if (sdptr->length >= sdptr->size) sdptr = StrDscBuffer (sdptr); sdptr->pointer[sdptr->length++] = '\n'; sdptr->pointer[sdptr->length] = '\0'; return (sdptr); } /*****************************************************************************/ /* Copy descriptor 2 or null-terminated string to descriptor 1 dynamically expanding buffer space as required. Returns a pointer to the current descriptor. */ STR_DSC* StrDscBuild ( STR_DSC *sd1ptr, STR_DSC *sd2ptr, char *AscizPtr ) { char *cptr, *czptr, *sptr, *zptr; STR_DSC *sdptr; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscBuild()\n"); if (!STR_DSC_SANITY(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (sd2ptr && !STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); /* find the latest descriptor */ if (!sd1ptr->pointer || sd1ptr->flags & STR_DSC_FLAG_FROZEN) sd1ptr = StrDscBuffer (sd1ptr); else { while (sd1ptr->length >= sd1ptr->size) { if (sd1ptr->itself != ITSELF(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (!sd1ptr->flink) break; sd1ptr = sd1ptr->flink; } } if (AscizPtr) cptr = AscizPtr; else czptr = (cptr = sd2ptr->pointer) + sd2ptr->length; for (;;) { if ((AscizPtr && !*cptr) || (!AscizPtr && cptr >= czptr)) break; zptr = (sptr = sd1ptr->pointer) + sd1ptr->size; sptr += sd1ptr->length; if (AscizPtr) while (*cptr && sptr < zptr) *sptr++ = *cptr++; else while (cptr < czptr && sptr < zptr) *sptr++ = *cptr++; *sptr = '\0'; sd1ptr->length = sptr - sd1ptr->pointer; if ((AscizPtr && !*cptr) || (!AscizPtr && cptr >= czptr)) break; sd1ptr = StrDscBuffer (sd1ptr); } return (sd1ptr); } /*****************************************************************************/ /* Copy descriptor 2 or null-terminated string to descriptor 1 dynamically expanding buffer space as required, HTML-escaping the '<', '>' and '&' characters. Returns a pointer to the current descriptor. */ STR_DSC* StrDscBuildHtmlEscape ( STR_DSC *sd1ptr, STR_DSC *sd2ptr, char *AscizPtr ) { static char ebuf [] = "\0"; char *cptr, *czptr, *eptr, *sptr, *zptr; STR_DSC *sdptr; /*********/ /* begin */ /*********/ if (DEBUG_STRDSC) fprintf (stdout, "StrDscBuildHtmlEscape()\n"); if (!sd1ptr->pointer) sd1ptr = StrDscBuffer (sd1ptr); if (!STR_DSC_SANITY(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (sd2ptr && !STR_DSC_SANITY(sd2ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); /* find the latest descriptor */ if (sd1ptr->flags & STR_DSC_FLAG_FROZEN) sd1ptr = StrDscBuffer (sd1ptr); else { while (sd1ptr->length >= sd1ptr->size) { if (sd1ptr->itself != ITSELF(sd1ptr)) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI); if (!sd1ptr->flink) break; sd1ptr = sd1ptr->flink; } } if (AscizPtr) cptr = AscizPtr; else czptr = (cptr = sd2ptr->pointer) + sd2ptr->length; zptr = (sptr = sd1ptr->pointer) + sd1ptr->size; sptr += sd1ptr->length; for (;;) { /* buffer non-forbidden chars and handle end-of-source */ if (AscizPtr) { while (*cptr && *cptr != '<' && *cptr != '>' && *cptr != '&' && sptr < zptr) *sptr++ = *cptr++; if (!*cptr) break; } else { while (cptr < czptr && *cptr != '<' && *cptr != '>' && *cptr != '&' && sptr < zptr) *sptr++ = *cptr++; if (cptr >= czptr) break; } /* forbidden character and buffer space exhausted drop through */ switch (*cptr) { case '<' : eptr = "<"; break; case '>' : eptr = ">"; break; case '&' : eptr = "&"; break; /* non-forbidden character (buffer space exhausted) */ default : *(eptr = ebuf) = *cptr; } cptr++; while (*eptr) { while (*eptr && sptr < zptr) *sptr++ = *eptr++; if (sptr >= zptr) { /* buffer space exhaustion */ *sptr = '\0'; sd1ptr->length = sptr - sd1ptr->pointer; sd1ptr = StrDscBuffer (sd1ptr); zptr = (sptr = sd1ptr->pointer) + sd1ptr->size; sptr += sd1ptr->length; } } } *sptr = '\0'; sd1ptr->length = sptr - sd1ptr->pointer; return (sd1ptr); } /*****************************************************************************/ /* Has happened often enough during development to warrant a sanity check. Avoid using standard WATCH which uses FaoToBuffer() which in turn uses FaolSAK() which in turn uses StrDsc..()! */ #if WATCH_MOD StrDscWatchNotHeap ( char *SourceModuleName, int SourceLineNumber ) { int len; char NotHeap [128]; /*********/ /* begin */ /*********/ len = sprintf (NotHeap, "|%11s %8s %04u %4s %10s %s|\n", "", "STRDSC ", SourceLineNumber, "", "", "+++++ W A R N I N G +++++ not request heap"); if (Watch.StdoutToo || Watch.StdoutOnly) fputs (NotHeap, stdout); if (Watch.RequestPtr) NetWrite (Watch.RequestPtr, 0, NotHeap, len); } #endif /*****************************************************************************/ /* Always seems a character flaw that perfect code cannot be written first-up! */ #if WATCH_MOD StrDscDebug ( STR_DSC *sdptr, char *WhereAt ) { /*********/ /* begin */ /*********/ if (sdptr) fprintf (stdout, "++++++++++ %s\n\ sdptr: %08.08X\n\ %08.08X%08.08X%08.08X%08.08X%08.08X%08.08X%08.08X\n\ ->itself: %08.08X (%08.08X) %s\n\ ->flags: %08.08X\n\ ->size: %d\n\ ->length: %d\n\ ->pointer: %08.08X\n\ ->realloc: %d\n\ ->rqptr: %08.08X\n\ ->flink: %08.08X\n\ ->blink: %08.08X\n\ ++++++++++\n", WhereAt ? WhereAt : "", sdptr, ((ULONGPTR)sdptr)[0], ((ULONGPTR)sdptr)[1], ((ULONGPTR)sdptr)[2], ((ULONGPTR)sdptr)[3], ((ULONGPTR)sdptr)[4], ((ULONGPTR)sdptr)[5], ((ULONGPTR)sdptr)[6], sdptr->itself, ~(unsigned long)sdptr, STR_DSC_SANITY(sdptr) ? "SANE" : "*", sdptr->flags, sdptr->size, sdptr->length, sdptr->pointer, sdptr->realloc, sdptr->rqptr, sdptr->flink, sdptr->blink); else fprintf (stdout, "++++++++++ %s\n\ sdptr: 00000000\n\ ++++++++++\n", WhereAt ? WhereAt : ""); } #endif /****************************************************************************/