?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add pgs color type setting
[xy_vsfilter.git] / include / atl / atlstencil.h
blob8694a0f4253a641003b6d12836566c0e6f0197d7
1 // This is a part of the Active Template Library.
2 // Copyright (C) Microsoft Corporation
3 // All rights reserved.
4 //
5 // This source code is only intended as a supplement to the
6 // Active Template Library Reference and related
7 // electronic documentation provided with the library.
8 // See these sources for detailed information regarding the
9 // Active Template Library product.
10
11 #ifndef __ATLSTENCIL_H__
12 #define __ATLSTENCIL_H__
13
14 #pragma once
15
16 #include <atlisapi.h>
17 #include <atlfile.h>
18 #include <atlutil.h>
19 #include <math.h>
20
21 #ifdef ATL_DEBUG_STENCILS
22 #include <atlsrvres.h>
23
24 #ifndef ATL_STENCIL_MAX_ERROR_LEN
25 #define ATL_STENCIL_MAX_ERROR_LEN 256
26 #endif
27 #endif // ATL_DEBUG_STENCILS
28
29 #ifndef ATL_NO_MLANG
30 #include <mlang.h>
31 #endif
32
33 #ifndef _ATL_NO_DEFAULT_LIBS
34 #pragma comment(lib, "shlwapi.lib")
35 #endif // !_ATL_NO_DEFAULT_LIBS
36
37 #pragma warning( push )
38 #pragma warning(disable: 4127) // conditional expression is constant
39 #pragma warning(disable: 4511) // copy constructor could not be generated
40 #pragma warning(disable: 4512) // assignment operator could not be generated
41 #pragma warning(disable: 4702) // assignment operator could not be generated
42 #pragma warning(disable: 4625) // copy constructor could not be generated because a base class copy constructor is inaccessible
43 #pragma warning(disable: 4626) // assignment operator could not be generated because a base class assignment operator is inaccessible
44 #pragma warning(disable: 4191) // unsafe conversion from 'functionptr1' to 'functionptr2'
45
46
47 #pragma pack(push,_ATL_PACKING)
48 namespace ATL {
49
50 // Token types
51 // These tags are token tags for the standard tag replacer implementation
52 extern __declspec(selectany) const DWORD STENCIL_TEXTTAG = 0x00000000;
53 extern __declspec(selectany) const DWORD STENCIL_REPLACEMENT = 0x00000001;
54 extern __declspec(selectany) const DWORD STENCIL_ITERATORSTART = 0x00000002;
55 extern __declspec(selectany) const DWORD STENCIL_ITERATOREND = 0x00000003;
56 extern __declspec(selectany) const DWORD STENCIL_CONDITIONALSTART = 0x00000004;
57 extern __declspec(selectany) const DWORD STENCIL_CONDITIONALELSE = 0x00000005;
58 extern __declspec(selectany) const DWORD STENCIL_CONDITIONALEND = 0x00000006;
59 extern __declspec(selectany) const DWORD STENCIL_STENCILINCLUDE = 0x00000007;
60 extern __declspec(selectany) const DWORD STENCIL_STATICINCLUDE = 0x00000008;
61 extern __declspec(selectany) const DWORD STENCIL_LOCALE = 0x00000009;
62 extern __declspec(selectany) const DWORD STENCIL_CODEPAGE = 0x0000000a;
63
64 // The base for user defined token types
65 extern __declspec(selectany) const DWORD STENCIL_USER_TOKEN_BASE = 0x00001000;
66
67 // Symbols to use in error handling in the stencil processor
68 #define STENCIL_INVALIDINDEX 0xFFFFFFFF
69 #define STENCIL_INVALIDOFFSET 0xFFFFFFFF
70
71 // error codes
72 #define STENCIL_SUCCESS HTTP_SUCCESS
73 #define STENCL_FAIL HTTP_FAIL
74
75 #define STENCIL_BASIC_MAP 0
76 #define STENCIL_ATTR_MAP 1
77
78 #ifndef ATL_MAX_METHOD_NAME_LEN
79 #define ATL_MAX_METHOD_NAME_LEN 64
80 #endif
81
82 #ifndef ATL_MAX_BLOCK_STACK
83 #define ATL_MAX_BLOCK_STACK 128
84 #endif
85
86 template <class TBase, typename T>
87 struct CTagReplacerMethodsEx
88 {
89 typedef HTTP_CODE (TBase::*REPLACE_FUNC)();
90 typedef HTTP_CODE (TBase::*REPLACE_FUNC_EX)(T*);
91 typedef HTTP_CODE (TBase::*PARSE_FUNC)(IAtlMemMgr *, LPCSTR, T**);
92 typedef HTTP_CODE (TBase::*REPLACE_FUNC_EX_V)(void *);
93 typedef HTTP_CODE (TBase::*PARSE_FUNC_V)(IAtlMemMgr *, LPCSTR, void**);
94
95 static REPLACE_FUNC_EX_V CheckRepl(REPLACE_FUNC p) throw()
96 {
97 return (REPLACE_FUNC_EX_V) p;
98 }
99
100 static REPLACE_FUNC_EX_V CheckReplEx(REPLACE_FUNC_EX p) throw()
101 {
102 return (REPLACE_FUNC_EX_V) p;
103 }
104
105 static PARSE_FUNC_V CheckParse(PARSE_FUNC p) throw()
106 {
107 return (PARSE_FUNC_V) p;
108 }
109 };
110
111 template <class TBase>
112 struct CTagReplacerMethods
113 {
114 union
115 {
116 HTTP_CODE (TBase::*pfnMethodEx)(void *);
117 HTTP_CODE (TBase::*pfnMethod)();
118 };
119 HTTP_CODE (TBase::*pfnParse)(IAtlMemMgr *pMemMgr, LPCSTR, void **);
120 };
121
122 #define REPLACEMENT_ENTRY_DEFAULT 0
123 #define REPLACEMENT_ENTRY_ARGS 1
124
125 template <class TBase>
126 struct CTagReplacerMethodEntry
127 {
128 int nType; // REPLACEMENT_ENTRY_*
129 LPCSTR szMethodName;
130 CTagReplacerMethods<TBase> Methods;
131 };
132
133
134 #define BEGIN_REPLACEMENT_METHOD_MAP(className)\
135 public:\
136 void GetReplacementMethodMap(const ATL::CTagReplacerMethodEntry<className> ** ppOut) const\
137 {\
138 typedef className __className;\
139 static const ATL::CTagReplacerMethodEntry<className> methods[] = {
140
141 #define REPLACEMENT_METHOD_ENTRY(methodName, methodFunc)\
142 { 0, methodName, { ATL::CTagReplacerMethodsEx<__className, void>::CheckRepl(&__className::methodFunc), NULL } },
143
144 #define REPLACEMENT_METHOD_ENTRY_EX(methodName, methodFunc, paramType, parseFunc)\
145 { 1, methodName, { ATL::CTagReplacerMethodsEx<__className, paramType>::CheckReplEx(&__className::methodFunc), ATL::CTagReplacerMethodsEx<__className, paramType>::CheckParse(&__className::parseFunc) } },
146
147 #define REPLACEMENT_METHOD_ENTRY_EX_STR(methodName, methodFunc) \
148 { 1, methodName, { ATL::CTagReplacerMethodsEx<__className, char>::CheckReplEx(&__className::methodFunc), ATL::CTagReplacerMethodsEx<__className, char>::CheckParse(&__className::DefaultParseString) } },
149
150 #define END_REPLACEMENT_METHOD_MAP()\
151 { 0, NULL, NULL } };\
152 *ppOut = methods;\
153 }
154
155 #define BEGIN_ATTR_REPLACEMENT_METHOD_MAP(className)\
156 public:\
157 void GetAttrReplacementMethodMap(const CTagReplacerMethodEntry<className> ** ppOut) const\
158 {\
159 typedef className __className;\
160 static const ATL::CTagReplacerMethodEntry<className> methods[] = {
161
162 #define END_ATTR_REPLACEMENT_METHOD_MAP()\
163 { NULL, NULL, NULL } };\
164 *ppOut = methods;\
165 }
166
167 template <class T>
168 class ITagReplacerImpl : public ITagReplacer
169 {
170 protected:
171 IWriteStream *m_pStream;
172
173 public:
174 typedef HTTP_CODE (T::*REPLACEMENT_METHOD)();
175 typedef HTTP_CODE (T::*REPLACEMENT_METHOD_EX)(void *pvParam);
176
177 ITagReplacerImpl() throw()
178 :m_pStream(NULL)
179 {
180 }
181
182 IWriteStream *SetStream(IWriteStream *pStream)
183 {
184 IWriteStream *pRetStream = m_pStream;
185 m_pStream = pStream;
186 return pRetStream;
187 }
188
189 // Looks up the replacement method offset. Optionally, it will
190 // look up the replacement method and object offset of an alternate
191 // tag replacer.
192 HTTP_CODE FindReplacementOffset(
193 LPCSTR szMethodName,
194 DWORD *pdwMethodOffset,
195 LPCSTR szHandlerName,
196 DWORD *pdwHandlerOffset,
197 DWORD *pdwMap, void **ppvParam, IAtlMemMgr *pMemMgr)
198 {
199 ATLENSURE(szMethodName != NULL);
200 ATLENSURE(pdwMethodOffset != NULL);
201 ATLENSURE((szHandlerName == NULL && pdwHandlerOffset == NULL) ||
202 (szHandlerName != NULL && pdwHandlerOffset != NULL));
203 ATLENSURE(pdwMap != NULL);
204 ATLENSURE(ppvParam != NULL);
205 ATLENSURE(pMemMgr != NULL);
206
207 // we at least have to be looking up a method offset
208 if (!pdwMethodOffset || !szMethodName)
209 return AtlsHttpError(500, ISE_SUBERR_UNEXPECTED);
210
211 *pdwMethodOffset = STENCIL_INVALIDOFFSET;
212 HTTP_CODE hcErr = HTTP_FAIL;
213 T *pT = static_cast<T *>(this);
214
215 char szName[ATL_MAX_METHOD_NAME_LEN+1];
216
217 // if a handler name was supplied, we will try to
218 // find a different object to handle the method
219 if (szHandlerName && *szHandlerName)
220 {
221 if (!pdwHandlerOffset)
222 return AtlsHttpError(500, ISE_SUBERR_UNEXPECTED);
223
224 hcErr = pT->GetHandlerOffset(szHandlerName, pdwHandlerOffset);
225 // got the alternate handler, now look up the method offset on
226 // the handler.
227 if (!hcErr)
228 {
229 CComPtr<ITagReplacer> spAltTagReplacer;
230 hcErr = pT->GetReplacementObject(*pdwHandlerOffset, &spAltTagReplacer);
231 if (!hcErr)
232 hcErr = spAltTagReplacer->FindReplacementOffset(szMethodName, pdwMethodOffset,
233 NULL, NULL, pdwMap, ppvParam, pMemMgr);
234 return hcErr;
235 }
236 else
237 return hcErr;
238 }
239
240 if (!SafeStringCopy(szName, szMethodName))
241 {
242 return AtlsHttpError(500, ISE_SUBERR_LONGMETHODNAME);
243 }
244
245 // check for params
246 char *szLeftPar = strchr(szName, '(');
247 if (szLeftPar)
248 {
249 *szLeftPar = '\0';
250 szLeftPar++;
251
252 char *szRightPar = strchr(szLeftPar, ')');
253 if (!szRightPar)
254 return AtlsHttpError(500, ISE_SUBERR_UNEXPECTED);
255
256 *szRightPar = '\0';
257
258 szMethodName = szName;
259
260 }
261
262 // No handler name is specified, so we look up the method name in
263 // T's replacement method map
264 const CTagReplacerMethodEntry<T> *pEntry = NULL;
265 pT->GetReplacementMethodMap(&pEntry);
266
267 hcErr = FindReplacementOffsetInMap(szMethodName, pdwMethodOffset, pEntry);
268 if (hcErr != HTTP_SUCCESS)
269 {
270 pT->GetAttrReplacementMethodMap(&pEntry);
271 hcErr = FindReplacementOffsetInMap(szMethodName, pdwMethodOffset, pEntry);
272 if (hcErr == HTTP_SUCCESS)
273 *pdwMap = STENCIL_ATTR_MAP;
274 }
275 else
276 {
277 *pdwMap = STENCIL_BASIC_MAP;
278 }
279
280 // This assert will be triggered if arguments are passed to a replacement method that doesn't handle them
281 ATLASSERT( szLeftPar == NULL || (szLeftPar != NULL && (pEntry != NULL && pEntry[*pdwMethodOffset].Methods.pfnParse != NULL)) );
282
283 if (hcErr == HTTP_SUCCESS && pEntry && pEntry[*pdwMethodOffset].Methods.pfnParse)
284 hcErr = (pT->*pEntry[*pdwMethodOffset].Methods.pfnParse)(pMemMgr, szLeftPar, ppvParam);
285 return hcErr;
286 }
287
288 HTTP_CODE FindReplacementOffsetInMap(
289 LPCSTR szMethodName,
290 LPDWORD pdwMethodOffset,
291 const CTagReplacerMethodEntry<T> *pEntry) throw()
292 {
293 if (pEntry == NULL)
294 return HTTP_FAIL;
295
296 const CTagReplacerMethodEntry<T> *pEntryHead = pEntry;
297
298 while (pEntry->szMethodName)
299 {
300 if (strcmp(pEntry->szMethodName, szMethodName) == 0)
301 {
302 if (pEntry->Methods.pfnMethod)
303 {
304 *pdwMethodOffset = (DWORD)(pEntry-pEntryHead);
305 return HTTP_SUCCESS;
306 }
307 }
308 pEntry++;
309 }
310
311 return HTTP_FAIL;
312 }
313
314
315 // Used to render a single replacement tag into a stream.
316 // Looks up a pointer to a member function in user code by offseting into the users
317 // replacement map. Much faster than the other overload of this function since
318 // no string compares are performed.
319 HTTP_CODE RenderReplacement(DWORD dwFnOffset, DWORD dwObjOffset, DWORD dwMap, void *pvParam)
320 {
321 HTTP_CODE hcErr = HTTP_FAIL;
322 T *pT = static_cast<T *>(this);
323
324 // if we were not passed an object offset, then we assume
325 // that the function at dwFnOffset is in T's replacement
326 // map
327 if (dwObjOffset == STENCIL_INVALIDOFFSET)
328 {
329 // call a function in T's replacement map
330 ATLASSERT(dwFnOffset != STENCIL_INVALIDOFFSET);
331 const CTagReplacerMethodEntry<T> *pEntry = NULL;
332 if (dwMap == STENCIL_BASIC_MAP)
333 pT->GetReplacementMethodMap(&pEntry);
334 else
335 pT->GetAttrReplacementMethodMap(&pEntry);
336 if (pEntry)
337 {
338 if (pEntry[dwFnOffset].nType == REPLACEMENT_ENTRY_DEFAULT)
339 {
340 REPLACEMENT_METHOD pfn = NULL;
341 pfn = pEntry[dwFnOffset].Methods.pfnMethod;
342 ATLASSERT(pfn);
343 if (pfn)
344 {
345 hcErr = (pT->*pfn)();
346 }
347 }
348 else if (pEntry[dwFnOffset].nType == REPLACEMENT_ENTRY_ARGS)
349 {
350 REPLACEMENT_METHOD_EX pfn = NULL;
351 pfn = pEntry[dwFnOffset].Methods.pfnMethodEx;
352 ATLASSERT(pfn);
353 if (pfn)
354 {
355 hcErr = (pT->*pfn)(pvParam);
356 }
357 }
358 else
359 {
360 // unknown entry type
361 ATLASSERT(FALSE);
362 }
363 }
364 }
365 else
366 {
367 // otherwise, we were passed an object offset. The object
368 // offset is a dword ID that T can use to look up the
369 // ITagReplacer* of a tag replacer that will render this
370 // replacement.
371 CComPtr<ITagReplacer> spAltReplacer = NULL;
372 if (!pT->GetReplacementObject(dwObjOffset, &spAltReplacer))
373 {
374 spAltReplacer->SetStream(m_pStream);
375 hcErr = spAltReplacer->RenderReplacement(dwFnOffset, STENCIL_INVALIDOFFSET, dwMap, pvParam);
376 }
377 }
378 return hcErr;
379 }
380
381 // Default GetHandlerOffset, does nothing
382 HTTP_CODE GetHandlerOffset(LPCSTR /*szHandlerName*/, DWORD* pdwOffset)
383 {
384 if (pdwOffset)
385 *pdwOffset = 0;
386 return HTTP_FAIL;
387 }
388
389 // Default GetReplacementObject, does nothing
390 HTTP_CODE GetReplacementObject(DWORD /*dwObjOffset*/, ITagReplacer **ppReplacer)
391 {
392 if (ppReplacer)
393 *ppReplacer = NULL;
394 return HTTP_FAIL;
395 }
396
397 void GetReplacementMethodMap(const CTagReplacerMethodEntry<T> ** ppOut) const
398 {
399 static const CTagReplacerMethodEntry<T> methods[] = { { NULL, NULL } };
400 *ppOut = methods;
401 }
402
403 void GetAttrReplacementMethodMap(const CTagReplacerMethodEntry<T> **ppOut) const
404 {
405 static const CTagReplacerMethodEntry<T> methods[] = { { NULL, NULL } };
406 *ppOut = methods;
407 }
408
409 HRESULT GetContext(REFIID, void**)
410 {
411 return E_NOINTERFACE;
412 }
413
414 virtual HINSTANCE GetResourceInstance()
415 {
416 return GetModuleHandle(NULL);
417 }
418
419 HTTP_CODE DefaultParseString(IAtlMemMgr *pMemMgr, LPCSTR szParams, char **ppParam) throw(...)
420 {
421 ATLENSURE( pMemMgr != NULL );
422 ATLENSURE( szParams != NULL );
423 ATLENSURE( ppParam != NULL );
424
425 size_t nLen = strlen(szParams);
426 if (nLen)
427 {
428 nLen++;
429 *ppParam = (char *) pMemMgr->Allocate(nLen);
430 if (*ppParam)
431 Checked::memcpy_s(*ppParam, nLen, szParams, nLen);
432 else
433 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
434 }
435
436 return HTTP_SUCCESS;
437 }
438
439 HTTP_CODE DefaultParseUChar(IAtlMemMgr *pMemMgr, LPCSTR szParams, unsigned char **ppParam) throw(...)
440 {
441 ATLENSURE( pMemMgr != NULL );
442 ATLENSURE( szParams != NULL );
443 ATLENSURE( ppParam != NULL );
444
445 *ppParam = (unsigned char *) pMemMgr->Allocate(sizeof(unsigned char));
446 if (*ppParam)
447 {
448 char *szEnd;
449 **ppParam = (unsigned char) strtoul(szParams, &szEnd, 10);
450 }
451 else
452 {
453 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
454 }
455 return HTTP_SUCCESS;
456 }
457
458 HTTP_CODE DefaultParseShort(IAtlMemMgr *pMemMgr, LPCSTR szParams, short **ppParam) throw(...)
459 {
460 ATLENSURE( pMemMgr != NULL );
461 ATLENSURE( szParams != NULL );
462 ATLENSURE( ppParam != NULL );
463
464 *ppParam = (short *) pMemMgr->Allocate(sizeof(short));
465 if (*ppParam)
466 {
467 **ppParam = (short)atoi(szParams);
468 }
469 else
470 {
471 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
472 }
473 return HTTP_SUCCESS;
474 }
475
476 HTTP_CODE DefaultParseUShort(IAtlMemMgr *pMemMgr, LPCSTR szParams, unsigned short **ppParam) throw(...)
477 {
478 ATLENSURE( pMemMgr != NULL );
479 ATLENSURE( szParams != NULL );
480 ATLENSURE( ppParam != NULL );
481
482 *ppParam = (unsigned short *) pMemMgr->Allocate(sizeof(short));
483 if (*ppParam)
484 {
485 char *szEnd;
486 **ppParam = (unsigned short) strtoul(szParams, &szEnd, 10);
487 }
488 else
489 {
490 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
491 }
492 return HTTP_SUCCESS;
493 }
494
495 HTTP_CODE DefaultParseInt(IAtlMemMgr *pMemMgr, LPCSTR szParams, int **ppParam) throw(...)
496 {
497 ATLENSURE( pMemMgr != NULL );
498 ATLENSURE( szParams != NULL );
499 ATLENSURE( ppParam != NULL );
500
501 *ppParam = (int *) pMemMgr->Allocate(sizeof(int));
502 if (*ppParam)
503 {
504 **ppParam = atoi(szParams);
505 }
506 else
507 {
508 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
509 }
510 return HTTP_SUCCESS;
511 }
512
513 HTTP_CODE DefaultParseUInt(IAtlMemMgr *pMemMgr, LPCSTR szParams, unsigned int **ppParam) throw(...)
514 {
515 ATLENSURE( pMemMgr != NULL );
516 ATLENSURE( szParams != NULL );
517 ATLENSURE( ppParam != NULL );
518
519 *ppParam = (unsigned int *) pMemMgr->Allocate(sizeof(unsigned int));
520 if (*ppParam)
521 {
522 char *szEnd;
523 **ppParam = strtoul(szParams, &szEnd, 10);
524 }
525 else
526 {
527 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
528 }
529 return HTTP_SUCCESS;
530 }
531
532 HTTP_CODE DefaultParseInt64(IAtlMemMgr *pMemMgr, LPCSTR szParams, __int64 **ppParam) throw(...)
533 {
534 ATLENSURE( pMemMgr != NULL );
535 ATLENSURE( szParams != NULL );
536 ATLENSURE( ppParam != NULL );
537
538 *ppParam = (__int64 *) pMemMgr->Allocate(sizeof(__int64));
539 if (*ppParam)
540 {
541 **ppParam = _atoi64(szParams);
542 }
543 else
544 {
545 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
546 }
547 return HTTP_SUCCESS;
548 }
549
550 HTTP_CODE DefaultParseUInt64(IAtlMemMgr *pMemMgr, LPCSTR szParams, unsigned __int64 **ppParam) throw(...)
551 {
552 ATLENSURE( pMemMgr != NULL );
553 ATLENSURE( szParams != NULL );
554 ATLENSURE( ppParam != NULL );
555
556 *ppParam = (unsigned __int64 *) pMemMgr->Allocate(sizeof(unsigned __int64));
557 if (*ppParam)
558 {
559 char *szEnd;
560 **ppParam = _strtoui64(szParams, &szEnd, 10);
561 }
562 else
563 {
564 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
565 }
566 return HTTP_SUCCESS;
567 }
568
569 HTTP_CODE DefaultParseBool(IAtlMemMgr *pMemMgr, LPCSTR szParams, bool **ppParam) throw(...)
570 {
571 ATLENSURE( pMemMgr != NULL );
572 ATLENSURE( szParams != NULL );
573 ATLENSURE( ppParam != NULL );
574
575 *ppParam = (bool *) pMemMgr->Allocate(sizeof(bool));
576 if (*ppParam)
577 {
578 if (!_strnicmp(szParams, "true", sizeof("true")-sizeof('\0')))
579 **ppParam = true;
580 else
581 **ppParam = false;
582 }
583 else
584 {
585 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
586 }
587
588 return HTTP_SUCCESS;
589 }
590
591 HTTP_CODE DefaultParseDouble(IAtlMemMgr *pMemMgr, LPCSTR szParams, double **ppParam) throw(...)
592 {
593 ATLENSURE( pMemMgr != NULL );
594 ATLENSURE( szParams != NULL );
595 ATLENSURE( ppParam != NULL );
596
597 *ppParam = (double *) pMemMgr->Allocate(sizeof(double));
598 if (*ppParam)
599 {
600 **ppParam = atof(szParams);
601 }
602 else
603 {
604 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
605 }
606 return HTTP_SUCCESS;
607 }
608
609 HTTP_CODE DefaultParseFloat(IAtlMemMgr *pMemMgr, LPCSTR szParams, float **ppParam) throw(...)
610 {
611 ATLENSURE( pMemMgr != NULL );
612 ATLENSURE( szParams != NULL );
613 ATLENSURE( ppParam != NULL );
614
615 errno_t errnoValue = 0;
616 *ppParam = (float *) pMemMgr->Allocate(sizeof(float));
617 if (*ppParam)
618 {
619 errno_t saveErrno = Checked::get_errno();
620 Checked::set_errno(0);
621 **ppParam = (float) atof(szParams);
622 errnoValue = Checked::get_errno();
623 Checked::set_errno(saveErrno);
624 }
625 else
626 {
627 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
628 }
629 if ((**ppParam == -HUGE_VAL) || (**ppParam == HUGE_VAL) || (errnoValue == ERANGE))
630 {
631 return HTTP_FAIL;
632 }
633 return HTTP_SUCCESS;
634 }
635 };
636
637 inline LPCSTR SkipSpace(LPCSTR sz, WORD nCodePage) throw()
638 {
639 if (sz == NULL)
640 return NULL;
641
642 while (isspace(static_cast<unsigned char>(*sz)))
643 sz = CharNextExA(nCodePage, sz, 0);
644 return sz;
645 }
646
647 inline LPCSTR RSkipSpace(LPCSTR pStart, LPCSTR sz, WORD nCodePage) throw()
648 {
649 if (sz == NULL || pStart == NULL)
650 return NULL;
651
652 while (isspace(static_cast<unsigned char>(*sz)) && sz != pStart)
653 sz = CharPrevExA(nCodePage, pStart, sz, 0);
654 return sz;
655 }
656
657 //
658 // StencilToken
659 // The stencil class will create an array of these tokens during the parse
660 // phase and use them during rendering to render the stencil
661 struct StencilToken
662 {
663 LPCSTR pStart; // Start of fragment to be rendered
664 LPCSTR pEnd; // End of fragment to be rendered
665 DWORD type; // Type of token
666 DWORD dwFnOffset; // Offset into the replacement map for the handler function.
667 DWORD dwMap;
668 DWORD dwObjOffset; // An identifier for the caller to use in identifiying the
669 // object that will render this token.
670 CHAR szHandlerName[ATL_MAX_HANDLER_NAME_LEN + 1]; // Name of handler object.
671 CHAR szMethodName[ATL_MAX_METHOD_NAME_LEN + 1]; // Name of handler method.
672 DWORD dwLoopIndex; // Offset into array of StencilTokens of the other loop tag
673 DWORD_PTR dwData;
674 BOOL bDynamicAlloc;
675 };
676
677
678 //
679 // Class CStencil
680 // The CStencil class is used to map in a stencil from a file or resource
681 // and parse the stencil into an array of StencilTokens. We then render
682 // the stencil from the array of tokens. This class's parse and render
683 // functions depend on an IReplacementHandlerLookup interface pointer to be
684 // passed so it can retrieve the IReplacementHandler interface pointer of the
685 // handler object that will be called to render replacement tags
686 class CStencil :
687 public IMemoryCacheClient
688 {
689 private:
690 LPCSTR m_pBufferStart; // Beginning of CHAR buffer that holds the stencil.
691 // For mapped files this is the beginning of the mapping.
692 LPCSTR m_pBufferEnd; // End of CHAR buffer that holds the stencil.
693 CAtlArray<StencilToken> m_arrTokens; //An array of tokens.
694 FILETIME m_ftLastModified; // Last modified time (0 for resource)
695 FILETIME m_ftLastChecked; // Last time we retrieved last modified time (0 for resource)
696 HCACHEITEM m_hCacheItem;
697 WORD m_nCodePage;
698 BOOL m_bUseLocaleACP;
699 char m_szDllPath[MAX_PATH];
700 char m_szHandlerName[ATL_MAX_HANDLER_NAME_LEN+1]; // Room for the path, the handler
701 // the '/' and the '\0'
702 #ifdef ATL_DEBUG_STENCILS
703 struct ParseError
704 {
705 char m_szError[ATL_STENCIL_MAX_ERROR_LEN];
706 LPCSTR m_szPosition;
707 LPCSTR m_szStartLine;
708 LPCSTR m_szEndLine;
709 int m_nLineNumber;
710
711 bool operator==(const ParseError& that) const throw()
712 {
713 return (m_nLineNumber == that.m_nLineNumber);
714 }
715 };
716
717 CSimpleArray<ParseError> m_Errors;
718 HINSTANCE m_hResInst;
719
720 class CParseErrorProvider : public ITagReplacerImpl<CParseErrorProvider>,
721 public CComObjectRootEx<CComSingleThreadModel>
722 {
723 public:
724 BEGIN_COM_MAP(CParseErrorProvider)
725 COM_INTERFACE_ENTRY(ITagReplacer)
726 END_COM_MAP()
727 CSimpleArray<ParseError> *m_pErrors;
728 int m_nCurrentError;
729
730 CParseErrorProvider() throw() :
731 m_pErrors(NULL),
732 m_nCurrentError(-1)
733 {
734 }
735
736 void Initialize(CSimpleArray<ParseError> *pErrors) throw()
737 {
738 m_pErrors = pErrors;
739 }
740
741 HTTP_CODE OnGetNextError() throw()
742 {
743 m_nCurrentError++;
744 if (m_nCurrentError >= m_pErrors->GetSize() ||
745 m_nCurrentError < 0 )
746 {
747 m_nCurrentError = -1;
748 return HTTP_S_FALSE;
749 }
750 else
751 return HTTP_SUCCESS;
752 }
753
754 HTTP_CODE OnGetErrorLineNumber() throw(...)
755 {
756 if (m_pErrors->GetSize() == 0)
757 return HTTP_SUCCESS;
758 if (m_nCurrentError > m_pErrors->GetSize() ||
759 m_nCurrentError < 0)
760 m_nCurrentError = 0;
761
762 CWriteStreamHelper c(m_pStream);
763 if (!c.Write((*m_pErrors)[m_nCurrentError].m_nLineNumber))
764 return HTTP_FAIL;
765
766 return HTTP_SUCCESS;
767 }
768
769 HTTP_CODE OnGetErrorText() throw(...)
770 {
771 if (m_pErrors->GetSize() == 0)
772 return HTTP_SUCCESS;
773 if (m_nCurrentError > m_pErrors->GetSize() ||
774 m_nCurrentError < 0)
775 m_nCurrentError = 0;
776
777 CWriteStreamHelper c(m_pStream);
778
779 if (!c.Write(static_cast<LPCSTR>((*m_pErrors)[m_nCurrentError].m_szError)))
780 return HTTP_FAIL;
781
782 return HTTP_SUCCESS;
783 }
784
785 HTTP_CODE OnGetErrorLine() throw(...)
786 {
787 ATLASSUME(m_pStream != NULL);
788
789 if (m_pErrors->GetSize() == 0)
790 return HTTP_SUCCESS;
791 if (m_nCurrentError > m_pErrors->GetSize() ||
792 m_nCurrentError < 0)
793 m_nCurrentError = 0;
794
795 m_pStream->WriteStream((*m_pErrors)[m_nCurrentError].m_szStartLine,
796 (int)((*m_pErrors)[m_nCurrentError].m_szEndLine - (*m_pErrors)[m_nCurrentError].m_szStartLine), NULL);
797
798 return HTTP_SUCCESS;
799 }
800
801 BEGIN_REPLACEMENT_METHOD_MAP(CParseErrorProvider)
802 REPLACEMENT_METHOD_ENTRY("GetNextError", OnGetNextError)
803 REPLACEMENT_METHOD_ENTRY("GetErrorText", OnGetErrorText)
804 REPLACEMENT_METHOD_ENTRY("GetErrorLine", OnGetErrorLine)
805 REPLACEMENT_METHOD_ENTRY("GetErrorLineNumber", OnGetErrorLineNumber)
806 END_REPLACEMENT_METHOD_MAP()
807 };
808
809 #else
810 bool m_bErrorsOccurred;
811 #endif
812
813 class CSaveThreadLocale
814 {
815 LCID m_locale;
816 public:
817 CSaveThreadLocale() throw()
818 {
819 m_locale = GetThreadLocale();
820 }
821 ~CSaveThreadLocale() throw()
822 {
823 SetThreadLocale(m_locale);
824 }
825 };
826
827 HTTP_CODE LoadFromResourceInternal(HINSTANCE hInstRes, HRSRC hRsrc) throw()
828 {
829 ATLASSERT( hRsrc != NULL );
830
831 HGLOBAL hgResource = NULL;
832 hgResource = LoadResource(hInstRes, hRsrc);
833 if (!hgResource)
834 {
835 return HTTP_FAIL;
836 }
837
838 DWORD dwSize = SizeofResource(hInstRes, hRsrc);
839 if (dwSize != 0)
840 {
841 m_pBufferStart = (LPSTR)LockResource(hgResource);
842 if (m_pBufferStart != NULL)
843 {
844 m_pBufferEnd = m_pBufferStart+dwSize;
845 return HTTP_SUCCESS;
846 }
847 }
848
849 // failed to load resource
850 return HTTP_FAIL;
851 }
852
853 protected:
854
855 ITagReplacer *m_pReplacer;
856 IAtlMemMgr *m_pMemMgr;
857 static CCRTHeap m_crtHeap;
858
859 inline BOOL CheckTag(LPCSTR szTag, DWORD dwTagLen, LPCSTR szStart, DWORD dwLen) throw()
860 {
861 if (dwLen < dwTagLen)
862 return FALSE;
863
864 if (memcmp(szStart, szTag, dwTagLen))
865 return FALSE;
866
867 if (isspace(static_cast<unsigned char>(szStart[dwTagLen])) || szStart[dwTagLen] == '}')
868 return TRUE;
869
870 return FALSE;
871 }
872
873 inline void FindTagArgs(LPCSTR& szstart, LPCSTR& szend, int nKeywordChars) throw()
874 {
875 // this function should only be called after finding a valid tag
876 // the first two characters of szstart should be {{
877 ATLASSERT(szstart[0] == '{' && szstart[1] == '{');
878
879 if (*szstart == '{')
880 szstart += 2; // move past {{
881 szstart = SkipSpace(szstart, m_nCodePage); // move past whitespace
882 szstart += nKeywordChars; // move past keyword
883 szstart = SkipSpace(szstart, m_nCodePage); // move past whitespace after keyword
884 if (*szend == '}')
885 szend -=2; // chop off }}
886 szend = RSkipSpace(szstart, szend, m_nCodePage); // chop of trailing whitespace
887 }
888
889 DWORD CheckTopAndPop(DWORD *pBlockStack, DWORD *pdwTop, DWORD dwToken) throw()
890 {
891 if (*pdwTop == 0)
892 return STENCIL_INVALIDINDEX;
893 if (m_arrTokens[pBlockStack[*pdwTop]].type == dwToken)
894 {
895 *pdwTop = (*pdwTop) - 1;
896 return pBlockStack[(*pdwTop)+1];
897 }
898 return STENCIL_INVALIDINDEX;
899 }
900
901 DWORD PushToken(DWORD *pBlockStack, DWORD *pdwTop, DWORD dwIndex) throw()
902 {
903 if (*pdwTop < (ATL_MAX_BLOCK_STACK-1))
904 {
905 *pdwTop = (*pdwTop) + 1;
906 pBlockStack[*pdwTop] = dwIndex;
907 }
908 else
909 {
910 dwIndex = STENCIL_INVALIDINDEX;
911 }
912
913 return dwIndex;
914 }
915
916 public:
917
918 enum PARSE_TOKEN_RESULT { INVALID_TOKEN, NORMAL_TOKEN, RESERVED_TOKEN };
919
920 CStencil(IAtlMemMgr *pMemMgr=NULL) throw()
921 {
922 m_pBufferStart = NULL;
923 m_pBufferEnd = NULL;
924 m_hCacheItem = NULL;
925 m_ftLastModified.dwLowDateTime = 0;
926 m_ftLastModified.dwHighDateTime = 0;
927 m_ftLastChecked.dwLowDateTime = 0;
928 m_ftLastChecked.dwHighDateTime = 0;
929 m_arrTokens.SetCount(0, 128);
930 m_nCodePage = CP_ACP;
931 m_bUseLocaleACP = TRUE;
932 m_szHandlerName[0] = '\0';
933 m_szDllPath[0] = '\0';
934 m_pMemMgr = pMemMgr;
935 if (!pMemMgr)
936 m_pMemMgr = &m_crtHeap;
937 #ifdef ATL_DEBUG_STENCILS
938 m_hResInst = NULL;
939 #else
940 m_bErrorsOccurred = false;
941 #endif
942
943 }
944
945 virtual ~CStencil() throw()
946 {
947 Uninitialize();
948 }
949
950 #ifdef ATL_DEBUG_STENCILS
951
952 bool RenderErrors(IWriteStream *pStream) throw(...)
953 {
954 if (pStream == NULL)
955 {
956 return false;
957 }
958
959 CComObjectStackEx<CParseErrorProvider> Errors;
960
961 Errors.Initialize(&m_Errors);
962 CStencil ErrorStencil;
963
964 if (m_hResInst != NULL)
965 {
966 CFixedStringT<CStringA, 256> strErrorStencil;
967 _ATLTRY
968 {
969 if (strErrorStencil.LoadString(m_hResInst, IDS_STENCIL_ERROR_STENCIL) == FALSE)
970 {
971 return false;
972 }
973 }
974 _ATLCATCHALL()
975 {
976 return false;
977 }
978
979 HTTP_CODE hcRet = ErrorStencil.LoadFromString(strErrorStencil, strErrorStencil.GetLength());
980
981 if (hcRet == HTTP_SUCCESS)
982 {
983 if (ErrorStencil.ParseReplacements(static_cast<ITagReplacer *>(&Errors)) != false)
984 {
985 ErrorStencil.FinishParseReplacements();
986 if (ErrorStencil.ParseSuccessful() != false)
987 {
988 hcRet = ErrorStencil.Render(static_cast<ITagReplacer *>(&Errors), pStream);
989
990 if (HTTP_ERROR_CODE(hcRet) < 400)
991 {
992 return true;
993 }
994 }
995 }
996 }
997 }
998
999 return false;
1000 }
1001
1002 void SetErrorResource(HINSTANCE hResInst)
1003 {
1004 m_hResInst = hResInst;
1005 }
1006
1007 bool ParseSuccessful()
1008 {
1009 return (m_Errors.GetSize() == 0);
1010 }
1011
1012 bool AddErrorInternal(LPCSTR szErrorText, LPCSTR szPosition) throw()
1013 {
1014 int nLineNum = 0;
1015 LPCSTR szStartLine = NULL;
1016 LPCSTR szPtr = m_pBufferStart;
1017 while (szPtr < szPosition)
1018 {
1019 if (*szPtr == '\n')
1020 {
1021 szStartLine = szPtr + 1;
1022 nLineNum++;
1023 }
1024
1025 LPSTR szNext = CharNextExA(m_nCodePage, szPtr, 0);
1026 if (szNext == szPtr)
1027 {
1028 break;
1029 }
1030 szPtr = szNext;
1031 }
1032 LPCSTR szEndLine = szPtr;
1033 while (*szPtr)
1034 {
1035 if (*szPtr == '\n')
1036 break;
1037 szEndLine = szPtr;
1038 LPSTR szNext = CharNextExA(m_nCodePage, szPtr, 0);
1039 if (szNext == szPtr)
1040 {
1041 break;
1042 }
1043 szPtr = szNext;
1044 }
1045
1046 ParseError p;
1047 SafeStringCopy(p.m_szError, szErrorText);
1048 p.m_szPosition = szPosition;
1049 p.m_nLineNumber = nLineNum;
1050 p.m_szStartLine = szStartLine;
1051 p.m_szEndLine = szEndLine;
1052
1053 return (m_Errors.Add(p) == TRUE);
1054 }
1055
1056 bool AddError(UINT uID, LPCSTR szPosition) throw()
1057 {
1058 if (m_hResInst != NULL)
1059 {
1060 _ATLTRY
1061 {
1062 CFixedStringT<CStringA, 256> strRes;
1063 if (strRes.LoadString(m_hResInst, uID) != FALSE)
1064 {
1065 return AddErrorInternal(strRes, szPosition);
1066 }
1067 }
1068 _ATLCATCHALL()
1069 {
1070 }
1071 }
1072 return AddErrorInternal("Could not load resource for error string", szPosition);
1073 }
1074
1075 bool AddReplacementError(LPCSTR szReplacement, LPCSTR szPosition) throw()
1076 {
1077 if (m_hResInst != NULL)
1078 {
1079 _ATLTRY
1080 {
1081 CFixedStringT<CStringA, 256> strRes;
1082 if (strRes.LoadString(m_hResInst, IDS_STENCIL_UNRESOLVED_REPLACEMENT) != FALSE)
1083 {
1084 CFixedStringT<CStringA, 256> strErrorText;
1085 strErrorText.Format(strRes, szReplacement);
1086 return AddErrorInternal(strErrorText, szPosition);
1087 }
1088 else
1089 {
1090 return AddErrorInternal("Could not load resource for error string", szPosition);
1091 }
1092 }
1093 _ATLCATCHALL()
1094 {
1095 return false;
1096 }
1097 }
1098
1099 return false;
1100 }
1101
1102 #else
1103
1104 bool ParseSuccessful()
1105 {
1106 return !m_bErrorsOccurred;
1107 }
1108
1109 bool AddError(UINT /*uID*/, LPCSTR /*szPosition*/) throw()
1110 {
1111 m_bErrorsOccurred = true;
1112 return true;
1113 }
1114
1115 bool AddReplacementError(LPCSTR /*szReplacement*/, LPCSTR /*szPosition*/) throw()
1116 {
1117 m_bErrorsOccurred = true;
1118 return true;
1119 }
1120
1121 void SetErrorResource(HINSTANCE) throw()
1122 {
1123 }
1124
1125 #endif
1126
1127 // Call Uninitialize if you want to re-use an already initialized CStencil
1128 void Uninitialize() throw()
1129 {
1130 int nSize = (int) m_arrTokens.GetCount();
1131 for (int nIndex = 0; nIndex < nSize; nIndex++)
1132 {
1133 if (m_arrTokens[nIndex].bDynamicAlloc)
1134 delete [] m_arrTokens[nIndex].pStart;
1135 if (m_arrTokens[nIndex].dwData != 0 && m_arrTokens[nIndex].type != STENCIL_LOCALE)
1136 m_pMemMgr->Free((void *) m_arrTokens[nIndex].dwData);
1137 }
1138
1139 m_arrTokens.RemoveAll();
1140 if ((m_ftLastModified.dwLowDateTime || m_ftLastModified.dwHighDateTime) && m_pBufferStart)
1141 {
1142 delete [] m_pBufferStart;
1143 }
1144 m_pBufferStart = NULL;
1145 m_pBufferEnd = NULL;
1146 }
1147
1148 void GetLastModified(FILETIME *pftLastModified)
1149 {
1150 ATLENSURE(pftLastModified);
1151 *pftLastModified = m_ftLastModified;
1152 }
1153
1154 void GetLastChecked(FILETIME *pftLastChecked)
1155 {
1156 ATLENSURE(pftLastChecked);
1157 *pftLastChecked = m_ftLastChecked;
1158 }
1159
1160 void SetLastChecked(FILETIME *pftLastChecked)
1161 {
1162 ATLENSURE(pftLastChecked);
1163 m_ftLastChecked = *pftLastChecked;
1164 }
1165
1166 HCACHEITEM GetCacheItem()
1167 {
1168 return m_hCacheItem;
1169 }
1170
1171 void SetCacheItem(HCACHEITEM hCacheItem)
1172 {
1173 ATLASSUME(m_hCacheItem == NULL);
1174 m_hCacheItem = hCacheItem;
1175 }
1176
1177 bool GetHandlerName(__out_ecount_z(nPathLen) LPSTR szDllPath, __in size_t nPathLen, __out_ecount_z(nHandlerNameLen) LPSTR szHandlerName, __in size_t nHandlerNameLen) throw()
1178 {
1179 if(strlen(m_szDllPath) >= nPathLen)
1180 {
1181 return false;
1182 }
1183
1184 if(strlen(m_szHandlerName) >= nHandlerNameLen)
1185 {
1186 return false;
1187 }
1188
1189 if(0 != strcpy_s(szDllPath, nPathLen, m_szDllPath))
1190 {
1191 return false;
1192 }
1193
1194 if(0 != strcpy_s(szHandlerName, nHandlerNameLen, m_szHandlerName))
1195 {
1196 return false;
1197 }
1198
1199 return true;
1200 }
1201
1202 // Adds a token to the token array, handler name, method name
1203 // and handler function offset are optional
1204 ATL_NOINLINE DWORD AddToken(
1205 LPCSTR pStart,
1206 LPCSTR pEnd,
1207 DWORD dwType,
1208 LPCSTR szHandlerName = NULL,
1209 LPCSTR szMethodName = NULL,
1210 DWORD dwFnOffset = STENCIL_INVALIDOFFSET,
1211 DWORD dwObjOffset = STENCIL_INVALIDOFFSET,
1212 DWORD_PTR dwData = 0,
1213 DWORD dwMap = 0,
1214 BOOL bDynamicAlloc = 0) throw()
1215 {
1216 StencilToken t;
1217
1218 memset(&t, 0x00, sizeof(t));
1219
1220 t.pStart = pStart;
1221 t.pEnd = pEnd;
1222 t.type = dwType;
1223 t.dwLoopIndex = STENCIL_INVALIDINDEX;
1224 t.dwFnOffset = dwFnOffset;
1225 t.dwObjOffset = dwObjOffset;
1226 t.dwData = dwData;
1227 t.dwMap = dwMap;
1228 t.bDynamicAlloc = bDynamicAlloc;
1229
1230 // this should never assert unless the user has overriden something incorrectly
1231 if ((szHandlerName != NULL) && (*szHandlerName))
1232 {
1233 ATLVERIFY( SafeStringCopy(t.szHandlerName, szHandlerName) );
1234 }
1235 if ((szMethodName != NULL) && (*szMethodName))
1236 {
1237 ATLVERIFY( SafeStringCopy(t.szMethodName, szMethodName) );
1238 }
1239
1240 _ATLTRY
1241 {
1242 return (DWORD) m_arrTokens.Add(t);
1243 }
1244 _ATLCATCHALL()
1245 {
1246 return STENCIL_INVALIDINDEX;
1247 }
1248 }
1249
1250 HTTP_CODE LoadFromFile(LPCSTR szFileName) throw()
1251 {
1252 HRESULT hr = E_FAIL;
1253 ULONGLONG dwLen = 0;
1254 CAtlFile file;
1255
1256 _ATLTRY
1257 {
1258 hr = file.Create(CA2CTEX<MAX_PATH>(szFileName), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING);
1259 if (FAILED(hr) || GetFileType(file) != FILE_TYPE_DISK)
1260 return AtlsHttpError(500, ISE_SUBERR_STENCIL_LOAD_FAIL); // couldn't load SRF!
1261
1262 if (GetFileTime(file, NULL, NULL, &m_ftLastModified))
1263 {
1264 if (SUCCEEDED(file.GetSize(dwLen)))
1265 {
1266 ATLASSERT(!m_pBufferStart);
1267
1268 GetSystemTimeAsFileTime(&m_ftLastChecked);
1269
1270 m_pBufferStart = NULL;
1271 CAutoVectorPtr<char> buffer;
1272 if (!buffer.Allocate((size_t) dwLen))
1273 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM); // out of memory
1274
1275 DWORD dwRead = 0;
1276 hr = file.Read(buffer, (DWORD) dwLen, dwRead);
1277 if (FAILED(hr))
1278 return AtlsHttpError(500, ISE_SUBERR_READFILEFAIL); // ReadFile failed
1279
1280 m_pBufferStart = buffer.Detach();
1281 m_pBufferEnd = m_pBufferStart + dwRead;
1282 }
1283 }
1284 }
1285 _ATLCATCHALL()
1286 {
1287 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
1288 }
1289
1290 return HTTP_SUCCESS;
1291 }
1292
1293 // loads a stencil from the specified resource.
1294 HTTP_CODE LoadFromResource(HINSTANCE hInstRes, LPCSTR szID, LPCSTR szType = NULL) throw()
1295 {
1296 if (szType == NULL)
1297 {
1298 szType = (LPCSTR) RT_HTML;
1299 }
1300
1301 HRSRC hRsrc = FindResourceA(hInstRes, szID, szType);
1302 if (hRsrc != NULL)
1303 {
1304 return LoadFromResourceInternal(hInstRes, hRsrc);
1305 }
1306
1307 return HTTP_FAIL;
1308 }
1309
1310 HTTP_CODE LoadFromResourceEx(HINSTANCE hInstRes, LPCSTR szID, WORD wLanguage, LPCSTR szType = NULL) throw()
1311 {
1312 if (szType == NULL)
1313 {
1314 szType = (LPCSTR) RT_HTML;
1315 }
1316
1317 HRSRC hRsrc = FindResourceExA(hInstRes, szType, szID, wLanguage);
1318 if (hRsrc != NULL)
1319 {
1320 return LoadFromResourceInternal(hInstRes, hRsrc);
1321 }
1322
1323 return HTTP_FAIL;
1324 }
1325
1326 // loads a stencil from the specified resource
1327 HTTP_CODE LoadFromResource(HINSTANCE hInstRes, UINT nId, LPCSTR szType = NULL) throw()
1328 {
1329 return LoadFromResource(hInstRes, MAKEINTRESOURCEA(nId), szType);
1330 }
1331
1332 HTTP_CODE LoadFromResourceEx(HINSTANCE hInstRes, UINT nId, WORD wLanguage, LPCSTR szType = NULL) throw()
1333 {
1334 return LoadFromResourceEx(hInstRes, MAKEINTRESOURCEA(nId), wLanguage, szType);
1335 }
1336
1337 // loads a stencil from a string
1338 HTTP_CODE LoadFromString(LPCSTR szString, DWORD dwSize) throw()
1339 {
1340 m_pBufferStart = szString;
1341 m_pBufferEnd = m_pBufferStart+dwSize;
1342 return HTTP_SUCCESS;
1343 }
1344
1345 // Cracks the loaded stencil into an array of StencilTokens in preparation for
1346 // rendering. LoadStencil must be called prior to calling this function.
1347 virtual bool ParseReplacements(ITagReplacer* pReplacer) throw(...)
1348 {
1349 return ParseReplacementsFromBuffer(pReplacer, GetBufferStart(), GetBufferEnd());
1350 }
1351
1352 virtual bool FinishParseReplacements() throw(...)
1353 {
1354 DWORD dwSize = (DWORD) m_arrTokens.GetCount();
1355 for (DWORD dwIndex = 0; dwIndex < dwSize; dwIndex++)
1356 {
1357 StencilToken& token = m_arrTokens[dwIndex];
1358 bool bUnclosedBlock = ((token.type == STENCIL_CONDITIONALSTART ||
1359 token.type == STENCIL_CONDITIONALELSE ||
1360 token.type == STENCIL_ITERATORSTART) &&
1361 token.dwLoopIndex == STENCIL_INVALIDINDEX);
1362 if ((token.szMethodName[0] && token.dwFnOffset == STENCIL_INVALIDOFFSET) || bUnclosedBlock)
1363 {
1364 if (bUnclosedBlock ||
1365 m_pReplacer->FindReplacementOffset(
1366 token.szMethodName, &token.dwFnOffset,
1367 token.szHandlerName, &token.dwObjOffset,
1368 &token.dwMap, (void **)(&token.dwData), m_pMemMgr) != HTTP_SUCCESS)
1369 {
1370 if (bUnclosedBlock && token.type == STENCIL_CONDITIONALSTART)
1371 {
1372 AddError(IDS_STENCIL_UNCLOSEDBLOCK_IF, token.pStart);
1373 }
1374 else if (bUnclosedBlock && token.type == STENCIL_CONDITIONALELSE)
1375 {
1376 AddError(IDS_STENCIL_UNCLOSEDBLOCK_ELSE, token.pStart);
1377 }
1378 else if (bUnclosedBlock && token.type == STENCIL_ITERATORSTART)
1379 {
1380 AddError(IDS_STENCIL_UNCLOSEDBLOCK_WHILE, token.pStart);
1381 }
1382 else
1383 {
1384 AddReplacementError(token.szMethodName, token.pStart);
1385 }
1386
1387 // unresolved replacement, convert it to a text token
1388 token.type = STENCIL_TEXTTAG;
1389
1390 // convert all linked tokens to text tokens as well
1391 // this includes: endif, else, endwhile
1392 DWORD dwLoopIndex = token.dwLoopIndex;
1393 while (dwLoopIndex != dwIndex && dwLoopIndex != STENCIL_INVALIDINDEX)
1394 {
1395 m_arrTokens[dwLoopIndex].type = STENCIL_TEXTTAG;
1396 dwLoopIndex = m_arrTokens[dwLoopIndex].dwLoopIndex;
1397 }
1398 }
1399 }
1400 }
1401
1402 return ParseSuccessful();
1403 }
1404
1405 virtual bool Parse(ITagReplacer *pReplacer) throw( ... )
1406 {
1407 if (ParseReplacements(pReplacer))
1408 {
1409 return FinishParseReplacements();
1410 }
1411 return false;
1412 }
1413
1414
1415 DWORD ParseReplacement( LPCSTR szTokenStart,
1416 LPCSTR szTokenEnd,
1417 DWORD dwTokenType = STENCIL_REPLACEMENT,
1418 DWORD dwKeywordLen = 0) throw()
1419 {
1420 // hold on to the start and end pointers (before removing curlies and whitespace)
1421 // this is needed so that we can convert the token to a text token if the method
1422 // is not resolved (in FinishParseReplacements)
1423 LPCSTR szStart = szTokenStart;
1424 LPCSTR szEnd = szTokenEnd;
1425
1426 FindTagArgs(szTokenStart, szTokenEnd, dwKeywordLen);
1427
1428 char szMethodName[ATL_MAX_METHOD_NAME_LEN+1];
1429 char szHandlerName[ATL_MAX_HANDLER_NAME_LEN+1];
1430
1431 DWORD dwIndex;
1432 //look up the handler name, method name and handler interface
1433 if (HTTP_SUCCESS == GetHandlerAndMethodNames(szTokenStart, szTokenEnd,
1434 szMethodName, ATL_MAX_METHOD_NAME_LEN+1,
1435 szHandlerName, ATL_MAX_HANDLER_NAME_LEN+1))
1436 dwIndex = AddToken(szStart, szEnd, dwTokenType,
1437 szHandlerName, szMethodName,
1438 STENCIL_INVALIDINDEX, STENCIL_INVALIDINDEX,
1439 0, STENCIL_BASIC_MAP);
1440 else
1441 dwIndex = STENCIL_INVALIDINDEX;
1442 return dwIndex;
1443 }
1444
1445 DWORD ParseWhile(LPCSTR szTokenStart, LPCSTR szTokenEnd, DWORD *pBlockStack, DWORD *pdwTop) throw()
1446 {
1447 DWORD dwIndex = ParseReplacement(szTokenStart, szTokenEnd, STENCIL_ITERATORSTART, sizeof("while")-1);
1448 if (dwIndex == STENCIL_INVALIDINDEX)
1449 return dwIndex;
1450 return PushToken(pBlockStack, pdwTop, dwIndex);
1451 }
1452
1453 DWORD ParseEndWhile(LPCSTR szTokenStart, LPCSTR szTokenEnd, DWORD *pBlockStack, DWORD *pdwTop) throw()
1454 {
1455 DWORD dwTopIndex = CheckTopAndPop(pBlockStack, pdwTop, STENCIL_ITERATORSTART);
1456 if (dwTopIndex == STENCIL_INVALIDINDEX)
1457 {
1458 AddError(IDS_STENCIL_UNOPENEDBLOCK_ENDWHILE, szTokenStart);
1459 return dwTopIndex;
1460 }
1461
1462 DWORD dwIndex = AddToken(szTokenStart, szTokenEnd, STENCIL_ITERATOREND);
1463 if (dwIndex != STENCIL_INVALIDINDEX)
1464 {
1465 m_arrTokens[dwTopIndex].dwLoopIndex = dwIndex;
1466 m_arrTokens[dwIndex].dwLoopIndex = dwTopIndex;
1467 }
1468 return dwIndex;
1469 }
1470
1471 DWORD ParseIf(LPCSTR szTokenStart, LPCSTR szTokenEnd, DWORD *pBlockStack, DWORD *pdwTop) throw()
1472 {
1473 DWORD dwIndex = ParseReplacement(szTokenStart, szTokenEnd, STENCIL_CONDITIONALSTART, sizeof("if")-1);
1474 if (dwIndex == STENCIL_INVALIDINDEX)
1475 return dwIndex;
1476 return PushToken(pBlockStack, pdwTop, dwIndex);
1477 }
1478
1479 DWORD ParseElse(LPCSTR szTokenStart, LPCSTR szTokenEnd, DWORD *pBlockStack, DWORD *pdwTop) throw()
1480 {
1481 DWORD dwTopIndex = CheckTopAndPop(pBlockStack, pdwTop, STENCIL_CONDITIONALSTART);
1482 if (dwTopIndex == STENCIL_INVALIDINDEX)
1483 {
1484 AddError(IDS_STENCIL_UNOPENEDBLOCK_ELSE, szTokenStart);
1485 return dwTopIndex;
1486 }
1487
1488 DWORD dwIndex = AddToken(szTokenStart, szTokenEnd, STENCIL_CONDITIONALELSE);
1489 if (dwIndex != STENCIL_INVALIDINDEX)
1490 {
1491 m_arrTokens[dwTopIndex].dwLoopIndex = dwIndex;
1492
1493 return PushToken(pBlockStack, pdwTop, dwIndex);
1494 }
1495 return dwIndex;
1496 }
1497
1498 DWORD ParseEndIf(LPCSTR szTokenStart, LPCSTR szTokenEnd, DWORD *pBlockStack, DWORD *pdwTop) throw()
1499 {
1500 DWORD dwTopIndex = CheckTopAndPop(pBlockStack, pdwTop, STENCIL_CONDITIONALSTART);
1501 if (dwTopIndex == STENCIL_INVALIDINDEX)
1502 {
1503 dwTopIndex = CheckTopAndPop(pBlockStack, pdwTop, STENCIL_CONDITIONALELSE);
1504 if (dwTopIndex == STENCIL_INVALIDINDEX)
1505 {
1506 AddError(IDS_STENCIL_UNOPENEDBLOCK_ENDIF, szTokenStart);
1507 return dwTopIndex;
1508 }
1509 }
1510 DWORD dwIndex = AddToken(szTokenStart, szTokenEnd, STENCIL_CONDITIONALEND);
1511 if (dwIndex != STENCIL_INVALIDINDEX)
1512 {
1513 m_arrTokens[dwTopIndex].dwLoopIndex = dwIndex;
1514 }
1515 return dwIndex;
1516 }
1517
1518 DWORD ParseLocale(LPCSTR szTokenStart, LPCSTR szTokenEnd) throw()
1519 {
1520 LPCSTR szstart = szTokenStart;
1521 LPCSTR szend = szTokenEnd;
1522 LCID locale = 0xFFFFFFFF;
1523 FindTagArgs(szstart, szend, 6);
1524 #ifndef ATL_NO_MLANG
1525 if (isdigit(static_cast<unsigned char>(szstart[0])))
1526 {
1527 locale = (LCID) atoi(szstart);
1528 }
1529 else
1530 {
1531 HRESULT hr;
1532
1533 CComPtr<IMultiLanguage> pML;
1534 hr = pML.CoCreateInstance(__uuidof(CMultiLanguage), NULL, CLSCTX_INPROC_SERVER);
1535 if (FAILED(hr))
1536 {
1537 ATLTRACE(atlTraceStencil, 0, _T("Couldn't create CMultiLanguage object. check MLANG installation."));
1538 AddError(IDS_STENCIL_MLANG_COCREATE, szTokenStart);
1539 }
1540 else
1541 {
1542 CStringW str(szstart, (int)((szend-szstart)+1));
1543
1544 #ifdef __IMultiLanguage2_INTERFACE_DEFINED__
1545
1546 // use IMultiLanguage2 if possible
1547 CComPtr<IMultiLanguage2> spML2;
1548 hr = pML.QueryInterface(&spML2);
1549 if (FAILED(hr) || !spML2.p)
1550 hr = pML->GetLcidFromRfc1766(&locale, CComBSTR(str));
1551 else
1552 hr = spML2->GetLcidFromRfc1766(&locale, CComBSTR(str));
1553
1554 #else // __IMultiLanguage2_INTERFACE_DEFINED__
1555
1556 hr = pML->GetLcidFromRfc1766(&locale, CComBSTR(str));
1557
1558 #endif // __IMultiLanguage2_INTERFACE_DEFINED__
1559
1560 if (FAILED(hr))
1561 {
1562 AddError(IDS_STENCIL_MLANG_LCID, szTokenStart);
1563 }
1564 }
1565 if (FAILED(hr))
1566 locale = 0xFFFFFFFF;
1567 }
1568 #else
1569 locale = (LCID) atoi(szstart);
1570 #endif
1571
1572 if (m_bUseLocaleACP)
1573 {
1574 TCHAR szACP[7];
1575 if (GetLocaleInfo(locale, LOCALE_IDEFAULTANSICODEPAGE, szACP, 7) != 0)
1576 {
1577 m_nCodePage = (WORD) _ttoi(szACP);
1578 }
1579 else
1580 {
1581 AddError(IDS_STENCIL_MLANG_GETLOCALE, szTokenStart);
1582 }
1583 }
1584 DWORD dwCurrentTokenIndex = STENCIL_INVALIDINDEX;
1585 if (locale != 0xFFFFFFFF)
1586 dwCurrentTokenIndex = AddToken(NULL, NULL, STENCIL_LOCALE,
1587 NULL, NULL, STENCIL_INVALIDOFFSET, STENCIL_INVALIDOFFSET, locale);
1588 else
1589 return STENCIL_INVALIDINDEX;
1590 return dwCurrentTokenIndex;
1591 }
1592
1593 DWORD ParseCodepage(LPCSTR szTokenStart, LPCSTR szTokenEnd) throw()
1594 {
1595 LPCSTR szstart = szTokenStart;
1596 LPCSTR szend = szTokenEnd;
1597 WORD nCodePage = 0xFFFF;
1598
1599 FindTagArgs(szstart, szend, 8);
1600 #ifndef ATL_NO_MLANG
1601 if (isdigit(static_cast<unsigned char>(szstart[0])))
1602 {
1603 nCodePage = (WORD) atoi(szstart);
1604 }
1605 else
1606 {
1607 HRESULT hr;
1608
1609 CComPtr<IMultiLanguage> pML;
1610 hr = pML.CoCreateInstance(__uuidof(CMultiLanguage), NULL, CLSCTX_INPROC_SERVER);
1611 if (FAILED(hr))
1612 {
1613 ATLTRACE(atlTraceStencil, 0, _T("Couldn't create CMultiLanguage object. check MLANG installation."));
1614 AddError(IDS_STENCIL_MLANG_COCREATE, szTokenStart);
1615 }
1616 else
1617 {
1618 CStringW str(szstart, (int)((szend-szstart)+1));
1619 MIMECSETINFO info;
1620
1621 #ifdef __IMultiLanguage2_INTERFACE_DEFINED__
1622
1623 // use IMultiLanguage2 if possible
1624 CComPtr<IMultiLanguage2> spML2;
1625 hr = pML.QueryInterface(&spML2);
1626 if (FAILED(hr) || !spML2.p)
1627 hr = pML->GetCharsetInfo(CComBSTR(str), &info);
1628 else
1629 hr = spML2->GetCharsetInfo(CComBSTR(str), &info);
1630
1631 #else // __IMultiLanguage2_INTERFACE_DEFINED__
1632
1633 hr = pML->GetCharsetInfo(CComBSTR(str), &info);
1634
1635 #endif // __IMultiLanguage2_INTERFACE_DEFINED__
1636
1637 // for most character sets, uiCodePage and uiInternetEncoding
1638 // are the same. UTF-8 is the exception that we're concerned about.
1639 // for that character set, we want uiInternetEncoding (65001 - UTF-8)
1640 // instead of uiCodePage (1200 - UCS-2)
1641 if (SUCCEEDED(hr))
1642 {
1643 nCodePage = (WORD) info.uiInternetEncoding;
1644 }
1645 else
1646 {
1647 AddError(IDS_STENCIL_MLANG_GETCHARSET, szTokenStart);
1648 }
1649 }
1650 if (FAILED(hr))
1651 nCodePage = 0xFFFF;
1652 }
1653 #else
1654 nCodePage = (WORD) atoi(szstart);
1655 #endif
1656 if (nCodePage != 0xFFFF)
1657 m_nCodePage = nCodePage;
1658 m_bUseLocaleACP = FALSE;
1659
1660 return STENCIL_INVALIDINDEX;
1661 }
1662
1663 PARSE_TOKEN_RESULT ParseHandler(LPCSTR szTokenStart, LPCSTR szTokenEnd) throw()
1664 {
1665 LPCSTR szstart = szTokenStart;
1666 LPCSTR szend = szTokenEnd;
1667
1668 if (m_szHandlerName[0] && m_szDllPath[0])
1669 return RESERVED_TOKEN; // already found the handler and path dll names
1670
1671 FindTagArgs(szstart, szend, 7);
1672 size_t nlen = (szend-szstart)+1;
1673 char szHandlerDllName[MAX_PATH + ATL_MAX_HANDLER_NAME_LEN + 1];
1674 if (nlen < MAX_PATH + ATL_MAX_HANDLER_NAME_LEN + 1)
1675 {
1676 Checked::memcpy_s(szHandlerDllName, MAX_PATH + ATL_MAX_HANDLER_NAME_LEN + 1, szstart, szend-szstart+1);
1677 szHandlerDllName[szend-szstart+1] = '\0';
1678
1679 DWORD dwDllPathLen = MAX_PATH;
1680 DWORD dwHandlerNameLen = ATL_MAX_HANDLER_NAME_LEN+1;
1681
1682 if (!_AtlCrackHandler(szHandlerDllName, m_szDllPath, &dwDllPathLen, m_szHandlerName, &dwHandlerNameLen))
1683 {
1684 AddError(IDS_STENCIL_INVALID_HANDLER, szTokenStart);
1685 return INVALID_TOKEN;
1686 }
1687 }
1688
1689 return RESERVED_TOKEN;
1690 }
1691
1692 virtual PARSE_TOKEN_RESULT ParseToken(LPCSTR szTokenStart, LPCSTR szTokenEnd, DWORD *pBlockStack, DWORD *pdwTop)
1693 {
1694 LPCSTR pStart = szTokenStart;
1695 pStart += 2; //skip curlies
1696 pStart = SkipSpace(pStart, m_nCodePage);
1697 DWORD dwLen = (DWORD)(szTokenEnd - szTokenStart);
1698
1699 DWORD dwIndex = STENCIL_INVALIDINDEX;
1700 PARSE_TOKEN_RESULT ret = RESERVED_TOKEN;
1701
1702 if (CheckTag("endwhile", 8, pStart, dwLen))
1703 dwIndex = ParseEndWhile(szTokenStart, szTokenEnd, pBlockStack, pdwTop);
1704 else if (CheckTag("while", 5, pStart, dwLen))
1705 dwIndex = ParseWhile(szTokenStart, szTokenEnd, pBlockStack, pdwTop);
1706 else if (CheckTag("endif", 5, pStart, dwLen))
1707 dwIndex = ParseEndIf(szTokenStart, szTokenEnd, pBlockStack, pdwTop);
1708 else if (CheckTag("else", 4, pStart, dwLen))
1709 dwIndex = ParseElse(szTokenStart, szTokenEnd, pBlockStack, pdwTop);
1710 else if (CheckTag("if", 2, pStart, dwLen))
1711 dwIndex = ParseIf(szTokenStart, szTokenEnd, pBlockStack, pdwTop);
1712 else if (CheckTag("locale", 6, pStart, dwLen))
1713 dwIndex = ParseLocale(szTokenStart, szTokenEnd);
1714 else if (CheckTag("handler", 7, pStart, dwLen))
1715 {
1716 return ParseHandler(szTokenStart, szTokenEnd);
1717 }
1718 else if (CheckTag("codepage", 8, pStart, dwLen))
1719 {
1720 ParseCodepage(szTokenStart, szTokenEnd);
1721 return RESERVED_TOKEN;
1722 }
1723 else
1724 {
1725 dwIndex = ParseReplacement(szTokenStart, szTokenEnd, STENCIL_REPLACEMENT);
1726 if (dwIndex == STENCIL_INVALIDINDEX)
1727 return INVALID_TOKEN;
1728 ret = NORMAL_TOKEN;
1729 }
1730
1731 if (dwIndex == STENCIL_INVALIDINDEX)
1732 return INVALID_TOKEN;
1733 return ret;
1734 }
1735
1736 virtual bool ParseReplacementsFromBuffer(ITagReplacer* pReplacer, LPCSTR pStart, LPCSTR pEnd)
1737 {
1738 LPCSTR szCurr = pStart;
1739 DWORD BlockStack[ATL_MAX_BLOCK_STACK];
1740 DWORD dwTop = 0;
1741
1742 m_pReplacer = pReplacer;
1743
1744 DWORD dwCurrentTokenIndex = 0;
1745
1746 if (!szCurr)
1747 {
1748 ATLASSERT(FALSE);
1749 AddError(IDS_STENCIL_NULLPARAM, NULL);
1750 return false;
1751 }
1752
1753 LPCSTR szEnd = pEnd;
1754 if (szEnd <= szCurr)
1755 {
1756 ATLASSERT(FALSE);
1757 AddError(IDS_STENCIL_INVALIDSTRING, NULL);
1758 return true;
1759 }
1760
1761 while(szCurr < szEnd)
1762 {
1763 //mark the start of this block, then find the end of the block
1764 //the end is denoted by an opening curly
1765 LPCSTR szStart = szCurr;
1766 while (szCurr < szEnd && (*szCurr != '{' || szCurr[1] != '{'))
1767 {
1768 LPSTR szNext = CharNextExA(m_nCodePage, szCurr, 0);
1769 if (szNext == szCurr)
1770 {
1771 // embedded null
1772 AddError(IDS_STENCIL_EMBEDDED_NULL, NULL);
1773 return true;
1774 }
1775 szCurr = szNext;
1776 }
1777
1778 //special case for the last text block, if there is one
1779 if (szCurr >= szEnd)
1780 {
1781 // add the last token. This is everything after the last
1782 // double curly block, which is text.
1783 dwCurrentTokenIndex = AddToken(szStart, szEnd-1, STENCIL_TEXTTAG);
1784 break;
1785 }
1786
1787 //if there are any characters between szStart and szCurr inclusive,
1788 //copy them to a text token.
1789 if (szCurr-1 >= szStart)
1790 dwCurrentTokenIndex = AddToken(szStart, szCurr-1, STENCIL_TEXTTAG);
1791
1792 if (dwCurrentTokenIndex == STENCIL_INVALIDINDEX)
1793 {
1794 AddError(IDS_STENCIL_OUTOFMEMORY, pStart);
1795 return false;
1796 }
1797
1798 //find the end of the tag
1799 LPSTR szEndTag;
1800 szStart = szCurr;
1801 szCurr += 2; // Skip over the two '{' s
1802 while (szCurr < szEnd)
1803 {
1804 if (szCurr[0] == '}' && szCurr[1] == '}')
1805 break;
1806 else if (szCurr[0] == '{')
1807 break;
1808
1809 LPSTR szNext = CharNextExA(m_nCodePage, szCurr, 0);
1810 if (szNext == szCurr)
1811 {
1812 // embedded null
1813 AddError(IDS_STENCIL_EMBEDDED_NULL, NULL);
1814 return true;
1815 }
1816 szCurr = szNext;
1817 }
1818
1819 if (szCurr >= szEnd)
1820 {
1821 AddError(IDS_STENCIL_UNMATCHED_TAG_START, szStart);
1822 if (AddToken(szStart, szCurr-1, STENCIL_TEXTTAG) == STENCIL_INVALIDINDEX)
1823 {
1824 AddError(IDS_STENCIL_OUTOFMEMORY, pStart);
1825 return false;
1826 }
1827
1828 break;
1829 }
1830
1831 if (szCurr[0] == '{')
1832 {
1833 if (szCurr[1] != '{')
1834 {
1835 szCurr--;
1836 }
1837 AddError(IDS_STENCIL_MISMATCHED_TAG_START, szStart);
1838 if (AddToken(szStart, szCurr-1, STENCIL_TEXTTAG) == STENCIL_INVALIDINDEX)
1839 {
1840 AddError(IDS_STENCIL_OUTOFMEMORY, pStart);
1841 return false;
1842 }
1843
1844 continue;
1845 }
1846
1847 szEndTag = CharNextExA(m_nCodePage, szCurr, 0);
1848 if (szEndTag == szCurr)
1849 {
1850 // embedded null
1851 AddError(IDS_STENCIL_EMBEDDED_NULL, NULL);
1852 return true;
1853 }
1854
1855 PARSE_TOKEN_RESULT ret = ParseToken(szStart, szEndTag, BlockStack, &dwTop);
1856
1857 if (ret == INVALID_TOKEN)
1858 {
1859 dwCurrentTokenIndex = AddToken(szStart, szEndTag, STENCIL_TEXTTAG);
1860 if (dwCurrentTokenIndex == STENCIL_INVALIDINDEX)
1861 {
1862 AddError(IDS_STENCIL_OUTOFMEMORY, pStart);
1863 return false;
1864 }
1865
1866 szCurr = CharNextExA(m_nCodePage, szEndTag, 0);
1867 continue;
1868 }
1869
1870 szCurr = CharNextExA(m_nCodePage, szEndTag, 0);
1871 if (szEndTag == szCurr)
1872 {
1873 // embedded null
1874 AddError(IDS_STENCIL_EMBEDDED_NULL, NULL);
1875 return true;
1876 }
1877
1878 if (ret == RESERVED_TOKEN)
1879 {
1880 if (szCurr < szEnd && *szCurr == '\n')
1881 szCurr++;
1882 else if ((szCurr+1 < szEnd && *szCurr == '\r' && *(szCurr+1) == '\n'))
1883 szCurr += 2;
1884 }
1885 }
1886
1887 return true;
1888 }
1889
1890 HTTP_CODE GetHandlerAndMethodNames(
1891 __in LPCSTR pStart,
1892 __in LPCSTR pEnd,
1893 __out_ecount_z(nMethodNameLen) LPSTR pszMethodName,
1894 __in size_t nMethodNameLen,
1895 __out_ecount_z(nHandlerNameLen) LPSTR pszHandlerName,
1896 __in size_t nHandlerNameLen) throw()
1897 {
1898
1899 ATLASSERT(pStart);
1900 ATLASSERT(pEnd);
1901 ATLASSERT(pEnd > pStart);
1902
1903 if (!pszMethodName || !pszHandlerName || nMethodNameLen < 1 || nHandlerNameLen < 1)
1904 {
1905 ATLASSERT(FALSE);
1906 AddError(IDS_STENCIL_BAD_PARAMETER, pStart);
1907 return AtlsHttpError(500, ISE_SUBERR_UNEXPECTED);
1908 }
1909
1910
1911 *pszMethodName = '\0';
1912 *pszHandlerName = '\0';
1913 CHAR szMethodString[ATL_MAX_METHOD_NAME_LEN + ATL_MAX_HANDLER_NAME_LEN+1];
1914 HTTP_CODE hcErr = HTTP_SUCCESS;
1915 //
1916 // copy the method string
1917 //
1918 size_t nMethodLen = (pEnd-pStart)+1;
1919 if (nMethodLen >= (ATL_MAX_METHOD_NAME_LEN + ATL_MAX_HANDLER_NAME_LEN+1))
1920 {
1921 AddError(IDS_STENCIL_METHODNAME_TOO_LONG, pStart);
1922 return AtlsHttpError(500, ISE_SUBERR_LONGMETHODNAME);
1923 }
1924
1925 Checked::memcpy_s(szMethodString, ATL_MAX_METHOD_NAME_LEN + ATL_MAX_HANDLER_NAME_LEN+1, pStart, nMethodLen);
1926 szMethodString[nMethodLen] = '\0';
1927
1928 //
1929 // now crack the method string and get the handler
1930 // id and function name
1931 //
1932 LPSTR szParen = strchr(szMethodString, '(');
1933 LPSTR szDot = strchr(szMethodString, '.');
1934 if (szDot && (!szParen || (szDot < szParen)))
1935 {
1936 *szDot = '\0';
1937 szDot++;
1938
1939 // copy method name
1940 if (strlen(szDot) < nMethodNameLen)
1941 Checked::strcpy_s(pszMethodName, nMethodNameLen, szDot);
1942 else
1943 {
1944 AddError(IDS_STENCIL_METHODNAME_TOO_LONG, pStart + (szDot - szMethodString));
1945 hcErr = AtlsHttpError(500, ISE_SUBERR_LONGMETHODNAME);
1946 }
1947 // copy handler name
1948 if (!hcErr)
1949 {
1950 if (strlen(szMethodString) < nHandlerNameLen)
1951 Checked::strcpy_s(pszHandlerName, nHandlerNameLen, szMethodString);
1952 else
1953 {
1954 AddError(IDS_STENCIL_HANDLERNAME_TOO_LONG, pStart);
1955 hcErr = AtlsHttpError(500, ISE_SUBERR_LONGHANDLERNAME);
1956 }
1957 }
1958 }
1959 else
1960 {
1961 // only a method name so just copy it.
1962 if (strlen(szMethodString) < nMethodNameLen)
1963 Checked::strcpy_s(pszMethodName, nMethodNameLen, szMethodString);
1964 else
1965 {
1966 AddError(IDS_STENCIL_METHODNAME_TOO_LONG, pStart);
1967 hcErr = AtlsHttpError(500, ISE_SUBERR_LONGMETHODNAME);
1968 }
1969 }
1970 return hcErr;
1971 }
1972
1973 virtual HTTP_CODE Render(
1974 ITagReplacer *pReplacer,
1975 IWriteStream *pWriteStream,
1976 CStencilState* pState = NULL) const throw(...)
1977 {
1978 ATLENSURE(pReplacer != NULL);
1979 ATLENSURE(pWriteStream != NULL);
1980
1981 HTTP_CODE hcErrorCode = HTTP_SUCCESS;
1982 DWORD dwIndex = 0;
1983 DWORD dwArraySize = GetTokenCount();
1984
1985 // set up locale info
1986 CSaveThreadLocale lcidSave;
1987
1988 if (pState)
1989 {
1990 dwIndex = pState->dwIndex;
1991
1992 // restore the locale if we're restarting rendering
1993 if (pState->locale != CP_ACP)
1994 SetThreadLocale(pState->locale);
1995 }
1996
1997 pReplacer->SetStream(pWriteStream);
1998 while (dwIndex < dwArraySize)
1999 {
2000 // RenderToken advances dwIndex appropriately for us.
2001 dwIndex = RenderToken(dwIndex, pReplacer, pWriteStream, &hcErrorCode, pState);
2002
2003 if (dwIndex == STENCIL_INVALIDINDEX ||
2004 hcErrorCode != HTTP_SUCCESS)
2005 break;
2006 }
2007
2008 if (IsAsyncStatus(hcErrorCode))
2009 {
2010 ATLASSERT( pState != NULL ); // state is required for async
2011 if (pState)
2012 pState->dwIndex = dwIndex;
2013 }
2014 // lcidSave destructor will restore the locale info in case it was changed
2015
2016 return hcErrorCode;
2017 }
2018
2019 inline BOOL IsValidIndex(DWORD dwIndex) const throw()
2020 {
2021 if (dwIndex == STENCIL_INVALIDINDEX)
2022 return FALSE;
2023 if (dwIndex < GetTokenCount())
2024 return TRUE;
2025 else
2026 return FALSE;
2027 }
2028
2029 virtual DWORD RenderToken(
2030 DWORD dwIndex,
2031 ITagReplacer *pReplacer,
2032 IWriteStream *pWriteStream,
2033 HTTP_CODE *phcErrorCode,
2034 CStencilState* pState = NULL) const throw(...)
2035 {
2036 ATLENSURE(pReplacer != NULL);
2037 ATLENSURE(pWriteStream != NULL);
2038
2039 const StencilToken* pToken = GetToken(dwIndex);
2040 DWORD dwNextToken = 0;
2041 HTTP_CODE hcErrorCode = HTTP_SUCCESS;
2042
2043 if (!pToken)
2044 return STENCIL_INVALIDINDEX;
2045
2046 switch (pToken->type)
2047 {
2048 case STENCIL_TEXTTAG:
2049 {
2050 pWriteStream->WriteStream(pToken->pStart,
2051 (int)((pToken->pEnd-pToken->pStart)+1), NULL);
2052 dwNextToken = dwIndex+1;
2053 }
2054 break;
2055 case STENCIL_ITERATORSTART:
2056 {
2057 HTTP_CODE hcErr = STENCIL_SUCCESS;
2058
2059 #ifdef ATL_DEBUG_STENCILS
2060 // A 'while' token has to at least be followed by an endwhile!
2061 if (!IsValidIndex(dwIndex+1))
2062 {
2063 // This should have been caught at parse time
2064 dwNextToken = STENCIL_INVALIDINDEX;
2065 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_INVALIDINDEX);
2066 ATLASSERT(FALSE);
2067 break;
2068 }
2069
2070 // End of loop should be valid
2071 if (!IsValidIndex(pToken->dwLoopIndex))
2072 {
2073 // This should have been caught at parse time
2074 dwNextToken = STENCIL_INVALIDINDEX;
2075 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_MISMATCHWHILE);
2076 ATLASSERT(FALSE);
2077 break;
2078 }
2079
2080 if (pToken->dwFnOffset == STENCIL_INVALIDOFFSET)
2081 {
2082 // This should have been caught at parse time
2083 dwNextToken = STENCIL_INVALIDINDEX;
2084 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_INVALIDFUNCOFFSET);
2085 ATLASSERT(FALSE);
2086 break;
2087 }
2088 #endif // ATL_DEBUG_STENCILS
2089
2090 DWORD dwLoopIndex = pToken->dwLoopIndex; // points to the end of the loop
2091
2092 // Call the replacement method
2093 // if it returns HTTP_SUCCESS, enter the loop
2094 // if it returns HTTP_S_FALSE, terminate the loop
2095 hcErr = pReplacer->RenderReplacement(pToken->dwFnOffset,
2096 pToken->dwObjOffset, pToken->dwMap, (void *) pToken->dwData);
2097
2098 if (hcErr == HTTP_SUCCESS)
2099 {
2100 dwNextToken = dwIndex+1;
2101 hcErrorCode = HTTP_SUCCESS;
2102 }
2103 else if (hcErr == HTTP_S_FALSE)
2104 {
2105 dwNextToken = dwLoopIndex+1;
2106 hcErrorCode = HTTP_SUCCESS;
2107 }
2108 else
2109 {
2110 dwNextToken = STENCIL_INVALIDINDEX;
2111 hcErrorCode = hcErr;
2112 break;
2113 }
2114 }
2115 break;
2116 case STENCIL_REPLACEMENT:
2117 {
2118 #ifdef ATL_DEBUG_STENCILS
2119 if (pToken->dwFnOffset == STENCIL_INVALIDOFFSET)
2120 {
2121 // This should have been caught at parse time
2122 ATLASSERT(FALSE);
2123 dwNextToken = STENCIL_INVALIDINDEX;
2124 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_INVALIDFUNCOFFSET);
2125 break;
2126 }
2127 #endif // ATL_DEBUG_STENCILS
2128
2129 hcErrorCode = pReplacer->RenderReplacement(pToken->dwFnOffset,
2130 pToken->dwObjOffset, pToken->dwMap, (void *)pToken->dwData);
2131
2132 if (IsAsyncContinueStatus(hcErrorCode))
2133 dwNextToken = dwIndex; // call the tag again after we get back
2134 else
2135 {
2136 dwNextToken = dwIndex + 1;
2137
2138 // when returned from a handler, these indicate that the handler is done
2139 // and that we should move on to the next handler when called back
2140 if (hcErrorCode == HTTP_SUCCESS_ASYNC_DONE)
2141 hcErrorCode = HTTP_SUCCESS_ASYNC;
2142 else if (hcErrorCode == HTTP_SUCCESS_ASYNC_NOFLUSH_DONE)
2143 hcErrorCode = HTTP_SUCCESS_ASYNC_NOFLUSH;
2144 }
2145 }
2146 break;
2147 case STENCIL_ITERATOREND:
2148 {
2149 dwNextToken = pToken->dwLoopIndex;
2150 hcErrorCode = HTTP_SUCCESS;
2151 ATLASSERT(GetToken(dwNextToken)->type == STENCIL_ITERATORSTART);
2152 }
2153 break;
2154 case STENCIL_CONDITIONALSTART:
2155 {
2156 #ifdef ATL_DEBUG_STENCILS
2157 if (pToken->type == STENCIL_CONDITIONALSTART && pToken->dwFnOffset == STENCIL_INVALIDOFFSET)
2158 {
2159 // This should have been caught at parse time
2160 ATLASSERT(FALSE);
2161 dwNextToken = STENCIL_INVALIDINDEX;
2162 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_INVALIDFUNCOFFSET);
2163 break;
2164 }
2165
2166 if (pToken->dwLoopIndex == STENCIL_INVALIDINDEX)
2167 {
2168 // This should have been caught at parse time
2169 ATLASSERT(FALSE);
2170 dwNextToken = STENCIL_INVALIDINDEX;
2171 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_MISMATCHIF);
2172 break;
2173 }
2174 #endif // ATL_DEBUG_STENCILS
2175
2176 DWORD dwLoopIndex = pToken->dwLoopIndex; // points to the end of the loop
2177
2178 HTTP_CODE hcErr;
2179 // Call the replacement method.
2180 // If it returns HTTP_SUCCESS, we render everything up to
2181 // the end of the conditional.
2182 // if it returns HTTP_S_FALSE, the condition is not met and we
2183 // render the else part if it exists or jump past the endif otherwise
2184 hcErr = pReplacer->RenderReplacement(pToken->dwFnOffset,
2185 pToken->dwObjOffset, pToken->dwMap, (void *)pToken->dwData);
2186
2187 if (hcErr == HTTP_SUCCESS)
2188 {
2189 dwNextToken = dwIndex+1;
2190 hcErrorCode = HTTP_SUCCESS;
2191 }
2192 else if (hcErr == HTTP_S_FALSE)
2193 {
2194 dwNextToken = dwLoopIndex+1;
2195 hcErrorCode = HTTP_SUCCESS;
2196 }
2197 else
2198 {
2199 dwNextToken = STENCIL_INVALIDINDEX;
2200 hcErrorCode = hcErr;
2201 break;
2202 }
2203 }
2204 break;
2205 case STENCIL_CONDITIONALELSE:
2206 {
2207 #ifdef ATL_DEBUG_STENCILS
2208 if (pToken->dwLoopIndex == STENCIL_INVALIDINDEX)
2209 {
2210 // This should have been caught at parse time
2211 ATLASSERT(FALSE);
2212 dwNextToken = STENCIL_INVALIDINDEX;
2213 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_MISMATCHIF);
2214 break;
2215 }
2216 #endif // ATL_DEBUG_STENCILS
2217
2218 dwNextToken = pToken->dwLoopIndex+1;
2219 hcErrorCode = HTTP_SUCCESS;
2220 }
2221 break;
2222 case STENCIL_CONDITIONALEND:
2223 {
2224 dwNextToken = dwIndex+1;
2225 hcErrorCode = HTTP_SUCCESS;
2226 }
2227 break;
2228 case STENCIL_LOCALE:
2229 {
2230 if (pState)
2231 {
2232 pState->locale = (LCID) pToken->dwData;
2233 }
2234 SetThreadLocale((LCID) pToken->dwData);
2235 dwNextToken = dwIndex + 1;
2236 }
2237 break;
2238 default:
2239 {
2240 ATLASSERT(FALSE);
2241 dwNextToken = STENCIL_INVALIDINDEX;
2242 hcErrorCode = AtlsHttpError(500, ISE_SUBERR_STENCIL_UNEXPECTEDTYPE);
2243 break;
2244 }
2245 }
2246
2247 ATLASSERT(dwNextToken != dwIndex || IsAsyncContinueStatus(hcErrorCode));
2248
2249 if (phcErrorCode)
2250 *phcErrorCode = hcErrorCode;
2251
2252 return dwNextToken;
2253 }
2254
2255 DWORD GetTokenCount() const throw()
2256 {
2257 return (DWORD) m_arrTokens.GetCount();
2258 }
2259
2260 const StencilToken* GetToken(DWORD dwIndex) const throw()
2261 {
2262 return &(m_arrTokens[dwIndex]);
2263 }
2264
2265 StencilToken* GetToken(DWORD dwIndex) throw()
2266 {
2267 return &(m_arrTokens[dwIndex]);
2268 }
2269
2270 LPCSTR GetBufferStart() const throw()
2271 {
2272 return m_pBufferStart;
2273 }
2274
2275 LPCSTR GetBufferEnd() const throw()
2276 {
2277 return m_pBufferEnd;
2278 }
2279
2280 WORD GetCodePage() const throw()
2281 {
2282 return m_nCodePage;
2283 }
2284
2285 // IMemoryCacheClient
2286 STDMETHOD(QueryInterface)(REFIID riid, void **ppv)
2287 {
2288 if (!ppv)
2289 return E_POINTER;
2290
2291 if (InlineIsEqualGUID(riid, __uuidof(IUnknown)) ||
2292 InlineIsEqualGUID(riid, __uuidof(IMemoryCacheClient)))
2293 {
2294 *ppv = static_cast<IMemoryCacheClient*>(this);
2295 return S_OK;
2296 }
2297
2298 *ppv = NULL;
2299 return E_NOINTERFACE;
2300 }
2301
2302 STDMETHOD_(ULONG, AddRef)()
2303 {
2304 return 1;
2305 }
2306
2307 STDMETHOD_(ULONG, Release)()
2308 {
2309 return 1;
2310 }
2311
2312 STDMETHOD(Free)(const void *pData)
2313 {
2314 if (!pData)
2315 return E_POINTER;
2316
2317 ATLASSERT(*((void **) pData) == static_cast<void*>(this));
2318
2319 delete this;
2320
2321 return S_OK;
2322 }
2323 }; // class CStencil
2324
2325 struct StencilIncludeInfo
2326 {
2327 public:
2328 CHAR m_szQueryString[ATL_URL_MAX_URL_LENGTH+1];
2329 CHAR m_szFileName[MAX_PATH];
2330 };
2331
2332
2333 class CIncludeServerContext :
2334 public CComObjectRootEx<CComMultiThreadModel>,
2335 public CWrappedServerContext
2336 {
2337 public:
2338 BEGIN_COM_MAP(CIncludeServerContext)
2339 COM_INTERFACE_ENTRY(IHttpServerContext)
2340 END_COM_MAP()
2341
2342 IWriteStream * m_pStream;
2343 const StencilIncludeInfo * m_pIncludeInfo;
2344
2345 CIncludeServerContext() throw()
2346 {
2347 m_pStream = NULL;
2348 m_pIncludeInfo = NULL;
2349 }
2350
2351 void Initialize(
2352 IWriteStream *pStream,
2353 IHttpServerContext* pServerContext,
2354 const StencilIncludeInfo * pIncludeInfo) throw()
2355 {
2356 ATLASSERT(pStream != NULL);
2357 ATLASSERT(pServerContext != NULL);
2358 ATLASSERT(pIncludeInfo != NULL);
2359 m_pStream = pStream;
2360 m_spParent = pServerContext;
2361 m_pIncludeInfo = pIncludeInfo;
2362 }
2363
2364 void Initialize(CIncludeServerContext *pOtherContext)
2365 {
2366 ATLENSURE(pOtherContext != NULL);
2367 m_pStream = pOtherContext->m_pStream;
2368 m_spParent = pOtherContext->m_spParent;
2369 m_pIncludeInfo = pOtherContext->m_pIncludeInfo;
2370 }
2371
2372 LPCSTR GetRequestMethod()
2373 {
2374 return "GET";
2375 }
2376
2377 LPCSTR GetQueryString()
2378 {
2379 ATLASSUME(m_pIncludeInfo != NULL);
2380 return m_pIncludeInfo->m_szQueryString;
2381 }
2382
2383 LPCSTR GetPathTranslated()
2384 {
2385 ATLASSUME(m_pIncludeInfo != NULL);
2386 return m_pIncludeInfo->m_szFileName;
2387 }
2388
2389 LPCSTR GetScriptPathTranslated()
2390 {
2391 ATLASSUME(m_pIncludeInfo != NULL);
2392 return m_pIncludeInfo->m_szFileName;
2393 }
2394
2395 DWORD GetTotalBytes()
2396 {
2397 return 0;
2398 }
2399
2400 DWORD GetAvailableBytes()
2401 {
2402 return 0;
2403 }
2404
2405 BYTE *GetAvailableData()
2406 {
2407 return NULL;
2408 }
2409
2410 LPCSTR GetContentType()
2411 {
2412 return 0;
2413 }
2414
2415 BOOL WriteClient(void *pvBuffer, DWORD *pdwBytes)
2416 {
2417 ATLASSUME(m_pStream != NULL);
2418 ATLENSURE(pvBuffer != NULL);
2419 ATLENSURE(pdwBytes != NULL);
2420
2421 HRESULT hr = S_OK;
2422 _ATLTRY
2423 {
2424 hr = m_pStream->WriteStream((LPCSTR) pvBuffer, *pdwBytes, pdwBytes);
2425 }
2426 _ATLCATCHALL()
2427 {
2428 hr = E_FAIL;
2429 }
2430
2431 return SUCCEEDED(hr);
2432 }
2433
2434 BOOL ReadClient(void * /*pvBuffer*/, DWORD * /*pdwSize*/)
2435 {
2436 return FALSE;
2437 }
2438
2439 BOOL AsyncReadClient(void * /*pvBuffer*/, DWORD * /*pdwSize*/)
2440 {
2441 return FALSE;
2442 }
2443
2444 BOOL SendRedirectResponse(LPCSTR /*pszRedirectURL*/)
2445 {
2446 return FALSE;
2447 }
2448
2449 BOOL SendResponseHeader(
2450 LPCSTR /*pszHeader*/,
2451 LPCSTR /*pszStatusCode*/,
2452 BOOL /*fKeepConn*/)
2453 {
2454 return TRUE;
2455 }
2456
2457 BOOL DoneWithSession(DWORD /*dwHttpStatusCode*/)
2458 {
2459 return TRUE;
2460 }
2461
2462 BOOL RequestIOCompletion(PFN_HSE_IO_COMPLETION /*pfn*/, DWORD * /*pdwContext*/)
2463 {
2464 return FALSE;
2465 }
2466 }; // class CIncludeServerContext
2467
2468 class CIDServerContext :
2469 public CComObjectRootEx<CComMultiThreadModel>,
2470 public CWrappedServerContext
2471 {
2472 public:
2473 CHttpResponse *m_pResponse;
2474 CHttpRequest *m_pRequest;
2475
2476 BEGIN_COM_MAP(CIDServerContext)
2477 COM_INTERFACE_ENTRY(IHttpServerContext)
2478 END_COM_MAP()
2479
2480 CIDServerContext() throw()
2481 : m_pResponse(NULL), m_pRequest(NULL)
2482 {
2483 }
2484
2485 BOOL Initialize(
2486 CHttpResponse *pResponse,
2487 CHttpRequest *pRequest) throw()
2488 {
2489 ATLASSERT(pResponse != NULL);
2490 ATLASSERT(pRequest != NULL);
2491 m_pResponse = pResponse;
2492 m_pRequest = pRequest;
2493 if(!m_pRequest)
2494 {
2495 return FALSE;
2496 }
2497
2498 HRESULT hr = m_pRequest->GetServerContext(&m_spParent);
2499 return (SUCCEEDED(hr));
2500 }
2501
2502 LPCSTR GetRequestMethod()
2503 {
2504 ATLASSUME(m_pRequest != NULL);
2505 return m_pRequest->GetMethodString();
2506 }
2507
2508 LPCSTR GetQueryString()
2509 {
2510 ATLASSUME(m_pRequest != NULL);
2511 return m_pRequest->GetQueryString();
2512 }
2513
2514 LPCSTR GetPathInfo()
2515 {
2516 ATLASSUME(m_pRequest != NULL);
2517 return m_pRequest->GetPathInfo();
2518 }
2519
2520 LPCSTR GetPathTranslated()
2521 {
2522 ATLASSUME(m_pRequest != NULL);
2523 return m_pRequest->GetPathTranslated();
2524 }
2525
2526 DWORD GetTotalBytes()
2527 {
2528 ATLASSUME(m_pRequest != NULL);
2529 return m_pRequest->GetTotalBytes();
2530 }
2531
2532 DWORD GetAvailableBytes()
2533 {
2534 ATLASSUME(m_pRequest != NULL);
2535 return m_pRequest->GetAvailableBytes();
2536 }
2537
2538 BYTE *GetAvailableData()
2539 {
2540 ATLASSUME(m_pRequest != NULL);
2541 return m_pRequest->GetAvailableData();
2542 }
2543
2544 LPCSTR GetContentType()
2545 {
2546 ATLASSUME(m_pRequest != NULL);
2547 return m_pRequest->GetContentType();
2548 }
2549
2550 LPCSTR GetScriptPathTranslated()
2551 {
2552 ATLASSUME(m_pRequest != NULL);
2553 return m_pRequest->GetScriptPathTranslated();
2554 }
2555
2556 BOOL WriteClient(void *pvBuffer, DWORD *pdwBytes)
2557 {
2558 ATLASSUME(m_pResponse != NULL);
2559 return m_pResponse->WriteLen((LPCSTR)pvBuffer, *pdwBytes);
2560 }
2561
2562 BOOL ReadClient(void *pvBuffer, DWORD *pdwSize)
2563 {
2564 ATLASSUME(m_pRequest != NULL);
2565 return m_pRequest->ReadData((LPSTR)pvBuffer, pdwSize);
2566 }
2567
2568 BOOL SendRedirectResponse(LPCSTR pszRedirectURL)
2569 {
2570 ATLASSUME(m_pResponse != NULL);
2571 return m_pResponse->Redirect(pszRedirectURL);
2572 }
2573
2574 BOOL TransmitFile(
2575 HANDLE hFile,
2576 PFN_HSE_IO_COMPLETION pfn,
2577 void *pContext,
2578 LPCSTR szStatusCode,
2579 DWORD dwBytesToWrite,
2580 DWORD dwOffset,
2581 void *pvHead,
2582 DWORD dwHeadLen,
2583 void *pvTail,
2584 DWORD dwTailLen,
2585 DWORD dwFlags)
2586 {
2587 ATLASSUME(m_pResponse != NULL);
2588 ATLASSUME(m_spParent != NULL);
2589
2590 m_pResponse->Flush();
2591 return m_spParent->TransmitFile(hFile, pfn, pContext, szStatusCode,
2592 dwBytesToWrite, dwOffset, pvHead, dwHeadLen, pvTail, dwTailLen, dwFlags);
2593 }
2594
2595 }; // class CIDServerContext
2596
2597 //
2598 // CHtmlStencil
2599 // CHtmlStencil is a specialization of CStencil. CHtmlStencil adds the following
2600 // capabilities to CStencil:
2601 //
2602 // Support for rendering {{include }} tags
2603 // The {{include }} tags specify another stencil to be included in-place during
2604 // stencil rendering. The {{include }} tag takes a single parameter which is the
2605 // URL of the stencil to include. That URL can optionally include parameters.
2606 // An example:
2607 // {{include mystencil.srf?param1=value1}}
2608 //
2609 // We also grab the handler name and the name of any subhandlers. The syntax for the
2610 // handler specification is:
2611 // {{handler MyDynamicHandler.dll/Default}}
2612 // which would cause the MyDynamicHandler.dll to be loaded. Once loaded, the stencil
2613 // processor will ask for the IReplacementHandler interface of the object named "Default".
2614 //
2615 // Additional handlers can be specified after the default handler. An example of an
2616 // additional handler would be:
2617 // {{subhandler OtherHandler MyOtherHandler.dll/Default}}
2618 // would cause the MyOtherHandler.dll to be loaded. Once loaded, the stencil processor will
2619 // ask for the IReplacementHandler interface of the object named "Default" and use it in
2620 // processing the stencil anywhere it sees a stencil tag of the form
2621 // {{OtherHandler.RenderReplacement}}
2622
2623 struct CStringPair
2624 {
2625 typedef CFixedStringT<CStringA, MAX_PATH> PathStrType;
2626 typedef CFixedStringT<CStringA, ATL_MAX_HANDLER_NAME_LEN+1> HdlrNameStrType;
2627 PathStrType strDllPath;
2628 HdlrNameStrType strHandlerName;
2629
2630 CStringPair()throw()
2631 {
2632 }
2633
2634 CStringPair(PathStrType &strDllPath_, HdlrNameStrType &strHandlerName_) throw(...)
2635 :strDllPath(strDllPath_), strHandlerName(strHandlerName_)
2636 {
2637 }
2638
2639 CStringPair(CStringA &strDllPath_, CStringA &strHandlerName_) throw(...)
2640 :strDllPath(strDllPath_), strHandlerName(strHandlerName_)
2641 {
2642 }
2643 };
2644
2645 class CStringPairElementTraits :
2646 public CElementTraitsBase< CStringPair >
2647 {
2648 private:
2649
2650 static ULONG HashStr( ULONG nHash, CStringElementTraits<CStringA>::INARGTYPE str )
2651 {
2652 ATLENSURE( str != NULL );
2653 const CStringA::XCHAR* pch = str;
2654 while( *pch != 0 )
2655 {
2656 nHash = (nHash<<5)+nHash+(*pch);
2657 pch++;
2658 }
2659
2660 return( nHash );
2661 }
2662
2663 public:
2664 static ULONG Hash( INARGTYPE pair ) throw()
2665 {
2666 ULONG nHash = HashStr(0, pair.strDllPath);
2667 return HashStr(nHash, pair.strHandlerName);
2668 }
2669
2670 static bool CompareElements( INARGTYPE pair1, INARGTYPE pair2 ) throw()
2671 {
2672 return( (pair1.strDllPath == pair2.strDllPath) && (pair1.strHandlerName == pair2.strHandlerName) );
2673 }
2674
2675 static int CompareElementsOrdered( INARGTYPE pair1, INARGTYPE pair2 ) throw()
2676 {
2677 return( pair1.strDllPath.Compare( pair2.strDllPath ) );
2678 }
2679 };
2680
2681 class CHtmlStencil : public CStencil
2682 {
2683 private:
2684
2685 ATL_NOINLINE HTTP_CODE RenderInclude(
2686 ITagReplacer *pReplacer,
2687 const StencilToken *pToken,
2688 IWriteStream *pWriteStream,
2689 CStencilState *pState) const
2690 {
2691 ATLASSUME(m_spServiceProvider);
2692 CComPtr<IHttpServerContext> spServerContext;
2693 CComPtr<IHttpRequestLookup> spLookup;
2694 if (FAILED(pReplacer->GetContext(__uuidof(IHttpServerContext), (VOID**) &spServerContext)))
2695 {
2696 return AtlsHttpError(500, 0);
2697 }
2698 if (FAILED(pReplacer->GetContext(__uuidof(IHttpRequestLookup), (VOID**) &spLookup)))
2699 {
2700 return AtlsHttpError(500, 0);
2701 }
2702 return RenderInclude(m_spServiceProvider, pWriteStream,
2703 (StencilIncludeInfo *)pToken->dwData, spServerContext, spLookup,
2704 pState);
2705 }
2706
2707 ATL_NOINLINE HTTP_CODE NoCachePage(ITagReplacer *pReplacer) const
2708 {
2709 CComPtr<IHttpServerContext> spContext;
2710 HRESULT hr = pReplacer->GetContext(__uuidof(IHttpServerContext), (void **)&spContext);
2711 if (hr == S_OK && spContext)
2712 {
2713 CComQIPtr<IPageCacheControl> spControl;
2714 spControl = spContext;
2715 if (spControl)
2716 spControl->Cache(FALSE);
2717 }
2718 return HTTP_SUCCESS;
2719 }
2720
2721
2722 // CAllocIncludeAsyncContext is an unsupported implementation detail of RenderInclude
2723 class CAllocIncludeAsyncContext :
2724 public CAllocContextBase
2725 {
2726 public:
2727 CAllocIncludeAsyncContext(CIncludeServerContext *pBase) :
2728 m_pBase(pBase)
2729 {
2730
2731 }
2732 HTTP_CODE Alloc(IHttpServerContext **ppNewContext)
2733 {
2734 ATLASSUME(m_pBase);
2735 if (!ppNewContext)
2736 return AtlsHttpError(500, ISE_SUBERR_UNEXPECTED);
2737 *ppNewContext = NULL;
2738 CComObjectNoLock<CIncludeServerContext>* pNewServerContext = NULL;
2739 ATLTRY(pNewServerContext = new CComObjectNoLock<CIncludeServerContext>);
2740 if (pNewServerContext == NULL)
2741 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
2742 pNewServerContext->Initialize(m_pBase);
2743 pNewServerContext->AddRef();
2744 *ppNewContext = pNewServerContext;
2745 return HTTP_SUCCESS;
2746 }
2747
2748 private:
2749 CIncludeServerContext *m_pBase;
2750 }; // CAllocIncludeAsyncContext
2751
2752
2753 ATL_NOINLINE HTTP_CODE RenderInclude(
2754 IServiceProvider *pServiceProvider,
2755 IWriteStream *pWriteStream,
2756 const StencilIncludeInfo *pIncludeInfo,
2757 IHttpServerContext *pServerContext,
2758 IHttpRequestLookup *pLookup,
2759 CStencilState* pState = NULL) const throw(...)
2760 {
2761 CComObjectStackEx<CIncludeServerContext> serverContext;
2762 serverContext.Initialize(pWriteStream, pServerContext, pIncludeInfo);
2763 CAllocIncludeAsyncContext AsyncAllocObj(&serverContext);
2764 return _AtlRenderInclude(static_cast<IHttpServerContext*>(&serverContext),
2765 pIncludeInfo->m_szFileName,
2766 pIncludeInfo->m_szQueryString,
2767 GetCodePage(),
2768 &AsyncAllocObj,
2769 pServiceProvider,
2770 pLookup,
2771 pState);
2772
2773 }
2774
2775 protected:
2776 CAtlMap<CStringA, CStringPair,
2777 CStringElementTraits<CStringA>, CStringPairElementTraits > m_arrExtraHandlers;
2778 CHAR m_szBaseDir[MAX_PATH];
2779 CComPtr<IServiceProvider> m_spServiceProvider;
2780 CComPtr<IIsapiExtension> m_spExtension;
2781 CComPtr<IStencilCache> m_spStencilCache;
2782 CComPtr<IDllCache> m_spDllCache;
2783
2784 public:
2785 typedef CAtlMap<CStringA, CStringPair,
2786 CStringElementTraits<CStringA>, CStringPairElementTraits > mapType;
2787 typedef CStencil baseType;
2788
2789 CHtmlStencil(IAtlMemMgr *pMemMgr=NULL) throw() :
2790 CStencil(pMemMgr)
2791 {
2792
2793 }
2794
2795 void Initialize(IServiceProvider *pProvider) throw(...)
2796 {
2797 ATLENSURE(pProvider);
2798 if (m_spServiceProvider)
2799 m_spServiceProvider.Release();
2800
2801 m_spServiceProvider = pProvider;
2802 if (!m_spDllCache)
2803 pProvider->QueryService(__uuidof(IDllCache), __uuidof(IDllCache), (void **) &m_spDllCache);
2804
2805 if (!m_spExtension)
2806 pProvider->QueryInterface(__uuidof(IIsapiExtension), (void **) &m_spExtension);
2807 }
2808
2809 BOOL GetIncludeInfo(LPCSTR szParamBegin, LPCSTR szParamEnd, StencilIncludeInfo *pInfo) const
2810 {
2811 ATLENSURE(szParamBegin != NULL);
2812 ATLENSURE(szParamEnd != NULL);
2813 ATLENSURE(pInfo != NULL);
2814
2815 LPCSTR szQueryBegin = szParamBegin;
2816
2817 while (*szQueryBegin && *szQueryBegin != '?' && *szQueryBegin != '}')
2818 {
2819 LPSTR szNext = CharNextExA(GetCodePage(), szQueryBegin, 0);
2820 if (szNext == szQueryBegin)
2821 {
2822 return FALSE;
2823 }
2824
2825 szQueryBegin = szNext;
2826 }
2827
2828 CFixedStringT<CStringA, MAX_PATH> strPath;
2829
2830 _ATLTRY
2831 {
2832 DWORD dwPrefixLen = 0;
2833 if (*szParamBegin == '"')
2834 {
2835 szParamBegin++;
2836 }
2837 if (!IsFullPathA(szParamBegin))
2838 {
2839 if (*szParamBegin != '\\')
2840 {
2841 strPath = m_szBaseDir;
2842 }
2843 else
2844 {
2845 LPCSTR szBackslash = strchr(m_szBaseDir, '\\');
2846 if (szBackslash)
2847 {
2848 #pragma warning(push)
2849 #pragma warning(disable: 6204)
2850 /* prefast noise VSW 492749 */
2851 strPath.SetString(m_szBaseDir, (int)(szBackslash-m_szBaseDir));
2852 #pragma warning(pop)
2853 }
2854 else
2855 {
2856 strPath = m_szBaseDir;
2857 }
2858 }
2859 dwPrefixLen = strPath.GetLength();
2860 }
2861
2862 if (*szQueryBegin=='?')
2863 {
2864 size_t nMinus = (*(szQueryBegin-1) == '"') ? 1 : 0;
2865 strPath.Append(szParamBegin, (int)(szQueryBegin-szParamBegin-nMinus));
2866 if ((szParamEnd-szQueryBegin) > ATL_URL_MAX_PATH_LENGTH || ((szParamEnd - szQueryBegin) < 0))
2867 {
2868 // query string is too long
2869 return FALSE;
2870 }
2871 Checked::memcpy_s(pInfo->m_szQueryString, ATL_URL_MAX_URL_LENGTH+1, szQueryBegin + 1, szParamEnd - szQueryBegin);
2872 pInfo->m_szQueryString[szParamEnd - szQueryBegin] = '\0';
2873 }
2874 else
2875 {
2876 pInfo->m_szQueryString[0] = '\0';
2877 size_t nAdd = (*szParamEnd == '"') ? 0 : 1;
2878 strPath.Append(szParamBegin, (int)(szParamEnd - szParamBegin + nAdd));
2879 }
2880 }
2881 _ATLCATCHALL()
2882 {
2883 // out of memory
2884 return FALSE;
2885 }
2886
2887 if (strPath.GetLength() > MAX_PATH-1)
2888 {
2889 // path is too long
2890 return FALSE;
2891 }
2892
2893 // strPath is <= MAX_PATH-1
2894 return PathCanonicalizeA(pInfo->m_szFileName, strPath);
2895 }
2896
2897 DWORD ParseInclude(LPCSTR szTokenStart, LPCSTR szTokenEnd) throw(...)
2898 {
2899 ATLENSURE(szTokenStart != NULL);
2900 ATLENSURE(szTokenEnd != NULL);
2901
2902 LPCSTR szStart = szTokenStart;
2903 LPCSTR szEnd = szTokenEnd;
2904
2905 FindTagArgs(szStart, szEnd, 7);
2906
2907 CFixedStringT<CStringA, MAX_PATH> strFileNameRelative;
2908 CFixedStringT<CString, MAX_PATH> strFileName;
2909
2910 _ATLTRY
2911 {
2912 strFileNameRelative.SetString(szStart, (int)(szEnd-szStart + 1));
2913
2914 if (!IsFullPathA(strFileNameRelative))
2915 {
2916 CFixedStringT<CStringA, MAX_PATH> strTemp;
2917 if (*((LPCSTR)strFileNameRelative) != '\\')
2918 {
2919 strTemp = m_szBaseDir;
2920 }
2921 else
2922 {
2923 LPCSTR szBackslash = strchr(m_szBaseDir, '\\');
2924 if (szBackslash)
2925 {
2926 #pragma warning(push)
2927 #pragma warning(disable: 6204)
2928 #pragma warning(disable: 6535)
2929 /* prefast noise VSW 492749 */
2930 /* prefast noise VSW 493256 */
2931 strTemp.SetString(m_szBaseDir, (int)(szBackslash-m_szBaseDir));
2932 #pragma warning(pop)
2933 }
2934 else
2935 {
2936 strTemp = m_szBaseDir;
2937 }
2938 }
2939
2940 strTemp.Append(strFileNameRelative, strFileNameRelative.GetLength());
2941 CFixedStringT<CString, MAX_PATH> strConv = (LPCTSTR) CA2CT(strTemp);
2942 LPTSTR szFileBuf = strFileName.GetBuffer(strConv.GetLength()+1);
2943 if (szFileBuf == NULL)
2944 {
2945 AddError(IDS_STENCIL_OUTOFMEMORY, szTokenStart);
2946 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
2947 }
2948
2949 if (!PathCanonicalize(szFileBuf, strConv))
2950 {
2951 return STENCIL_INVALIDINDEX;
2952 }
2953
2954 strFileName.ReleaseBuffer();
2955 }
2956 else
2957 {
2958 strFileName = CA2CTEX<MAX_PATH>(strFileNameRelative);
2959 }
2960 }
2961 _ATLCATCHALL()
2962 {
2963 AddError(IDS_STENCIL_OUTOFMEMORY, szTokenStart);
2964 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
2965 }
2966
2967 LPCTSTR szFileName = strFileName;
2968
2969 LPCTSTR szDot = NULL;
2970 LPCTSTR szExtra = _tcschr(szFileName, '?');
2971 if (!szExtra)
2972 {
2973 szExtra = _tcschr(szFileName, '#');
2974 if (!szExtra)
2975 {
2976 szDot = _tcsrchr(szFileName, '.');
2977 }
2978 }
2979
2980 if (szExtra != NULL)
2981 {
2982 // there is some extra information
2983 LPCTSTR szDotTmp = szFileName;
2984 do
2985 {
2986 szDot = szDotTmp;
2987 szDotTmp = _tcschr(szDotTmp+1, '.');
2988 } while (szDotTmp && szDotTmp < szExtra);
2989 }
2990
2991 if (!szDot || *szDot != '.')
2992 {
2993 AddError(IDS_STENCIL_UNEXPECTED, szTokenStart);
2994 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
2995 }
2996
2997 LPCTSTR szExtEnd = szDot;
2998
2999 while (true)
3000 {
3001 szExtEnd++;
3002 if (!*szExtEnd || *szExtEnd == '/' || *szExtEnd == '\\' || *szExtEnd == '?' || *szExtEnd == '#' || *szExtEnd == '"')
3003 break;
3004 }
3005
3006 if (szDot && (size_t)(szExtEnd-szDot) == _tcslen(c_tAtlDLLExtension) &&
3007 !_tcsnicmp(szDot, c_tAtlDLLExtension, _tcslen(c_tAtlDLLExtension)))
3008 {
3009 // Do .dll stuff
3010 DWORD dwIndex = AddToken(szStart, szEnd, STENCIL_STENCILINCLUDE);
3011 if (dwIndex == STENCIL_INVALIDINDEX)
3012 {
3013 AddError(IDS_STENCIL_OUTOFMEMORY, szTokenStart);
3014 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
3015 }
3016 StencilIncludeInfo *pInfo = (StencilIncludeInfo *)m_pMemMgr->Allocate(sizeof(StencilIncludeInfo));
3017 if (!pInfo)
3018 {
3019 return STENCIL_INVALIDINDEX;
3020 }
3021
3022 if (!GetIncludeInfo(szStart, szEnd, pInfo))
3023 {
3024 return STENCIL_INVALIDINDEX;
3025 }
3026
3027 GetToken(dwIndex)->dwData = (DWORD_PTR) pInfo;
3028 return dwIndex;
3029 }
3030 else if (szDot && (size_t)(szExtEnd-szDot) == _tcslen(c_tAtlSRFExtension) &&
3031 !_tcsnicmp(szDot, c_tAtlSRFExtension, _tcslen(c_tAtlSRFExtension)))
3032 {
3033 // Do .srf stuff
3034 DWORD dwIndex = AddToken(szStart, szEnd, STENCIL_STENCILINCLUDE);
3035 if (dwIndex == STENCIL_INVALIDINDEX)
3036 {
3037 AddError(IDS_STENCIL_OUTOFMEMORY, szTokenStart);
3038 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
3039 }
3040 StencilIncludeInfo *pInfo = (StencilIncludeInfo *)m_pMemMgr->Allocate(sizeof(StencilIncludeInfo));
3041 if (!pInfo)
3042 {
3043 return STENCIL_INVALIDINDEX;
3044 }
3045
3046 if (!GetIncludeInfo(szStart, szEnd, pInfo))
3047 {
3048 return STENCIL_INVALIDINDEX;
3049 }
3050
3051 GetToken(dwIndex)->dwData = (DWORD_PTR) pInfo;
3052 return dwIndex;
3053 }
3054 else
3055 {
3056 // Assume static content
3057 CAtlFile file;
3058
3059 HRESULT hr = file.Create(szFileName, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING);
3060 if (FAILED(hr) || GetFileType(file) != FILE_TYPE_DISK)
3061 {
3062 if (FAILED(hr))
3063 {
3064 AddError(IDS_STENCIL_INCLUDE_ERROR, szTokenStart);
3065 }
3066 else
3067 {
3068 AddError(IDS_STENCIL_INCLUDE_INVALID, szTokenStart);
3069 }
3070 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
3071 }
3072
3073 CAutoVectorPtr<CHAR> szBufferStart;
3074 LPSTR szBufferEnd = NULL;
3075 ULONGLONG dwLen = 0;
3076 if (FAILED(file.GetSize(dwLen)))
3077 {
3078 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
3079 }
3080
3081 if (!szBufferStart.Allocate((size_t) dwLen))
3082 {
3083 AddError(IDS_STENCIL_OUTOFMEMORY, szTokenStart);
3084 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
3085 }
3086
3087 DWORD dwRead;
3088 if (FAILED(file.Read(szBufferStart, (DWORD) dwLen, dwRead)))
3089 {
3090 return AddToken(szTokenStart, szTokenEnd, STENCIL_TEXTTAG);
3091 }
3092
3093 szBufferEnd = szBufferStart + dwRead-1;
3094
3095 DWORD dwIndex = AddToken(szBufferStart, szBufferEnd, STENCIL_STATICINCLUDE);
3096 if (dwIndex != STENCIL_INVALIDINDEX)
3097 {
3098 GetToken(dwIndex)->bDynamicAlloc = TRUE;
3099 szBufferStart.Detach();
3100 }
3101
3102 return dwIndex;
3103 }
3104 }
3105
3106 PARSE_TOKEN_RESULT ParseSubhandler(LPCSTR szTokenStart, LPCSTR szTokenEnd) throw()
3107 {
3108 ATLASSERT(szTokenStart != NULL);
3109 ATLASSERT(szTokenEnd != NULL);
3110
3111 LPCSTR szStart = szTokenStart;
3112 LPCSTR szEnd = szTokenEnd;
3113
3114 // move to the start of the arguments
3115 // (the first char past 'subhandler'
3116 FindTagArgs(szStart, szEnd, 10);
3117
3118 // skip any space to bring us to the start
3119 // of the id for the subhandler.
3120 szStart = SkipSpace(szStart, GetCodePage());
3121
3122 // id names cannot contain spaces. Mark the
3123 // beginning and end if the subhandler id
3124 LPCSTR szIdStart = szStart;
3125 while (!isspace(static_cast<unsigned char>(*szStart)) && *szStart != '}')
3126 {
3127 if (!isalnum(static_cast<unsigned char>(*szStart)))
3128 {
3129 // id names can only contain alphanumeric characters
3130 return INVALID_TOKEN;
3131 }
3132
3133 LPSTR szNext = CharNextExA(GetCodePage(), szStart, 0);
3134 if (szNext == szStart)
3135 {
3136 // embedded null
3137 AddError(IDS_STENCIL_EMBEDDED_NULL, NULL);
3138 return INVALID_TOKEN;
3139 }
3140 szStart = szNext;
3141 }
3142 LPCSTR szIdEnd = szStart;
3143
3144 // skip space to bring us to the beginning of the
3145 // the dllpath/handlername
3146 szStart = SkipSpace(szStart, GetCodePage());
3147
3148 // everything up to the end if the tag is
3149 // part of the dllpath/handlername
3150 LPCSTR szHandlerStart = szStart;
3151 while (*szStart != '}')
3152 {
3153 LPCSTR szNext = CharNextExA(GetCodePage(), szStart, 0);
3154 if (szNext == szStart)
3155 {
3156 // embedded null
3157 AddError(IDS_STENCIL_EMBEDDED_NULL, NULL);
3158 return INVALID_TOKEN;
3159 }
3160 szStart = szNext;
3161 }
3162 LPCSTR szHandlerEnd = szStart;
3163
3164 _ATLTRY
3165 {
3166 CStringPair::HdlrNameStrType strName(szIdStart, (int)(szIdEnd-szIdStart));
3167 CStringPair::PathStrType strPath(szHandlerStart, (int)(szHandlerEnd-szHandlerStart));
3168
3169 CStringPair::PathStrType strDllPath;
3170 CStringPair::HdlrNameStrType strHandlerName;
3171 DWORD dwDllPathLen = MAX_PATH;
3172 DWORD dwHandlerNameLen = ATL_MAX_HANDLER_NAME_LEN+1;
3173
3174 LPSTR szDllPath = strDllPath.GetBuffer(dwDllPathLen);
3175 LPSTR szHandlerName = strHandlerName.GetBuffer(dwHandlerNameLen);
3176
3177 if (!_AtlCrackHandler(strPath, szDllPath, &dwDllPathLen, szHandlerName, &dwHandlerNameLen))
3178 {
3179 strDllPath.ReleaseBuffer();
3180 strHandlerName.ReleaseBuffer();
3181 AddError(IDS_STENCIL_INVALID_SUBHANDLER, szTokenStart);
3182 return INVALID_TOKEN;
3183 }
3184
3185 strDllPath.ReleaseBuffer(dwDllPathLen);
3186 strHandlerName.ReleaseBuffer(dwHandlerNameLen);
3187
3188 m_arrExtraHandlers.SetAt(strName, CStringPair(strDllPath, strHandlerName));
3189 }
3190 _ATLCATCHALL()
3191 {
3192 AddError(IDS_STENCIL_OUTOFMEMORY, NULL);
3193 return INVALID_TOKEN;
3194 }
3195 return RESERVED_TOKEN;
3196 }
3197
3198 virtual PARSE_TOKEN_RESULT ParseToken(LPCSTR szTokenStart, LPCSTR szTokenEnd, DWORD *pBlockStack, DWORD *pdwTop)
3199 {
3200 ATLASSERT(szTokenStart != NULL);
3201 ATLASSERT(szTokenEnd != NULL);
3202
3203 LPCSTR pStart = szTokenStart;
3204 pStart += 2; //skip curlies
3205 pStart = SkipSpace(pStart, GetCodePage());
3206 DWORD dwLen = (DWORD)(szTokenEnd - szTokenStart);
3207
3208 DWORD dwIndex = STENCIL_INVALIDINDEX;
3209
3210 if (CheckTag("include", sizeof("include")-1, pStart, dwLen))
3211 {
3212 dwIndex = ParseInclude(szTokenStart, szTokenEnd);
3213 }
3214 else if (dwLen > 3 && !memcmp("!--", pStart, 3))
3215 {
3216 return RESERVED_TOKEN;
3217 }
3218 else if (dwLen > 2 && !memcmp("//", pStart, 2))
3219 {
3220 return RESERVED_TOKEN;
3221 }
3222 else if (CheckTag("subhandler", sizeof("subhandler")-1, pStart, dwLen))
3223 {
3224 return ParseSubhandler(szTokenStart, szTokenEnd);
3225 }
3226 else
3227 {
3228 return CStencil::ParseToken(szTokenStart, szTokenEnd, pBlockStack, pdwTop);
3229 }
3230 if (dwIndex == STENCIL_INVALIDINDEX)
3231 {
3232 return INVALID_TOKEN;
3233 }
3234 return RESERVED_TOKEN;
3235 }
3236
3237 mapType* GetExtraHandlers() throw()
3238 {
3239 return &m_arrExtraHandlers;
3240 }
3241
3242 BOOL SetBaseDirFromFile(LPCSTR szBaseDir)
3243 {
3244 if (!SafeStringCopy(m_szBaseDir, szBaseDir))
3245 {
3246 return FALSE;
3247 }
3248
3249 LPSTR szSlash = strrchr(m_szBaseDir, '\\');
3250 if (szSlash)
3251 {
3252 szSlash++;
3253 *szSlash = '\0';
3254 }
3255 else
3256 {
3257 *m_szBaseDir = '\0';
3258 }
3259
3260 return TRUE;
3261 }
3262
3263 LPCSTR GetBaseDir()
3264 {
3265 return m_szBaseDir;
3266 }
3267
3268 DWORD RenderToken(
3269 DWORD dwIndex,
3270 ITagReplacer* pReplacer,
3271 IWriteStream *pWriteStream,
3272 HTTP_CODE *phcErrorCode,
3273 CStencilState* pState = NULL) const throw(...)
3274 {
3275 DWORD dwNextToken = STENCIL_INVALIDINDEX;
3276 HTTP_CODE hcErrorCode = HTTP_SUCCESS;
3277 const StencilToken* pToken = GetToken(dwIndex);
3278 if (pToken)
3279 {
3280 if (pToken->type == STENCIL_STENCILINCLUDE)
3281 {
3282 hcErrorCode = RenderInclude(pReplacer, pToken, pWriteStream, pState);
3283 if (hcErrorCode == HTTP_SUCCESS || IsAsyncDoneStatus(hcErrorCode))
3284 {
3285 dwNextToken = dwIndex+1;
3286 }
3287 else if (IsAsyncContinueStatus(hcErrorCode))
3288 {
3289 dwNextToken = dwIndex;
3290 }
3291 }
3292 else if (pToken->type == STENCIL_STATICINCLUDE)
3293 {
3294 pWriteStream->WriteStream(pToken->pStart,
3295 (int)((pToken->pEnd-pToken->pStart)+1), NULL);
3296 dwNextToken = dwIndex+1;
3297 }
3298 else
3299 {
3300 dwNextToken = baseType::RenderToken(dwIndex, pReplacer,
3301 pWriteStream, &hcErrorCode, pState);
3302 }
3303 }
3304
3305 if (hcErrorCode == HTTP_SUCCESS_NO_CACHE)
3306 {
3307 hcErrorCode = NoCachePage(pReplacer);
3308 }
3309
3310 if (phcErrorCode)
3311 {
3312 *phcErrorCode = hcErrorCode;
3313 }
3314 return dwNextToken;
3315 }
3316 }; // class CHtmlStencil
3317
3318
3319 __declspec(selectany) CCRTHeap CStencil::m_crtHeap;
3320
3321 //
3322 // CHtmlTagReplacer
3323 // This class manages CStencil based objects for HTTP requests. This class will retrieve
3324 // CStencil based objects from the stencil cache, store CStencil based objects in the
3325 // stencil cache and allocate and initialize CStencil based objects on a per reqeust
3326 // basis. Typically, one instance of this class is created for each HTTP request. The
3327 // instance is destroyed once the request has been completed.
3328 template <class THandler, class StencilType=CHtmlStencil>
3329 class CHtmlTagReplacer :
3330 public ITagReplacerImpl<THandler>
3331 {
3332 protected:
3333 typedef StencilType StencilType;
3334
3335 CSimpleArray<HINSTANCE> m_hInstHandlers;
3336 typedef CAtlMap<CStringA, IRequestHandler*, CStringElementTraits<CStringA> > mapType;
3337 mapType m_Handlers;
3338 StencilType *m_pLoadedStencil;
3339 WORD m_nCodePage;
3340 CComPtr<IStencilCache> m_spStencilCache;
3341
3342 AtlServerRequest m_RequestInfo;
3343
3344 public:
3345 // public members
3346
3347 CHtmlTagReplacer() throw() :
3348 m_pLoadedStencil(NULL)
3349 {
3350 memset(&m_RequestInfo, 0x00, sizeof(m_RequestInfo));
3351 m_nCodePage = CP_THREAD_ACP;
3352 }
3353
3354 ~CHtmlTagReplacer() throw()
3355 {
3356 // you should call FreeHandlers before
3357 // the object is destructed
3358 ATLASSUME(m_hInstHandlers.GetSize() == 0);
3359 }
3360
3361 HTTP_CODE Initialize(AtlServerRequest *pRequestInfo, IHttpServerContext *pSafeSrvCtx=NULL) throw(...)
3362 {
3363 ATLASSERT(pRequestInfo != NULL);
3364
3365 CComPtr<IServiceProvider> spServiceProvider;
3366 THandler *pT = static_cast<THandler*>(this);
3367 HRESULT hr = pT->GetContext(__uuidof(IServiceProvider), (void **)&spServiceProvider);
3368 if (FAILED(hr))
3369 return HTTP_FAIL;
3370
3371 spServiceProvider->QueryService(__uuidof(IStencilCache), __uuidof(IStencilCache), (void **) &m_spStencilCache);
3372 if (!m_spStencilCache)
3373 {
3374 ATLASSERT(FALSE);
3375 return HTTP_FAIL;
3376 }
3377
3378 // copy the AtlServerRequest into the safe version
3379 Checked::memcpy_s(&m_RequestInfo, sizeof(m_RequestInfo), pRequestInfo, sizeof(m_RequestInfo));
3380
3381 // override appropriate fields
3382 m_RequestInfo.cbSize = sizeof(m_RequestInfo);
3383 m_RequestInfo.pServerContext = pSafeSrvCtx;
3384
3385 return HTTP_SUCCESS;
3386 }
3387
3388 HTTP_CODE LoadStencilResource(
3389 HINSTANCE hInstResource,
3390 LPCSTR szResourceID,
3391 LPCSTR szResourceType = NULL, LPCSTR szStencilName=NULL) throw(...)
3392 {
3393 if (!szResourceType)
3394 szResourceType = (LPCSTR) (RT_HTML);
3395 // look up stencil in cache
3396 HTTP_CODE hcErr = HTTP_SUCCESS;
3397
3398 // check the cache first
3399 StencilType *pStencil = FindCacheStencil(szStencilName ? szStencilName : szResourceID);
3400 if (!pStencil)
3401 {
3402 // create a new stencil
3403 pStencil = GetNewCacheStencil();
3404 if (!pStencil)
3405 {
3406 return AtlsHttpError(500,ISE_SUBERR_OUTOFMEM);
3407 }
3408
3409 THandler *pT = static_cast<THandler*>(this);
3410 LPCSTR szFileName = pT->m_spServerContext->GetScriptPathTranslated();
3411
3412 if (!szFileName)
3413 return HTTP_FAIL;
3414
3415 if (!pStencil->SetBaseDirFromFile(szFileName))
3416 {
3417 return HTTP_FAIL;
3418 }
3419
3420 pStencil->SetErrorResource(GetResourceInstance());
3421
3422 // load the stencil and parse its replacements
3423 if (HTTP_SUCCESS == pStencil->LoadFromResource(hInstResource,
3424 szResourceID, szResourceType))
3425 {
3426 _ATLTRY
3427 {
3428 if (!pStencil->ParseReplacements(this))
3429 {
3430 return AtlsHttpError(500, ISE_SUBERR_BADSRF);
3431 }
3432
3433 hcErr = FinishLoadStencil(pStencil, NULL);
3434 if (!hcErr)
3435 {
3436 #ifdef ATL_DEBUG_STENCILS
3437 pStencil->FinishParseReplacements();
3438 #else
3439 if (!pStencil->FinishParseReplacements())
3440 {
3441 return AtlsHttpError(500, ISE_SUBERR_BADSRF);
3442 }
3443 #endif // ATL_DEBUG_STENCILS
3444 }
3445 }
3446 _ATLCATCHALL()
3447 {
3448 return HTTP_FAIL;
3449 }
3450 }
3451 else
3452 {
3453 hcErr = HTTP_FAIL;
3454 }
3455
3456 // if everything went OK, put the stencil in the stencil cache.
3457 if (!hcErr)
3458 {
3459 hcErr = CacheStencil(szStencilName ? szStencilName : szResourceID, pStencil);
3460 }
3461
3462 if (pStencil && hcErr) // something went wrong, free the stencil data
3463 {
3464 FreeCacheStencil(pStencil);
3465 }
3466 }
3467 else
3468 {
3469 hcErr = FinishLoadStencil(pStencil);
3470 }
3471
3472 return hcErr;
3473 }
3474
3475 HTTP_CODE LoadStencilResource(HINSTANCE hInstResource, UINT nID, LPCSTR szResourceType = NULL) throw(...)
3476 {
3477 if (!szResourceType)
3478 szResourceType = (LPCSTR) RT_HTML;
3479 char szName[80];
3480 int nResult = sprintf_s(szName, sizeof(szName), "%p/%u", hInstResource, nID);
3481 if ((nResult < 0) || (nResult == sizeof(szName)))
3482 {
3483 return HTTP_FAIL;
3484 }
3485 return LoadStencilResource(hInstResource, MAKEINTRESOURCEA(nID), szResourceType, szName);
3486 }
3487
3488 HTTP_CODE LoadStencil(LPCSTR szFileName, IHttpRequestLookup * pLookup = NULL) throw(...)
3489 {
3490 if (!szFileName)
3491 {
3492 return HTTP_FAIL;
3493 }
3494
3495 HTTP_CODE hcErr = HTTP_FAIL;
3496 // try to find the stencil in the cache
3497 StencilType *pStencil = FindCacheStencil(szFileName);
3498
3499 if (!pStencil)
3500 {
3501 // not in cache. Create a new one
3502 pStencil = GetNewCacheStencil();
3503 if (!pStencil)
3504 {
3505 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM); // out of memory!
3506 }
3507
3508 if (!pStencil->SetBaseDirFromFile(szFileName))
3509 {
3510 return HTTP_FAIL;
3511 }
3512
3513 pStencil->SetErrorResource(GetResourceInstance());
3514
3515 // finish loading
3516 hcErr = pStencil->LoadFromFile(szFileName);
3517 if (!hcErr)
3518 {
3519 _ATLTRY
3520 {
3521 if (!pStencil->ParseReplacements(static_cast<ITagReplacer*>(this)))
3522 {
3523 return AtlsHttpError(500, ISE_SUBERR_BADSRF);
3524 }
3525
3526 hcErr = FinishLoadStencil(pStencil, pLookup);
3527 if (!hcErr)
3528 {
3529 #ifdef ATL_DEBUG_STENCILS
3530 pStencil->FinishParseReplacements();
3531 #else
3532 if (!pStencil->FinishParseReplacements())
3533 {
3534 return AtlsHttpError(500, ISE_SUBERR_BADSRF);
3535 }
3536 #endif // ATL_DEBUG_STENCILS
3537 }
3538 }
3539 _ATLCATCHALL()
3540 {
3541 return HTTP_FAIL;
3542 }
3543 }
3544
3545 // if everything is OK, cache the stencil
3546 if (!hcErr)
3547 {
3548 hcErr = CacheStencil(szFileName, pStencil);
3549 }
3550
3551 if (pStencil && hcErr) // something went wrong, free stencil data
3552 FreeCacheStencil(pStencil);
3553 }
3554 else
3555 {
3556 hcErr = FinishLoadStencil(pStencil, pLookup);
3557 }
3558 return hcErr;
3559 }
3560
3561 HTTP_CODE RenderStencil(IWriteStream* pStream, CStencilState* pState = NULL) throw(...)
3562 {
3563 if (!m_pLoadedStencil)
3564 return AtlsHttpError(500, ISE_SUBERR_UNEXPECTED);
3565
3566 WORD nCodePage = m_pLoadedStencil->GetCodePage();
3567 if (nCodePage != CP_ACP)
3568 m_nCodePage = nCodePage;
3569
3570 HTTP_CODE hcErr = HTTP_FAIL;
3571
3572 hcErr = m_pLoadedStencil->Render(static_cast<ITagReplacer*>(this),
3573 pStream, pState);
3574
3575 if (!IsAsyncStatus(hcErr) && m_pLoadedStencil->GetCacheItem())
3576 m_spStencilCache->ReleaseStencil(m_pLoadedStencil->GetCacheItem());
3577
3578 return hcErr;
3579 }
3580
3581
3582 //Implementation
3583
3584 void FreeHandlers() throw(...)
3585 {
3586 POSITION pos = m_Handlers.GetStartPosition();
3587 while (pos)
3588 {
3589 m_Handlers.GetValueAt(pos)->UninitializeHandler();
3590 m_Handlers.GetNextValue(pos)->Release();
3591 }
3592 m_Handlers.RemoveAll();
3593
3594 int nLen = m_hInstHandlers.GetSize();
3595 if (nLen != 0)
3596 {
3597 THandler *pT = static_cast<THandler *>(this);
3598 CComPtr<IDllCache> spDllCache;
3599 pT->m_spServiceProvider->QueryService(__uuidof(IDllCache), __uuidof(IDllCache),
3600 (void **)&spDllCache);
3601 for (int i=0; i<nLen; i++)
3602 {
3603 spDllCache->Free(m_hInstHandlers[i]);
3604 }
3605 m_hInstHandlers.RemoveAll();
3606 }
3607 }
3608
3609 StencilType* GetNewCacheStencil() throw(...)
3610 {
3611 StencilType *pStencil = NULL;
3612 THandler *pT = static_cast<THandler *>(this);
3613 IAtlMemMgr *pMemMgr;
3614 if (FAILED(pT->m_spServiceProvider->QueryService(__uuidof(IAtlMemMgr), __uuidof(IAtlMemMgr), (void **)&pMemMgr)))
3615 pMemMgr = NULL;
3616
3617 ATLTRY(pStencil = new StencilType(pMemMgr));
3618 if (pStencil != NULL)
3619 {
3620 pStencil->Initialize(pT->m_spServiceProvider);
3621 }
3622 return pStencil;
3623 }
3624
3625 HTTP_CODE CacheStencil(
3626 LPCSTR szName,
3627 StencilType* pStencilData) throw()
3628 {
3629 THandler *pT = static_cast<THandler *>(this);
3630 HRESULT hr = E_FAIL;
3631
3632 HCACHEITEM hCacheItem = NULL;
3633
3634 hr = m_spStencilCache->CacheStencil(szName,
3635 pStencilData,
3636 sizeof(StencilType*),
3637 &hCacheItem,
3638 pT->m_hInstHandler,
3639 static_cast<IMemoryCacheClient*>(pStencilData));
3640
3641 if (hr == S_OK && hCacheItem)
3642 {
3643 _ATLTRY
3644 {
3645 pStencilData->SetCacheItem(hCacheItem);
3646 }
3647 _ATLCATCHALL()
3648 {
3649 hr = E_FAIL;
3650 }
3651 }
3652
3653 return (hr == S_OK) ? HTTP_SUCCESS : HTTP_FAIL;
3654 }
3655
3656 StencilType *FindCacheStencil(LPCSTR szName) throw()
3657 {
3658 if (!szName || !m_spStencilCache)
3659 return NULL;
3660
3661 StencilType *pStencilData = NULL;
3662
3663 HCACHEITEM hStencil;
3664
3665 if (m_spStencilCache->LookupStencil(szName, &hStencil) != S_OK)
3666 return NULL;
3667
3668 m_spStencilCache->GetStencil(hStencil, reinterpret_cast<void **>(&pStencilData));
3669
3670 return pStencilData;
3671 }
3672
3673 void FreeCacheStencil(StencilType* pStencilData)
3674 {
3675 ATLASSERT( pStencilData != NULL );
3676
3677 if(!pStencilData)
3678 {
3679 return;
3680 }
3681
3682 IMemoryCacheClient *pMemCacheClient = static_cast<IMemoryCacheClient *>(pStencilData);
3683
3684 if(!pMemCacheClient)
3685 {
3686 return;
3687 }
3688
3689 _ATLTRY
3690 {
3691 pMemCacheClient->Free(pStencilData);
3692 }
3693 _ATLCATCHALL()
3694 {
3695 }
3696 }
3697
3698 HTTP_CODE GetHandlerOffset(LPCSTR szHandlerName, DWORD* pdwOffset)
3699 {
3700 if (!pdwOffset)
3701 return HTTP_FAIL;
3702
3703 mapType::CPair *p = m_Handlers.Lookup(szHandlerName);
3704 if (p)
3705 {
3706 DWORD dwIndex = 0;
3707 POSITION pos = m_Handlers.GetStartPosition();
3708 while (pos)
3709 {
3710 const mapType::CPair *p1 = m_Handlers.GetNext(pos);
3711 if (p1 == p)
3712 {
3713 *pdwOffset = dwIndex;
3714 return HTTP_SUCCESS;
3715 }
3716 dwIndex++;
3717 }
3718 ATLASSERT(FALSE);
3719 }
3720 *pdwOffset = 0;
3721 return HTTP_FAIL;
3722 }
3723
3724 HTTP_CODE GetReplacementObject(DWORD dwObjOffset, ITagReplacer **ppReplacer)
3725 {
3726 HRESULT hr = E_FAIL;
3727
3728 POSITION pos = m_Handlers.GetStartPosition();
3729 for (DWORD dwIndex=0; dwIndex < dwObjOffset; dwIndex++)
3730 m_Handlers.GetNext(pos);
3731
3732 ATLASSERT(pos != NULL);
3733
3734 IRequestHandler *pHandler = NULL;
3735 pHandler = m_Handlers.GetValueAt(pos);
3736
3737 ATLENSURE(pHandler != NULL);
3738
3739 hr = pHandler->QueryInterface(__uuidof(ITagReplacer), (void**)ppReplacer);
3740
3741 if (hr != S_OK)
3742 return HTTP_FAIL;
3743
3744 return HTTP_SUCCESS;
3745 }
3746
3747 // This is where we would actually load any extra request
3748 // handlers the HTML stencil might have parsed for us.
3749 HTTP_CODE FinishLoadStencil(StencilType *pStencil, IHttpRequestLookup * pLookup = NULL) throw(...)
3750 {
3751 THandler *pT = static_cast<THandler *>(this);
3752 ATLASSERT(pStencil);
3753 if (!pStencil)
3754 return AtlsHttpError(500, ISE_SUBERR_UNEXPECTED); // unexpected condition
3755 m_pLoadedStencil = pStencil;
3756 //load extra handlers if there are any
3757 StencilType::mapType *pExtraHandlersMap =
3758 pStencil->GetExtraHandlers();
3759
3760 if (pExtraHandlersMap)
3761 {
3762 POSITION pos = pExtraHandlersMap->GetStartPosition();
3763 CStringA name;
3764 CStringPair path;
3765 IRequestHandler *pHandler;
3766 HINSTANCE hInstHandler;
3767 while(pos)
3768 {
3769 pExtraHandlersMap->GetNextAssoc(pos, name, path);
3770 pHandler = NULL;
3771 hInstHandler = NULL;
3772 HTTP_CODE hcErr = pT->m_spExtension->LoadRequestHandler(path.strDllPath, path.strHandlerName,
3773 pT->m_spServerContext,
3774 &hInstHandler,
3775 &pHandler);
3776 if (!hcErr)
3777 {
3778 _ATLTRY
3779 {
3780 //map the name to the pointer to request handler
3781 m_Handlers.SetAt(name, pHandler);
3782 //store HINSTANCE of handler
3783 m_hInstHandlers.Add(hInstHandler);
3784 }
3785 _ATLCATCHALL()
3786 {
3787 return HTTP_FAIL;
3788 }
3789
3790 if (pLookup)
3791 {
3792 hcErr = pHandler->InitializeChild(&m_RequestInfo, pT->m_spServiceProvider, pLookup);
3793 if (hcErr != HTTP_SUCCESS)
3794 return hcErr;
3795 }
3796
3797 }
3798 else
3799 return hcErr;
3800 }
3801 }
3802 return HTTP_SUCCESS;
3803 }
3804 }; // class CHtmlTagReplacer
3805
3806
3807 // CRequestHandlerT
3808 // This is the base class for all user request handlers. This class implements
3809 // the IReplacementHandler interface whose methods will be called to render HTML
3810 // into a stream. The stream will be returned as the HTTP response upon completion
3811 // of the HTTP request.
3812 template < class THandler,
3813 class ThreadModel=CComSingleThreadModel,
3814 class TagReplacerType=CHtmlTagReplacer<THandler>
3815 >
3816 class CRequestHandlerT :
3817 public TagReplacerType,
3818 public CComObjectRootEx<ThreadModel>,
3819 public IRequestHandlerImpl<THandler>
3820 {
3821 protected:
3822 CStencilState m_state;
3823 CComObjectStackEx<CIDServerContext> m_SafeSrvCtx;
3824 typedef CRequestHandlerT<THandler, ThreadModel, TagReplacerType> _requestHandler;
3825
3826 public:
3827 BEGIN_COM_MAP(_requestHandler)
3828 COM_INTERFACE_ENTRY(IRequestHandler)
3829 COM_INTERFACE_ENTRY(ITagReplacer)
3830 END_COM_MAP()
3831
3832 // public CRequestHandlerT members
3833 CHttpResponse m_HttpResponse;
3834 CHttpRequest m_HttpRequest;
3835 ATLSRV_REQUESTTYPE m_dwRequestType;
3836 AtlServerRequest* m_pRequestInfo;
3837
3838 CRequestHandlerT() throw()
3839 {
3840 m_hInstHandler = NULL;
3841 m_dwAsyncFlags = 0;
3842 m_pRequestInfo = NULL;
3843 }
3844
3845 ~CRequestHandlerT() throw()
3846 {
3847 _ATLTRY
3848 {
3849 FreeHandlers(); // free handlers held by CTagReplacer
3850 }
3851 _ATLCATCHALL()
3852 {
3853 }
3854 }
3855
3856 void ClearResponse() throw()
3857 {
3858 m_HttpResponse.ClearResponse();
3859 }
3860 // Where user initialization should take place
3861 HTTP_CODE ValidateAndExchange()
3862 {
3863 return HTTP_SUCCESS; // continue processing request
3864 }
3865
3866 // Where user Uninitialization should take place
3867 HTTP_CODE Uninitialize(HTTP_CODE hcError)
3868 {
3869 return hcError;
3870 }
3871
3872 HTTP_CODE InitializeInternal(AtlServerRequest *pRequestInfo, IServiceProvider *pProvider)
3873 {
3874 // Initialize our internal references to required services
3875 m_pRequestInfo = pRequestInfo;
3876 m_state.pParentInfo = pRequestInfo;
3877 m_hInstHandler = pRequestInfo->hInstDll;
3878 m_spServerContext = pRequestInfo->pServerContext;
3879 m_spServiceProvider = pProvider;
3880 return HTTP_SUCCESS;
3881 }
3882
3883 HTTP_CODE InitializeHandler(
3884 AtlServerRequest *pRequestInfo,
3885 IServiceProvider *pProvider)
3886 {
3887 HTTP_CODE hcErr = HTTP_FAIL;
3888 ATLASSERT(pRequestInfo);
3889 ATLASSERT(pProvider);
3890
3891 THandler* pT = static_cast<THandler*>(this);
3892 hcErr = pT->InitializeInternal(pRequestInfo, pProvider);
3893 if (!hcErr)
3894 {
3895 m_HttpResponse.Initialize(m_spServerContext);
3896 hcErr = pT->CheckValidRequest();
3897 if (!hcErr)
3898 {
3899 hcErr = HTTP_FAIL;
3900 if (m_HttpRequest.Initialize(m_spServerContext,
3901 pT->MaxFormSize(),
3902 pT->FormFlags()))
3903 {
3904 if (m_SafeSrvCtx.Initialize(&m_HttpResponse, &m_HttpRequest))
3905 {
3906 hcErr = TagReplacerType::Initialize(pRequestInfo, &m_SafeSrvCtx);
3907 if (!hcErr)
3908 {
3909 hcErr = pT->ValidateAndExchange();
3910 }
3911 }
3912 }
3913 }
3914 }
3915 return hcErr;
3916 }
3917
3918 HTTP_CODE InitializeChild(
3919 AtlServerRequest *pRequestInfo,
3920 IServiceProvider *pProvider,
3921 IHttpRequestLookup *pRequestLookup)
3922 {
3923 ATLASSERT(pRequestInfo);
3924 ATLASSERT(pProvider);
3925
3926 THandler *pT = static_cast<THandler*>(this);
3927 HTTP_CODE hcErr = pT->InitializeInternal(pRequestInfo, pProvider);
3928 if (hcErr)
3929 return hcErr;
3930
3931 if (pRequestLookup)
3932 {
3933 // initialize with the pRequestLookup
3934 if(!m_HttpResponse.Initialize(pRequestLookup))
3935 {
3936 return HTTP_FAIL;
3937 }
3938
3939 // Initialize with the IHttpServerContext if it exists
3940 // the only time this is different than the previous call to
3941 // initialize is if the user passes a different IHttpServerContext
3942 // in pRequestInfo than the one extracted from pRequestLookup.
3943 if (m_spServerContext)
3944 {
3945 if(!m_HttpResponse.Initialize(m_spServerContext))
3946 {
3947 return HTTP_FAIL;
3948 }
3949 }
3950 hcErr = pT->CheckValidRequest();
3951 if (hcErr)
3952 {
3953 return hcErr;
3954 }
3955
3956 // initialize with the pRequestLookup to chain query parameters
3957 m_HttpRequest.Initialize(pRequestLookup);
3958
3959 // initialize with the m_spServerContext to get additional query params
3960 // if they exist.
3961 if (m_spServerContext)
3962 {
3963 m_HttpRequest.Initialize(m_spServerContext);
3964 }
3965 }
3966
3967 m_HttpResponse.SetBufferOutput(false); // child cannot buffer
3968
3969 // initialize the safe server context
3970 if (!m_SafeSrvCtx.Initialize(&m_HttpResponse, &m_HttpRequest))
3971 {
3972 return HTTP_FAIL;
3973 }
3974
3975 hcErr = TagReplacerType::Initialize(pRequestInfo, &m_SafeSrvCtx);
3976 if (hcErr)
3977 {
3978 return hcErr;
3979 }
3980
3981 return pT->ValidateAndExchange();
3982 }
3983
3984 // HandleRequest is called to perform default processing of HTTP requests. Users
3985 // can override this function in their derived classes if they need to perform
3986 // specific initialization prior to processing this request or want to change the
3987 // way the request is processed.
3988 HTTP_CODE HandleRequest(
3989 AtlServerRequest *pRequestInfo,
3990 IServiceProvider* /*pServiceProvider*/)
3991 {
3992 ATLENSURE(pRequestInfo);
3993
3994 THandler *pT = static_cast<THandler *>(this);
3995 HTTP_CODE hcErr = HTTP_SUCCESS;
3996
3997 if (pRequestInfo->dwRequestState == ATLSRV_STATE_BEGIN)
3998 {
3999 m_dwRequestType = pRequestInfo->dwRequestType;
4000
4001 if (pRequestInfo->dwRequestType==ATLSRV_REQUEST_STENCIL)
4002 {
4003 LPCSTR szFileName = pRequestInfo->pServerContext->GetScriptPathTranslated();
4004 hcErr = HTTP_FAIL;
4005 if (szFileName)
4006 hcErr = pT->LoadStencil(szFileName, static_cast<IHttpRequestLookup *>(&m_HttpRequest));
4007 }
4008 }
4009 else if (pRequestInfo->dwRequestState == ATLSRV_STATE_CONTINUE)
4010 m_HttpResponse.ClearContent();
4011
4012 #ifdef ATL_DEBUG_STENCILS
4013 if (m_pLoadedStencil && !m_pLoadedStencil->ParseSuccessful())
4014 {
4015 // An error or series of errors occurred in parsing the stencil
4016 _ATLTRY
4017 {
4018 m_pLoadedStencil->RenderErrors(static_cast<IWriteStream*>(&m_HttpResponse));
4019 }
4020 _ATLCATCHALL()
4021 {
4022 return HTTP_FAIL;
4023 }
4024 }
4025 #endif
4026
4027 if (hcErr == HTTP_SUCCESS && m_pLoadedStencil)
4028 {
4029 // if anything other than HTTP_SUCCESS is returned during
4030 // the rendering of replacement tags, we return that value
4031 // here.
4032 hcErr = pT->RenderStencil(static_cast<IWriteStream*>(&m_HttpResponse), &m_state);
4033
4034 if (hcErr == HTTP_SUCCESS && !m_HttpResponse.Flush(TRUE))
4035 hcErr = HTTP_FAIL;
4036 }
4037
4038 if (IsAsyncFlushStatus(hcErr))
4039 {
4040 pRequestInfo->pszBuffer = LPCSTR(m_HttpResponse.m_strContent);
4041 pRequestInfo->dwBufferLen = m_HttpResponse.m_strContent.GetLength();
4042 }
4043
4044 if (pRequestInfo->dwRequestState == ATLSRV_STATE_BEGIN || IsAsyncDoneStatus(hcErr))
4045 return pT->Uninitialize(hcErr);
4046
4047 else if (!IsAsyncStatus(hcErr))
4048 m_HttpResponse.ClearContent();
4049
4050 return hcErr;
4051 }
4052
4053 HTTP_CODE ServerTransferRequest(LPCSTR szRequest, bool bContinueAfterTransfer=false,
4054 WORD nCodePage = 0, CStencilState *pState = NULL) throw(...)
4055 {
4056 return m_spExtension->TransferRequest(
4057 m_pRequestInfo,
4058 m_spServiceProvider,
4059 static_cast<IWriteStream*>(&m_HttpResponse),
4060 static_cast<IHttpRequestLookup*>(&m_HttpRequest),
4061 szRequest,
4062 nCodePage == 0 ? m_nCodePage : nCodePage,
4063 bContinueAfterTransfer,
4064 pState);
4065 }
4066
4067 inline DWORD MaxFormSize()
4068 {
4069 return DEFAULT_MAX_FORM_SIZE;
4070 }
4071
4072 inline DWORD FormFlags()
4073 {
4074 return ATL_FORM_FLAG_IGNORE_FILES;
4075 }
4076
4077 // Override this function to check if the request
4078 // is valid. This function is called after m_HttpResponse
4079 // has been initialized, so you can use it if you need
4080 // to return an error to the client. This is also a
4081 // good place to initialize any internal class data needed
4082 // to handle the request. CRequestHandlerT::CheckValidRequest
4083 // is called after CRequestHandlerT::InitializeInternal is
4084 // called, so your override of this method will have access to
4085 // m_pRequestInfo (this request's AtlServerRequest structure),
4086 // m_hInstHandler (the HINSTANCE of this handler dll),
4087 // m_spServerContext (the IHttpServerContext interface for this request),
4088 // m_spServiceProvider (the IServiceProvider interface for this request).
4089 // You should call CRequestHandlerT::CheckValidRequest in your override
4090 // if you override this function.
4091 //
4092 // Note that m_HttpRequest has not been initialized, so
4093 // you cannot use it. This function is intended to
4094 // do simple checking throught IHttpServerContext to avoid
4095 // expensive initialization of m_HttpRequest.
4096 HTTP_CODE CheckValidRequest()
4097 {
4098 LPCSTR szMethod = NULL;
4099 ATLASSUME(m_pRequestInfo);
4100 szMethod = m_pRequestInfo->pServerContext->GetRequestMethod();
4101 if (strcmp(szMethod, "GET") && strcmp(szMethod, "POST") && strcmp(szMethod, "HEAD"))
4102 return HTTP_NOT_IMPLEMENTED;
4103
4104 return HTTP_SUCCESS;
4105 }
4106
4107 HRESULT GetContext(REFIID riid, void** ppv)
4108 {
4109 if (!ppv)
4110 return E_POINTER;
4111 if (InlineIsEqualGUID(riid, __uuidof(IHttpServerContext)))
4112 {
4113 return m_spServerContext.CopyTo((IHttpServerContext **)ppv);
4114 }
4115 if (InlineIsEqualGUID(riid, __uuidof(IHttpRequestLookup)))
4116 {
4117 *ppv = static_cast<IHttpRequestLookup*>(&m_HttpRequest);
4118 m_HttpRequest.AddRef();
4119 return S_OK;
4120 }
4121 if (InlineIsEqualGUID(riid, __uuidof(IServiceProvider)))
4122 {
4123 *ppv = m_spServiceProvider;
4124 m_spServiceProvider.p->AddRef();
4125 return S_OK;
4126 }
4127 return E_NOINTERFACE;
4128 }
4129
4130 HINSTANCE GetResourceInstance()
4131 {
4132 if (m_pRequestInfo != NULL)
4133 {
4134 return m_pRequestInfo->hInstDll;
4135 }
4136
4137 return NULL;
4138 }
4139
4140 template <typename Interface>
4141 HRESULT GetContext(Interface** ppInterface) throw(...)
4142 {
4143 return GetContext(__uuidof(Interface), reinterpret_cast<void**>(ppInterface));
4144 }
4145 }; // class CRequestHandlerT
4146
4147 } // namespace ATL
4148 #pragma pack(pop)
4149
4150 #pragma warning( pop )
4151
4152 #endif // __ATLSTENCIL_H__
vsfilter mod based on vsfilter 2.39