?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Support unrar64.dll
[xy_vsfilter.git] / include / atl / atlsoap.h
blobb286e7c61542ab4dde0749f527f5b693d4bcf956
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 __ATLSOAP_H__
12 #define __ATLSOAP_H__
13
14 #pragma once
15
16 #if (defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_))
17 #error require winsock2.h -- include <winsock2.h> before you include <windows.h>
18 #endif
19
20 #if ((_WIN32_WINNT < 0x0400) && (_WIN32_WINDOWS <= 0x0400))
21 #error require _WIN32_WINNT >= 0x0400 or _WIN32_WINDOWS > 0x0400
22 #endif
23
24 #ifndef ATLSOAP_TRACE
25 #ifdef _ATLSOAP_TRACE_XML
26 #define ATLSOAP_TRACE(__data, __len) AtlSoapTraceXML(__data, __len)
27 #else
28 #define ATLSOAP_TRACE(__data, __len) __noop
29 #endif
30 #endif // ATLSOAP_TRACE
31
32 // override this macro to ATL_BASE64_FLAG_NOCRLF if you do
33 // not want Base64-encoded binary data to contain CRLFs
34 #ifndef ATLSOAP_BASE64_FLAGS
35 #define ATLSOAP_BASE64_FLAGS ATL_BASE64_FLAG_NONE
36 #endif // ATLSOAP_BASE64_FLAGS
37
38 [ emitidl(restricted) ];
39 #include <winsock2.h>
40 #include <atlstr.h>
41 #include <atlcoll.h>
42 #include <atlbase.h>
43 #include <msxml2.h>
44 #include <atlenc.h>
45 #include <fcntl.h>
46 #include <float.h>
47 #include <math.h>
48 #include <limits>
49 #include <atlisapi.h>
50 #include <atlstencil.h>
51 #include <atlhttp.h>
52 #include <atlhttp.inl>
53
54 #pragma warning(push)
55 #pragma warning(disable: 4625) // copy constructor could not be generated because a base class copy constructor is inaccessible
56 #pragma warning(disable: 4626) // assignment operator could not be generated because a base class assignment operator is inaccessible
57 #pragma warning(disable: 4061) // enumerate 'enum value' in switch of enum 'enum type' is not explicitly handled by a case label
58
59 #ifndef _CPPUNWIND
60 #pragma warning(disable: 4702) // unreachable code
61 #endif // _CPPUNWIND
62
63 #ifndef ATLSOAP_NOWININET
64 #include <wininet.h>
65 #ifndef ATLSOAPINET_CLIENT
66 #define ATLSOAPINET_CLIENT _T("VCSoapClient")
67 #endif
68 #endif
69
70 #ifndef _ATL_NO_DEFAULT_LIBS
71 #pragma comment(lib, "msxml2.lib")
72 #ifndef ATLSOAP_NOWININET
73 #pragma comment(lib, "wininet.lib")
74 #endif
75 #endif
76
77 #define _ATLSOAP_MAKEWIDESTR( str ) L ## str
78 #define ATLSOAP_MAKEWIDESTR( str ) _ATLSOAP_MAKEWIDESTR( str )
79
80
81 #pragma pack(push,_ATL_PACKING)
82 namespace ATL
83 {
84
85 ATL_NOINLINE inline void AtlSoapTraceXML(LPBYTE pdwData, DWORD dwLen)
86 {
87 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
88 if (hStdOut != INVALID_HANDLE_VALUE)
89 {
90 DWORD dwWritten;
91 WriteFile(hStdOut,
92 "\n-----------------------------------------------------------------\n",
93 sizeof("\n-----------------------------------------------------------------\n")-1,
94 &dwWritten, NULL);
95
96 WriteFile(hStdOut, pdwData, dwLen, &dwWritten, NULL);
97
98 WriteFile(hStdOut,
99 "\n-----------------------------------------------------------------\n",
100 sizeof("\n-----------------------------------------------------------------\n")-1,
101 &dwWritten, NULL);
102 }
103 }
104
105 ////////////////////////////////////////////////////////////////////////////////
106 //
107 // IStreamImpl - stub IStream implementation class
108 //
109 ////////////////////////////////////////////////////////////////////////////////
110
111 class IStreamImpl : public IStream
112 {
113 public:
114
115 HRESULT __stdcall Read(void * /*pDest*/, ULONG /*nMaxLen*/, ULONG * /*pnRead*/)
116 {
117 return E_NOTIMPL;
118 }
119
120 HRESULT __stdcall Write(const void * /*pv*/, ULONG /*cb*/, ULONG * /*pcbWritten*/)
121 {
122 return E_NOTIMPL;
123 }
124
125 HRESULT __stdcall Seek(LARGE_INTEGER /*dlibMove*/, DWORD /*dwOrigin*/,
126 ULARGE_INTEGER * /*pLibNewPosition*/)
127 {
128 return E_NOTIMPL;
129 }
130
131 HRESULT __stdcall SetSize(ULARGE_INTEGER /*libNewSize*/)
132 {
133 return E_NOTIMPL;
134 }
135
136 HRESULT __stdcall CopyTo(IStream * /*pStream*/, ULARGE_INTEGER /*cb*/,
137 ULARGE_INTEGER * /*pcbRead*/, ULARGE_INTEGER * /*pcbWritten*/)
138 {
139 return E_NOTIMPL;
140 }
141
142 HRESULT __stdcall Commit(DWORD /*grfCommitFlags*/)
143 {
144 return E_NOTIMPL;
145 }
146
147 HRESULT __stdcall Revert()
148 {
149 return E_NOTIMPL;
150 }
151
152 HRESULT __stdcall LockRegion(ULARGE_INTEGER /*libOffset*/, ULARGE_INTEGER /*cb*/, DWORD /*dwLockType*/)
153 {
154 return E_NOTIMPL;
155 }
156
157 HRESULT __stdcall UnlockRegion(ULARGE_INTEGER /*libOffset*/, ULARGE_INTEGER /*cb*/, DWORD /*dwLockType*/)
158 {
159 return E_NOTIMPL;
160 }
161
162 HRESULT __stdcall Stat(STATSTG * /*pstatstg*/, DWORD /*grfStatFlag*/)
163 {
164 return E_NOTIMPL;
165 }
166
167 HRESULT __stdcall Clone(IStream ** /*ppstm*/)
168 {
169 return E_NOTIMPL;
170 }
171 }; // class IStreamImpl
172
173 ////////////////////////////////////////////////////////////////////////////////
174 //
175 // CStreamOnServerContext
176 //
177 ////////////////////////////////////////////////////////////////////////////////
178
179 class CStreamOnServerContext : public IStreamImpl
180 {
181 public:
182
183 HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
184 {
185 if (ppv == NULL)
186 {
187 return E_POINTER;
188 }
189
190 *ppv = NULL;
191
192 if (InlineIsEqualGUID(riid, IID_IUnknown) ||
193 InlineIsEqualGUID(riid, IID_IStream) ||
194 InlineIsEqualGUID(riid, IID_ISequentialStream))
195 {
196 *ppv = static_cast<IStream *>(this);
197 return S_OK;
198 }
199
200 return E_NOINTERFACE;
201 }
202
203 ULONG __stdcall AddRef()
204 {
205 return 1;
206 }
207
208 ULONG __stdcall Release()
209 {
210 return 1;
211 }
212
213 private:
214
215 IHttpServerContext * m_pServerContext;
216 DWORD m_dwBytesRead;
217
218 public:
219
220 CStreamOnServerContext(IHttpServerContext *pServerContext = NULL)
221 : m_pServerContext(pServerContext), m_dwBytesRead(0)
222 {
223 }
224
225 void SetServerContext(IHttpServerContext *pServerContext)
226 {
227 ATLASSUME( m_pServerContext == NULL );
228
229 m_pServerContext = pServerContext;
230 }
231
232 HRESULT __stdcall Read(void *pDest, ULONG nMaxLen, ULONG *pnRead)
233 {
234 ATLENSURE( pDest != NULL );
235 ATLASSUME( m_pServerContext != NULL );
236
237 DWORD dwToRead = __min(m_pServerContext->GetTotalBytes()-m_dwBytesRead, nMaxLen);
238 if (ReadClientData(m_pServerContext, (LPSTR) pDest, &dwToRead, m_dwBytesRead) != FALSE)
239 {
240 m_dwBytesRead+= dwToRead;
241
242 if (pnRead != NULL)
243 {
244 *pnRead = dwToRead;
245 }
246
247 return S_OK;
248 }
249
250 ATLTRACE( _T("ATLSOAP: CStreamOnServerContext::Read -- ReadClientData failed.\r\n") );
251
252 return E_FAIL;
253 }
254 }; // class CStreamOnServerContext
255
256 ////////////////////////////////////////////////////////////////////////////////
257 //
258 // CReadStreamOnSocket
259 //
260 ////////////////////////////////////////////////////////////////////////////////
261
262 template <typename TSocketClass>
263 class CReadStreamOnSocket : public IStreamImpl
264 {
265 public:
266
267 HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
268 {
269 if (ppv == NULL)
270 {
271 return E_POINTER;
272 }
273
274 *ppv = NULL;
275
276 if (InlineIsEqualGUID(riid, IID_IUnknown) ||
277 InlineIsEqualGUID(riid, IID_IStream) ||
278 InlineIsEqualGUID(riid, IID_ISequentialStream))
279 {
280 *ppv = static_cast<IStream *>(this);
281 return S_OK;
282 }
283
284 return E_NOINTERFACE;
285 }
286
287 ULONG __stdcall AddRef()
288 {
289 return 1;
290 }
291
292 ULONG __stdcall Release()
293 {
294 return 1;
295 }
296
297 private:
298
299 CAtlHttpClientT<TSocketClass> * m_pSocket;
300 LPCSTR m_szBuffer;
301 LPCSTR m_szCurr;
302 long m_nBodyLen;
303
304 public:
305
306 CReadStreamOnSocket()
307 : m_pSocket(NULL), m_szBuffer(NULL), m_szCurr(NULL), m_nBodyLen(0)
308 {
309 }
310
311 BOOL Init(CAtlHttpClientT<TSocketClass> *pSocket)
312 {
313 ATLENSURE( pSocket != NULL );
314
315 m_pSocket = pSocket;
316 m_szBuffer = (LPCSTR) pSocket->GetBody();
317
318 ATLSOAP_TRACE( (LPBYTE) pSocket->GetBody(), pSocket->GetBodyLength() );
319
320 if (m_szBuffer != NULL)
321 {
322 m_szCurr = m_szBuffer;
323 m_nBodyLen = pSocket->GetBodyLength();
324 if (m_nBodyLen != 0)
325 {
326 return TRUE;
327 }
328 }
329
330 ATLTRACE( _T("ATLSOAP: CReadStreamOnSocket::Init failed.\r\n") );
331
332 return FALSE;
333 }
334
335 HRESULT __stdcall Read(void *pDest, ULONG nMaxLen, ULONG *pnRead)
336 {
337 ATLASSERT( pDest != NULL );
338 ATLASSUME( m_pSocket != NULL );
339 ATLASSUME( m_szBuffer != NULL );
340
341 if (pnRead != NULL)
342 {
343 *pnRead = 0;
344 }
345
346 long nRead = (int) (m_szCurr-m_szBuffer);
347 if (nRead < m_nBodyLen)
348 {
349 long nLength = __min((int)(m_nBodyLen-nRead), (LONG) nMaxLen);
350 Checked::memcpy_s(pDest, nMaxLen, m_szCurr, nLength);
351 m_szCurr+= nLength;
352
353 if (pnRead != NULL)
354 {
355 *pnRead = (ULONG) nLength;
356 }
357 }
358
359 return S_OK;
360 }
361 }; // class CReadStreamOnSocket
362
363 ////////////////////////////////////////////////////////////////////////////////
364 //
365 // CWriteStreamOnCString
366 //
367 ////////////////////////////////////////////////////////////////////////////////
368
369 class CWriteStreamOnCString : public IWriteStream
370 {
371
372 public:
373 CStringA m_str;
374
375 virtual ~CWriteStreamOnCString()
376 {
377 }
378
379 HRESULT WriteStream(LPCSTR szOut, int nLen, LPDWORD pdwWritten)
380 {
381 ATLENSURE_RETURN( szOut != NULL );
382
383 if (nLen < 0)
384 {
385 nLen = (int) strlen(szOut);
386 }
387
388 _ATLTRY
389 {
390 m_str.Append(szOut, nLen);
391 }
392 _ATLCATCHALL()
393 {
394 return E_OUTOFMEMORY;
395 }
396
397 if (pdwWritten != NULL)
398 {
399 *pdwWritten = (DWORD) nLen;
400 }
401
402 return S_OK;
403 }
404
405 HRESULT FlushStream()
406 {
407 return S_OK;
408 }
409
410 void Cleanup()
411 {
412 m_str.Empty();
413 }
414 }; // class CWriteStreamOnCString
415
416 ////////////////////////////////////////////////////////////////////////////////
417 //
418 // Namespaces
419 //
420 ////////////////////////////////////////////////////////////////////////////////
421
422 #define SOAPENV_NAMESPACEA "http://schemas.xmlsoap.org/soap/envelope/"
423 #define SOAPENV_NAMESPACEW ATLSOAP_MAKEWIDESTR( SOAPENV_NAMESPACEA )
424
425 #define SOAPENC_NAMESPACEA "http://schemas.xmlsoap.org/soap/encoding/"
426 #define SOAPENC_NAMESPACEW ATLSOAP_MAKEWIDESTR( SOAPENC_NAMESPACEA )
427
428 #define XSI_NAMESPACEA "http://www.w3.org/2001/XMLSchema-instance"
429 #define XSI_NAMESPACEW ATLSOAP_MAKEWIDESTR( XSI_NAMESPACEA )
430
431 #define XSD_NAMESPACEA "http://www.w3.org/2001/XMLSchema"
432 #define XSD_NAMESPACEW ATLSOAP_MAKEWIDESTR( XSD_NAMESPACEA )
433
434 #ifndef ATLSOAP_GENERIC_NAMESPACE
435 #define ATLSOAP_GENERIC_NAMESPACE L"http://www.tempuri.org"
436 #endif
437
438 ////////////////////////////////////////////////////////////////////////////////
439 //
440 // Helpers
441 //
442 ////////////////////////////////////////////////////////////////////////////////
443
444 inline HRESULT GetAttribute(
445 __in ISAXAttributes *pAttributes,
446 __in_ecount(cchName) const wchar_t *wszAttrName, __in int cchName,
447 __out_ecount_part(*pcchValue, *pcchValue) const wchar_t **pwszValue, __inout int *pcchValue,
448 __in_ecount_opt(cchNamespace) wchar_t *wszNamespace = NULL, __in int cchNamespace = 0)
449 {
450 if (!pAttributes || !wszAttrName || !pwszValue || !pcchValue)
451 {
452 return E_INVALIDARG;
453 }
454
455 *pwszValue = NULL;
456 *pcchValue = 0;
457 if (!wszNamespace)
458 {
459 return (pAttributes->getValueFromQName(wszAttrName, cchName, pwszValue, pcchValue) == S_OK ? S_OK : E_FAIL);
460 }
461 return (pAttributes->getValueFromName(wszNamespace, cchNamespace,
462 wszAttrName, cchName, pwszValue, pcchValue) == S_OK ? S_OK : E_FAIL);
463 }
464
465 inline HRESULT GetAttribute(
466 __in ISAXAttributes *pAttributes,
467 __in_ecount(cchName) const wchar_t *wszAttrName, __in int cchName,
468 __inout CStringW &strValue,
469 __in_ecount_opt(cchNamespace) wchar_t *wszNamespace = NULL, __in int cchNamespace = 0)
470 {
471 const wchar_t *wszValue = NULL;
472 int cchValue = 0;
473
474 if (!pAttributes || !wszAttrName)
475 {
476 return E_INVALIDARG;
477 }
478
479 HRESULT hr;
480 if (!wszNamespace)
481 {
482 hr = (pAttributes->getValueFromQName(wszAttrName, cchName, &wszValue, &cchValue) == S_OK ? S_OK : E_FAIL);
483 }
484 else
485 {
486 hr = (pAttributes->getValueFromName(wszNamespace, cchNamespace,
487 wszAttrName, cchName, &wszValue, &cchValue) == S_OK ? S_OK : E_FAIL);
488 }
489
490 if (hr == S_OK)
491 {
492 _ATLTRY
493 {
494 strValue.SetString(wszValue, cchValue);
495 }
496 _ATLCATCHALL()
497 {
498 ATLTRACE( _T("ATLSOAP: GetAttribute -- out of memory.\r\n") );
499
500 hr = E_OUTOFMEMORY;
501 }
502 }
503
504 return hr;
505 }
506
507 inline const wchar_t *SkipWhitespace(const wchar_t *wsz)
508 {
509 while (*wsz && iswspace(*wsz))
510 ++wsz;
511 return wsz;
512 }
513
514 } // namespace ATL
515 #pragma pack(pop)
516
517 ////////////////////////////////////////////////////////////////////////////////
518 //
519 // BLOB data type - use this struct when you want to send BLOB data
520 // the attribute provider and proxy generator will only properly special
521 // case blob data when using this struct.
522 //
523 ////////////////////////////////////////////////////////////////////////////////
524
525 [ export ]
526 typedef struct _tagATLSOAP_BLOB
527 {
528 unsigned long size;
529 unsigned char *data;
530 } ATLSOAP_BLOB;
531
532 #ifndef _ATL_SOAP_NO_PARAMETER_VALIDATIONS
533 #define _ATL_VALIDATE_PARAMETER_END(p)\
534 do \
535 { \
536 if(*(p) !='\0') \
537 return E_FAIL; \
538 } while(0)
539 #else
540 #define _ATL_VALIDATE_PARAMETER_END(p)
541 #endif
542
543 // All non-integral types have specializations which
544 // will be called. The following function will be called
545 // only for integral types
546
547 #pragma push_macro("max")
548 #pragma push_macro("min")
549 #undef max
550 #undef min
551 template <typename T>
552 inline HRESULT AtlGetSAXValue(T * pVal , const wchar_t * wsz , int cch )
553 {
554 __int64 nVal = *pVal;
555 if (FAILED(AtlGetSAXValue(&nVal, wsz, cch)))
556 return E_FAIL;
557
558 #ifndef _ATL_SOAP_NO_PARAMETER_VALIDATIONS
559 if(nVal < std::numeric_limits<T>::min() || nVal > std::numeric_limits<T>::max())
560 return E_FAIL;
561 #endif
562
563 *pVal = T(nVal);
564 return S_OK;
565
566
567 }
568 #pragma pop_macro("max")
569 #pragma pop_macro("min")
570
571 ////////////////////////////////////////////////////////////////////////////////
572 //
573 // AtlGetXMLValue (for IXMLDOMDocument) - get the real type from the XML data
574 //
575 ///////////////////////////////////////////////////////////////////////////////
576
577 //
578 // generic IXMLDOMNode template function
579 // delegates to AtlGetSAXValue
580 //
581 template <typename T>
582 inline HRESULT AtlGetXMLValue(IXMLDOMNode *pParam, T *pVal)
583 {
584 CComBSTR bstrVal;
585 HRESULT hr = AtlGetXMLValue(pParam, &bstrVal);
586 if (SUCCEEDED(hr))
587 {
588 hr = AtlGetSAXValue(pVal, bstrVal, bstrVal.Length());
589 }
590
591 return hr;
592 }
593
594 // specialization for BSTR
595 template <>
596 inline HRESULT AtlGetXMLValue<BSTR>(IXMLDOMNode *pParam, BSTR *pbstrVal)
597 {
598 if (pParam == NULL)
599 {
600 return E_INVALIDARG;
601 }
602 if (pbstrVal == NULL)
603 {
604 return E_POINTER;
605 }
606
607 CComPtr<IXMLDOMNode> spChild;
608 if (pParam->get_firstChild(&spChild) == S_OK)
609 {
610 CComPtr<IXMLDOMNode> spXmlChild;
611 if (spChild->get_firstChild(&spXmlChild) == S_OK)
612 {
613 return (pParam->get_xml(pbstrVal) == S_OK ? S_OK : E_FAIL);
614 }
615 }
616
617 return (pParam->get_text(pbstrVal) == S_OK) ? S_OK : E_FAIL;
618 }
619
620 ////////////////////////////////////////////////////////////////////////////////
621 //
622 // AtlGetSAXValue - (for SAX or generic) get the real type from the XML data
623 //
624 ////////////////////////////////////////////////////////////////////////////////
625
626 template <>
627 inline HRESULT AtlGetSAXValue<bool>(bool *pVal, __in_z const wchar_t *wsz, int cch)
628 {
629 ATLENSURE( wsz != NULL );
630
631 if (!pVal)
632 {
633 return E_POINTER;
634 }
635
636 *pVal = false;
637
638 HRESULT hr = E_FAIL;
639 switch (wsz[0])
640 {
641 case L'1':
642 {
643 if (cch==1)
644 {
645 *pVal = true;
646 hr = S_OK;
647 }
648 break;
649 }
650 case L'0':
651 {
652 if (cch==1)
653 {
654 *pVal = false;
655 hr = S_OK;
656 }
657 break;
658 }
659 case L't':
660 {
661 if (cch==sizeof("true")-1 && !wcsncmp(wsz, L"true", cch))
662 {
663 *pVal = true;
664 hr = S_OK;
665 }
666 break;
667 }
668 case L'f':
669 {
670 if (cch==sizeof("false")-1 && !wcsncmp(wsz, L"false", cch))
671 {
672 *pVal = false;
673 hr = S_OK;
674 }
675 break;
676 }
677 }
678
679 return hr;
680 }
681
682 template <>
683 inline HRESULT AtlGetSAXValue<__int64>(__int64 *pVal, __in_z const wchar_t *wsz, int cch)
684 {
685 ATLENSURE_RETURN( wsz != NULL );
686
687 if (!pVal)
688 {
689 return E_POINTER;
690 }
691
692 _ATLTRY
693 {
694 CFixedStringT<CStringW, 1024> wstr(wsz, cch);
695 const wchar_t *pStart = ATL::SkipWhitespace(static_cast<LPCWSTR>(wstr));
696 const wchar_t *pEnd;
697
698 __int64 i = 0;
699 errno_t errnoValue = AtlStrToNum(&i, pStart, const_cast<wchar_t **>(&pEnd), 10);
700 if (errnoValue == ERANGE)
701 {
702 return E_FAIL;//overflow or underflow case
703 }
704 pEnd = ATL::SkipWhitespace(pEnd);
705 _ATL_VALIDATE_PARAMETER_END(pEnd);
706 *pVal = i;
707 }
708 _ATLCATCHALL()
709 {
710 return E_OUTOFMEMORY;
711 }
712
713 return S_OK;
714 }
715
716 template <>
717 inline HRESULT AtlGetSAXValue<unsigned __int64>(unsigned __int64 *pVal, __in_z const wchar_t *wsz, int cch)
718 {
719 ATLENSURE_RETURN( wsz != NULL );
720
721 if (!pVal)
722 {
723 return E_POINTER;
724 }
725
726 _ATLTRY
727 {
728 CFixedStringT<CStringW, 1024> wstr(wsz, cch);
729 const wchar_t *pStart = ATL::SkipWhitespace(static_cast<LPCWSTR>(wstr));
730 const wchar_t *pEnd;
731
732 unsigned __int64 i = 0;
733 errno_t errnoValue = AtlStrToNum(&i, pStart, const_cast<wchar_t **>(&pEnd), 10);
734 if (errnoValue == ERANGE)
735 {
736 return E_FAIL;//overflow or underflow case
737 }
738 pEnd = ATL::SkipWhitespace(pEnd);
739 _ATL_VALIDATE_PARAMETER_END(pEnd);
740 *pVal = i;
741 }
742 _ATLCATCHALL()
743 {
744 return E_OUTOFMEMORY;
745 }
746
747 return S_OK;
748 }
749 template <>
750 inline HRESULT AtlGetSAXValue<double>(double *pVal, __in_z const wchar_t *wsz, int cch)
751 {
752 ATLENSURE_RETURN( wsz != NULL );
753
754 if (!pVal)
755 {
756 return E_POINTER;
757 }
758
759 if ((cch == 3) && (wsz[0]==L'I') && (!wcsncmp(wsz, L"INF", cch)))
760 {
761 *(((int *) pVal)+0) = 0x0000000;
762 *(((int *) pVal)+1) = 0x7FF00000;
763 }
764 else if ((cch == 3) && (wsz[0]==L'N') && (!wcsncmp(wsz, L"NaN", cch)))
765 {
766 *(((int *) pVal)+0) = 0x0000000;
767 *(((int *) pVal)+1) = 0xFFF80000;
768 }
769 else if ((cch == 4) && (wsz[1]==L'I') && (!wcsncmp(wsz, L"-INF", cch)))
770 {
771 *(((int *) pVal)+0) = 0x0000000;
772 *(((int *) pVal)+1) = 0xFFF00000;
773 }
774 else
775 {
776 errno_t errnoValue = 0;
777
778 _ATLTRY
779 {
780 CFixedStringT<CStringW, 1024> wstr(wsz, cch);
781 const wchar_t *pStart = ATL::SkipWhitespace(static_cast<LPCWSTR>(wstr));
782 const wchar_t *pEnd;
783 double d = 0.0;
784 errnoValue = AtlStrToNum(&d, pStart, const_cast<wchar_t **>(&pEnd));
785 pEnd = ATL::SkipWhitespace(pEnd);
786 _ATL_VALIDATE_PARAMETER_END(pEnd);
787 *pVal = d;
788 }
789 _ATLCATCHALL()
790 {
791 return E_OUTOFMEMORY;
792 }
793
794 if ((*pVal == -HUGE_VAL) || (*pVal == HUGE_VAL) || (errnoValue == ERANGE))
795 {
796 return E_FAIL;
797 }
798 }
799
800 return S_OK;
801 }
802
803 template <>
804 inline HRESULT AtlGetSAXValue<float>(float *pVal, __in_z const wchar_t *wsz, int cch)
805 {
806 ATLASSERT( wsz != NULL );
807
808 if (!pVal)
809 {
810 return E_POINTER;
811 }
812
813 double d = *pVal;
814 if (SUCCEEDED(AtlGetSAXValue(&d, wsz, cch)))
815 {
816 #ifdef _ATL_SOAP_PARAMETER_VALIDATIONS
817 if(d > FLT_MAX || d < -FLT_MAX)
818 return E_FAIL;
819 #endif
820 *pVal = (float) d;
821 return S_OK;
822 }
823
824 return E_FAIL;
825 }
826
827 template <>
828 inline HRESULT AtlGetSAXValue<BSTR>(BSTR *pVal, __in_z const wchar_t *wsz, int cch)
829 {
830 ATLASSERT( wsz != NULL );
831
832 if (pVal == NULL)
833 {
834 return E_POINTER;
835 }
836
837 *pVal = SysAllocStringLen(wsz, cch);
838
839 return ((*pVal != NULL) ? S_OK : E_OUTOFMEMORY);
840 }
841
842 inline HRESULT AtlGetSAXBlobValue(
843 ATLSOAP_BLOB *pVal,
844 const wchar_t *wsz,
845 int cch,
846 IAtlMemMgr *pMemMgr,
847 bool bHex = false)
848 {
849 ATLENSURE_RETURN( wsz != NULL );
850 ATLENSURE_RETURN( pMemMgr != NULL );
851
852 if (pVal == NULL)
853 {
854 return E_POINTER;
855 }
856
857 if (pVal->data != NULL)
858 {
859 return E_INVALIDARG;
860 }
861
862 pVal->data = NULL;
863 pVal->size = 0;
864
865 int nLength = AtlUnicodeToUTF8(wsz, cch, NULL, 0);
866
867 if (nLength != 0)
868 {
869 char * pSrc = (char *) pMemMgr->Allocate(nLength);
870 if (pSrc != NULL)
871 {
872 nLength = AtlUnicodeToUTF8(wsz, cch, pSrc, nLength);
873 if (nLength != 0)
874 {
875 pVal->data = (unsigned char *) pMemMgr->Allocate(nLength);
876 if (pVal->data != NULL)
877 {
878 BOOL bRet;
879 int nDataLength = nLength;
880 if (!bHex)
881 {
882 bRet = Base64Decode(pSrc, nLength, pVal->data, &nDataLength);
883 }
884 else
885 {
886 bRet = AtlHexDecode(pSrc, nLength, pVal->data, &nDataLength);
887 }
888 if (bRet)
889 {
890 pVal->size = nDataLength;
891 }
892 }
893 }
894
895 pMemMgr->Free(pSrc);
896 }
897 }
898
899 if (pVal->size == 0)
900 {
901 if (pVal->data != NULL)
902 {
903 pMemMgr->Free(pVal->data);
904 pVal->data = NULL;
905 }
906 }
907
908 return S_OK;
909 }
910
911 ////////////////////////////////////////////////////////////////////////////////
912 //
913 // AtlGenXMLValue template and specializations
914 //
915 ////////////////////////////////////////////////////////////////////////////////
916
917 template <typename T>
918 inline HRESULT AtlGenXMLValue(__in IWriteStream *pStream, __in T *pVal)
919 {
920 if ((pStream == NULL) || (pVal == NULL))
921 {
922 return E_INVALIDARG;
923 }
924
925 //
926 // delegate to CWriteStreamHelper
927 //
928 CWriteStreamHelper s(pStream);
929
930 return (s.Write(*pVal) == TRUE ? S_OK : E_FAIL);
931 }
932
933 #ifdef _NATIVE_WCHAR_T_DEFINED
934 template <>
935 inline HRESULT AtlGenXMLValue<wchar_t>(__in IWriteStream *pStream, __in wchar_t *pVal)
936 {
937 return AtlGenXMLValue(pStream, (unsigned short *)pVal);
938 }
939 #endif
940
941 template <>
942 inline HRESULT AtlGenXMLValue<wchar_t *>(__in IWriteStream *pStream, __deref_inout_z wchar_t **pVal)
943 {
944 if ((pStream == NULL) || (*pVal == NULL))
945 {
946 return E_INVALIDARG;
947 }
948
949 wchar_t *wszWrite = *pVal;
950 int nSrcLen = (int)wcslen(*pVal);
951 int nCnt = EscapeXML(*pVal, nSrcLen, NULL, 0);
952 if (nCnt > nSrcLen)
953 {
954 nCnt++;
955 wszWrite = (wchar_t *)calloc((nCnt),sizeof(wchar_t));
956 if (wszWrite == NULL)
957 {
958 return E_OUTOFMEMORY;
959 }
960
961 nCnt = EscapeXML(*pVal, nSrcLen, wszWrite, nCnt);
962 if (nCnt == 0)
963 {
964 free(wszWrite);
965 return E_FAIL;
966 }
967 wszWrite[nCnt] = L'\0';
968 nSrcLen = nCnt;
969 }
970
971 nCnt = AtlUnicodeToUTF8(wszWrite, nSrcLen, NULL, 0);
972 HRESULT hr = E_FAIL;
973 if ((nCnt == 0) || (nCnt == nSrcLen))
974 {
975 CWriteStreamHelper s(pStream);
976
977 hr = (s.Write(wszWrite) == TRUE ? S_OK : E_FAIL);
978 }
979 else
980 {
981 nCnt++;
982 CHeapPtr<char> szWrite;
983 szWrite.AllocateBytes((size_t)(nCnt));
984 if (szWrite != NULL)
985 {
986 nCnt = AtlUnicodeToUTF8(wszWrite, nSrcLen, szWrite, nCnt);
987 if (nCnt != 0)
988 {
989 hr = pStream->WriteStream(szWrite, nCnt, NULL);
990 }
991 }
992 else
993 {
994 ATLTRACE( _T("ATLSOAP: AtlGenXMLValue<wchar_t *> -- out of memory.\r\n") );
995
996 hr = E_OUTOFMEMORY;
997 }
998 }
999
1000 if (wszWrite != *pVal)
1001 {
1002 free(wszWrite);
1003 }
1004
1005 return hr;
1006 }
1007
1008 template <>
1009 inline HRESULT AtlGenXMLValue<double>(IWriteStream *pStream, double *pVal)
1010 {
1011 if ((pStream == NULL) || (pVal == NULL))
1012 {
1013 return E_INVALIDARG;
1014 }
1015
1016 HRESULT hr;
1017 switch (_fpclass(*pVal))
1018 {
1019 case _FPCLASS_SNAN:
1020 case _FPCLASS_QNAN:
1021 {
1022 hr = pStream->WriteStream("NaN", 3, NULL);
1023 break;
1024 }
1025 case _FPCLASS_NINF:
1026 {
1027 hr = pStream->WriteStream("-INF", 4, NULL);
1028 break;
1029 }
1030 case _FPCLASS_PINF:
1031 {
1032 hr = pStream->WriteStream("INF", 3, NULL);
1033 break;
1034 }
1035 case _FPCLASS_NZ:
1036 {
1037 hr = pStream->WriteStream("-0", 2, NULL);
1038 break;
1039 }
1040 default:
1041 {
1042 /***
1043 * 2 = sign + decimal point
1044 * ndec = decimal digits
1045 * 5 = exponent letter (e or E), exponent sign, three digits exponent
1046 * 1 = extra space for rounding
1047 * 1 = string terminator '\0'
1048 ***/
1049 const int ndec = 512;
1050 CHAR szBuf[ndec+9];
1051 szBuf[0] = '\0';
1052 Checked::gcvt_s(szBuf, _countof(szBuf), *pVal, ndec);
1053 size_t nLen = strlen(szBuf);
1054 if (nLen && szBuf[nLen-1] == '.')
1055 {
1056 szBuf[--nLen] = '\0';
1057 }
1058
1059 hr = pStream->WriteStream(szBuf, (int)nLen, NULL);
1060 break;
1061 }
1062 }
1063
1064 return hr;
1065 }
1066
1067 template <>
1068 inline HRESULT AtlGenXMLValue<float>(IWriteStream *pStream, float *pVal)
1069 {
1070 if ((pStream == NULL) || (pVal == NULL))
1071 {
1072 return E_INVALIDARG;
1073 }
1074
1075 double d = *pVal;
1076
1077 return AtlGenXMLValue(pStream, &d);
1078 }
1079
1080 template <>
1081 inline HRESULT AtlGenXMLValue<bool>(IWriteStream *pStream, bool *pVal)
1082 {
1083 if ((pStream == NULL) || (pVal == NULL))
1084 {
1085 return E_INVALIDARG;
1086 }
1087
1088 if (*pVal == true)
1089 {
1090 return pStream->WriteStream("true", sizeof("true")-1, NULL);
1091 }
1092
1093 return pStream->WriteStream("false", sizeof("false")-1, NULL);
1094 }
1095
1096 inline HRESULT AtlGenXMLBlobValue(
1097 IWriteStream *pStream,
1098 ATLSOAP_BLOB *pVal,
1099 IAtlMemMgr *pMemMgr,
1100 bool bHex = false)
1101 {
1102 if ((pStream == NULL) || (pVal == NULL) || (pMemMgr == NULL))
1103 {
1104 return E_INVALIDARG;
1105 }
1106
1107 HRESULT hr = E_FAIL;
1108 int nLength;
1109 if (!bHex)
1110 {
1111 nLength = Base64EncodeGetRequiredLength(pVal->size, ATLSOAP_BASE64_FLAGS);
1112 }
1113 else
1114 {
1115 nLength = AtlHexEncodeGetRequiredLength(pVal->size);
1116 }
1117
1118 char *pEnc = (char *) pMemMgr->Allocate(nLength);
1119 if (pEnc != NULL)
1120 {
1121 BOOL bRet;
1122 if (!bHex)
1123 {
1124 bRet = Base64Encode(pVal->data, pVal->size, pEnc, &nLength, ATLSOAP_BASE64_FLAGS);
1125 }
1126 else
1127 {
1128 bRet = AtlHexEncode(pVal->data, pVal->size, pEnc, &nLength);
1129 }
1130 if (bRet)
1131 {
1132 hr = pStream->WriteStream(pEnc, nLength, NULL);
1133 }
1134
1135 pMemMgr->Free(pEnc);
1136 }
1137
1138 return hr;
1139 }
1140
1141 template <typename T>
1142 inline HRESULT AtlCleanupValue(T * /*pVal*/)
1143 {
1144 return S_OK;
1145 }
1146
1147 inline HRESULT AtlCleanupBlobValue(ATLSOAP_BLOB *pVal, IAtlMemMgr *pMemMgr)
1148 {
1149 if ((pVal == NULL) || (pMemMgr == NULL))
1150 {
1151 return E_INVALIDARG;
1152 }
1153
1154 if (pVal->data != NULL)
1155 {
1156 pMemMgr->Free(pVal->data);
1157 pVal->data = NULL;
1158 pVal->size = 0;
1159 }
1160
1161 return S_OK;
1162 }
1163
1164 template <>
1165 inline HRESULT AtlCleanupValue<ATLSOAP_BLOB>(ATLSOAP_BLOB *pVal)
1166 {
1167 ATLTRACE( _T("Warning: AtlCleanupValue<ATLSOAP_BLOB> was called -- assuming CRT allocator.\r\n") );
1168
1169 if (pVal == NULL)
1170 {
1171 return E_INVALIDARG;
1172 }
1173
1174 if (pVal->data != NULL)
1175 {
1176 free(pVal->data);
1177 pVal->data = NULL;
1178 pVal->size = 0;
1179 }
1180
1181 return S_OK;
1182 }
1183
1184 template <>
1185 inline HRESULT AtlCleanupValue<BSTR>(BSTR *pVal)
1186 {
1187 if (pVal == NULL)
1188 {
1189 // should never happen
1190 ATLASSERT( FALSE );
1191 return E_INVALIDARG;
1192 }
1193
1194 if ((*pVal) != NULL)
1195 {
1196 // null strings are okay
1197 SysFreeString(*pVal);
1198 *pVal = NULL;
1199 }
1200
1201 return S_OK;
1202 }
1203
1204 template <typename T>
1205 inline HRESULT AtlCleanupValueEx(T *pVal, IAtlMemMgr *pMemMgr)
1206 {
1207 pMemMgr;
1208
1209 return AtlCleanupValue(pVal);
1210 }
1211
1212 template <>
1213 inline HRESULT AtlCleanupValueEx<ATLSOAP_BLOB>(ATLSOAP_BLOB *pVal, IAtlMemMgr *pMemMgr)
1214 {
1215 return AtlCleanupBlobValue(pVal, pMemMgr);
1216 }
1217
1218 // single dimensional arrays
1219 template <typename T>
1220 inline HRESULT AtlCleanupArray(T *pArray, int nCnt)
1221 {
1222 if (pArray == NULL)
1223 {
1224 return E_INVALIDARG;
1225 }
1226
1227 for (int i=0; i<nCnt; i++)
1228 {
1229 AtlCleanupValue(&pArray[i]);
1230 }
1231
1232 return S_OK;
1233 }
1234
1235
1236 template <typename T>
1237 inline HRESULT AtlCleanupArrayEx(T *pArray, int nCnt, IAtlMemMgr *pMemMgr)
1238 {
1239 if (pArray == NULL)
1240 {
1241 return E_INVALIDARG;
1242 }
1243
1244 for (int i=0; i<nCnt; i++)
1245 {
1246 AtlCleanupValueEx(&pArray[i], pMemMgr);
1247 }
1248
1249 return S_OK;
1250 }
1251
1252
1253 // multi-dimensional arrays
1254 template <typename T>
1255 inline HRESULT AtlCleanupArrayMD(T *pArray, const int *pDims)
1256 {
1257 if ((pArray == NULL) || (pDims == NULL))
1258 {
1259 return E_INVALIDARG;
1260 }
1261
1262 // calculate size
1263 int nCnt = 1;
1264 for (int i=1; i<=pDims[0]; i++)
1265 {
1266 nCnt*= pDims[i];
1267 }
1268
1269 return AtlCleanupArray(pArray, nCnt);
1270 }
1271
1272 template <typename T>
1273 inline HRESULT AtlCleanupArrayMDEx(T *pArray, const int *pDims, IAtlMemMgr *pMemMgr)
1274 {
1275 if ((pArray == NULL) || (pDims == NULL))
1276 {
1277 return E_INVALIDARG;
1278 }
1279
1280 // calculate size
1281 int nCnt = 1;
1282 for (int i=1; i<=pDims[0]; i++)
1283 {
1284 nCnt*= pDims[i];
1285 }
1286
1287 return AtlCleanupArrayEx(pArray, nCnt, pMemMgr);
1288 }
1289
1290
1291 #pragma pack(push,_ATL_PACKING)
1292 namespace ATL
1293 {
1294
1295 ////////////////////////////////////////////////////////////////////////////////
1296 //
1297 // CSAXSoapErrorHandler
1298 //
1299 ////////////////////////////////////////////////////////////////////////////////
1300
1301 class CSAXSoapErrorHandler : public ISAXErrorHandler
1302 {
1303 private:
1304
1305 CFixedStringT<CStringW, 256> m_strParseError;
1306
1307 public:
1308 virtual ~CSAXSoapErrorHandler()
1309 {
1310 }
1311
1312 HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
1313 {
1314 if (!ppv)
1315 {
1316 return E_POINTER;
1317 }
1318
1319 if (InlineIsEqualGUID(riid, __uuidof(ISAXErrorHandler)) ||
1320 InlineIsEqualGUID(riid, __uuidof(IUnknown)))
1321 {
1322 *ppv = static_cast<ISAXErrorHandler*>(this);
1323 return S_OK;
1324 }
1325 return E_NOINTERFACE;
1326 }
1327
1328 ULONG __stdcall AddRef()
1329 {
1330 return 1;
1331 }
1332
1333 ULONG __stdcall Release()
1334 {
1335 return 1;
1336 }
1337
1338 const CStringW& GetParseError()
1339 {
1340 return m_strParseError;
1341 }
1342
1343 HRESULT __stdcall error(
1344 ISAXLocator *pLocator,
1345 const wchar_t *wszErrorMessage,
1346 HRESULT hrErrorCode)
1347 {
1348 (pLocator);
1349 (wszErrorMessage);
1350 (hrErrorCode);
1351
1352 ATLTRACE( _T("ATLSOAP: parse error: %ws\r\n"), wszErrorMessage );
1353
1354 _ATLTRY
1355 {
1356 m_strParseError = wszErrorMessage;
1357 }
1358 _ATLCATCHALL()
1359 {
1360 return E_FAIL;
1361 }
1362
1363 return hrErrorCode;
1364 }
1365
1366 HRESULT __stdcall fatalError(
1367 ISAXLocator *pLocator,
1368 const wchar_t *wszErrorMessage,
1369 HRESULT hrErrorCode)
1370 {
1371 (pLocator);
1372 (wszErrorMessage);
1373 (hrErrorCode);
1374
1375 ATLTRACE( _T("ATLSOAP: fatal parse error: %ws\r\n"), wszErrorMessage );
1376
1377 _ATLTRY
1378 {
1379 m_strParseError = wszErrorMessage;
1380 }
1381 _ATLCATCHALL()
1382 {
1383 return E_FAIL;
1384 }
1385
1386 return hrErrorCode;
1387 }
1388
1389 HRESULT __stdcall ignorableWarning(
1390 ISAXLocator *pLocator,
1391 const wchar_t *wszErrorMessage,
1392 HRESULT hrErrorCode)
1393 {
1394 (pLocator);
1395 (wszErrorMessage);
1396 (hrErrorCode);
1397
1398 ATLTRACE( _T("ATLSOAP: ignorable warning: %ws\r\n"), wszErrorMessage );
1399
1400 return hrErrorCode;
1401 }
1402 };
1403
1404 ////////////////////////////////////////////////////////////////////////////////
1405 //
1406 // ISAXContentHandlerImpl
1407 //
1408 ////////////////////////////////////////////////////////////////////////////////
1409
1410 class ISAXContentHandlerImpl :
1411 public ISAXContentHandler
1412 {
1413 public:
1414
1415 //
1416 // ISAXContentHandler interface
1417 //
1418
1419 HRESULT __stdcall putDocumentLocator(ISAXLocator * /*pLocator*/)
1420 {
1421 return S_OK;
1422 }
1423
1424 HRESULT __stdcall startDocument()
1425 {
1426 return S_OK;
1427 }
1428
1429 HRESULT __stdcall endDocument()
1430 {
1431 return S_OK;
1432 }
1433
1434 HRESULT __stdcall startPrefixMapping(
1435 const wchar_t * /*wszPrefix*/,
1436 int /*cchPrefix*/,
1437 const wchar_t * /*wszUri*/,
1438 int /*cchUri*/)
1439 {
1440 return S_OK;
1441 }
1442
1443 HRESULT __stdcall endPrefixMapping(
1444 const wchar_t * /*wszPrefix*/,
1445 int /*cchPrefix*/)
1446 {
1447 return S_OK;
1448 }
1449
1450 HRESULT __stdcall startElement(
1451 const wchar_t * /*wszNamespaceUri*/,
1452 int /*cchNamespaceUri*/,
1453 const wchar_t * /*wszLocalName*/,
1454 int /*cchLocalName*/,
1455 const wchar_t * /*wszQName*/,
1456 int /*cchQName*/,
1457 ISAXAttributes * /*pAttributes*/)
1458 {
1459 return S_OK;
1460 }
1461
1462 HRESULT __stdcall endElement(
1463 const wchar_t * /*wszNamespaceUri*/,
1464 int /*cchNamespaceUri*/,
1465 const wchar_t * /*wszLocalName*/,
1466 int /*cchLocalName*/,
1467 const wchar_t * /*wszQName*/,
1468 int /*cchQName*/)
1469 {
1470 return S_OK;
1471 }
1472
1473 HRESULT __stdcall characters(
1474 const wchar_t * /*wszChars*/,
1475 int /*cchChars*/)
1476 {
1477 return S_OK;
1478 }
1479
1480 HRESULT __stdcall ignorableWhitespace(
1481 const wchar_t * /*wszChars*/,
1482 int /*cchChars*/)
1483 {
1484 return S_OK;
1485 }
1486
1487 HRESULT __stdcall processingInstruction(
1488 const wchar_t * /*wszTarget*/,
1489 int /*cchTarget*/,
1490 const wchar_t * /*wszData*/,
1491 int /*cchData*/)
1492 {
1493 return S_OK;
1494 }
1495
1496 HRESULT __stdcall skippedEntity(
1497 const wchar_t * /*wszName*/,
1498 int /*cchName*/)
1499 {
1500 return S_OK;
1501 }
1502 }; // class ISAXContentHandlerImpl
1503
1504 ////////////////////////////////////////////////////////////////////////////////
1505 //
1506 // SAX skip element handler utility class
1507 // (skip an element and all its child elements)
1508 //
1509 ////////////////////////////////////////////////////////////////////////////////
1510
1511 class CSkipHandler : public ISAXContentHandlerImpl
1512 {
1513 public:
1514 virtual ~CSkipHandler()
1515 {
1516 }
1517
1518 HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
1519 {
1520 if (ppv == NULL)
1521 {
1522 return E_POINTER;
1523 }
1524
1525 *ppv = NULL;
1526
1527 if (InlineIsEqualGUID(riid, IID_IUnknown) ||
1528 InlineIsEqualGUID(riid, IID_ISAXContentHandler))
1529 {
1530 *ppv = static_cast<ISAXContentHandler *>(this);
1531 return S_OK;
1532 }
1533
1534 return E_NOINTERFACE;
1535 }
1536
1537 ULONG __stdcall AddRef()
1538 {
1539 return 1;
1540 }
1541
1542 ULONG __stdcall Release()
1543 {
1544 return 1;
1545 }
1546
1547 private:
1548
1549 DWORD m_dwReset;
1550 CComPtr<ISAXXMLReader> m_spReader;
1551 CComPtr<ISAXContentHandler> m_spParent;
1552
1553 DWORD DisableReset(DWORD dwCnt = 1)
1554 {
1555 m_dwReset += dwCnt;
1556
1557 return m_dwReset;
1558 }
1559
1560 DWORD EnableReset()
1561 {
1562 if (m_dwReset > 0)
1563 {
1564 --m_dwReset;
1565 }
1566
1567 return m_dwReset;
1568 }
1569
1570 public:
1571
1572 CSkipHandler(ISAXContentHandler *pParent = NULL, ISAXXMLReader *pReader = NULL)
1573 : m_spParent(pParent), m_spReader(pReader), m_dwReset(1)
1574 {
1575 }
1576
1577 void SetParent(ISAXContentHandler *pParent)
1578 {
1579 m_spParent = pParent;
1580 }
1581 void DetachParent()
1582 {
1583 m_spParent.Detach();
1584 }
1585
1586 void SetReader(ISAXXMLReader *pReader)
1587 {
1588 m_spReader = pReader;
1589 }
1590
1591 HRESULT __stdcall startElement(
1592 const wchar_t * /*wszNamespaceUri*/,
1593 int /*cchNamespaceUri*/,
1594 const wchar_t * /*wszLocalName*/,
1595 int /*cchLocalName*/,
1596 const wchar_t * /*wszQName*/,
1597 int /*cchQName*/,
1598 ISAXAttributes * /*pAttributes*/)
1599 {
1600 DisableReset();
1601 return S_OK;
1602 }
1603
1604 HRESULT __stdcall endElement(
1605 const wchar_t * /*wszNamespaceUri*/,
1606 int /*cchNamespaceUri*/,
1607 const wchar_t * /*wszLocalName*/,
1608 int /*cchLocalName*/,
1609 const wchar_t * /*wszQName*/,
1610 int /*cchQName*/)
1611 {
1612 if (EnableReset() == 0)
1613 {
1614 m_spReader->putContentHandler(m_spParent);
1615 }
1616
1617 return S_OK;
1618 }
1619 }; // class CSkipHandler
1620
1621
1622 ////////////////////////////////////////////////////////////////////////////////
1623 //
1624 // SAX string builder class
1625 //
1626 ////////////////////////////////////////////////////////////////////////////////
1627
1628 class CSAXStringBuilder : public ISAXContentHandlerImpl
1629 {
1630 public:
1631
1632 HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
1633 {
1634 if (ppv == NULL)
1635 {
1636 return E_POINTER;
1637 }
1638
1639 *ppv = NULL;
1640
1641 if (InlineIsEqualGUID(riid, IID_IUnknown) ||
1642 InlineIsEqualGUID(riid, IID_ISAXContentHandler))
1643 {
1644 *ppv = static_cast<ISAXContentHandler *>(this);
1645 return S_OK;
1646 }
1647
1648 return E_NOINTERFACE;
1649 }
1650
1651 ULONG __stdcall AddRef()
1652 {
1653 return 1;
1654 }
1655
1656 ULONG __stdcall Release()
1657 {
1658 return 1;
1659 }
1660
1661 private:
1662
1663 ISAXContentHandler * m_pParent;
1664 ISAXXMLReader * m_pReader;
1665 DWORD m_dwReset;
1666 CFixedStringT<CStringW, 64> m_str;
1667
1668 DWORD DisableReset(DWORD dwReset = 1)
1669 {
1670 m_dwReset+= dwReset;
1671
1672 return m_dwReset;
1673 }
1674
1675 DWORD EnableReset()
1676 {
1677 if (m_dwReset > 0)
1678 {
1679 --m_dwReset;
1680 }
1681
1682 return m_dwReset;
1683 }
1684
1685 public:
1686
1687 CSAXStringBuilder(ISAXXMLReader *pReader = NULL, ISAXContentHandler *pParent = NULL)
1688 :m_pReader(pReader), m_pParent(pParent), m_dwReset(0)
1689 {
1690 }
1691
1692 virtual ~CSAXStringBuilder()
1693 {
1694 }
1695
1696 void SetReader(ISAXXMLReader *pReader)
1697 {
1698 m_pReader = pReader;
1699 }
1700
1701 void SetParent(ISAXContentHandler *pParent)
1702 {
1703 m_pParent = pParent;
1704 }
1705
1706 const CStringW& GetString()
1707 {
1708 return m_str;
1709 }
1710
1711 void Clear()
1712 {
1713 m_str.Empty();
1714 m_dwReset = 0;
1715 }
1716
1717 HRESULT __stdcall startElement(
1718 const wchar_t * /*wszNamespaceUri*/,
1719 int /*cchNamespaceUri*/,
1720 const wchar_t * /*wszLocalName*/,
1721 int /*cchLocalName*/,
1722 const wchar_t *wszQName,
1723 int cchQName,
1724 ISAXAttributes *pAttributes)
1725 {
1726 if (m_dwReset == 0)
1727 {
1728 // if there is unescaped, nested XML, must disable
1729 // an additional time for the first element
1730 DisableReset();
1731 }
1732 DisableReset();
1733
1734 int nAttrs = 0;
1735 HRESULT hr = pAttributes->getLength(&nAttrs);
1736
1737 _ATLTRY
1738 {
1739 if (SUCCEEDED(hr))
1740 {
1741 m_str.Append(L"<", 1);
1742 m_str.Append(wszQName, cchQName);
1743
1744 const wchar_t *wszAttrNamespaceUri = NULL;
1745 const wchar_t *wszAttrLocalName = NULL;
1746 const wchar_t *wszAttrQName = NULL;
1747 const wchar_t *wszAttrValue = NULL;
1748 int cchAttrUri = 0;
1749 int cchAttrLocalName = 0;
1750 int cchAttrQName = 0;
1751 int cchAttrValue = 0;
1752
1753 for (int i=0; i<nAttrs; i++)
1754 {
1755 hr = pAttributes->getName(i, &wszAttrNamespaceUri, &cchAttrUri,
1756 &wszAttrLocalName, &cchAttrLocalName, &wszAttrQName, &cchAttrQName);
1757
1758 if (FAILED(hr))
1759 {
1760 ATLTRACE( _T("ATLSOAP: CSAXStringBuilder::startElement -- MSXML error.\r\n") );
1761
1762 break;
1763 }
1764
1765 m_str.Append(L" ", 1);
1766 m_str.Append(wszAttrQName, cchAttrQName);
1767
1768 hr = pAttributes->getValue(i, &wszAttrValue, &cchAttrValue);
1769
1770 if (FAILED(hr))
1771 {
1772 ATLTRACE( _T("ATLSOAP: CSAXStringBuilder::startElement -- MSXML error.\r\n") );
1773
1774 break;
1775 }
1776
1777 m_str.Append(L"=\"", sizeof("=\"")-1);
1778 if (cchAttrValue != 0)
1779 {
1780 m_str.Append(wszAttrValue, cchAttrValue);
1781 }
1782 m_str.Append(L"\"", 1);
1783 }
1784
1785 if (SUCCEEDED(hr))
1786 {
1787 m_str.Append(L">", 1);
1788 }
1789 }
1790 }
1791 _ATLCATCHALL()
1792 {
1793 ATLTRACE( _T("ATLSOAP: CSAXStringBuilder::startElement -- out of memory.\r\n") );
1794
1795 hr = E_OUTOFMEMORY;
1796 }
1797
1798 return hr;
1799 }
1800
1801 HRESULT __stdcall endElement(
1802 const wchar_t * wszNamespaceUri,
1803 int cchNamespaceUri,
1804 const wchar_t * wszLocalName,
1805 int cchLocalName,
1806 const wchar_t *wszQName,
1807 int cchQName)
1808 {
1809 HRESULT hr = S_OK;
1810 _ATLTRY
1811 {
1812 if (EnableReset() == 0)
1813 {
1814 hr = m_pParent->characters((LPCWSTR) m_str, m_str.GetLength());
1815 if (SUCCEEDED(hr))
1816 {
1817 hr = m_pParent->endElement(wszNamespaceUri, cchNamespaceUri,
1818 wszLocalName, cchLocalName, wszQName, cchQName);
1819 }
1820
1821 m_pReader->putContentHandler(m_pParent);
1822 }
1823
1824 if (m_dwReset > 0)
1825 {
1826 m_str.Append(L"</", 2);
1827 m_str.Append(wszQName, cchQName);
1828 m_str.Append(L">", 1);
1829 }
1830 }
1831 _ATLCATCHALL()
1832 {
1833 ATLTRACE( _T("ATLSOAP: CSAXStringBuilder::endElement -- out of memory.\r\n") );
1834
1835 hr = E_OUTOFMEMORY;
1836 }
1837
1838 return hr;
1839 }
1840
1841 HRESULT __stdcall characters(
1842 const wchar_t *wszChars,
1843 int cchChars)
1844 {
1845 _ATLTRY
1846 {
1847 m_str.Append(wszChars, cchChars);
1848 }
1849 _ATLCATCHALL()
1850 {
1851 ATLTRACE( _T("ATLSOAP: CSAXStringBuilder::characters -- out of memory.\r\n") );
1852
1853 return E_OUTOFMEMORY;
1854 }
1855
1856 return S_OK;
1857 }
1858
1859 HRESULT __stdcall ignorableWhitespace(
1860 const wchar_t *wszChars,
1861 int cchChars)
1862 {
1863 _ATLTRY
1864 {
1865 m_str.Append(wszChars, cchChars);
1866 }
1867 _ATLCATCHALL()
1868 {
1869 ATLTRACE( _T("ATLSOAP: CSAXStringBuilder::ignorableWhitespace -- out of memory.\r\n") );
1870
1871 return E_OUTOFMEMORY;
1872 }
1873
1874 return S_OK;
1875 }
1876 }; // class CSAXStringBuilder
1877
1878 } // namespace ATL
1879 #pragma pack(pop)
1880
1881 ////////////////////////////////////////////////////////////////////////////////
1882 //
1883 // SOAP data structure definitions
1884 //
1885 ////////////////////////////////////////////////////////////////////////////////
1886
1887 //
1888 // ***************************** WARNING *****************************
1889 // THESE STRUCTURES ARE INTERNAL ONLY, FOR USE WITH THE ATL SERVER SOAP
1890 // ATTRIBUTES. USERS SHOULD NOT USE THESE TYPES DIRECTLY. ABSOLUTELY NO
1891 // GUARANTEES ARE MADE ABOUT BACKWARD COMPATIBILITY FOR DIRECT USE OF
1892 // THESE TYPES.
1893 //
1894
1895 ////////////////////////////////////////////////////////////////////////////////
1896 //
1897 // BEGIN PRIVATE DEFINITIONS
1898 //
1899 ////////////////////////////////////////////////////////////////////////////////
1900
1901 inline HRESULT AtlSoapGetArraySize(ISAXAttributes *pAttributes, size_t *pnSize,
1902 const wchar_t **pwszTypeStart = NULL, const wchar_t **pwszTypeEnd = NULL)
1903 {
1904 if (pnSize == NULL)
1905 {
1906 return E_POINTER;
1907 }
1908
1909 if (pAttributes == NULL)
1910 {
1911 return E_INVALIDARG;
1912 }
1913
1914 *pnSize = 0;
1915
1916 HRESULT hr = S_OK;
1917
1918 _ATLTRY
1919 {
1920 const wchar_t *wszTmp;
1921 int cch;
1922
1923 hr = GetAttribute(pAttributes, L"arrayType", sizeof("arrayType")-1,
1924 &wszTmp, &cch, SOAPENC_NAMESPACEW, sizeof(SOAPENC_NAMESPACEA)-1);
1925
1926 if ((SUCCEEDED(hr)) && (wszTmp != NULL))
1927 {
1928 hr = E_FAIL;
1929
1930 CFixedStringT<CStringW, 1024> wstrArrayType(wszTmp, cch);
1931 const wchar_t *wsz = static_cast<LPCWSTR>(wstrArrayType);
1932
1933 const wchar_t *wszTypeStart = NULL;
1934 const wchar_t *wszTypeEnd = NULL;
1935
1936 // skip spaces
1937 while (iswspace(*wsz) != 0)
1938 {
1939 wsz++;
1940 }
1941
1942 // no need to walk the string if the caller is not interested
1943 if ((pwszTypeStart != NULL) && (pwszTypeEnd != NULL))
1944 {
1945 wszTypeStart = wsz;
1946 wszTypeEnd = wcschr(wszTypeStart, L':');
1947 if (wszTypeEnd != NULL)
1948 {
1949 wszTypeStart = wszTypeEnd+1;
1950 }
1951 }
1952
1953 // SOAP Section 5 encodings are of the form:
1954 // <soap_enc namespace>:arrayType="<type_qname>[dim1(,dim_i)*]
1955 // for example: SOAP-ENC:arrayType="xsd:string[2,4]"
1956
1957 wsz = wcschr(wsz, L'[');
1958 if (wsz != NULL)
1959 {
1960 wszTypeEnd = wsz-1;
1961 if (wsz[1] == ']')
1962 {
1963 return S_FALSE;
1964 }
1965
1966 *pnSize = 1;
1967
1968 // get the size of each dimension
1969 while (wsz != NULL)
1970 {
1971 wsz++;
1972 int nDim = _wtoi(wsz);
1973 if (nDim < 0)
1974 {
1975 hr = E_FAIL;
1976 break;
1977 }
1978 *pnSize *= (size_t) nDim;
1979 if (!nDim)
1980 {
1981 break;
1982 }
1983
1984 wsz = wcschr(wsz, L',');
1985 }
1986
1987 if ((pwszTypeStart != NULL) && (pwszTypeEnd != NULL))
1988 {
1989 *pwszTypeStart = wszTypeStart;
1990 *pwszTypeEnd = wszTypeEnd;
1991 }
1992
1993 hr = S_OK;
1994 }
1995 }
1996 else
1997 {
1998 // not a section-5 encoding
1999 hr = S_FALSE;
2000 }
2001 }
2002 _ATLCATCHALL()
2003 {
2004 hr = E_OUTOFMEMORY;
2005 }
2006
2007 return hr;
2008 }
2009
2010 inline size_t AtlSoapGetArrayDims(const int *pDims)
2011 {
2012 if (pDims == NULL)
2013 {
2014 return 0;
2015 }
2016
2017 size_t nRet = 1;
2018 for (int i=1; i<=pDims[0]; i++)
2019 {
2020 nRet *= pDims[i];
2021 }
2022
2023 return nRet;
2024 }
2025
2026 enum SOAPFLAGS
2027 {
2028 SOAPFLAG_NONE = 0x00000000,
2029 SOAPFLAG_IN = 0x00000001,
2030 SOAPFLAG_OUT = 0x00000002,
2031 SOAPFLAG_RETVAL = 0x00000004,
2032 SOAPFLAG_DYNARR = 0x00000008,
2033 SOAPFLAG_FIXEDARR = 0x00000010,
2034 SOAPFLAG_MUSTUNDERSTAND = 0x00000020,
2035 SOAPFLAG_UNKSIZE = 0x00000040,
2036 SOAPFLAG_READYSTATE = 0x00000080,
2037 SOAPFLAG_FIELD = 0x00000100,
2038 SOAPFLAG_NOMARSHAL = 0x00000200,
2039 SOAPFLAG_NULLABLE = 0x00000400,
2040 SOAPFLAG_DOCUMENT = 0x00000800,
2041 SOAPFLAG_RPC = 0x00001000,
2042 SOAPFLAG_LITERAL = 0x00002000,
2043 SOAPFLAG_ENCODED = 0x00004000,
2044 SOAPFLAG_PID = 0x00008000,
2045 SOAPFLAG_PAD = 0x00010000,
2046 SOAPFLAG_CHAIN = 0x00020000,
2047 SOAPFLAG_SIZEIS = 0x00040000,
2048 SOAPFLAG_DYNARRWRAPPER = 0x00080000
2049 };
2050
2051 enum SOAPMAPTYPE
2052 {
2053 SOAPMAP_ERR = 0,
2054 SOAPMAP_ENUM,
2055 SOAPMAP_FUNC,
2056 SOAPMAP_STRUCT,
2057 SOAPMAP_UNION,
2058 SOAPMAP_HEADER,
2059 SOAPMAP_PARAM
2060 };
2061
2062 struct _soapmap;
2063
2064 struct _soapmapentry
2065 {
2066 ULONG nHash;
2067 const char * szField;
2068 const WCHAR * wszField;
2069 int cchField;
2070 int nVal;
2071 DWORD dwFlags;
2072
2073 size_t nOffset;
2074 const int * pDims;
2075
2076 const _soapmap * pChain;
2077
2078 int nSizeIs;
2079
2080 ULONG nNamespaceHash;
2081 const char *szNamespace;
2082 const wchar_t *wszNamespace;
2083 int cchNamespace;
2084 };
2085
2086 struct _soapmap
2087 {
2088 ULONG nHash;
2089 const char * szName;
2090 const wchar_t * wszName;
2091 int cchName;
2092 int cchWName;
2093 SOAPMAPTYPE mapType;
2094 const _soapmapentry * pEntries;
2095 size_t nElementSize;
2096 size_t nElements;
2097 int nRetvalIndex;
2098
2099 DWORD dwCallFlags;
2100
2101 ULONG nNamespaceHash;
2102 const char *szNamespace;
2103 const wchar_t *wszNamespace;
2104 int cchNamespace;
2105 };
2106
2107 enum SOAPTYPES
2108 {
2109 SOAPTYPE_ERR = -2,
2110 SOAPTYPE_UNK = -1,
2111 SOAPTYPE_STRING = 0,
2112 SOAPTYPE_BOOLEAN,
2113 SOAPTYPE_FLOAT,
2114 SOAPTYPE_DOUBLE,
2115 SOAPTYPE_DECIMAL,
2116 SOAPTYPE_DURATION,
2117 SOAPTYPE_HEXBINARY,
2118 SOAPTYPE_BASE64BINARY,
2119 SOAPTYPE_ANYURI,
2120 SOAPTYPE_ID,
2121 SOAPTYPE_IDREF,
2122 SOAPTYPE_ENTITY,
2123 SOAPTYPE_NOTATION,
2124 SOAPTYPE_QNAME,
2125 SOAPTYPE_NORMALIZEDSTRING,
2126 SOAPTYPE_TOKEN,
2127 SOAPTYPE_LANGUAGE,
2128 SOAPTYPE_IDREFS,
2129 SOAPTYPE_ENTITIES,
2130 SOAPTYPE_NMTOKEN,
2131 SOAPTYPE_NMTOKENS,
2132 SOAPTYPE_NAME,
2133 SOAPTYPE_NCNAME,
2134 SOAPTYPE_INTEGER,
2135 SOAPTYPE_NONPOSITIVEINTEGER,
2136 SOAPTYPE_NEGATIVEINTEGER,
2137 SOAPTYPE_LONG,
2138 SOAPTYPE_INT,
2139 SOAPTYPE_SHORT,
2140 SOAPTYPE_BYTE,
2141 SOAPTYPE_NONNEGATIVEINTEGER,
2142 SOAPTYPE_UNSIGNEDLONG,
2143 SOAPTYPE_UNSIGNEDINT,
2144 SOAPTYPE_UNSIGNEDSHORT,
2145 SOAPTYPE_UNSIGNEDBYTE,
2146 SOAPTYPE_POSITIVEINTEGER,
2147 SOAPTYPE_DATETIME,
2148 SOAPTYPE_TIME,
2149 SOAPTYPE_DATE,
2150 SOAPTYPE_GMONTH,
2151 SOAPTYPE_GYEARMONTH,
2152 SOAPTYPE_GYEAR,
2153 SOAPTYPE_GMONTHDAY,
2154 SOAPTYPE_GDAY,
2155
2156 SOAPTYPE_USERBASE = 0x00001000
2157 };
2158
2159 inline ULONG AtlSoapHashStr(const char * sz)
2160 {
2161 ULONG nHash = 0;
2162 while (*sz != 0)
2163 {
2164 nHash = (nHash<<5)+nHash+(*sz);
2165 sz++;
2166 }
2167
2168 return nHash;
2169 }
2170
2171 inline ULONG AtlSoapHashStr(const wchar_t * sz)
2172 {
2173 ULONG nHash = 0;
2174 while (*sz != 0)
2175 {
2176 nHash = (nHash<<5)+nHash+(*sz);
2177 sz++;
2178 }
2179
2180 return nHash;
2181 }
2182
2183 inline ULONG AtlSoapHashStr(const char * sz, int cch)
2184 {
2185 ULONG nHash = 0;
2186 for (int i=0; i<cch; i++)
2187 {
2188 nHash = (nHash<<5)+nHash+(*sz);
2189 sz++;
2190 }
2191
2192 return nHash;
2193 }
2194
2195 inline ULONG AtlSoapHashStr(const wchar_t * sz, int cch)
2196 {
2197 ULONG nHash = 0;
2198 for (int i=0; i<cch; i++)
2199 {
2200 nHash = (nHash<<5)+nHash+(*sz);
2201 sz++;
2202 }
2203
2204 return nHash;
2205 }
2206
2207 inline size_t AtlSoapGetElementSize(SOAPTYPES type)
2208 {
2209 size_t nRet;
2210 switch (type)
2211 {
2212 case SOAPTYPE_BOOLEAN:
2213 nRet = sizeof(bool);
2214 break;
2215 case SOAPTYPE_FLOAT:
2216 nRet = sizeof(float);
2217 break;
2218 case SOAPTYPE_DOUBLE:
2219 case SOAPTYPE_DECIMAL:
2220 nRet = sizeof(double);
2221 break;
2222 case SOAPTYPE_HEXBINARY:
2223 case SOAPTYPE_BASE64BINARY:
2224 nRet = sizeof(ATLSOAP_BLOB);
2225 break;
2226 case SOAPTYPE_INTEGER:
2227 case SOAPTYPE_NONPOSITIVEINTEGER:
2228 case SOAPTYPE_NEGATIVEINTEGER:
2229 case SOAPTYPE_LONG:
2230 nRet = sizeof(__int64);
2231 break;
2232 case SOAPTYPE_INT:
2233 nRet = sizeof(int);
2234 break;
2235 case SOAPTYPE_SHORT:
2236 nRet = sizeof(short);
2237 break;
2238 case SOAPTYPE_BYTE:
2239 nRet = sizeof(char);
2240 break;
2241 case SOAPTYPE_POSITIVEINTEGER:
2242 case SOAPTYPE_NONNEGATIVEINTEGER:
2243 case SOAPTYPE_UNSIGNEDLONG:
2244 nRet = sizeof(unsigned __int64);
2245 break;
2246 case SOAPTYPE_UNSIGNEDINT:
2247 nRet = sizeof(unsigned int);
2248 break;
2249 case SOAPTYPE_UNSIGNEDSHORT:
2250 nRet = sizeof(unsigned short);
2251 break;
2252 case SOAPTYPE_UNSIGNEDBYTE:
2253 nRet = sizeof(unsigned char);
2254 break;
2255 default:
2256 if ((type != SOAPTYPE_ERR) && (type != SOAPTYPE_UNK) && (type != SOAPTYPE_USERBASE))
2257 {
2258 // treat as string
2259 nRet = sizeof(BSTR);
2260 }
2261 else
2262 {
2263 ATLTRACE( _T("ATLSOAP: AtlSoapGetElementSize -- internal error.\r\n") );
2264 // should never get here
2265 ATLASSERT( FALSE );
2266 nRet = 0;
2267 }
2268 break;
2269 }
2270
2271 return nRet;
2272 }
2273
2274 inline HRESULT AtlSoapGetElementValue(const wchar_t *wsz, int cch,
2275 void *pVal, SOAPTYPES type, IAtlMemMgr *pMemMgr)
2276 {
2277 HRESULT hr = E_FAIL;
2278
2279 switch (type)
2280 {
2281 case SOAPTYPE_BOOLEAN:
2282 hr = AtlGetSAXValue((bool *)pVal, wsz, cch);
2283 break;
2284 case SOAPTYPE_FLOAT:
2285 hr = AtlGetSAXValue((float *)pVal, wsz, cch);
2286 break;
2287 case SOAPTYPE_DOUBLE:
2288 case SOAPTYPE_DECIMAL:
2289 hr = AtlGetSAXValue((double *)pVal, wsz, cch);
2290 break;
2291 case SOAPTYPE_HEXBINARY:
2292 hr = AtlGetSAXBlobValue((ATLSOAP_BLOB *)pVal, wsz, cch, pMemMgr, true);
2293 break;
2294 case SOAPTYPE_BASE64BINARY:
2295 hr = AtlGetSAXBlobValue((ATLSOAP_BLOB *)pVal, wsz, cch, pMemMgr, false);
2296 break;
2297
2298 case SOAPTYPE_INTEGER:
2299 case SOAPTYPE_NONPOSITIVEINTEGER:
2300 case SOAPTYPE_NEGATIVEINTEGER:
2301 case SOAPTYPE_LONG:
2302 hr = AtlGetSAXValue((__int64 *)pVal, wsz, cch);
2303 break;
2304 case SOAPTYPE_INT:
2305 hr = AtlGetSAXValue((int *)pVal, wsz, cch);
2306 break;
2307 case SOAPTYPE_SHORT:
2308 hr = AtlGetSAXValue((short *)pVal, wsz, cch);
2309 break;
2310 case SOAPTYPE_BYTE:
2311 hr = AtlGetSAXValue((char *)pVal, wsz, cch);
2312 break;
2313 case SOAPTYPE_POSITIVEINTEGER:
2314 case SOAPTYPE_NONNEGATIVEINTEGER:
2315 case SOAPTYPE_UNSIGNEDLONG:
2316 hr = AtlGetSAXValue((unsigned __int64 *)pVal, wsz, cch);
2317 break;
2318 case SOAPTYPE_UNSIGNEDINT:
2319 hr = AtlGetSAXValue((unsigned int *)pVal, wsz, cch);
2320 break;
2321 case SOAPTYPE_UNSIGNEDSHORT:
2322 hr = AtlGetSAXValue((unsigned short *)pVal, wsz, cch);
2323 break;
2324 case SOAPTYPE_UNSIGNEDBYTE:
2325 hr = AtlGetSAXValue((unsigned char *)pVal, wsz, cch);
2326 break;
2327 default:
2328 if ((type != SOAPTYPE_ERR) && (type != SOAPTYPE_UNK) && (type != SOAPTYPE_USERBASE))
2329 {
2330 hr = AtlGetSAXValue((BSTR *)pVal, wsz, cch);
2331 }
2332 #ifdef _DEBUG
2333 else
2334 {
2335 ATLTRACE( _T("ATLSOAP: AtlSoapGetElementValue -- internal error.\r\n") );
2336
2337 // should never get here
2338 ATLASSERT( FALSE );
2339 }
2340 #endif
2341 break;
2342 }
2343
2344 return hr;
2345 }
2346
2347 inline HRESULT AtlSoapGenElementValue(void *pVal, IWriteStream *pStream, SOAPTYPES type, IAtlMemMgr *pMemMgr)
2348 {
2349 HRESULT hr = E_FAIL;
2350
2351 switch (type)
2352 {
2353 case SOAPTYPE_BOOLEAN:
2354 hr = AtlGenXMLValue(pStream, (bool *)pVal);
2355 break;
2356 case SOAPTYPE_FLOAT:
2357 hr = AtlGenXMLValue(pStream, (float *)pVal);
2358 break;
2359 case SOAPTYPE_DOUBLE:
2360 case SOAPTYPE_DECIMAL:
2361 hr = AtlGenXMLValue(pStream, (double *)pVal);
2362 break;
2363 case SOAPTYPE_HEXBINARY:
2364 hr = AtlGenXMLBlobValue(pStream, (ATLSOAP_BLOB *)pVal, pMemMgr, true);
2365 break;
2366 case SOAPTYPE_BASE64BINARY:
2367 hr = AtlGenXMLBlobValue(pStream, (ATLSOAP_BLOB *)pVal, pMemMgr, false);
2368 break;
2369
2370 case SOAPTYPE_INTEGER:
2371 case SOAPTYPE_NONPOSITIVEINTEGER:
2372 case SOAPTYPE_NEGATIVEINTEGER:
2373 case SOAPTYPE_LONG:
2374 hr = AtlGenXMLValue(pStream, (__int64 *)pVal);
2375 break;
2376 case SOAPTYPE_INT:
2377 hr = AtlGenXMLValue(pStream, (int *)pVal);
2378 break;
2379 case SOAPTYPE_SHORT:
2380 hr = AtlGenXMLValue(pStream, (short *)pVal);
2381 break;
2382 case SOAPTYPE_BYTE:
2383 hr = AtlGenXMLValue(pStream, (char *)pVal);
2384 break;
2385 case SOAPTYPE_POSITIVEINTEGER:
2386 case SOAPTYPE_NONNEGATIVEINTEGER:
2387 case SOAPTYPE_UNSIGNEDLONG:
2388 hr = AtlGenXMLValue(pStream, (unsigned __int64 *)pVal);
2389 break;
2390 case SOAPTYPE_UNSIGNEDINT:
2391 hr = AtlGenXMLValue(pStream, (unsigned int *)pVal);
2392 break;
2393 case SOAPTYPE_UNSIGNEDSHORT:
2394 hr = AtlGenXMLValue(pStream, (unsigned short *)pVal);
2395 break;
2396 case SOAPTYPE_UNSIGNEDBYTE:
2397 hr = AtlGenXMLValue(pStream, (unsigned char *)pVal);
2398 break;
2399 default:
2400 if ((type != SOAPTYPE_ERR) && (type != SOAPTYPE_UNK) && (type != SOAPTYPE_USERBASE))
2401 {
2402 hr = AtlGenXMLValue(pStream, (BSTR *)pVal);
2403 }
2404 #ifdef _DEBUG
2405 else
2406 {
2407 ATLTRACE( _T("ATLSOAP: AtlSoapGenElementValue -- internal error.\r\n" ) );
2408
2409 // should never get here
2410 ATLASSERT( FALSE );
2411 }
2412 #endif
2413 break;
2414 }
2415 return hr;
2416 }
2417
2418 inline HRESULT AtlSoapCleanupElement(void *pVal, SOAPTYPES type, IAtlMemMgr *pMemMgr)
2419 {
2420 HRESULT hr = S_OK;
2421
2422 switch (type)
2423 {
2424 case SOAPTYPE_BOOLEAN:
2425 case SOAPTYPE_FLOAT:
2426 case SOAPTYPE_DOUBLE:
2427 case SOAPTYPE_DECIMAL:
2428 case SOAPTYPE_INT:
2429 case SOAPTYPE_INTEGER:
2430 case SOAPTYPE_NONPOSITIVEINTEGER:
2431 case SOAPTYPE_NEGATIVEINTEGER:
2432 case SOAPTYPE_LONG:
2433 case SOAPTYPE_SHORT:
2434 case SOAPTYPE_BYTE:
2435 case SOAPTYPE_POSITIVEINTEGER:
2436 case SOAPTYPE_NONNEGATIVEINTEGER:
2437 case SOAPTYPE_UNSIGNEDLONG:
2438 case SOAPTYPE_UNSIGNEDINT:
2439 case SOAPTYPE_UNSIGNEDSHORT:
2440 case SOAPTYPE_UNSIGNEDBYTE:
2441 break;
2442
2443 case SOAPTYPE_HEXBINARY:
2444 case SOAPTYPE_BASE64BINARY:
2445 hr = AtlCleanupBlobValue((ATLSOAP_BLOB *)pVal, pMemMgr);
2446 break;
2447
2448 default:
2449 if ((type != SOAPTYPE_ERR) && (type != SOAPTYPE_UNK) && (type != SOAPTYPE_USERBASE))
2450 {
2451 // treat as string
2452 hr = AtlCleanupValue((BSTR *)pVal);
2453 }
2454 #ifdef _DEBUG
2455 else
2456 {
2457 ATLTRACE( _T("ATLSOAP: AtlSoapCleanupElement -- internal error.\r\n" ) );
2458
2459 // should never get here
2460 ATLASSERT( FALSE );
2461 }
2462 #endif
2463 break;
2464 }
2465
2466 return hr;
2467 }
2468
2469 ////////////////////////////////////////////////////////////////////////////////
2470 //
2471 // END PRIVATE DEFINITIONS
2472 //
2473 ////////////////////////////////////////////////////////////////////////////////
2474
2475 #define SOAP_ENVELOPEA "Envelope"
2476 #define SOAP_ENVELOPEW ATLSOAP_MAKEWIDESTR( SOAP_ENVELOPEA )
2477
2478 #define SOAP_HEADERA "Header"
2479 #define SOAP_HEADERW ATLSOAP_MAKEWIDESTR( SOAP_HEADERA )
2480
2481 #define SOAP_BODYA "Body"
2482 #define SOAP_BODYW ATLSOAP_MAKEWIDESTR( SOAP_BODYA )
2483
2484
2485 #pragma pack(push,_ATL_PACKING)
2486 namespace ATL
2487 {
2488
2489 //
2490 // SOAP fault helpers
2491 //
2492
2493 enum SOAP_ERROR_CODE
2494 {
2495 SOAP_E_UNK=0,
2496 SOAP_E_VERSION_MISMATCH=100,
2497 SOAP_E_MUST_UNDERSTAND=200,
2498 SOAP_E_CLIENT=300,
2499 SOAP_E_SERVER=400
2500 };
2501
2502 // forward declaration of CSoapFault
2503 class CSoapFault;
2504
2505 class CSoapFaultParser : public ISAXContentHandlerImpl
2506 {
2507 private:
2508
2509 CSoapFault *m_pFault;
2510
2511 DWORD m_dwState;
2512
2513 const static DWORD STATE_ERROR = 0;
2514 const static DWORD STATE_ENVELOPE = 1;
2515 const static DWORD STATE_BODY = 2;
2516 const static DWORD STATE_START = 4;
2517 const static DWORD STATE_FAULTCODE = 8;
2518 const static DWORD STATE_FAULTSTRING = 16;
2519 const static DWORD STATE_FAULTACTOR = 32;
2520 const static DWORD STATE_DETAIL = 64;
2521 const static DWORD STATE_RESET = 128;
2522 const static DWORD STATE_SKIP = 256;
2523
2524
2525 CComPtr<ISAXXMLReader> m_spReader;
2526 CSAXStringBuilder m_stringBuilder;
2527 CSkipHandler m_skipHandler;
2528
2529 const wchar_t *m_wszSoapPrefix;
2530 int m_cchSoapPrefix;
2531
2532 public:
2533 virtual ~CSoapFaultParser()
2534 {
2535 m_skipHandler.DetachParent();
2536 }
2537
2538 // IUnknown interface
2539 HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
2540 {
2541 if (ppv == NULL)
2542 {
2543 return E_POINTER;
2544 }
2545
2546 *ppv = NULL;
2547
2548 if (InlineIsEqualGUID(riid, IID_IUnknown) ||
2549 InlineIsEqualGUID(riid, IID_ISAXContentHandler))
2550 {
2551 *ppv = static_cast<ISAXContentHandler *>(this);
2552 return S_OK;
2553 }
2554
2555 return E_NOINTERFACE;
2556 }
2557
2558 ULONG __stdcall AddRef()
2559 {
2560 return 1;
2561 }
2562
2563 ULONG __stdcall Release()
2564 {
2565 return 1;
2566 }
2567
2568 // constructor
2569
2570 CSoapFaultParser(CSoapFault *pFault, ISAXXMLReader *pReader)
2571 :m_pFault(pFault), m_dwState(STATE_ERROR), m_spReader(pReader)
2572 {
2573 ATLASSERT( pFault != NULL );
2574 ATLASSERT( pReader != NULL );
2575 }
2576
2577 // ISAXContentHandler interface
2578 HRESULT __stdcall startElement(
2579 const wchar_t * wszNamespaceUri,
2580 int cchNamespaceUri,
2581 const wchar_t * wszLocalName,
2582 int cchLocalName,
2583 const wchar_t * /*wszQName*/,
2584 int /*cchQName*/,
2585 ISAXAttributes * /*pAttributes*/)
2586 {
2587 struct _faultmap
2588 {
2589 const wchar_t *wszTag;
2590 int cchTag;
2591 DWORD dwState;
2592 };
2593
2594 const static _faultmap s_faultParseMap[] =
2595 {
2596 { L"Envelope", sizeof("Envelope")-1, CSoapFaultParser::STATE_ENVELOPE },
2597 { L"Body", sizeof("Body")-1, CSoapFaultParser::STATE_BODY },
2598 { L"Header", sizeof("Header")-1, CSoapFaultParser::STATE_BODY },
2599 { L"Fault", sizeof("Fault")-1, CSoapFaultParser::STATE_START },
2600 { L"faultcode", sizeof("faultcode")-1, CSoapFaultParser::STATE_FAULTCODE },
2601 { L"faultstring", sizeof("faultstring")-1, CSoapFaultParser::STATE_FAULTSTRING },
2602 { L"faultactor", sizeof("faultactor")-1, CSoapFaultParser::STATE_FAULTACTOR },
2603 { L"detail", sizeof("detail")-1, CSoapFaultParser::STATE_DETAIL }
2604 };
2605
2606 if (m_spReader.p == NULL)
2607 {
2608 ATLTRACE( _T("ATLSOAP: CSoapFaultParser::startElement -- ISAXXMLReader is NULL.\r\n" ) );
2609
2610 return E_INVALIDARG;
2611 }
2612
2613 m_dwState &= ~STATE_RESET;
2614 for (int i=0; i<(sizeof(s_faultParseMap)/sizeof(s_faultParseMap[0])); i++)
2615 {
2616 if ((cchLocalName == s_faultParseMap[i].cchTag) &&
2617 (!wcsncmp(wszLocalName, s_faultParseMap[i].wszTag, cchLocalName)))
2618 {
2619 DWORD dwState = s_faultParseMap[i].dwState;
2620 if ((dwState & (STATE_START | STATE_ENVELOPE | STATE_BODY)) == 0)
2621 {
2622 m_stringBuilder.SetReader(m_spReader);
2623 m_stringBuilder.SetParent(this);
2624
2625 m_stringBuilder.Clear();
2626 m_spReader->putContentHandler( &m_stringBuilder );
2627 }
2628 else
2629 {
2630 if ((dwState <= m_dwState) ||
2631 (cchNamespaceUri != sizeof(SOAPENV_NAMESPACEA)-1) ||
2632 (wcsncmp(wszNamespaceUri, SOAPENV_NAMESPACEW, cchNamespaceUri)))
2633 {
2634 ATLTRACE( _T("ATLSOAP: CSoapFaultParser::startElement -- malformed SOAP fault.\r\n" ) );
2635
2636 return E_FAIL;
2637 }
2638 }
2639
2640 m_dwState = dwState;
2641 return S_OK;
2642 }
2643 }
2644 if (m_dwState > STATE_START)
2645 {
2646 m_dwState = STATE_SKIP;
2647 m_skipHandler.SetReader(m_spReader);
2648 m_skipHandler.SetParent(this);
2649
2650 m_spReader->putContentHandler( &m_skipHandler );
2651 return S_OK;
2652 }
2653
2654 ATLTRACE( _T("ATLSOAP: CSoapFaultParser::startElement -- malformed SOAP fault.\r\n" ) );
2655
2656 return E_FAIL;
2657 }
2658
2659 HRESULT __stdcall startPrefixMapping(
2660 const wchar_t * wszPrefix,
2661 int cchPrefix,
2662 const wchar_t * wszUri,
2663 int cchUri)
2664 {
2665 if ((cchUri == sizeof(SOAPENV_NAMESPACEA)-1) &&
2666 (!wcsncmp(wszUri, SOAPENV_NAMESPACEW, cchUri)))
2667 {
2668 m_wszSoapPrefix = wszPrefix;
2669 m_cchSoapPrefix = cchPrefix;
2670 }
2671
2672 return S_OK;
2673 }
2674
2675 HRESULT __stdcall characters(
2676 const wchar_t * wszChars,
2677 int cchChars);
2678 };
2679
2680 extern __declspec(selectany) const int ATLS_SOAPFAULT_CNT = 4;
2681
2682 class CSoapFault
2683 {
2684 private:
2685
2686 struct _faultcode
2687 {
2688 const wchar_t *wsz;
2689 int cch;
2690 const wchar_t *wszFaultString;
2691 int cchFaultString;
2692 SOAP_ERROR_CODE errCode;
2693 };
2694
2695 static const _faultcode s_faultCodes[];
2696
2697 public:
2698
2699 // members
2700 SOAP_ERROR_CODE m_soapErrCode;
2701 CStringW m_strFaultCode;
2702 CStringW m_strFaultString;
2703 CStringW m_strFaultActor;
2704 CStringW m_strDetail;
2705
2706 CSoapFault()
2707 : m_soapErrCode(SOAP_E_UNK)
2708 {
2709 }
2710
2711 HRESULT SetErrorCode(
2712 const wchar_t *wsz,
2713 const wchar_t *wszSoapPrefix,
2714 int cch = -1,
2715 int cchSoapPrefix = -1,
2716 bool bSetFaultString = true)
2717 {
2718 if ((wsz == NULL) || (wszSoapPrefix == NULL))
2719 {
2720 return E_INVALIDARG;
2721 }
2722
2723 if (cch == -1)
2724 {
2725 cch = (int) wcslen(wsz);
2726 }
2727
2728 while (*wsz && iswspace(*wsz))
2729 {
2730 ++wsz;
2731 --cch;
2732 }
2733
2734 if (cchSoapPrefix == -1)
2735 {
2736 cchSoapPrefix = (int) wcslen(wszSoapPrefix);
2737 }
2738
2739 const wchar_t *wszLocalName = wcschr(wsz, L':');
2740 if (wszLocalName == NULL)
2741 {
2742 // faultCode must be QName
2743
2744 ATLTRACE( _T("ATLSOAP: CSoapFault::SetErrorCode -- faultCode is not a QName.\r\n" ) );
2745
2746 return E_FAIL;
2747 }
2748
2749 // make sure the namespace of the fault is the
2750 // SOAPENV namespace
2751 if ((cchSoapPrefix != (int)(wszLocalName-wsz)) ||
2752 (wcsncmp(wsz, wszSoapPrefix, cchSoapPrefix)))
2753 {
2754 ATLTRACE( _T("ATLSOAP: CSoapFault::SetErrorCode -- fault namespace is incorrect.\r\n" ) );
2755
2756 return E_FAIL;
2757 }
2758
2759 wszLocalName++;
2760 cch -= (int) (wszLocalName-wsz);
2761
2762 _ATLTRY
2763 {
2764 for (int i=0; i<ATLS_SOAPFAULT_CNT; i++)
2765 {
2766 if ((cch == s_faultCodes[i].cch) &&
2767 (!wcsncmp(wszLocalName, s_faultCodes[i].wsz, cch)))
2768 {
2769 m_soapErrCode = s_faultCodes[i].errCode;
2770 if (bSetFaultString != false)
2771 {
2772 m_strFaultString.SetString(s_faultCodes[i].wszFaultString, s_faultCodes[i].cchFaultString);
2773 break;
2774 }
2775 }
2776 }
2777 if (m_strFaultString.GetLength() == 0)
2778 {
2779 m_strFaultCode.SetString(wszLocalName, cch);
2780 }
2781 }
2782 _ATLCATCHALL()
2783 {
2784 ATLTRACE( _T("ATLSOAP: CSoapFault::SetErrorCode -- out of memory.\r\n" ) );
2785
2786 return E_OUTOFMEMORY;
2787 }
2788
2789 return S_OK;
2790 }
2791
2792 HRESULT ParseFault(IStream *pStream, ISAXXMLReader *pReader = NULL)
2793 {
2794 if (pStream == NULL)
2795 {
2796 ATLTRACE( _T("ATLSOAP: CSoapFault::ParseFault -- NULL IStream was passed.\r\n" ) );
2797
2798 return E_INVALIDARG;
2799 }
2800
2801 CComPtr<ISAXXMLReader> spReader;
2802 if (pReader != NULL)
2803 {
2804 spReader = pReader;
2805 }
2806 else
2807 {
2808 if (FAILED(spReader.CoCreateInstance(ATLS_SAXXMLREADER_CLSID, NULL, CLSCTX_INPROC_SERVER)))
2809 {
2810 ATLTRACE( _T("ATLSOAP: CSoapFault::ParseFault -- CoCreateInstance of SAXXMLReader failed.\r\n" ) );
2811
2812 return E_FAIL;
2813 }
2814 }
2815
2816 Clear();
2817 CSoapFaultParser parser(const_cast<CSoapFault *>(this), spReader);
2818 spReader->putContentHandler(&parser);
2819
2820 CComVariant varStream;
2821 varStream = static_cast<IUnknown*>(pStream);
2822
2823 HRESULT hr = spReader->parse(varStream);
2824 spReader->putContentHandler(NULL);
2825 return hr;
2826 }
2827
2828 HRESULT GenerateFault(IWriteStream *pWriteStream)
2829 {
2830 if ((pWriteStream == NULL) || (m_soapErrCode == SOAP_E_UNK))
2831 {
2832 return E_INVALIDARG;
2833 }
2834
2835 ATLASSERT( (m_soapErrCode == SOAP_E_UNK) ||
2836 (m_soapErrCode == SOAP_E_VERSION_MISMATCH) ||
2837 (m_soapErrCode == SOAP_E_MUST_UNDERSTAND) ||
2838 (m_soapErrCode == SOAP_E_CLIENT) ||
2839 (m_soapErrCode == SOAP_E_SERVER) );
2840
2841 HRESULT hr = S_OK;
2842 _ATLTRY
2843 {
2844 const wchar_t *wszFaultCode = NULL;
2845 if (m_strFaultCode.GetLength() == 0)
2846 {
2847 for (int i=0; i<4; i++)
2848 {
2849 if (s_faultCodes[i].errCode == m_soapErrCode)
2850 {
2851 if (m_strFaultString.GetLength() == 0)
2852 {
2853 m_strFaultString.SetString(s_faultCodes[i].wszFaultString,
2854 s_faultCodes[i].cchFaultString);
2855 }
2856
2857 wszFaultCode = s_faultCodes[i].wsz;
2858 break;
2859 }
2860 }
2861 }
2862
2863 if (wszFaultCode == NULL)
2864 {
2865 if (m_strFaultCode.GetLength() != 0)
2866 {
2867 wszFaultCode = m_strFaultCode;
2868 }
2869 else
2870 {
2871 ATLTRACE( _T("CSoapFault::GenerateFault -- missing/invalid fault code.\r\n") );
2872 return E_FAIL;
2873 }
2874 }
2875
2876 const LPCSTR s_szErrorFormat =
2877 "<SOAP:Envelope xmlns:SOAP=\"" SOAPENV_NAMESPACEA "\">"
2878 "<SOAP:Body>"
2879 "<SOAP:Fault>"
2880 "<faultcode>SOAP:%ws</faultcode>"
2881 "<faultstring>%ws</faultstring>"
2882 "%s%ws%s"
2883 "<detail>%ws</detail>"
2884 "</SOAP:Fault>"
2885 "</SOAP:Body>"
2886 "</SOAP:Envelope>";
2887
2888 CStringA strFault;
2889 strFault.Format(s_szErrorFormat, wszFaultCode, m_strFaultString,
2890 m_strFaultActor.GetLength() ? "<faultactor>" : "", m_strFaultActor,
2891 m_strFaultActor.GetLength() ? "</faultactor>" : "",
2892 m_strDetail);
2893
2894 hr = pWriteStream->WriteStream(strFault, strFault.GetLength(), NULL);
2895 }
2896 _ATLCATCHALL()
2897 {
2898 ATLTRACE( _T("ATLSOAP: CSoapFault::GenerateFault -- out of memory.\r\n" ) );
2899 hr = E_OUTOFMEMORY;
2900 }
2901
2902 return hr;
2903 }
2904
2905 void Clear()
2906 {
2907 m_soapErrCode = SOAP_E_UNK;
2908 m_strFaultCode.Empty();
2909 m_strFaultString.Empty();
2910 m_strFaultActor.Empty();
2911 m_strDetail.Empty();
2912 }
2913 }; // class CSoapFault
2914
2915 #define DECLARE_SOAP_FAULT(__name, __faultstring, __errcode) \
2916 { L ## __name, sizeof(__name)-1, L ## __faultstring, sizeof(__faultstring), __errcode },
2917
2918 __declspec(selectany) const CSoapFault::_faultcode CSoapFault::s_faultCodes[] =
2919 {
2920 DECLARE_SOAP_FAULT("VersionMismatch", "SOAP Version Mismatch Error", SOAP_E_VERSION_MISMATCH)
2921 DECLARE_SOAP_FAULT("MustUnderstand", "SOAP Must Understand Error", SOAP_E_MUST_UNDERSTAND)
2922 DECLARE_SOAP_FAULT("Client", "SOAP Invalid Request", SOAP_E_CLIENT)
2923 DECLARE_SOAP_FAULT("Server", "SOAP Server Application Faulted", SOAP_E_SERVER)
2924 };
2925
2926 ATL_NOINLINE inline HRESULT __stdcall CSoapFaultParser::characters(
2927 const wchar_t * wszChars,
2928 int cchChars)
2929 {
2930 if (m_pFault == NULL)
2931 {
2932 return E_INVALIDARG;
2933 }
2934
2935 if (m_dwState & STATE_RESET)
2936 {
2937 return S_OK;
2938 }
2939
2940 HRESULT hr = E_FAIL;
2941 _ATLTRY
2942 {
2943 switch (m_dwState)
2944 {
2945 case STATE_FAULTCODE:
2946 if (m_pFault->m_soapErrCode == SOAP_E_UNK)
2947 {
2948 hr = m_pFault->SetErrorCode(wszChars, m_wszSoapPrefix,
2949 cchChars, m_cchSoapPrefix, false);
2950 }
2951 break;
2952 case STATE_FAULTSTRING:
2953 if (m_pFault->m_strFaultString.GetLength() == 0)
2954 {
2955 m_pFault->m_strFaultString.SetString(wszChars, cchChars);
2956 hr = S_OK;
2957 }
2958 break;
2959 case STATE_FAULTACTOR:
2960 if (m_pFault->m_strFaultActor.GetLength() == 0)
2961 {
2962 m_pFault->m_strFaultActor.SetString(wszChars, cchChars);
2963 hr = S_OK;
2964 }
2965 break;
2966 case STATE_DETAIL:
2967 if (m_pFault->m_strDetail.GetLength() == 0)
2968 {
2969 m_pFault->m_strDetail.SetString(wszChars, cchChars);
2970 hr = S_OK;
2971 }
2972 break;
2973 case STATE_START: case STATE_ENVELOPE : case STATE_BODY : case STATE_SKIP:
2974 hr = S_OK;
2975 break;
2976 default:
2977 // should never get here
2978 ATLASSERT( FALSE );
2979 break;
2980 }
2981 }
2982 _ATLCATCHALL()
2983 {
2984 ATLTRACE( _T("ATLSOAP: CSoapFaultParser::characters -- out of memory.\r\n" ) );
2985
2986 hr = E_OUTOFMEMORY;
2987 }
2988
2989 m_dwState |= STATE_RESET;
2990
2991 return hr;
2992 }
2993
2994 ////////////////////////////////////////////////////////////////////////////////
2995 //
2996 // CSoapRootHandler - the class that does most of the work
2997 //
2998 ////////////////////////////////////////////////////////////////////////////////
2999
3000 #ifndef ATLSOAP_STACKSIZE
3001 // 16 will be plenty for the 99% case
3002 #define ATLSOAP_STACKSIZE 16
3003 #endif
3004
3005 #ifndef ATLSOAP_GROWARRAY
3006 #define ATLSOAP_GROWARRAY 10
3007 #endif
3008
3009 class CSoapRootHandler : public ISAXContentHandlerImpl
3010 {
3011 private:
3012
3013 friend class _CSDLGenerator;
3014
3015 //
3016 // state constants
3017 //
3018 const static DWORD SOAP_START = 0;
3019 const static DWORD SOAP_ENVELOPE = 1;
3020 const static DWORD SOAP_HEADERS = 2;
3021 const static DWORD SOAP_BODY = 3;
3022 const static DWORD SOAP_PARAMS = 4;
3023 const static DWORD SOAP_CALLED = 5;
3024 const static DWORD SOAP_RESPONSE = 6;
3025 const static DWORD SOAP_HEADERS_DONE = 7;
3026
3027 //
3028 // hash values for SOAP namespaces and elements
3029 //
3030 const static ULONG SOAP_ENV = 0x5D3574E2;
3031 const static ULONG SOAP_ENC = 0xBD62724B;
3032 const static ULONG ENVELOPE = 0xDBE6009E;
3033 const static ULONG HEADER = 0xAF4DFFC9;
3034 const static ULONG BODY = 0x0026168E;
3035
3036 //
3037 // XSD Names
3038 //
3039 struct XSDEntry
3040 {
3041 wchar_t * wszName;
3042 char * szName;
3043 int cchName;
3044 };
3045
3046 const static XSDEntry s_xsdNames[];
3047
3048 //
3049 // CBitVector - a dynamically sized bit vector class
3050 //
3051 class CBitVector
3052 {
3053 private:
3054
3055 // 64 bits will handle the 99% case
3056 unsigned __int64 m_nBits;
3057
3058 // when we need to grow
3059 unsigned __int64 * m_pBits;
3060
3061 size_t m_nSize;
3062
3063 bool Grow(size_t nIndex)
3064 {
3065 // Think carefully
3066 // In our current implementation, CHAR_BIT==8, and sizeof(m_nBits)==8. Easy to confuse the two.
3067
3068 // We do math in bits, so this is our max size
3069 ATLENSURE(nIndex<SIZE_MAX/((sizeof(m_nBits)*CHAR_BIT)));
3070
3071 // round up to nearest 64 bits
3072 size_t nAllocSizeBits = nIndex+((sizeof(m_nBits)*CHAR_BIT)-(nIndex%(sizeof(m_nBits)*CHAR_BIT)));
3073 size_t nAllocSizeBytes = nAllocSizeBits/CHAR_BIT;
3074
3075 if (m_pBits != &m_nBits)
3076 {
3077 unsigned __int64 * pNewBits=NULL;
3078 pNewBits = (unsigned __int64 *) realloc(m_pBits, nAllocSizeBytes );
3079 if(!pNewBits)
3080 {
3081 return false;
3082 }
3083 m_pBits=pNewBits;
3084 }
3085 else
3086 {
3087 m_pBits = (unsigned __int64 *) malloc(nAllocSizeBytes );
3088 if (m_pBits != NULL)
3089 {
3090 Checked::memcpy_s(m_pBits, nAllocSizeBytes, &m_nBits, sizeof(m_nBits));
3091 }
3092 }
3093
3094 if (m_pBits != NULL)
3095 {
3096 // set new bits to 0
3097 memset(m_pBits+(m_nSize/(CHAR_BIT*sizeof(m_nBits))), 0x00, (nAllocSizeBits-m_nSize)/CHAR_BIT);
3098 m_nSize = nAllocSizeBits;
3099 return true;
3100 }
3101
3102 ATLTRACE( _T("ATLSOAP: CBitVector::Grow -- out of memory.\r\n" ) );
3103
3104 return false;
3105 }
3106
3107 public:
3108
3109 CBitVector()
3110 : m_nBits(0), m_nSize(sizeof(m_nBits)*CHAR_BIT)
3111 {
3112 m_pBits = &m_nBits;
3113 }
3114
3115 CBitVector(const CBitVector&)
3116 {
3117 m_pBits = &m_nBits;
3118 }
3119
3120 const CBitVector& operator=(const CBitVector& that)
3121 {
3122 if (this != &that)
3123 {
3124 m_pBits = &m_nBits;
3125 }
3126
3127 return *this;
3128 }
3129
3130 bool GetBit(size_t nIndex) const
3131 {
3132 if (nIndex >= m_nSize)
3133 {
3134 return false;
3135 }
3136
3137 size_t i = nIndex/(sizeof(m_nBits)*CHAR_BIT);
3138 size_t nBits = nIndex-i*(sizeof(m_nBits)*CHAR_BIT);
3139 return ((m_pBits[i] >> nBits) & 0x01);
3140 }
3141
3142 bool SetBit(size_t nIndex)
3143 {
3144 if (nIndex >= m_nSize)
3145 {
3146 if (!Grow(nIndex))
3147 {
3148 return false;
3149 }
3150 }
3151
3152 size_t i = nIndex/(sizeof(m_nBits)*CHAR_BIT);
3153 size_t nBits = nIndex-i*(sizeof(m_nBits)*CHAR_BIT);
3154 m_pBits[i] |= (((unsigned __int64) 1) << nBits);
3155
3156 return true;
3157 }
3158
3159 void Clear()
3160 {
3161 if (m_pBits == &m_nBits)
3162 {
3163 m_nBits = 0;
3164 }
3165 else
3166 {
3167 memset(m_pBits, 0x00, (m_nSize/CHAR_BIT));
3168 }
3169 }
3170
3171 ~CBitVector()
3172 {
3173 if (m_pBits != &m_nBits)
3174 {
3175 free(m_pBits);
3176 }
3177
3178 m_pBits = &m_nBits;
3179 m_nSize = sizeof(m_nBits)*CHAR_BIT;
3180 }
3181
3182 void RelocateFixup()
3183 {
3184 if (m_nSize <= sizeof(m_nBits)*CHAR_BIT)
3185 {
3186 m_pBits = &m_nBits;
3187 }
3188 }
3189 }; // class CBitVector
3190
3191 //
3192 // Parsing State
3193 //
3194 struct ParseState
3195 {
3196 void *pvElement;
3197 DWORD dwFlags;
3198 size_t nAllocSize;
3199 size_t nExpectedElements;
3200 size_t nElement;
3201 const _soapmap *pMap;
3202 const _soapmapentry *pEntry;
3203
3204 // mark when we get an item
3205 CBitVector vec;
3206
3207 size_t nDepth;
3208
3209 ParseState(void *pvElement_ = NULL, DWORD dwFlags_ = 0,
3210 size_t nAllocSize_ = 0, size_t nExpectedElements_ = 0,
3211 size_t nElement_ = 0, const _soapmap *pMap_ = NULL,
3212 const _soapmapentry *pEntry_ = NULL)
3213 : pvElement(pvElement_), dwFlags(dwFlags_), nAllocSize(nAllocSize_),
3214 nExpectedElements(nExpectedElements_), nElement(nElement_), pMap(pMap_),
3215 pEntry(pEntry_), nDepth(0)
3216 {
3217 vec.Clear();
3218 }
3219
3220 ParseState(const ParseState& that)
3221 {
3222 pvElement = that.pvElement;
3223 dwFlags = that.dwFlags;
3224 nAllocSize = that.nAllocSize;
3225 nExpectedElements = that.nExpectedElements;
3226 nElement = that.nElement;
3227 pMap = that.pMap;
3228 pEntry = that.pEntry;
3229 nDepth = that.nDepth;
3230 vec.Clear();
3231 }
3232
3233 ~ParseState()
3234 {
3235 pvElement = NULL;
3236 dwFlags = 0;
3237 nAllocSize = 0;
3238 nExpectedElements = 0;
3239 nElement = 0;
3240 pMap = NULL;
3241 pEntry = NULL;
3242 nDepth = 0;
3243 vec.Clear();
3244 }
3245
3246 void RelocateFixup()
3247 {
3248 vec.RelocateFixup();
3249 }
3250 }; // struct ParseState
3251
3252 class CParseStateElementTraits : public CDefaultElementTraits<ParseState>
3253 {
3254 public:
3255 // CBitVector relocate fixup
3256 static void RelocateElements( ParseState* pDest, ParseState* pSrc, size_t nElements )
3257 {
3258 CDefaultElementTraits<ParseState>::RelocateElements(pDest, pSrc, nElements);
3259
3260 // fixup CBitVector
3261 for (size_t i=0; i<nElements; i++)
3262 {
3263 pDest[i].RelocateFixup();
3264 }
3265 }
3266 };
3267
3268 class CResponseGenerator
3269 {
3270 public:
3271 HRESULT StartEnvelope(IWriteStream *pStream)
3272 {
3273 ATLENSURE_RETURN( pStream != NULL );
3274
3275 return pStream->WriteStream("<soap:Envelope "
3276 "xmlns:soap=\"" SOAPENV_NAMESPACEA "\" "
3277 "xmlns:xsi=\"" XSI_NAMESPACEA "\" "
3278 "xmlns:xsd=\"" XSD_NAMESPACEA "\" "
3279 "xmlns:soapenc=\"" SOAPENC_NAMESPACEA "\">",
3280
3281 sizeof("<soap:Envelope "
3282 "xmlns:soap=\"" SOAPENV_NAMESPACEA "\" "
3283 "xmlns:xsi=\"" XSI_NAMESPACEA "\" "
3284 "xmlns:xsd=\"" XSD_NAMESPACEA "\" "
3285 "xmlns:soapenc=\"" SOAPENC_NAMESPACEA "\">")-1,
3286
3287 NULL);
3288 }
3289
3290 HRESULT StartHeaders(IWriteStream *pStream, const _soapmap *pMap)
3291 {
3292 ATLENSURE_RETURN( pStream != NULL );
3293 ATLENSURE_RETURN( pMap != NULL );
3294
3295 HRESULT hr = pStream->WriteStream("<soap:Header", sizeof("<soap:Header")-1, NULL);
3296 if (SUCCEEDED(hr))
3297 {
3298 if ((pMap->dwCallFlags & (SOAPFLAG_RPC | SOAPFLAG_ENCODED)) !=
3299 (SOAPFLAG_RPC | SOAPFLAG_ENCODED))
3300 {
3301 // qualify document/literal by default
3302 // For this version, ATL Server will not respect
3303 // the elementForm* attributes in an XSD schema
3304
3305 hr = pStream->WriteStream(" xmlns=\"", sizeof(" xmlns=\"")-1, NULL);
3306 if (SUCCEEDED(hr))
3307 {
3308 hr = pStream->WriteStream(pMap->szNamespace, pMap->cchNamespace, NULL);
3309 if (SUCCEEDED(hr))
3310 {
3311 hr = pStream->WriteStream("\">", sizeof("\">")-1, NULL);
3312 }
3313 }
3314 }
3315 else
3316 {
3317 // rpc/encoded
3318 hr = pStream->WriteStream(">", sizeof(">")-1, NULL);
3319 }
3320 }
3321 return hr;
3322 }
3323
3324 HRESULT EndHeaders(IWriteStream *pStream)
3325 {
3326 ATLENSURE_RETURN( pStream != NULL );
3327
3328 return pStream->WriteStream("</soap:Header>", sizeof("</soap:Header>")-1, NULL);
3329 }
3330
3331 virtual HRESULT StartBody(IWriteStream *pStream)
3332 {
3333 ATLENSURE_RETURN( pStream != NULL );
3334
3335 return pStream->WriteStream(
3336 "<soap:Body>", sizeof("<soap:Body>")-1, NULL);
3337 }
3338
3339 HRESULT EndBody(IWriteStream *pStream)
3340 {
3341 ATLENSURE_RETURN( pStream != NULL );
3342
3343 return pStream->WriteStream("</soap:Body>", sizeof("</soap:Body>")-1, NULL);
3344 }
3345
3346 HRESULT EndEnvelope(IWriteStream *pStream)
3347 {
3348 ATLENSURE_RETURN( pStream != NULL );
3349
3350 return pStream->WriteStream("</soap:Envelope>", sizeof("</soap:Envelope>")-1, NULL);
3351 }
3352
3353 virtual HRESULT StartMap(IWriteStream *pStream, const _soapmap *pMap, bool bClient) = 0;
3354 virtual HRESULT EndMap(IWriteStream *pStream, const _soapmap *pMap, bool bClient) = 0;
3355
3356 virtual HRESULT StartEntry(IWriteStream *pStream, const _soapmap *pMap, const _soapmapentry *pEntry)
3357 {
3358 ATLENSURE_RETURN( pStream != NULL );
3359 ATLENSURE_RETURN( pEntry != NULL );
3360
3361 // output name
3362 HRESULT hr = pStream->WriteStream("<", 1, NULL);
3363 if (SUCCEEDED(hr))
3364 {
3365 const char *szHeaderNamespace = NULL;
3366 int cchHeaderNamespace = 0;
3367
3368 if ((pMap != NULL) && (pMap->mapType == SOAPMAP_HEADER) &&
3369 ((pEntry->pChain != NULL) &&
3370 (pEntry->pChain->szNamespace !=NULL)) ||
3371 (pEntry->szNamespace != NULL))
3372 {
3373 hr = pStream->WriteStream("snp:", sizeof("snp:")-1, NULL);
3374 if (SUCCEEDED(hr))
3375 {
3376 szHeaderNamespace = pEntry->pChain ?
3377 pEntry->pChain->szNamespace : pEntry->szNamespace;
3378
3379 cchHeaderNamespace = pEntry->pChain ?
3380 pEntry->pChain->cchNamespace : pEntry->cchNamespace;
3381 }
3382 }
3383
3384 if (SUCCEEDED(hr))
3385 {
3386 if ((pEntry->dwFlags & SOAPFLAG_RETVAL)==0)
3387 {
3388 hr = pStream->WriteStream(pEntry->szField, pEntry->cchField, NULL);
3389 }
3390 else
3391 {
3392 hr = pStream->WriteStream("return", sizeof("return")-1, NULL);
3393 }
3394 if (SUCCEEDED(hr))
3395 {
3396 if (szHeaderNamespace != NULL)
3397 {
3398 ATLASSERT( cchHeaderNamespace != 0 );
3399
3400 hr = pStream->WriteStream(" xmlns:snp=\"", sizeof(" xmlns:snp=\"")-1, NULL);
3401 if (SUCCEEDED(hr))
3402 {
3403 hr = pStream->WriteStream(szHeaderNamespace, cchHeaderNamespace, NULL);
3404 if (SUCCEEDED(hr))
3405 {
3406 hr = pStream->WriteStream("\"", sizeof("\"")-1, NULL);
3407 }
3408 }
3409 }
3410 }
3411 }
3412 }
3413 if (SUCCEEDED(hr))
3414 {
3415 if (pEntry->dwFlags & SOAPFLAG_MUSTUNDERSTAND)
3416 {
3417 // output mustUnderstand
3418 hr = pStream->WriteStream(" soap:mustUnderstand=\"1\"", sizeof(" soap:mustUnderstand=\"1\"")-1, NULL);
3419 }
3420 }
3421 return hr;
3422 }
3423
3424 HRESULT EndEntry(IWriteStream *pStream, const _soapmap *pMap, const _soapmapentry *pEntry)
3425 {
3426 ATLENSURE_RETURN( pStream != NULL );
3427 ATLENSURE_RETURN( pEntry != NULL );
3428
3429 HRESULT hr = pStream->WriteStream("</", 2, NULL);
3430 if (SUCCEEDED(hr))
3431 {
3432 if ((pMap != NULL) &&
3433 (pMap->mapType == SOAPMAP_HEADER) &&
3434 ((pEntry->pChain != NULL) &&
3435 (pEntry->pChain->szNamespace !=NULL)) ||
3436 (pEntry->szNamespace != NULL))
3437 {
3438 hr = pStream->WriteStream("snp:", sizeof("snp:")-1, NULL);
3439 }
3440 if ((pEntry->dwFlags & SOAPFLAG_RETVAL)==0)
3441 {
3442 hr = pStream->WriteStream(pEntry->szField, pEntry->cchField, NULL);
3443 }
3444 else
3445 {
3446 hr = pStream->WriteStream("return", sizeof("return")-1, NULL);
3447 }
3448 if (SUCCEEDED(hr))
3449 {
3450 hr = pStream->WriteStream(">", 1, NULL);
3451 }
3452 }
3453 return hr;
3454 }
3455 }; // class CResponseGenerator
3456
3457 class CDocLiteralGenerator : public CResponseGenerator
3458 {
3459 public:
3460
3461 HRESULT StartMap(IWriteStream *pStream, const _soapmap *pMap, bool bClient)
3462 {
3463 ATLENSURE_RETURN( pStream != NULL );
3464 ATLENSURE_RETURN( pMap != NULL );
3465
3466 HRESULT hr = S_OK;
3467 // output type name
3468 hr = pStream->WriteStream("<", 1, NULL);
3469 if (SUCCEEDED(hr))
3470 {
3471 hr = pStream->WriteStream(pMap->szName, pMap->cchName, NULL);
3472 if (SUCCEEDED(hr))
3473 {
3474 if ((pMap->mapType == SOAPMAP_FUNC) &&
3475 (bClient == false) &&
3476 (pMap->dwCallFlags & SOAPFLAG_PID))
3477 {
3478 hr = pStream->WriteStream("Response", sizeof("Response")-1, NULL);
3479 if (FAILED(hr))
3480 {
3481 return hr;
3482 }
3483 }
3484
3485 if (pMap->mapType == SOAPMAP_FUNC)
3486 {
3487 hr = pStream->WriteStream(" xmlns=\"", sizeof(" xmlns=\"")-1, NULL);
3488 if (SUCCEEDED(hr))
3489 {
3490 hr = pStream->WriteStream(pMap->szNamespace, pMap->cchNamespace, NULL);
3491 if (SUCCEEDED(hr))
3492 {
3493 hr = pStream->WriteStream("\">", sizeof("\">")-1, NULL);
3494 }
3495 }
3496 }
3497 else
3498 {
3499 hr = pStream->WriteStream(">", 1, NULL);
3500 }
3501 }
3502 }
3503 return hr;
3504 }
3505
3506 HRESULT EndMap(IWriteStream *pStream, const _soapmap *pMap, bool bClient)
3507 {
3508 ATLENSURE_RETURN( pStream != NULL );
3509 ATLENSURE_RETURN( pMap != NULL );
3510
3511 HRESULT hr = pStream->WriteStream("</", sizeof("</")-1, NULL);
3512 if (SUCCEEDED(hr))
3513 {
3514 hr = pStream->WriteStream(pMap->szName, pMap->cchName, NULL);
3515 if (SUCCEEDED(hr))
3516 {
3517 if ((pMap->mapType == SOAPMAP_FUNC) &&
3518 (bClient == false) &&
3519 (pMap->dwCallFlags & SOAPFLAG_PID))
3520 {
3521 hr = pStream->WriteStream("Response", sizeof("Response")-1, NULL);
3522 if (FAILED(hr))
3523 {
3524 return hr;
3525 }
3526 }
3527 hr = pStream->WriteStream(">", 1, NULL);
3528 }
3529 }
3530
3531 return hr;
3532 }
3533
3534 }; // class CDocLiteralGenerator
3535
3536 class CPIDGenerator : public CDocLiteralGenerator
3537 {
3538 };
3539
3540 class CPADGenerator : public CDocLiteralGenerator
3541 {
3542 public:
3543
3544 virtual HRESULT StartEntry(IWriteStream *pStream, const _soapmap *pMap, const _soapmapentry *pEntry)
3545 {
3546 ATLENSURE_RETURN( pStream != NULL );
3547 ATLENSURE_RETURN( pEntry != NULL );
3548
3549 HRESULT hr = __super::StartEntry(pStream, pMap, pEntry);
3550 if (SUCCEEDED(hr) && (pMap->dwCallFlags & SOAPFLAG_PAD))
3551 {
3552 hr = pStream->WriteStream(" xmlns=\"", sizeof(" xmlns=\"")-1, NULL);
3553 if (SUCCEEDED(hr))
3554 {
3555 hr = pStream->WriteStream(pMap->szNamespace, pMap->cchNamespace, NULL);
3556 if (SUCCEEDED(hr))
3557 {
3558 hr = pStream->WriteStream("\"", sizeof("\"")-1, NULL);
3559 }
3560 }
3561 }
3562
3563 return hr;
3564 }
3565 }; // class CPADGenerator
3566
3567 class CRpcEncodedGenerator : public CResponseGenerator
3568 {
3569 public:
3570
3571 HRESULT StartBody(IWriteStream *pStream)
3572 {
3573 ATLENSURE_RETURN( pStream != NULL );
3574
3575 return pStream->WriteStream(
3576 "<soap:Body soap:encodingStyle=\"" SOAPENC_NAMESPACEA "\">",
3577 sizeof("<soap:Body soap:encodingStyle=\"" SOAPENC_NAMESPACEA "\">")-1, NULL);
3578 }
3579
3580 HRESULT StartMap(IWriteStream *pStream, const _soapmap *pMap, bool bClient)
3581 {
3582 ATLENSURE_RETURN( pStream != NULL );
3583 ATLENSURE_RETURN( pMap != NULL );
3584
3585 (bClient); // unused for rpc/encoded
3586
3587 HRESULT hr = pStream->WriteStream("<snp:", sizeof("<snp:")-1, NULL);
3588 if (SUCCEEDED(hr))
3589 {
3590 hr = pStream->WriteStream(pMap->szName, pMap->cchName, NULL);
3591 if (SUCCEEDED(hr))
3592 {
3593 if (pMap->mapType == SOAPMAP_FUNC)
3594 {
3595 hr = pStream->WriteStream(" xmlns:snp=\"", sizeof(" xmlns:snp=\"")-1, NULL);
3596 if (SUCCEEDED(hr))
3597 {
3598 ATLASSERT( pMap->szNamespace != NULL );
3599 hr = pStream->WriteStream(pMap->szNamespace, pMap->cchNamespace, NULL);
3600 if (SUCCEEDED(hr))
3601 {
3602 hr = pStream->WriteStream("\">", sizeof("\">")-1, NULL);
3603 }
3604 }
3605 }
3606 else
3607 {
3608 hr = pStream->WriteStream(">", 1, NULL);
3609 }
3610 }
3611 }
3612 return hr;
3613 }
3614
3615 HRESULT EndMap(IWriteStream *pStream, const _soapmap *pMap, bool bClient)
3616 {
3617 ATLENSURE_RETURN( pStream != NULL );
3618 ATLENSURE_RETURN( pMap != NULL );
3619
3620 (bClient); // unused for rpc/encoded
3621
3622 HRESULT hr = pStream->WriteStream("</snp:", sizeof("</snp:")-1, NULL);
3623 if (SUCCEEDED(hr))
3624 {
3625 hr = pStream->WriteStream(pMap->szName, pMap->cchName, NULL);
3626 if (SUCCEEDED(hr))
3627 {
3628 hr = pStream->WriteStream(">", 1, NULL);
3629 }
3630 }
3631
3632 return hr;
3633 }
3634 }; // class CRpcEncodedGenerator
3635
3636 //
3637 // members
3638 //
3639 CAtlArray<ParseState, CParseStateElementTraits> m_stateStack;
3640 size_t m_nState;
3641
3642 DWORD m_dwState;
3643
3644 CComPtr<ISAXXMLReader> m_spReader;
3645
3646 CSAXStringBuilder m_stringBuilder;
3647 CSkipHandler m_skipHandler;
3648
3649 IAtlMemMgr * m_pMemMgr;
3650
3651 static CCRTHeap m_crtHeap;
3652
3653 bool m_bClient;
3654
3655 void *m_pvParam;
3656
3657 bool m_bNullCheck;
3658 bool m_bChildCheck;
3659 bool m_bCharacters;
3660 size_t m_nDepth;
3661
3662 typedef CFixedStringT<CStringW, 16> REFSTRING;
3663
3664 // used for rpc/encoded messages with href's
3665 typedef CAtlMap<REFSTRING, ParseState, CStringRefElementTraits<REFSTRING> > REFMAP;
3666 REFMAP m_refMap;
3667
3668 //
3669 // Implementation helpers
3670 //
3671
3672 HRESULT PushState(void *pvElement = NULL, const _soapmap *pMap = NULL,
3673 const _soapmapentry *pEntry = NULL, DWORD dwFlags = 0, size_t nAllocSize = 0,
3674 size_t nExpectedElements = 0, size_t nElement = 0)
3675 {
3676 if (m_stateStack.IsEmpty())
3677 {
3678 // 16 will be plenty for the 99% case
3679 if (!m_stateStack.SetCount(0, 16))
3680 {
3681 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::PushState -- out of memory.\r\n" ) );
3682
3683 return E_OUTOFMEMORY;
3684 }
3685 }
3686
3687 size_t nCnt = m_stateStack.GetCount();
3688 m_nState = m_stateStack.Add();
3689 if (m_stateStack.GetCount() <= nCnt)
3690 {
3691 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::PushState -- out of memory.\r\n" ) );
3692
3693 return E_OUTOFMEMORY;
3694 }
3695
3696 ParseState &state = m_stateStack[m_nState];
3697
3698 state.pvElement = pvElement;
3699 state.dwFlags = dwFlags;
3700 state.nAllocSize = nAllocSize;
3701 state.nExpectedElements = nExpectedElements;
3702 state.nElement = nElement;
3703 state.pMap = pMap;
3704 state.pEntry = pEntry;
3705 state.nDepth = m_nDepth;
3706
3707 return S_OK;
3708 }
3709
3710 ParseState& GetState()
3711 {
3712 return m_stateStack[m_nState];
3713 }
3714
3715 void PopState(bool bForce = false)
3716 {
3717 if ((m_nState != 0) || (bForce != false))
3718 {
3719 m_stateStack.RemoveAt(m_nState);
3720 --m_nState;
3721 }
3722 }
3723
3724 BOOL IsEqualElement(int cchLocalNameCheck, const wchar_t *wszLocalNameCheck,
3725 int cchNamespaceUriCheck, const wchar_t *wszNamespaceUriCheck,
3726 int cchLocalName, const wchar_t *wszLocalName,
3727 int cchNamespaceUri, const wchar_t *wszNamespaceUri)
3728 {
3729 ATLENSURE(wszLocalName);
3730 ATLENSURE(wszLocalNameCheck);
3731 ATLENSURE(wszNamespaceUri);
3732 ATLENSURE(wszNamespaceUriCheck);
3733
3734 if (cchLocalName == cchLocalNameCheck &&
3735 cchNamespaceUri == cchNamespaceUriCheck &&
3736 !wcsncmp(wszLocalName, wszLocalNameCheck, cchLocalName) &&
3737 !wcsncmp(wszNamespaceUri, wszNamespaceUriCheck, cchNamespaceUri))
3738 {
3739 return TRUE;
3740 }
3741
3742 return FALSE;
3743 }
3744
3745 ATL_FORCEINLINE BOOL IsEqualString(const wchar_t *wszStr1, int cchStr1, const wchar_t *wszStr2, int cchStr2)
3746 {
3747 ATLENSURE( wszStr1 != NULL );
3748 ATLENSURE( wszStr2 != NULL );
3749 ATLENSURE( cchStr1 >= 0 );
3750 ATLENSURE( cchStr2 >= 0 );
3751
3752 if (cchStr1 == cchStr2)
3753 {
3754 return !wcsncmp(wszStr1, wszStr2, cchStr2);
3755 }
3756 return FALSE;
3757 }
3758
3759 ATL_FORCEINLINE BOOL IsEqualStringHash(const wchar_t *wszStr1, int cchStr1, ULONG nHash1,
3760 const wchar_t *wszStr2, int cchStr2, ULONG nHash2)
3761 {
3762 ATLENSURE( wszStr1 != NULL );
3763 ATLENSURE( wszStr2 != NULL );
3764 ATLENSURE( cchStr1 >= 0 );
3765 ATLENSURE( cchStr2 >= 0 );
3766
3767 if (nHash1 == nHash2)
3768 {
3769 return IsEqualString(wszStr1, cchStr1, wszStr2, cchStr2);
3770 }
3771
3772 return FALSE;
3773 }
3774
3775 BOOL IsEqualElement(int cchLocalNameCheck, const wchar_t *wszLocalNameCheck,
3776 int cchLocalName, const wchar_t *wszLocalName)
3777 {
3778 if (cchLocalName == cchLocalNameCheck &&
3779 !wcsncmp(wszLocalName, wszLocalNameCheck, cchLocalName))
3780 {
3781 return TRUE;
3782 }
3783
3784 return FALSE;
3785 }
3786
3787 void SetOffsetValue(void *pBase, void *pSrc, size_t nOffset)
3788 {
3789 void **ppDest = (void **)(((unsigned char *)pBase)+nOffset);
3790 *ppDest = pSrc;
3791 }
3792
3793 bool IsRpcEncoded()
3794 {
3795 if ((m_stateStack[0].pMap->dwCallFlags & (SOAPFLAG_RPC | SOAPFLAG_ENCODED)) ==
3796 (SOAPFLAG_RPC | SOAPFLAG_ENCODED))
3797 {
3798 return true;
3799 }
3800 return false;
3801 }
3802
3803
3804 HRESULT ValidateArrayEntry(
3805 ParseState& state,
3806 const wchar_t *wszLocalName,
3807 int cchLocalName)
3808 {
3809 (cchLocalName);
3810 (wszLocalName);
3811
3812 ATLASSERT( state.pEntry != NULL );
3813
3814 // SOAP Section 5.4.2
3815
3816 // check number of elements
3817 if (state.nElement == state.nExpectedElements)
3818 {
3819 // too many elements
3820 if ((state.dwFlags & SOAPFLAG_UNKSIZE)==0)
3821 {
3822 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::ValidateArrayEntry -- too many elements.\r\n" ) );
3823 return E_FAIL;
3824 }
3825
3826 ATLASSERT( IsRpcEncoded() == false );
3827
3828 // see if we need to allocate more
3829 if (state.nElement == state.nAllocSize)
3830 {
3831 unsigned char **ppArr = (unsigned char **)state.pvElement;
3832 size_t nNewElement=0;
3833 HRESULT hr=E_FAIL;
3834 if(FAILED(hr=::ATL::AtlMultiply(&nNewElement, state.nElement, static_cast<size_t>(2))))
3835 {
3836 return hr;
3837 }
3838 hr = AllocateArray(state.pEntry, (void **)ppArr, __max(nNewElement, ATLSOAP_GROWARRAY), state.nElement);
3839
3840 if (SUCCEEDED(hr))
3841 {
3842 state.nAllocSize = __max((state.nElement)*2, ATLSOAP_GROWARRAY);
3843 }
3844
3845 return hr;
3846 }
3847 }
3848
3849 return S_OK;
3850 }
3851
3852 HRESULT CheckID(
3853 const wchar_t *wszNamespaceUri,
3854 const wchar_t *wszLocalName,
3855 int cchLocalName,
3856 ISAXAttributes *pAttributes)
3857 {
3858 (cchLocalName);
3859 (wszLocalName);
3860 (wszNamespaceUri);
3861 ATLASSERT( pAttributes != NULL );
3862
3863 const wchar_t *wsz = NULL;
3864 int cch = 0;
3865
3866 HRESULT hr = GetAttribute(pAttributes, L"id", sizeof("id")-1, &wsz, &cch);
3867 if ((hr == S_OK) && (wsz != NULL))
3868 {
3869 const REFMAP::CPair *p = NULL;
3870 _ATLTRY
3871 {
3872 REFSTRING strRef(wsz, cch);
3873 p = m_refMap.Lookup(strRef);
3874 if (p == NULL)
3875 {
3876 return S_FALSE;
3877 }
3878 }
3879 _ATLCATCHALL()
3880 {
3881 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::CheckID -- out of memory.\r\n" ) );
3882
3883 return E_OUTOFMEMORY;
3884 }
3885
3886 ATLASSERT( IsRpcEncoded() == true );
3887
3888 const ParseState& state = p->m_value;
3889
3890 // disallow href-chaining
3891 hr = CheckHref(state.pEntry, state.pvElement, pAttributes);
3892 if (hr != S_FALSE)
3893 {
3894 return E_FAIL;
3895 }
3896
3897 hr = S_OK;
3898
3899 // do array stuff
3900 if (state.dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR))
3901 {
3902 hr = GetSection5Info(state, state.pEntry, pAttributes);
3903 }
3904 else
3905 {
3906 // only structs and arrays are allowed for hrefs
3907 ATLASSERT( state.pEntry->pChain != NULL );
3908 ATLASSERT( state.pEntry->pChain->mapType == SOAPMAP_STRUCT );
3909
3910 // structs must have child entries
3911 m_bChildCheck = state.pEntry->pChain->nElements != 0;
3912
3913 if (S_OK != PushState(state.pvElement, state.pEntry->pChain, state.pEntry,
3914 state.dwFlags, 0, state.pEntry->pChain->nElements))
3915 {
3916 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::CheckID -- out of memory.\n" ) );
3917 hr = E_OUTOFMEMORY;
3918 }
3919 }
3920
3921 m_refMap.DisableAutoRehash();
3922 m_refMap.RemoveAtPos(const_cast<REFMAP::CPair*>(p));
3923 m_refMap.EnableAutoRehash();
3924
3925 return hr;
3926 }
3927
3928 return S_FALSE;
3929 }
3930
3931 HRESULT GetElementEntry(
3932 ParseState& state,
3933 const wchar_t *wszNamespaceUri,
3934 const wchar_t *wszLocalName,
3935 int cchLocalName,
3936 ISAXAttributes *pAttributes,
3937 const _soapmapentry **ppEntry)
3938 {
3939 ATLENSURE_RETURN( state.pMap != NULL );
3940 ATLENSURE_RETURN( ppEntry != NULL );
3941
3942 *ppEntry = NULL;
3943 const _soapmapentry *pEntries = state.pMap->pEntries;
3944 DWORD dwIncludeFlags;
3945 DWORD dwExcludeFlags;
3946
3947 HRESULT hr = CheckID(wszNamespaceUri, wszLocalName, cchLocalName, pAttributes);
3948 if (hr != S_FALSE)
3949 {
3950 if (hr == S_OK)
3951 {
3952 hr = S_FALSE;
3953 }
3954 return hr;
3955 }
3956
3957 if (m_bClient != false)
3958 {
3959 dwIncludeFlags = SOAPFLAG_OUT;
3960 dwExcludeFlags = SOAPFLAG_IN;
3961 }
3962 else
3963 {
3964 dwIncludeFlags = SOAPFLAG_IN;
3965 dwExcludeFlags = SOAPFLAG_OUT;
3966 }
3967
3968 ULONG nHash = AtlSoapHashStr(wszLocalName, cchLocalName);
3969
3970 for (size_t i=0; pEntries[i].nHash != 0; i++)
3971 {
3972 if (nHash == pEntries[i].nHash &&
3973 ((pEntries[i].dwFlags & dwIncludeFlags) ||
3974 ((pEntries[i].dwFlags & dwExcludeFlags) == 0)) &&
3975 IsEqualElement(pEntries[i].cchField, pEntries[i].wszField,
3976 cchLocalName, wszLocalName)/* &&
3977 !wcscmp(wszNamespaceUri, wszNamespace)*/)
3978 {
3979 // check bit vector
3980
3981 if (state.vec.GetBit(i) == false)
3982 {
3983 if (state.vec.SetBit(i) == false)
3984 {
3985 return E_OUTOFMEMORY;
3986 }
3987 }
3988 else
3989 {
3990 // already received this element
3991 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::GetElementEntry -- duplicate element was sent.\r\n" ) );
3992
3993 return E_FAIL;
3994 }
3995
3996 state.nElement++;
3997 *ppEntry = &pEntries[i];
3998
3999 return S_OK;
4000 }
4001 }
4002
4003 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::GetElementEntry -- element not found: %.*ws.\r\n" ), cchLocalName, wszLocalName );
4004
4005 return E_FAIL;
4006 }
4007
4008 HRESULT CheckMustUnderstandHeader(ISAXAttributes *pAttributes)
4009 {
4010 ATLASSERT( pAttributes != NULL );
4011
4012 const wchar_t* wszMustUnderstand;
4013 int cchMustUnderstand;
4014 bool bMustUnderstand= false;
4015
4016 if (SUCCEEDED(GetAttribute(pAttributes, L"mustUnderstand", sizeof("mustUnderstand")-1,
4017 &wszMustUnderstand, &cchMustUnderstand,
4018 SOAPENV_NAMESPACEW, sizeof(SOAPENV_NAMESPACEA)-1)) &&
4019 (wszMustUnderstand != NULL))
4020 {
4021 if (FAILED(AtlGetSAXValue(&bMustUnderstand, wszMustUnderstand, cchMustUnderstand)))
4022 {
4023 bMustUnderstand = true;
4024 }
4025 }
4026
4027 if (bMustUnderstand == false)
4028 {
4029 ATLASSERT( GetReader() != NULL );
4030
4031 m_skipHandler.SetReader(GetReader());
4032 m_skipHandler.SetParent(this);
4033
4034 return GetReader()->putContentHandler( &m_skipHandler );
4035 }
4036 else
4037 {
4038 SoapFault(SOAP_E_MUST_UNDERSTAND, NULL, 0);
4039 }
4040
4041 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::CheckMustUnderstandHeader -- unknown \"mustUnderstand\" SOAP Header was received.\r\n" ) );
4042
4043 return E_FAIL;
4044 }
4045
4046 HRESULT AllocateArray(
4047 const _soapmapentry *pEntry,
4048 void **ppArr, size_t nElements,
4049 size_t nCurrElements = 0)
4050 {
4051 ATLENSURE_RETURN( ppArr != NULL );
4052 ATLENSURE_RETURN( pEntry != NULL );
4053
4054 size_t nElementSize;
4055 if (pEntry->nVal != SOAPTYPE_UNK)
4056 {
4057 nElementSize = AtlSoapGetElementSize((SOAPTYPES) pEntry->nVal);
4058 }
4059 else // UDT
4060 {
4061 ATLENSURE_RETURN( pEntry->pChain != NULL );
4062 nElementSize = pEntry->pChain->nElementSize;
4063 }
4064 if (nElementSize != 0)
4065 {
4066 if (*ppArr == NULL)
4067 {
4068 ATLASSERT( nCurrElements == 0 );
4069 size_t nBytes=0;
4070 HRESULT hr=S_OK;
4071 if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nElementSize, nElements)))
4072 {
4073 return hr;
4074 }
4075 *ppArr = m_pMemMgr->Allocate(nBytes);
4076 }
4077 else // *ppArr != NULL
4078 {
4079 ATLASSERT( nCurrElements != 0 );
4080 size_t nBytes=0;
4081 HRESULT hr=S_OK;
4082 if( FAILED(hr=::ATL::AtlAdd(&nBytes, nElements, nCurrElements)) ||
4083 FAILED(hr=::ATL::AtlMultiply(&nBytes, nElementSize, nBytes)))
4084 {
4085 return hr;
4086 }
4087 *ppArr = m_pMemMgr->Reallocate(*ppArr, nBytes);
4088 }
4089 }
4090 else
4091 {
4092 // internal error
4093 ATLASSERT( FALSE );
4094 return E_FAIL;
4095 }
4096
4097 if (*ppArr == NULL)
4098 {
4099 return E_OUTOFMEMORY;
4100 }
4101
4102 memset(((unsigned char *)(*ppArr))+(nCurrElements*nElementSize), 0x00, nElements*nElementSize);
4103
4104 return S_OK;
4105 }
4106
4107 HRESULT GetSection5Info(
4108 const ParseState& state,
4109 const _soapmapentry *pEntry,
4110 ISAXAttributes *pAttributes)
4111 {
4112 ATLENSURE_RETURN( pEntry != NULL );
4113 ATLENSURE_RETURN( pAttributes != NULL );
4114
4115 HRESULT hr;
4116 if (IsRpcEncoded() != false)
4117 {
4118 // check for href
4119 // we ONLY do this for rpc/encoded (required for interop)
4120 // NOTE: ATL Server does not support object graphs, so
4121 // only single-reference elements are allowed
4122 hr = CheckHref(pEntry, state.pvElement, pAttributes,
4123 pEntry->dwFlags, SOAPFLAG_READYSTATE);
4124 if (hr != S_FALSE)
4125 {
4126 return hr;
4127 }
4128 }
4129
4130 size_t nElements;
4131 DWORD dwFlags = 0;
4132 hr = AtlSoapGetArraySize(pAttributes, &nElements);
4133 if (FAILED(hr))
4134 {
4135 return hr;
4136 }
4137
4138 size_t nAllocSize = 0;
4139 size_t nElementsPush = 0;
4140
4141 if (pEntry->dwFlags & SOAPFLAG_DYNARR)
4142 {
4143 // set size_is value
4144 ATLENSURE_RETURN( state.pMap != NULL );
4145 int *pnSizeIs = (int *)(((unsigned char *)state.pvElement)+
4146 (state.pMap->pEntries[pEntry->nSizeIs].nOffset));
4147
4148 if (hr != S_OK)
4149 {
4150 if (IsRpcEncoded())
4151 {
4152 // rpc/encoded requires soapenc:arrayType attribute
4153 return E_FAIL;
4154 }
4155
4156 nElements = ATLSOAP_GROWARRAY;
4157 nAllocSize = ATLSOAP_GROWARRAY;
4158 dwFlags |= SOAPFLAG_UNKSIZE;
4159 *pnSizeIs = 0;
4160 }
4161 else
4162 {
4163 *pnSizeIs = (int)nElements;
4164 if (nElements == 0)
4165 {
4166 // soapenc:arrayType="type[0]"
4167 // treat as null array
4168
4169 m_bNullCheck = true;
4170
4171 // push an emtpy state
4172 return PushState();
4173 }
4174
4175 nElementsPush = nElements;
4176 }
4177 void *p = NULL;
4178 hr = AllocateArray(pEntry, &p, nElements);
4179 if (hr != S_OK)
4180 {
4181 return hr;
4182 }
4183
4184 SetOffsetValue(state.pvElement, p, pEntry->nOffset);
4185 }
4186 else
4187 {
4188 // for fixed-size arrays, we know the number of elements
4189 ATLASSERT( pEntry->dwFlags & SOAPFLAG_FIXEDARR );
4190 if (hr == S_OK)
4191 {
4192 if (nElements != AtlSoapGetArrayDims(pEntry->pDims))
4193 {
4194 return E_FAIL;
4195 }
4196 }
4197 else
4198 {
4199 hr = S_OK;
4200 nElements = AtlSoapGetArrayDims(pEntry->pDims);
4201 }
4202 nElementsPush = nElements;
4203 }
4204
4205 dwFlags |= pEntry->dwFlags;
4206
4207 // push element with array flag
4208
4209 if (S_OK != PushState(((unsigned char *)state.pvElement)+pEntry->nOffset,
4210 state.pMap, pEntry, dwFlags & ~SOAPFLAG_READYSTATE, nAllocSize, nElementsPush))
4211 {
4212 return E_OUTOFMEMORY;
4213 }
4214
4215 m_bChildCheck = true;
4216
4217 return S_OK;
4218 }
4219
4220 void * UpdateArray(ParseState& state, const _soapmapentry *pEntry)
4221 {
4222 ATLENSURE(pEntry);
4223
4224 size_t nSize;
4225 void *pVal = NULL;
4226
4227 if (pEntry->nVal != SOAPTYPE_UNK)
4228 {
4229 nSize = AtlSoapGetElementSize((SOAPTYPES) pEntry->nVal);
4230 }
4231 else
4232 {
4233 ATLENSURE( pEntry->pChain != NULL );
4234
4235 nSize = pEntry->pChain->nElementSize;
4236 }
4237
4238 if (state.dwFlags & SOAPFLAG_FIXEDARR)
4239 {
4240 unsigned char *ppArr = (unsigned char *)state.pvElement;
4241 pVal = ppArr+(state.nElement*nSize);
4242 }
4243 else
4244 {
4245 ATLASSERT( state.dwFlags & SOAPFLAG_DYNARR );
4246
4247 unsigned char **ppArr = (unsigned char **)state.pvElement;
4248 pVal = (*ppArr)+(state.nElement*nSize);
4249 if (state.dwFlags & SOAPFLAG_UNKSIZE)
4250 {
4251 ATLASSERT( IsRpcEncoded() == false );
4252
4253 // need to use the previous state's pvElement to update the size_is value
4254 ATLASSUME( m_nState > 0 );
4255 int *pnSizeIs = (int *)(((unsigned char *)m_stateStack[m_nState-1].pvElement)+
4256 (state.pMap->pEntries[pEntry->nSizeIs].nOffset));
4257
4258 // update size_is parameter
4259 *pnSizeIs = (int)(state.nElement+1);
4260 state.nExpectedElements++;
4261 }
4262 }
4263 state.nElement++;
4264
4265 return pVal;
4266 }
4267
4268 HRESULT ProcessString(const _soapmapentry *pEntry, void *pVal)
4269 {
4270 ATLENSURE_RETURN( pEntry != NULL );
4271
4272 // set to the string builder class
4273
4274 ATLASSERT( GetReader() != NULL );
4275
4276 m_stringBuilder.SetReader(GetReader());
4277 m_stringBuilder.SetParent(this);
4278
4279 m_stringBuilder.Clear();
4280 GetReader()->putContentHandler( &m_stringBuilder );
4281
4282 if (S_OK != PushState(pVal, NULL, pEntry, SOAPFLAG_READYSTATE | pEntry->dwFlags))
4283 {
4284 return E_OUTOFMEMORY;
4285 }
4286
4287 return S_OK;
4288 }
4289
4290
4291 HRESULT CheckHref(
4292 const _soapmapentry *pEntry,
4293 void *pVal,
4294 ISAXAttributes *pAttributes,
4295 DWORD dwIncludeFlags = 0,
4296 DWORD dwExcludeFlags = 0)
4297 {
4298 ATLASSERT( pEntry != NULL );
4299 ATLASSERT( pVal != NULL );
4300 ATLASSERT( pAttributes != NULL );
4301
4302 const wchar_t *wsz = NULL;
4303 int cch = 0;
4304
4305 HRESULT hr = GetAttribute(pAttributes, L"href", sizeof("href")-1, &wsz, &cch);
4306 if ((hr == S_OK) && (wsz != NULL))
4307 {
4308 // only allow hrefs on structs and arrays
4309 if (((pEntry->dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR))==0) &&
4310 (pEntry->pChain == NULL || pEntry->pChain->mapType != SOAPMAP_STRUCT))
4311 {
4312 ATLTRACE( _T("ATL Server only allows href's on arrays and structs.\r\n") );
4313
4314 return E_FAIL;
4315 }
4316
4317 ATLASSERT( IsRpcEncoded() == true );
4318
4319 _ATLTRY
4320 {
4321 if (*wsz == L'#')
4322 {
4323 wsz++;
4324 cch--;
4325 }
4326
4327 REFSTRING strRef(wsz, cch);
4328 if (m_refMap.Lookup(strRef) != NULL)
4329 {
4330 // ATL Server does not support multi-reference objects
4331 ATLASSERT( FALSE );
4332 return E_FAIL;
4333 }
4334
4335 ParseState& currState = GetState();
4336 if ((currState.pEntry != NULL) && (currState.pEntry->dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR)))
4337 {
4338 // it is an array item
4339 ATLASSERT( currState.nElement != 0 );
4340
4341 // exclude array flags for href'd array elements
4342 dwExcludeFlags |= SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR;
4343 }
4344
4345 ParseState state;
4346 state.pvElement = pVal;
4347 state.dwFlags = (pEntry->dwFlags | dwIncludeFlags) & ~dwExcludeFlags;
4348 state.nExpectedElements = 0;
4349
4350 state.nElement = 0;
4351 state.pMap = GetState().pMap;
4352 state.pEntry = pEntry;
4353
4354 if (!m_refMap.SetAt(strRef, state))
4355 {
4356 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::CheckHref -- out of memory.\r\n" ) );
4357
4358 return E_OUTOFMEMORY;
4359 }
4360
4361 // make sure there are no child elements
4362 m_bNullCheck = true;
4363
4364 // push an emtpy state
4365 return PushState();
4366 }
4367 _ATLCATCHALL()
4368 {
4369 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::CheckHref -- out of memory.\r\n" ) );
4370
4371 return E_OUTOFMEMORY;
4372 }
4373 }
4374
4375 return S_FALSE;
4376 }
4377
4378 HRESULT ProcessUDT(
4379 const _soapmapentry *pEntry,
4380 void *pVal)
4381 {
4382 ATLENSURE_RETURN( pEntry != NULL );
4383 ATLENSURE_RETURN( pVal != NULL );
4384 ATLENSURE_RETURN( pEntry->nVal != SOAPTYPE_ERR );
4385 ATLENSURE_RETURN( pEntry->nVal != SOAPTYPE_USERBASE );
4386
4387 // if it is a complex type, get the chain entry
4388 // and push the new state on the stack
4389
4390 DWORD dwFlags = pEntry->dwFlags;
4391 if (pEntry->pChain->mapType != SOAPMAP_ENUM)
4392 {
4393 // struct
4394 dwFlags &= ~(SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR);
4395 m_bChildCheck = pEntry->pChain->nElements != 0;
4396 }
4397 else
4398 {
4399 // enum
4400 dwFlags |= SOAPFLAG_READYSTATE;
4401
4402 // enums must not have child elements
4403 m_bNullCheck = true;
4404
4405 // enums must be specified
4406 m_bCharacters = true;
4407 }
4408
4409 if (S_OK != PushState(pVal, pEntry->pChain, pEntry, dwFlags, 0, pEntry->pChain->nElements))
4410 {
4411 return E_OUTOFMEMORY;
4412 }
4413
4414 return S_OK;
4415 }
4416
4417 HRESULT ChainEntry(
4418 const ParseState& state,
4419 const wchar_t *wszNamespaceUri,
4420 int cchNamespaceUri,
4421 const wchar_t *wszLocalName,
4422 int cchLocalName,
4423 ISAXAttributes *pAttributes)
4424 {
4425 ATLENSURE_RETURN( state.pMap != NULL );
4426
4427 // PAD is only supported on the client
4428 const _soapmap *pMap = state.pMap;
4429 if ((pMap->dwCallFlags & SOAPFLAG_CHAIN)==0)
4430 {
4431 return S_FALSE;
4432 }
4433
4434 ATLENSURE_RETURN( pMap->dwCallFlags & SOAPFLAG_PAD );
4435 ATLASSUME( m_bClient == true );
4436 ATLENSURE_RETURN( pMap->nElements == 1 );
4437 const _soapmapentry *pEntries = pMap->pEntries;
4438 ATLENSURE_RETURN( pEntries != NULL );
4439
4440 int nIndex;
4441 if (pEntries[0].dwFlags & SOAPFLAG_OUT)
4442 {
4443 nIndex = 0;
4444 }
4445 else
4446 {
4447 nIndex = 1;
4448 }
4449
4450 const _soapmapentry *pEntry = &pEntries[nIndex];
4451 ATLENSURE_RETURN( pEntry->nHash != 0 );
4452 ATLENSURE_RETURN( pEntry->pChain != NULL );
4453
4454 if (S_OK != PushState(state.pvElement, pEntry->pChain, pEntry, pEntry->dwFlags, 0, pEntry->pChain->nElements))
4455 {
4456 return E_OUTOFMEMORY;
4457 }
4458
4459 return ProcessParams(wszNamespaceUri, cchNamespaceUri, wszLocalName, cchLocalName, pAttributes);
4460 }
4461
4462 HRESULT IsNullEntry(const _soapmapentry *pEntry, ISAXAttributes *pAttributes)
4463 {
4464 ATLASSERT( pEntry != NULL );
4465 ATLASSERT( pAttributes != NULL );
4466
4467 HRESULT hr = E_FAIL;
4468 bool bNull = false;
4469 const wchar_t *wszNull = NULL;
4470 int cchNull = 0;
4471 hr = GetAttribute(pAttributes, L"nil", sizeof("nil")-1, &wszNull, &cchNull,
4472 XSI_NAMESPACEW, sizeof(XSI_NAMESPACEA)-1);
4473 if ((hr == S_OK) && (wszNull != NULL))
4474 {
4475 hr = AtlGetSAXValue(&bNull, wszNull, cchNull);
4476 if (hr == S_OK)
4477 {
4478 if (bNull != false)
4479 {
4480 if (pEntry->dwFlags & SOAPFLAG_NULLABLE)
4481 {
4482 m_bNullCheck = true;
4483
4484 // push an emtpy state
4485 return PushState();
4486 }
4487
4488 // non-nullable element
4489 return E_FAIL;
4490 }
4491 }
4492 }
4493
4494 return S_FALSE;
4495 }
4496
4497 HRESULT ProcessParams(
4498 const wchar_t *wszNamespaceUri,
4499 int cchNamespaceUri,
4500 const wchar_t *wszLocalName,
4501 int cchLocalName,
4502 ISAXAttributes *pAttributes)
4503 {
4504 (wszNamespaceUri);
4505 (cchNamespaceUri);
4506
4507 if (m_stateStack.IsEmpty())
4508 {
4509 if (m_dwState == SOAP_HEADERS)
4510 {
4511 return CheckMustUnderstandHeader(pAttributes);
4512 }
4513
4514 return E_FAIL;
4515 }
4516
4517 ParseState &state = GetState();
4518
4519 ATLASSERT( state.pvElement != NULL );
4520 HRESULT hr = E_FAIL;
4521 const _soapmapentry *pEntry = NULL;
4522
4523 // if array element
4524 if (state.dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR))
4525 {
4526 hr = ValidateArrayEntry(state, wszLocalName, cchLocalName);
4527
4528 if (SUCCEEDED(hr))
4529 {
4530 pEntry = state.pEntry;
4531 }
4532 else
4533 {
4534 return hr;
4535 }
4536 }
4537 else // not an array element
4538 {
4539 // special-case for PAD with type=
4540 hr = ChainEntry(state, wszNamespaceUri, cchNamespaceUri,
4541 wszLocalName, cchLocalName, pAttributes);
4542
4543 if (hr == S_FALSE)
4544 {
4545 hr = GetElementEntry(state, wszNamespaceUri, wszLocalName, cchLocalName, pAttributes, &pEntry);
4546 if (hr != S_OK)
4547 {
4548 if (hr == S_FALSE)
4549 {
4550 hr = S_OK;
4551 }
4552 else if (m_dwState == SOAP_HEADERS)
4553 {
4554 hr = CheckMustUnderstandHeader(pAttributes);
4555 }
4556 return hr;
4557 }
4558
4559 ATLASSERT( pEntry != NULL );
4560 }
4561 else
4562 {
4563 return hr;
4564 }
4565 }
4566
4567 hr = IsNullEntry(pEntry, pAttributes);
4568 if (hr != S_FALSE)
4569 {
4570 return hr;
4571 }
4572 hr = S_OK;
4573 ATLENSURE_RETURN(pEntry);
4574 // if is array
4575 if (((pEntry->pDims != NULL) || (pEntry->dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR))) &&
4576 ((state.dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR)) == 0))
4577 {
4578 // get SOAP section-5 info (if it is there)
4579 return GetSection5Info(state, pEntry, pAttributes);
4580 }
4581 else
4582 {
4583 // if it is a simple type, push a new (ready) state on the stack
4584 void *pVal;
4585 if (state.dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR))
4586 {
4587 pVal = UpdateArray(state, pEntry);
4588 ATLASSERT( pVal != NULL );
4589 }
4590 else
4591 {
4592 pVal = (((unsigned char *)state.pvElement)+pEntry->nOffset);
4593 }
4594
4595 if (IsRpcEncoded() != false)
4596 {
4597 // check for href
4598 // we ONLY do this for rpc/encoded (required for interop)
4599 // NOTE: ATL Server does not support object graphs, so
4600 // only single-reference elements are allowed
4601 hr = CheckHref(pEntry, pVal, pAttributes);
4602 if (hr != S_FALSE)
4603 {
4604 return hr;
4605 }
4606 hr = S_OK;
4607 }
4608
4609 if (pEntry->nVal != SOAPTYPE_UNK)
4610 {
4611 // simple types should not have child elements
4612 m_bNullCheck = true;
4613
4614 // if it is a string
4615 if ((pEntry->nVal == SOAPTYPE_STRING) || (pEntry->nVal == SOAPTYPE_BASE64BINARY))
4616 {
4617 hr = ProcessString(pEntry, pVal);
4618 }
4619 else
4620 {
4621 // expect characters for all non-string simple types
4622 m_bCharacters = true;
4623
4624 // basic simple type
4625 if (S_OK != PushState(pVal, NULL, pEntry, SOAPFLAG_READYSTATE | pEntry->dwFlags))
4626 {
4627 hr = E_OUTOFMEMORY;
4628 }
4629 }
4630 }
4631 else
4632 {
4633 hr = ProcessUDT(pEntry, pVal);
4634 if (pEntry->dwFlags & (SOAPFLAG_DYNARRWRAPPER))
4635 {
4636 // We're moving to the **first** entry in the dynamic array wrapper.
4637 // We know it is the first entry because the dynamic array wrapper is created
4638 // by sproxy and it guarantees this layouts.
4639 ++m_nDepth;
4640 ProcessParams (wszNamespaceUri, cchNamespaceUri, pEntry->pChain->pEntries[0].wszField,
4641 pEntry->pChain->pEntries[0].cchField, pAttributes);
4642 }
4643 }
4644 }
4645
4646 return hr;
4647 }
4648
4649 size_t GetSizeIsValue(void *pvParam, const _soapmap *pMap, const _soapmapentry *pEntry)
4650 {
4651 ATLENSURE( pvParam != NULL );
4652 ATLENSURE( pMap != NULL );
4653 ATLENSURE( pEntry != NULL );
4654
4655 int nSizeIs = pEntry->nSizeIs;
4656 size_t nOffset = pMap->pEntries[nSizeIs].nOffset;
4657 void *pVal = ((unsigned char *)pvParam)+nOffset;
4658
4659 __int64 nVal = 0;
4660 switch(pMap->pEntries[nSizeIs].nVal)
4661 {
4662 case SOAPTYPE_INTEGER:
4663 case SOAPTYPE_NONPOSITIVEINTEGER:
4664 case SOAPTYPE_NEGATIVEINTEGER:
4665 case SOAPTYPE_LONG:
4666 nVal = *((__int64 *)pVal);
4667 break;
4668 case SOAPTYPE_INT:
4669 nVal = *((int *)pVal);
4670 break;
4671 case SOAPTYPE_SHORT:
4672 nVal = *((short *)pVal);
4673 break;
4674 case SOAPTYPE_BYTE:
4675 nVal = *((char *)pVal);
4676 break;
4677 case SOAPTYPE_POSITIVEINTEGER:
4678 case SOAPTYPE_NONNEGATIVEINTEGER:
4679 case SOAPTYPE_UNSIGNEDLONG:
4680 unsigned __int64 n;
4681 n = *((unsigned __int64 *)pVal);
4682 if (n > _I64_MAX)
4683 {
4684 // come on ...
4685 nVal = 0;
4686 }
4687 else
4688 {
4689 nVal = (__int64)n;
4690 }
4691 break;
4692 case SOAPTYPE_UNSIGNEDINT:
4693 nVal = *((unsigned int *)pVal);
4694 break;
4695 case SOAPTYPE_UNSIGNEDSHORT:
4696 nVal = *((unsigned short *)pVal);
4697 break;
4698 case SOAPTYPE_UNSIGNEDBYTE:
4699 nVal = *((unsigned char *)pVal);
4700 break;
4701 default:
4702 nVal = 0;
4703 }
4704
4705 if (nVal < 0)
4706 {
4707 nVal = 0;
4708 }
4709
4710 return (size_t) nVal;
4711 }
4712
4713 HRESULT GenerateArrayInfo(const _soapmapentry *pEntry, const int *pDims, IWriteStream *pStream)
4714 {
4715 ATLENSURE_RETURN( pEntry != NULL );
4716 ATLENSURE_RETURN( pStream != NULL );
4717
4718 HRESULT hr = S_OK;
4719 if (pEntry->nVal != SOAPTYPE_UNK)
4720 {
4721 // xsd type
4722 hr = pStream->WriteStream(" soapenc:arrayType=\"xsd:",
4723 sizeof(" soapenc:arrayType=\"xsd:")-1, NULL);
4724 }
4725 else
4726 {
4727 ATLENSURE_RETURN( pEntry->pChain != NULL );
4728
4729 hr = pStream->WriteStream(" xmlns:q1=\"", sizeof(" xmlns:q1=\"")-1, NULL);
4730 if (SUCCEEDED(hr))
4731 {
4732 if (pEntry->pChain->szNamespace != NULL)
4733 {
4734 hr = pStream->WriteStream(pEntry->pChain->szNamespace, pEntry->pChain->cchNamespace, NULL);
4735 }
4736 else
4737 {
4738 hr = pStream->WriteStream(GetNamespaceUriA(), -1, NULL);
4739 }
4740 if (SUCCEEDED(hr))
4741 {
4742 hr = pStream->WriteStream("\"", 1, NULL);
4743 if (SUCCEEDED(hr))
4744 {
4745 hr = pStream->WriteStream(" soapenc:arrayType=\"q1:",
4746 sizeof(" soapenc:arrayType=\"q1:")-1, NULL);
4747 }
4748 }
4749 }
4750 }
4751
4752 if (FAILED(hr))
4753 {
4754 return hr;
4755 }
4756
4757 if (pEntry->nVal != SOAPTYPE_UNK)
4758 {
4759 hr = pStream->WriteStream(s_xsdNames[pEntry->nVal].szName ,
4760 s_xsdNames[pEntry->nVal].cchName, NULL);
4761 }
4762 else
4763 {
4764 ATLASSERT( pEntry->pChain != NULL );
4765
4766 hr = pStream->WriteStream(pEntry->pChain->szName, pEntry->pChain->cchName, NULL);
4767 }
4768
4769 if (FAILED(hr))
4770 {
4771 return hr;
4772 }
4773
4774 hr = pStream->WriteStream("[", 1, NULL);
4775 if (FAILED(hr))
4776 {
4777 return hr;
4778 }
4779
4780 CWriteStreamHelper s( pStream );
4781 for (int i=1; i<=pDims[0]; i++)
4782 {
4783 if (!s.Write(pDims[i]) ||
4784 ((i < pDims[0]) && (S_OK != pStream->WriteStream(", ", 2, NULL))))
4785 {
4786 return E_FAIL;
4787 }
4788 }
4789
4790 hr = pStream->WriteStream("]\"", 2, NULL);
4791 if (FAILED(hr))
4792 {
4793 return hr;
4794 }
4795
4796 return S_OK;
4797 }
4798
4799 HRESULT GenerateXSDWrapper(bool bStart, int nVal, bool bNull, IWriteStream *pStream)
4800 {
4801 ATLENSURE_RETURN( pStream != NULL );
4802
4803 HRESULT hr = pStream->WriteStream((bStart != false) ? "<" : "</",
4804 (bStart != false) ? 1 : 2, NULL);
4805 if (SUCCEEDED(hr))
4806 {
4807 hr = pStream->WriteStream(s_xsdNames[nVal].szName,
4808 s_xsdNames[nVal].cchName, NULL);
4809 if ((bNull != false) && (SUCCEEDED(hr)))
4810 {
4811 hr = pStream->WriteStream(" xsi:nil=\"1\"", sizeof(" xsi:nil=\"1\"")-1, NULL);
4812 }
4813 if (SUCCEEDED(hr))
4814 {
4815 hr = pStream->WriteStream(">", 1, NULL);
4816 }
4817 }
4818
4819 return hr;
4820 }
4821
4822 HRESULT GenerateGenericWrapper(bool bStart, const _soapmap *pMap, IWriteStream *pStream)
4823 {
4824 ATLENSURE_RETURN( pStream != NULL );
4825 ATLENSURE_RETURN( pMap != NULL );
4826
4827 HRESULT hr = pStream->WriteStream((bStart != false) ? "<" : "</",
4828 (bStart != false) ? 1 : 2, NULL);
4829 if (SUCCEEDED(hr))
4830 {
4831 hr = pStream->WriteStream(pMap->szName, pMap->cchName, NULL);
4832 if (SUCCEEDED(hr))
4833 {
4834 hr = pStream->WriteStream(">", 1, NULL);
4835 }
4836 }
4837
4838 return hr;
4839 }
4840
4841 HRESULT GetArrayInformation(
4842 IWriteStream *pStream,
4843 const _soapmap *pMap,
4844 const _soapmapentry *pEntry,
4845 void *pvParam,
4846 size_t &nCnt,
4847 size_t &nElementSize)
4848 {
4849 ATLENSURE_RETURN( pStream != NULL );
4850 ATLENSURE_RETURN( pMap != NULL );
4851 ATLENSURE_RETURN( pEntry != NULL );
4852 ATLENSURE_RETURN( pvParam != NULL );
4853
4854 const int *pDims = NULL;
4855 int arrDims[2] = { 0 };
4856
4857 if (pEntry->dwFlags & SOAPFLAG_FIXEDARR)
4858 {
4859 pDims = pEntry->pDims;
4860 }
4861 else
4862 {
4863 ATLASSERT( pEntry->dwFlags & SOAPFLAG_DYNARR );
4864 nCnt = GetSizeIsValue(pvParam, pMap, pEntry);
4865
4866 if (nCnt == 0)
4867 {
4868 // array size should only be zero if array is NULL
4869 // did you forget to set the array size?
4870 ATLASSERT( FALSE );
4871 return E_FAIL;
4872 }
4873
4874 arrDims[0] = 1;
4875 arrDims[1] = (int) nCnt;
4876
4877 pDims = arrDims;
4878 }
4879
4880 // output array information
4881 HRESULT hr = GenerateArrayInfo(pEntry, pDims, pStream);
4882 if (FAILED(hr))
4883 {
4884 return hr;
4885 }
4886 if (SUCCEEDED(hr))
4887 {
4888 nCnt = AtlSoapGetArrayDims(pDims);
4889
4890 // did you forget to set the size_is value?
4891 ATLASSERT( nCnt != 0 );
4892
4893 if (pEntry->nVal != SOAPTYPE_UNK)
4894 {
4895 nElementSize = AtlSoapGetElementSize((SOAPTYPES) pEntry->nVal);
4896 }
4897 else
4898 {
4899 ATLENSURE_RETURN( pEntry->pChain != NULL );
4900
4901 nElementSize = pEntry->pChain->nElementSize;
4902 }
4903 }
4904
4905 return hr;
4906 }
4907
4908 HRESULT GenerateEnum(IWriteStream *pStream, void *pVal, const _soapmapentry *pEntry, bool bArray)
4909 {
4910 ATLENSURE_RETURN( pStream != NULL );
4911 ATLENSURE_RETURN( pVal != NULL );
4912 ATLENSURE_RETURN( pEntry != NULL );
4913
4914 int nVal = *((int *)pVal);
4915 const _soapmapentry *pEnumEntries = pEntry->pChain->pEntries;
4916
4917 ATLENSURE_RETURN( pEnumEntries != NULL );
4918 size_t j;
4919 HRESULT hr = E_FAIL;
4920 for (j=0; pEnumEntries[j].nHash != 0; j++)
4921 {
4922 if (nVal == pEnumEntries[j].nVal)
4923 {
4924 hr = pStream->WriteStream(pEnumEntries[j].szField, pEnumEntries[j].cchField, NULL);
4925 if ((bArray != false) && (SUCCEEDED(hr)))
4926 {
4927 hr = GenerateGenericWrapper(false, pEntry->pChain, pStream);
4928 }
4929 break;
4930 }
4931 }
4932
4933 return hr;
4934 }
4935
4936 HRESULT GenerateHeaders(CResponseGenerator *pGenerator, const _soapmap *pMap, IWriteStream *pStream)
4937 {
4938 ATLENSURE_RETURN( pStream != NULL );
4939 ATLENSURE_RETURN( pMap != NULL );
4940
4941 ATLENSURE_RETURN( pGenerator != NULL );
4942
4943 DWORD dwIncludeFlags = SOAPFLAG_OUT;
4944 if (m_bClient != false)
4945 {
4946 dwIncludeFlags = SOAPFLAG_IN;
4947 }
4948
4949 size_t nCnt = 0;
4950 for (size_t i=0; pMap->pEntries[i].nHash != 0; i++)
4951 {
4952 if (pMap->pEntries[i].dwFlags & dwIncludeFlags)
4953 {
4954 nCnt++;
4955 }
4956 }
4957
4958 // no headers to be sent
4959 if (nCnt == 0)
4960 {
4961 return S_OK;
4962 }
4963
4964 HRESULT hr = pGenerator->StartHeaders(pStream, pMap);
4965 if (SUCCEEDED(hr))
4966 {
4967 hr = GenerateResponseHelper(pGenerator, pMap, GetHeaderValue(), pStream);
4968 if (SUCCEEDED(hr))
4969 {
4970 hr = pGenerator->EndHeaders(pStream);
4971 }
4972 }
4973
4974 return hr;
4975 }
4976
4977 bool IsNullElement(const _soapmapentry *pEntry, void *pVal, DWORD dwExcludeFlags=0)
4978 {
4979 ATLENSURE( pEntry != NULL );
4980 ATLENSURE( pVal != NULL );
4981
4982 bool bNull = false;
4983
4984 DWORD dwFlags = pEntry->dwFlags & ~dwExcludeFlags;
4985
4986 if (dwFlags & SOAPFLAG_DYNARR)
4987 {
4988 unsigned char **ppArr = (unsigned char **)pVal;
4989 if (*ppArr == NULL)
4990 {
4991 bNull = true;
4992 }
4993 }
4994 else if (pEntry->nVal == SOAPTYPE_STRING)
4995 {
4996 BSTR *pBSTR = (BSTR *)pVal;
4997 if (*pBSTR == NULL)
4998 {
4999 bNull = true;
5000 }
5001 }
5002 else if ((pEntry->nVal == SOAPTYPE_BASE64BINARY) || (pEntry->nVal == SOAPTYPE_HEXBINARY))
5003 {
5004 if (((ATLSOAP_BLOB *)pVal)->data == NULL)
5005 {
5006 bNull = true;
5007 }
5008 }
5009
5010 return bNull;
5011 }
5012
5013 HRESULT GenerateNull(IWriteStream *pStream)
5014 {
5015 ATLENSURE_RETURN( pStream != NULL );
5016 return pStream->WriteStream(" xsi:nil=\"1\"/>", sizeof(" xsi:nil=\"1\"/>")-1, NULL);
5017 }
5018
5019 HRESULT GenerateResponseHelper(CResponseGenerator *pGenerator, const _soapmap *pMap, void *pvParam, IWriteStream *pStream,
5020 bool bArrayElement = false)
5021 {
5022 ATLENSURE_RETURN( pGenerator != NULL );
5023 ATLENSURE_RETURN( pMap != NULL );
5024 ATLENSURE_RETURN( pStream != NULL );
5025
5026 HRESULT hr = S_OK;
5027
5028 if ((bArrayElement != false) &&
5029 ((pMap->dwCallFlags & SOAPFLAG_PAD)==0))
5030 {
5031 hr = pGenerator->StartMap(pStream, pMap, m_bClient);
5032 if (FAILED(hr))
5033 {
5034 return hr;
5035 }
5036 }
5037
5038 ATLENSURE_RETURN( pMap->pEntries != NULL );
5039
5040 const _soapmapentry *pEntries = pMap->pEntries;
5041 size_t i;
5042
5043 DWORD dwIncludeFlags;
5044 DWORD dwExcludeFlags;
5045 if (m_bClient != false)
5046 {
5047 dwIncludeFlags = SOAPFLAG_IN;
5048 dwExcludeFlags = SOAPFLAG_OUT;
5049 }
5050 else
5051 {
5052 dwIncludeFlags = SOAPFLAG_OUT;
5053 dwExcludeFlags = SOAPFLAG_IN;
5054 }
5055
5056 for (i=0; pEntries[i].nHash != 0; i++)
5057 {
5058 if (((pEntries[i].dwFlags & dwIncludeFlags) ||
5059 ((pEntries[i].dwFlags & dwExcludeFlags)==0)) &&
5060 ((pEntries[i].dwFlags & SOAPFLAG_NOMARSHAL)==0))
5061 {
5062 hr = pGenerator->StartEntry(pStream, pMap, &pEntries[i]);
5063 if (FAILED(hr))
5064 {
5065 return hr;
5066 }
5067
5068 size_t nElementSize = 0;
5069 size_t nCnt = 1;
5070
5071 ATLASSERT( pvParam != NULL );
5072
5073 void *pvCurrent = ((unsigned char *)pvParam)+pEntries[i].nOffset;
5074
5075 if (IsNullElement(&pEntries[i], pvCurrent))
5076 {
5077 hr = GenerateNull(pStream);
5078 if (SUCCEEDED(hr))
5079 {
5080 continue;
5081 }
5082 return hr;
5083 }
5084
5085 bool bArray = (pEntries[i].dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR)) != 0;
5086 if (bArray != false)
5087 {
5088 hr = GetArrayInformation(pStream, pMap, &pEntries[i], pvParam, nCnt, nElementSize);
5089 }
5090
5091 hr = pStream->WriteStream(">", 1, NULL);
5092 if (FAILED(hr))
5093 {
5094 return hr;
5095 }
5096
5097 for (size_t nElement=0; nElement<nCnt; nElement++)
5098 {
5099 void *pVal;
5100
5101 // get updated value
5102 if (bArray != false)
5103 {
5104 if (pEntries[i].dwFlags & SOAPFLAG_FIXEDARR)
5105 {
5106 unsigned char *ppArr = (unsigned char *)pvCurrent;
5107 pVal = ppArr+(nElement*nElementSize);
5108 }
5109 else
5110 {
5111 ATLASSERT( pEntries[i].dwFlags & SOAPFLAG_DYNARR );
5112
5113 unsigned char **ppArr = (unsigned char **)pvCurrent;
5114 pVal = (*ppArr)+(nElement*nElementSize);
5115 }
5116 }
5117 else
5118 {
5119 pVal = pvCurrent;
5120 }
5121
5122 if (pEntries[i].nVal != SOAPTYPE_UNK)
5123 {
5124 bool bNull = false;
5125 if (bArray != false)
5126 {
5127 bNull = IsNullElement(&pEntries[i], pVal, SOAPFLAG_DYNARR | SOAPFLAG_FIXEDARR);
5128 hr = GenerateXSDWrapper(true, pEntries[i].nVal, bNull, pStream);
5129 if (FAILED(hr))
5130 {
5131 return hr;
5132 }
5133 }
5134 if (bNull == false)
5135 {
5136 hr = AtlSoapGenElementValue(pVal, pStream, (SOAPTYPES) pEntries[i].nVal, GetMemMgr());
5137 }
5138 if ((SUCCEEDED(hr)) && (bArray != false))
5139 {
5140 hr = GenerateXSDWrapper(false, pEntries[i].nVal, false, pStream);
5141 }
5142
5143 if (FAILED(hr))
5144 {
5145 return hr;
5146 }
5147 }
5148 else
5149 {
5150 ATLASSERT( pEntries[i].pChain != NULL );
5151
5152 if (pEntries[i].pChain->mapType != SOAPMAP_ENUM)
5153 {
5154 // struct
5155 hr = GenerateResponseHelper(pGenerator, pEntries[i].pChain, pVal, pStream, bArray);
5156 }
5157 else
5158 {
5159 if (bArray != false)
5160 {
5161 hr = GenerateGenericWrapper(true, pEntries[i].pChain, pStream);
5162 if (FAILED(hr))
5163 {
5164 return hr;
5165 }
5166 }
5167
5168 hr = GenerateEnum(pStream, pVal, &pEntries[i], bArray);
5169 }
5170 }
5171 }
5172
5173 // output element close
5174 if (SUCCEEDED(hr))
5175 {
5176 hr = pGenerator->EndEntry(pStream, pMap, &pEntries[i]);
5177 }
5178 }
5179
5180 if (FAILED(hr))
5181 {
5182 return hr;
5183 }
5184 }
5185
5186 if ((bArrayElement != false) &&
5187 ((pMap->dwCallFlags & SOAPFLAG_PAD)==0))
5188 {
5189 // output type name
5190 hr = pGenerator->EndMap(pStream, pMap, m_bClient);
5191 }
5192
5193 return hr;
5194 }
5195
5196 void CleanupHelper(const _soapmap *pMap, void *pvParam)
5197 {
5198 ATLENSURE( pMap != NULL );
5199 ATLENSURE( pMap->pEntries != NULL );
5200
5201 if (pvParam == NULL)
5202 {
5203 return;
5204 }
5205
5206 const _soapmapentry *pEntries = pMap->pEntries;
5207 size_t i;
5208
5209 for (i=0; pEntries[i].nHash != 0; i++)
5210 {
5211 if ((m_bClient != false) && ((pEntries[i].dwFlags & SOAPFLAG_OUT)==0))
5212 {
5213 // skip in-only headers on the client
5214 continue;
5215 }
5216
5217 void *pvCheck = ((unsigned char *)pvParam)+pEntries[i].nOffset;
5218 if (IsNullElement(&pEntries[i], pvCheck))
5219 {
5220 continue;
5221 }
5222
5223 size_t nElementSize = 0;
5224 size_t nCnt = 1;
5225
5226 const int *pDims = NULL;
5227 int arrDims[2] = { 0 };
5228
5229 bool bArray = (pEntries[i].dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR)) != 0;
5230
5231 if (bArray != false)
5232 {
5233 if (pEntries[i].dwFlags & SOAPFLAG_FIXEDARR)
5234 {
5235 pDims = pEntries[i].pDims;
5236 }
5237 else
5238 {
5239 ATLASSERT( pEntries[i].dwFlags & SOAPFLAG_DYNARR );
5240 nCnt = GetSizeIsValue(pvParam, pMap, &pEntries[i]);
5241
5242 arrDims[0] = 1;
5243 arrDims[1] = (int) nCnt;
5244
5245 pDims = arrDims;
5246 }
5247
5248 nCnt = AtlSoapGetArrayDims(pDims);
5249
5250 if (pEntries[i].nVal != SOAPTYPE_UNK)
5251 {
5252 nElementSize = AtlSoapGetElementSize((SOAPTYPES) pEntries[i].nVal);
5253 }
5254 else
5255 {
5256 ATLENSURE( pEntries[i].pChain != NULL );
5257
5258 nElementSize = pEntries[i].pChain->nElementSize;
5259 }
5260 }
5261
5262 void *pvCurrent = ((unsigned char *)pvParam)+pEntries[i].nOffset;
5263
5264 for (size_t nElement=0; nElement<nCnt; nElement++)
5265 {
5266 void *pVal;
5267
5268 // get updated value
5269 if (bArray != false)
5270 {
5271 if (pEntries[i].dwFlags & SOAPFLAG_FIXEDARR)
5272 {
5273 unsigned char *ppArr = (unsigned char *)pvCurrent;
5274 pVal = ppArr+(nElement*nElementSize);
5275 }
5276 else
5277 {
5278 ATLASSERT( pEntries[i].dwFlags & SOAPFLAG_DYNARR );
5279
5280 unsigned char **ppArr = (unsigned char **)pvCurrent;
5281 if (*ppArr == NULL)
5282 {
5283 break;
5284 }
5285 pVal = (*ppArr)+(nElement*nElementSize);
5286 }
5287 }
5288 else
5289 {
5290 pVal = pvCurrent;
5291 }
5292
5293 if (pEntries[i].nVal != SOAPTYPE_UNK)
5294 {
5295 AtlSoapCleanupElement(pVal, (SOAPTYPES) pEntries[i].nVal, GetMemMgr());
5296 }
5297 else
5298 {
5299 ATLENSURE( pEntries[i].pChain != NULL );
5300
5301 if (pEntries[i].pChain->mapType != SOAPMAP_ENUM)
5302 {
5303 CleanupHelper(pEntries[i].pChain, pVal);
5304 }
5305 }
5306 }
5307
5308 if (pEntries[i].dwFlags & SOAPFLAG_DYNARR)
5309 {
5310 // free it
5311 unsigned char **ppArr = (unsigned char **)pvCurrent;
5312
5313 ATLENSURE( ppArr != NULL );
5314
5315 if (*ppArr != NULL)
5316 {
5317 m_pMemMgr->Free(*ppArr);
5318 *ppArr = NULL;
5319 }
5320 }
5321 }
5322 }
5323
5324 const _soapmap * GetSoapMapFromName(
5325 const wchar_t * wszName,
5326 int cchName = -1,
5327 const wchar_t * wszNamespaceUri = NULL,
5328 int cchNamespaceUri = -1,
5329 int *pnVal = NULL,
5330 bool bHeader = false)
5331 {
5332 (cchNamespaceUri);
5333
5334 const _soapmap ** pEntry = NULL;
5335
5336 if (bHeader == false)
5337 {
5338 pEntry = GetFunctionMap();
5339 }
5340 else
5341 {
5342 pEntry = GetHeaderMap();
5343 }
5344
5345 if (pEntry == NULL)
5346 {
5347 return NULL;
5348 }
5349
5350 if (cchName < 0)
5351 {
5352 cchName = (int)wcslen(wszName);
5353 }
5354 if ((cchNamespaceUri < 0) && (wszNamespaceUri != NULL))
5355 {
5356 cchNamespaceUri = (int)wcslen(wszNamespaceUri);
5357 }
5358
5359 ULONG nFunctionHash = AtlSoapHashStr(wszName, cchName);
5360 ULONG nNamespaceHash = wszNamespaceUri ? AtlSoapHashStr(wszNamespaceUri, cchNamespaceUri) : 0;
5361
5362 int i;
5363 for (i=0; pEntry[i] != NULL; i++)
5364 {
5365 if ((IsEqualStringHash(wszName, cchName, nFunctionHash,
5366 pEntry[i]->wszName, pEntry[i]->cchWName, pEntry[i]->nHash) != FALSE) &&
5367 (!wszNamespaceUri ||
5368 IsEqualStringHash(wszNamespaceUri, cchNamespaceUri, nNamespaceHash,
5369 pEntry[i]->wszNamespace, pEntry[i]->cchNamespace, pEntry[i]->nNamespaceHash) != FALSE))
5370 {
5371 break;
5372 }
5373 }
5374
5375 if (pnVal != NULL)
5376 {
5377 *pnVal = i;
5378 }
5379 return pEntry[i];
5380 }
5381
5382 HRESULT CheckEndElement(const ParseState& state)
5383 {
5384 // check for all elements
5385 if (state.nElement == state.nExpectedElements)
5386 {
5387 return S_OK;
5388 }
5389
5390 // error check for fixed arrays
5391 if (state.dwFlags & SOAPFLAG_FIXEDARR)
5392 {
5393 return E_FAIL;
5394 }
5395
5396 // check for dynamic arrays
5397 if (state.dwFlags & SOAPFLAG_DYNARR)
5398 {
5399 // check for dynamic arrays with known size
5400 // (from soap:arrayType attribute)
5401 if ((state.dwFlags & SOAPFLAG_UNKSIZE)==0)
5402 {
5403 return E_FAIL;
5404 }
5405 }
5406
5407 DWORD dwIncludeFlags;
5408 DWORD dwExcludeFlags;
5409
5410 if (m_bClient != false)
5411 {
5412 dwIncludeFlags = SOAPFLAG_OUT;
5413 dwExcludeFlags = SOAPFLAG_IN;
5414 }
5415 else
5416 {
5417 dwIncludeFlags = SOAPFLAG_IN;
5418 dwExcludeFlags = SOAPFLAG_OUT;
5419 }
5420
5421 if (state.pMap != NULL)
5422 {
5423 // ensure all omitted elements were nullable elements or nomarshal elements
5424 const _soapmapentry *pEntries = state.pMap->pEntries;
5425 for (size_t i=0; pEntries[i].nHash != 0; i++)
5426 {
5427 if ((pEntries[i].dwFlags & dwIncludeFlags) ||
5428 ((pEntries[i].dwFlags & dwExcludeFlags)==0))
5429 {
5430 if (state.vec.GetBit(i) == false)
5431 {
5432 if (((pEntries[i].dwFlags & (SOAPFLAG_NULLABLE | SOAPFLAG_NOMARSHAL))==0) && (pEntries[i].nVal != SOAPTYPE_UNK))
5433 {
5434 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::CheckEndElement -- invalid number of elements for parameter/field\r\n") );
5435 return E_FAIL;
5436 }
5437 }
5438 }
5439 }
5440 }
5441
5442 return S_OK;
5443 }
5444
5445 HRESULT CheckSoapHeaders(const ParseState &state)
5446 {
5447 DWORD dwIncludeFlags;
5448 DWORD dwExcludeFlags;
5449
5450 if (m_bClient != false)
5451 {
5452 dwIncludeFlags = SOAPFLAG_OUT;
5453 dwExcludeFlags = SOAPFLAG_IN;
5454 }
5455 else
5456 {
5457 dwIncludeFlags = SOAPFLAG_IN;
5458 dwExcludeFlags = SOAPFLAG_OUT;
5459 }
5460
5461 if (state.pMap != NULL)
5462 {
5463 ATLASSERT( state.pMap->mapType == SOAPMAP_HEADER );
5464
5465 // ensure all omitted elements were nullable elements, nomarshal elements, or non-required elements
5466 const _soapmapentry *pEntries = state.pMap->pEntries;
5467 for (size_t i=0; pEntries[i].nHash != 0; i++)
5468 {
5469 if ((pEntries[i].dwFlags & dwIncludeFlags) ||
5470 ((pEntries[i].dwFlags & dwExcludeFlags)==0))
5471 {
5472 if (state.vec.GetBit(i) == false)
5473 {
5474 bool bNoOmit = (pEntries[i].dwFlags & (SOAPFLAG_NULLABLE | SOAPFLAG_NOMARSHAL))==0;
5475
5476 if ((bNoOmit != false) ||
5477 ((bNoOmit != false) && (pEntries[i].dwFlags & SOAPFLAG_MUSTUNDERSTAND)))
5478 {
5479 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::CheckSoapHeaders -- missing header\r\n") );
5480 return E_FAIL;
5481 }
5482 }
5483 }
5484 }
5485 }
5486
5487 return S_OK;
5488 }
5489
5490 HRESULT CheckEndHeaders(
5491 const wchar_t * wszNamespaceUri,
5492 int cchNamespaceUri,
5493 const wchar_t * wszLocalName,
5494 int cchLocalName)
5495 {
5496 if (IsEqualElement(sizeof(SOAP_HEADERA)-1, SOAP_HEADERW,
5497 sizeof(SOAPENV_NAMESPACEA)-1, SOAPENV_NAMESPACEW,
5498 cchLocalName, wszLocalName,
5499 cchNamespaceUri, wszNamespaceUri))
5500 {
5501 m_dwState = SOAP_HEADERS_DONE;
5502 return S_OK;
5503 }
5504
5505 // some sort of error
5506 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::endElement -- invalid SOAP message format while processing headers.\r\n" ) );
5507
5508 return E_FAIL;
5509 }
5510
5511 protected:
5512
5513 ISAXXMLReader * SetReader(ISAXXMLReader *pReader)
5514 {
5515 ISAXXMLReader *pPrevRdr = m_spReader;
5516 m_spReader = pReader;
5517
5518 return pPrevRdr;
5519 }
5520
5521 ISAXXMLReader * GetReader()
5522 {
5523 return m_spReader;
5524 }
5525
5526 HRESULT SetSoapMapFromName(
5527 const wchar_t * wszName,
5528 int cchName = -1,
5529 const wchar_t * wszNamespaceUri = NULL,
5530 int cchNamespaceUri = -1,
5531 bool bHeader = false)
5532 {
5533 ATLENSURE_RETURN( wszName != NULL );
5534
5535 int nVal;
5536 const _soapmap *pMap = NULL;
5537 if (m_stateStack.GetCount() != 0)
5538 {
5539 ATLASSUME( m_stateStack[0].pMap != NULL );
5540 nVal = (int) m_stateStack[0].nAllocSize;
5541 ATLASSERT( GetFunctionMap() != NULL );
5542 pMap = GetFunctionMap()[nVal];
5543 }
5544 else
5545 {
5546 pMap = GetSoapMapFromName(wszName, cchName,
5547 wszNamespaceUri, cchNamespaceUri, &nVal, bHeader);
5548 }
5549
5550 if (pMap == NULL)
5551 {
5552 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::SetSoapMapFromName -- _soapmap not found for: %.*ws, with namespace %.*ws\r\n"),
5553 (int)wcslen(wszName), wszName, wszNamespaceUri ? (int)wcslen(wszNamespaceUri) : 0, wszNamespaceUri ? wszNamespaceUri : L"");
5554
5555 return E_FAIL;
5556 }
5557
5558 HRESULT hr = E_OUTOFMEMORY;
5559
5560 // allocate the parameter struct
5561
5562 void *pvParam = NULL;
5563 if (bHeader != false)
5564 {
5565 pvParam = GetHeaderValue();
5566 }
5567 else
5568 {
5569 if (m_bClient == false)
5570 {
5571 m_pvParam = m_pMemMgr->Allocate(pMap->nElementSize);
5572 }
5573 pvParam = m_pvParam;
5574 }
5575
5576 if (pvParam != NULL)
5577 {
5578 if (bHeader == false)
5579 {
5580 memset(pvParam, 0x00, pMap->nElementSize);
5581 }
5582
5583 // push initial state
5584
5585 if (m_stateStack.GetCount() != 0)
5586 {
5587 m_stateStack.RemoveAll();
5588 }
5589
5590 hr = PushState(pvParam, pMap, NULL, 0, nVal, pMap->nElements);
5591
5592 if (FAILED(hr))
5593 {
5594 if ((m_bClient == false) && (bHeader == false))
5595 {
5596 m_pMemMgr->Free(pvParam);
5597 }
5598 }
5599 }
5600
5601 #ifdef _DEBUG
5602 if (hr == E_OUTOFMEMORY)
5603 {
5604 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::SetSoapMapFromName -- out of memory.\r\n" ) );
5605 }
5606 #endif // _DEBUG
5607
5608 return hr;
5609 }
5610
5611 // implementation
5612 virtual const _soapmap ** GetFunctionMap() = 0;
5613 virtual const _soapmap ** GetHeaderMap() = 0;
5614 virtual const wchar_t * GetNamespaceUri() = 0;
5615 virtual const char * GetServiceName() = 0;
5616 virtual const char * GetNamespaceUriA() = 0;
5617 virtual HRESULT CallFunction(
5618 void *pvParam,
5619 const wchar_t *wszLocalName, int cchLocalName,
5620 size_t nItem) = 0;
5621 virtual void * GetHeaderValue() = 0;
5622
5623 public:
5624
5625 CSoapRootHandler(ISAXXMLReader *pReader = NULL)
5626 : m_pMemMgr(&m_crtHeap), m_spReader(pReader), m_bClient(false),
5627 m_nState(0), m_pvParam(NULL), m_nDepth(0)
5628 {
5629 InitHandlerState();
5630 }
5631 virtual ~CSoapRootHandler()
5632 {
5633 m_skipHandler.DetachParent();
5634 }
5635
5636 IAtlMemMgr * SetMemMgr(IAtlMemMgr *pMemMgr)
5637 {
5638 IAtlMemMgr *pPrevMgr = m_pMemMgr;
5639 m_pMemMgr = pMemMgr;
5640
5641 return pPrevMgr;
5642 }
5643
5644 IAtlMemMgr * GetMemMgr()
5645 {
5646 return m_pMemMgr;
5647 }
5648
5649 // override this function to do SOAP Fault handling
5650 virtual HRESULT SoapFault(
5651 SOAP_ERROR_CODE /*errCode*/,
5652 const wchar_t * /*wszDetail*/,
5653 int /*cchDetail*/)
5654 {
5655 if (m_bClient != false)
5656 {
5657 return S_OK;
5658 }
5659
5660 // SOAP servers must implement this function
5661 ATLASSERT( FALSE );
5662 return E_FAIL;
5663 }
5664
5665 //
5666 // implementation
5667 //
5668
5669 void InitHandlerState()
5670 {
5671 m_bNullCheck = false;
5672 m_bCharacters = false;
5673 m_bChildCheck = false;
5674 m_dwState = SOAP_START;
5675 }
5676 HRESULT __stdcall startDocument()
5677 {
5678 InitHandlerState();
5679 return S_OK;
5680 }
5681
5682 HRESULT __stdcall startElement(
5683 const wchar_t *wszNamespaceUri,
5684 int cchNamespaceUri,
5685 const wchar_t *wszLocalName,
5686 int cchLocalName,
5687 const wchar_t * wszQName,
5688 int cchQName,
5689 ISAXAttributes *pAttributes)
5690 {
5691 if (m_bNullCheck || m_bCharacters)
5692 {
5693 // make sure elements that aren't supposed to have child elements
5694 // do not have child elements, and where we were expecting
5695 // characters, we got them
5696 return E_FAIL;
5697 }
5698
5699 m_bChildCheck = false;
5700 ++m_nDepth;
5701
5702 HRESULT hr = S_OK;
5703 switch (m_dwState)
5704 {
5705 case SOAP_PARAMS: case SOAP_HEADERS:
5706 {
5707 hr = ProcessParams(wszNamespaceUri, cchNamespaceUri, wszLocalName,
5708 cchLocalName, pAttributes);
5709
5710 break;
5711 }
5712 case SOAP_START: case SOAP_ENVELOPE: case SOAP_HEADERS_DONE:
5713 {
5714 ULONG nNamespaceHash = AtlSoapHashStr(wszNamespaceUri,
5715 cchNamespaceUri);
5716 if (nNamespaceHash != SOAP_ENV)
5717 {
5718 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::startElement -- incorrect SOAP-ENV namespace.\r\n" ) );
5719
5720 return E_FAIL;
5721 }
5722
5723 ULONG nElementHash = AtlSoapHashStr(wszLocalName, cchLocalName);
5724
5725 if (nElementHash == ENVELOPE &&
5726 IsEqualElement(
5727 sizeof(SOAP_ENVELOPEA)-1, SOAP_ENVELOPEW,
5728 sizeof(SOAPENV_NAMESPACEA)-1, SOAPENV_NAMESPACEW,
5729 cchLocalName, wszLocalName,
5730 cchNamespaceUri, wszNamespaceUri))
5731 {
5732 // Envelope must be first element in package
5733
5734 if (m_dwState != SOAP_START)
5735 {
5736 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::startElement -- invalid SOAP message format: \"Envelope\" in unexpected location.\r\n" ) );
5737
5738 hr = E_FAIL;
5739 }
5740 m_dwState = SOAP_ENVELOPE;
5741 }
5742 else if (nElementHash == HEADER &&
5743 IsEqualElement(sizeof(SOAP_HEADERA)-1, SOAP_HEADERW,
5744 sizeof(SOAPENV_NAMESPACEA)-1, SOAPENV_NAMESPACEW,
5745 cchLocalName, wszLocalName,
5746 cchNamespaceUri, wszNamespaceUri))
5747 {
5748 if (m_dwState != SOAP_ENVELOPE)
5749 {
5750 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::startElement -- invalid SOAP message format: \"Headers\" in unexpected location.\r\n" ) );
5751
5752 hr = E_FAIL;
5753 }
5754
5755 m_dwState = SOAP_HEADERS;
5756 }
5757 else if (nElementHash == BODY &&
5758 IsEqualElement(sizeof(SOAP_BODYA)-1, SOAP_BODYW,
5759 sizeof(SOAPENV_NAMESPACEA)-1, SOAPENV_NAMESPACEW,
5760 cchLocalName, wszLocalName,
5761 cchNamespaceUri, wszNamespaceUri))
5762 {
5763 if (m_dwState == SOAP_START)
5764 {
5765 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::startElement -- invalid SOAP message format: \"Body\" in unexpected location.\r\n" ) );
5766
5767 hr = E_FAIL;
5768 }
5769 m_dwState = SOAP_BODY;
5770 }
5771
5772 break;
5773 }
5774 case SOAP_BODY:
5775 {
5776 hr = DispatchSoapCall(wszNamespaceUri, cchNamespaceUri,
5777 wszLocalName, cchLocalName);
5778
5779 m_dwState = SOAP_PARAMS;
5780
5781 if (SUCCEEDED(hr))
5782 {
5783 if (GetState().pMap->dwCallFlags & SOAPFLAG_PAD)
5784 {
5785 hr = startElement(wszNamespaceUri, cchNamespaceUri,
5786 wszLocalName, cchLocalName, wszQName, cchQName,
5787 pAttributes);
5788 }
5789 }
5790
5791 break;
5792 }
5793
5794 #ifdef _DEBUG
5795
5796 default:
5797 {
5798 // should never get here -- internal error
5799 ATLASSERT( FALSE );
5800 }
5801
5802 #endif // _DEBUG
5803 }
5804
5805 return hr;
5806 }
5807
5808 HRESULT __stdcall characters(
5809 const wchar_t *wszChars,
5810 int cchChars)
5811 {
5812 m_bCharacters = false;
5813
5814 // if it is a ready state, get the value
5815 if (m_stateStack.IsEmpty() == false)
5816 {
5817 ParseState& state = GetState();
5818 if ((state.dwFlags & SOAPFLAG_READYSTATE) &&
5819 ((state.dwFlags & SOAPFLAG_SIZEIS)==0)) // don't marshal struct size_is elements -- should be filled in by array marshaling code
5820 {
5821 if ((state.pMap == NULL) || (state.pMap->mapType != SOAPMAP_ENUM))
5822 {
5823 return AtlSoapGetElementValue(wszChars, cchChars,
5824 state.pvElement, (SOAPTYPES)state.pEntry->nVal, GetMemMgr());
5825 }
5826 else
5827 {
5828 // enum
5829
5830 ATLASSERT( state.pMap != NULL );
5831 ATLASSERT( state.pMap->pEntries != NULL );
5832
5833 ULONG nHash = AtlSoapHashStr(wszChars, cchChars);
5834 const _soapmapentry *pEntries = state.pMap->pEntries;
5835
5836 size_t i;
5837 for (i=0; pEntries[i].nHash != 0; i++)
5838 {
5839 if ((nHash == pEntries[i].nHash) &&
5840 (cchChars == pEntries[i].cchField) &&
5841 (!wcsncmp(wszChars, pEntries[i].wszField, cchChars)))
5842 {
5843 break;
5844 }
5845 }
5846
5847 if (pEntries[i].nHash != 0)
5848 {
5849 *((int *)state.pvElement) = pEntries[i].nVal;
5850 state.nElement++;
5851 return S_OK;
5852 }
5853
5854 // no matching enum entry found
5855 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::characters -- no matching enum entry found for: %.*ws.\r\n" ), cchChars, wszChars );
5856
5857 return E_FAIL;
5858 }
5859 }
5860 }
5861
5862 // otherwise, ignore
5863
5864 return S_OK;
5865 }
5866
5867 HRESULT __stdcall endElement(
5868 const wchar_t * wszNamespaceUri,
5869 int cchNamespaceUri,
5870 const wchar_t * wszLocalName,
5871 int cchLocalName,
5872 const wchar_t * /*wszQName*/,
5873 int /*cchQName*/)
5874 {
5875 static bool bDynArrWrapper = false;
5876 if (m_bCharacters)
5877 {
5878 return E_FAIL;
5879 }
5880
5881 m_bNullCheck = false;
5882
5883 if (m_stateStack.IsEmpty() != false)
5884 {
5885 return S_OK;
5886 }
5887
5888 if (!bDynArrWrapper && (m_nState > 1))
5889 {
5890 ParseState prevState = m_stateStack.GetAt(m_nState - 1);
5891 ParseState curState = m_stateStack.GetAt(m_nState);
5892 if (prevState.dwFlags & SOAPFLAG_DYNARRWRAPPER)
5893 {
5894 bDynArrWrapper = true;
5895 endElement (wszNamespaceUri, cchNamespaceUri, curState.pEntry->wszField,
5896 curState.pEntry->cchField, NULL, 0);
5897 }
5898 }
5899 else
5900 {
5901 bDynArrWrapper = false;
5902 }
5903
5904 --m_nDepth;
5905
5906 const ParseState& state = GetState();
5907
5908 if ((m_dwState == SOAP_HEADERS) && (m_stateStack.GetCount() == 1))
5909 {
5910 return CheckEndHeaders(wszNamespaceUri, cchNamespaceUri, wszLocalName, cchLocalName);
5911 }
5912
5913 if (state.dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR))
5914 {
5915 if (state.dwFlags & SOAPFLAG_READYSTATE)
5916 {
5917 PopState();
5918 }
5919
5920 const ParseState& currstate = GetState();
5921 ATLENSURE_RETURN( currstate.pEntry != NULL );
5922
5923 if (m_nDepth == (currstate.nDepth-1))
5924 {
5925 if (S_OK != CheckEndElement(currstate))
5926 {
5927 // invalid number of elements
5928 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::endElement -- invalid number of array elements for array parameter %.*ws.\r\n"),
5929 currstate.pEntry->cchField, currstate.pEntry->wszField );
5930
5931 return E_FAIL;
5932 }
5933
5934 PopState();
5935 }
5936 }
5937 else
5938 {
5939 if (S_OK != CheckEndElement(state))
5940 {
5941 return E_FAIL;
5942 }
5943
5944 PopState();
5945 }
5946
5947 return S_OK;
5948 }
5949
5950 HRESULT SetClientStruct(void *pvParam, int nMapIndex)
5951 {
5952 ATLENSURE_RETURN( pvParam != NULL );
5953 ATLENSURE_RETURN( nMapIndex >= 0 );
5954
5955 // this is the params struct
5956 // store for later use
5957 m_pvParam = pvParam;
5958
5959 const _soapmap ** pEntries = GetHeaderMap();
5960 ATLENSURE_RETURN( pEntries != NULL );
5961
5962 // push header value
5963 return PushState(GetHeaderValue(), pEntries[nMapIndex], NULL, 0, nMapIndex, pEntries[nMapIndex]->nElements);
5964 }
5965
5966 void ResetClientState(bool bFull = false)
5967 {
5968 m_stateStack.RemoveAll();
5969 m_nState = 0;
5970 if (bFull != false)
5971 {
5972 m_dwState = SOAP_START;
5973 m_pvParam = NULL;
5974 }
5975 }
5976
5977 HRESULT CreateReader()
5978 {
5979 return m_spReader.CoCreateInstance(ATLS_SAXXMLREADER_CLSID, NULL, CLSCTX_INPROC_SERVER);
5980 }
5981
5982 HRESULT InitializeSOAP(IServiceProvider *pProvider)
5983 {
5984 HRESULT hr = S_OK;
5985
5986 if (m_spReader.p == NULL)
5987 {
5988 hr = E_FAIL;
5989 if (pProvider != NULL)
5990 {
5991 IAtlMemMgr *pMemMgr = NULL;
5992 hr = pProvider->QueryService(__uuidof(IAtlMemMgr),
5993 __uuidof(IAtlMemMgr), (void **)&pMemMgr);
5994 if ((SUCCEEDED(hr)) && (pMemMgr != NULL))
5995 {
5996 SetMemMgr(pMemMgr);
5997 }
5998
5999 hr = pProvider->QueryService(__uuidof(ISAXXMLReader),
6000 __uuidof(ISAXXMLReader), (void **)&m_spReader);
6001 }
6002
6003 if (FAILED(hr))
6004 {
6005 hr = CreateReader();
6006 }
6007 }
6008
6009 if (SUCCEEDED(hr))
6010 {
6011 hr = m_spReader->putContentHandler(this);
6012 }
6013
6014 #ifdef _DEBUG
6015 else
6016 {
6017 ATLTRACE( _T("ATLSOAP: CSoapRootHandler::InitializeSOAP -- failed to get SAXXMLReader.\r\n" ) );
6018 }
6019 #endif // _DEBUG
6020
6021 return hr;
6022 }
6023
6024 void UninitializeSOAP()
6025 {
6026 if (m_spReader.p != NULL)
6027 {
6028 m_spReader->putContentHandler(NULL);
6029 m_spReader.Release();
6030 }
6031 }
6032
6033 virtual HRESULT DispatchSoapCall(const wchar_t *wszNamespaceUri,
6034 int cchNamespaceUri, const wchar_t *wszLocalName,
6035 int cchLocalName)
6036 {
6037 HRESULT hr = S_OK;
6038
6039 if (m_stateStack.IsEmpty() == false)
6040 {
6041 ATLASSUME( m_stateStack[0].pMap != NULL );
6042
6043 // check to see if all required and non-nullable SOAP headers were sent
6044 if (m_stateStack[0].pMap->mapType == SOAPMAP_HEADER)
6045 {
6046 hr = CheckSoapHeaders(m_stateStack[0]);
6047 }
6048 if (SUCCEEDED(hr))
6049 {
6050 hr = SetSoapMapFromName(wszLocalName, cchLocalName,
6051 wszNamespaceUri, cchNamespaceUri);
6052 }
6053 }
6054 else
6055 {
6056 // get the appropriate function map
6057 hr = SetSoapMapFromName(wszLocalName, cchLocalName,
6058 wszNamespaceUri, cchNamespaceUri);
6059
6060 if (SUCCEEDED(hr))
6061 {
6062 // set the SOAP Header map for the function
6063 ATLASSUME( m_stateStack.IsEmpty() == false );
6064
6065 const _soapmap **ppHeaderMap = GetHeaderMap();
6066 ATLENSURE_RETURN( ppHeaderMap != NULL );
6067
6068 // create a temporary parse state for checking headers
6069 ParseState state;
6070 state.pMap = ppHeaderMap[m_stateStack[0].nAllocSize];
6071 ATLENSURE_RETURN( state.pMap != NULL );
6072
6073 // check to see if all required and non-nullable SOAP headers were sent
6074 hr = CheckSoapHeaders(state);
6075 }
6076 }
6077
6078 return hr;
6079 }
6080
6081 virtual HRESULT BeginParse(IStream *pStream)
6082 {
6083 ATLASSERT( pStream != NULL );
6084
6085 CComVariant varStream;
6086 varStream = static_cast<IUnknown*>(pStream);
6087
6088 HRESULT hr = m_spReader->parse(varStream);
6089 if (SUCCEEDED(hr))
6090 {
6091 if (m_refMap.GetCount() != 0)
6092 {
6093 hr = E_FAIL;
6094 }
6095 }
6096 return hr;
6097 }
6098
6099 HRESULT CallFunctionInternal()
6100 {
6101 HRESULT hr = E_FAIL;
6102 const ParseState& state = m_stateStack[0];
6103 hr = CallFunction(
6104 state.pvElement,
6105 state.pMap->wszName,
6106 state.pMap->cchWName,
6107 state.nAllocSize);
6108
6109 return hr;
6110 }
6111
6112 virtual HRESULT GenerateResponse(IWriteStream *pStream)
6113 {
6114 ATLASSUME( m_stateStack.IsEmpty() == false );
6115 ATLASSUME( m_stateStack[0].pMap != NULL );
6116 ATLASSUME( m_stateStack[0].pvElement != NULL );
6117
6118 const ParseState& state = m_stateStack[0];
6119
6120 const _soapmap *pHeaderMap = NULL;
6121 if (m_bClient == false)
6122 {
6123 const _soapmap **ppHeaderMap = GetHeaderMap();
6124 if (ppHeaderMap != NULL)
6125 {
6126 pHeaderMap = ppHeaderMap[state.nAllocSize];
6127 }
6128 }
6129 else
6130 {
6131 pHeaderMap = state.pMap;
6132 }
6133
6134 const _soapmap *pFuncMap = NULL;
6135 if (m_bClient == false)
6136 {
6137 pFuncMap = state.pMap;
6138 }
6139 else
6140 {
6141 const _soapmap **ppFuncMap = GetFunctionMap();
6142 ATLENSURE_RETURN( ppFuncMap != NULL );
6143 pFuncMap = ppFuncMap[state.nAllocSize];
6144 }
6145
6146 ATLENSURE_RETURN( pFuncMap != NULL );
6147
6148 CRpcEncodedGenerator rpcGen;
6149 CPADGenerator padGen;
6150 CPIDGenerator pidGen;
6151
6152 CResponseGenerator *pGenerator = NULL;
6153
6154 if ((pFuncMap->dwCallFlags & (SOAPFLAG_RPC | SOAPFLAG_ENCODED)) == (SOAPFLAG_RPC | SOAPFLAG_ENCODED))
6155 {
6156 pGenerator = &rpcGen;
6157 }
6158 else if (pFuncMap->dwCallFlags & SOAPFLAG_PID)
6159 {
6160 ATLASSERT( (pFuncMap->dwCallFlags & (SOAPFLAG_DOCUMENT | SOAPFLAG_LITERAL)) == (SOAPFLAG_DOCUMENT | SOAPFLAG_LITERAL) );
6161 pGenerator = &pidGen;
6162 }
6163 else
6164 {
6165 ATLASSERT( (pFuncMap->dwCallFlags & (SOAPFLAG_DOCUMENT | SOAPFLAG_LITERAL)) == (SOAPFLAG_DOCUMENT | SOAPFLAG_LITERAL) );
6166 ATLASSERT( pFuncMap->dwCallFlags & SOAPFLAG_PAD );
6167 pGenerator = &padGen;
6168 }
6169
6170 HRESULT hr = pGenerator->StartEnvelope(pStream);
6171 if (SUCCEEDED(hr))
6172 {
6173 // generate headers if necessary
6174 hr = GenerateHeaders(pGenerator, pHeaderMap, pStream);
6175 if (SUCCEEDED(hr))
6176 {
6177 hr = pGenerator->StartBody(pStream);
6178 if (SUCCEEDED(hr))
6179 {
6180 hr = GenerateResponseHelper(pGenerator, pFuncMap, m_pvParam, pStream, true);
6181 if (SUCCEEDED(hr))
6182 {
6183 hr = pGenerator->EndBody(pStream);
6184 if (SUCCEEDED(hr))
6185 {
6186 hr = pGenerator->EndEnvelope(pStream);
6187 }
6188 }
6189 }
6190 }
6191 }
6192
6193 return hr;
6194 }
6195
6196 virtual void Cleanup()
6197 {
6198 // cleanup headers
6199 CleanupHeaders();
6200
6201 if ((m_stateStack.IsEmpty() == false) && (m_pvParam != NULL))
6202 {
6203 const _soapmap **ppFuncMap = GetFunctionMap();
6204 ATLENSURE( ppFuncMap != NULL );
6205
6206 const _soapmap *pFuncMap = ppFuncMap[m_stateStack[0].nAllocSize];
6207 ATLENSURE( pFuncMap != NULL );
6208
6209 CleanupHelper(pFuncMap, m_pvParam);
6210 if (m_bClient == false)
6211 {
6212 m_pMemMgr->Free(m_pvParam);
6213 m_stateStack.RemoveAll();
6214 }
6215 }
6216 }
6217
6218 virtual void CleanupHeaders()
6219 {
6220 if (m_stateStack.IsEmpty() == false)
6221 {
6222 const _soapmap **ppHeaderMap = GetHeaderMap();
6223 ATLENSURE( ppHeaderMap != NULL );
6224
6225 const _soapmap *pHeaderMap = ppHeaderMap[m_stateStack[0].nAllocSize];
6226 ATLENSURE( pHeaderMap != NULL );
6227
6228 CleanupHelper(pHeaderMap, GetHeaderValue());
6229 }
6230 }
6231
6232 void SetClient(bool bClient)
6233 {
6234 m_bClient = bClient;
6235 }
6236
6237 }; // class CSoapRootHandler
6238
6239 #define DECLARE_XSD_ENTRY( __name ) \
6240 { L ## __name, __name, sizeof(__name)-1 },
6241
6242 __declspec(selectany) const CSoapRootHandler::XSDEntry CSoapRootHandler::s_xsdNames[] =
6243 {
6244 DECLARE_XSD_ENTRY("string")
6245 DECLARE_XSD_ENTRY("boolean")
6246 DECLARE_XSD_ENTRY("float")
6247 DECLARE_XSD_ENTRY("double")
6248 DECLARE_XSD_ENTRY("decimal")
6249 DECLARE_XSD_ENTRY("duration")
6250 DECLARE_XSD_ENTRY("hexBinary")
6251 DECLARE_XSD_ENTRY("base64Binary")
6252 DECLARE_XSD_ENTRY("anyURI")
6253 DECLARE_XSD_ENTRY("ID")
6254 DECLARE_XSD_ENTRY("IDREF")
6255 DECLARE_XSD_ENTRY("ENTITY")
6256 DECLARE_XSD_ENTRY("NOTATION")
6257 DECLARE_XSD_ENTRY("QName")
6258 DECLARE_XSD_ENTRY("normalizedString")
6259 DECLARE_XSD_ENTRY("token")
6260 DECLARE_XSD_ENTRY("language")
6261 DECLARE_XSD_ENTRY("IDREFS")
6262 DECLARE_XSD_ENTRY("ENTITIES")
6263 DECLARE_XSD_ENTRY("NMTOKEN")
6264 DECLARE_XSD_ENTRY("NMTOKENS")
6265 DECLARE_XSD_ENTRY("Name")
6266 DECLARE_XSD_ENTRY("NCName")
6267 DECLARE_XSD_ENTRY("integer")
6268 DECLARE_XSD_ENTRY("nonPositiveInteger")
6269 DECLARE_XSD_ENTRY("negativeInteger")
6270 DECLARE_XSD_ENTRY("long")
6271 DECLARE_XSD_ENTRY("int")
6272 DECLARE_XSD_ENTRY("short")
6273 DECLARE_XSD_ENTRY("byte")
6274 DECLARE_XSD_ENTRY("nonNegativeInteger")
6275 DECLARE_XSD_ENTRY("unsignedLong")
6276 DECLARE_XSD_ENTRY("unsignedInt")
6277 DECLARE_XSD_ENTRY("unsignedShort")
6278 DECLARE_XSD_ENTRY("unsignedByte")
6279 DECLARE_XSD_ENTRY("positiveInteger")
6280 DECLARE_XSD_ENTRY("dateTime")
6281 DECLARE_XSD_ENTRY("time")
6282 DECLARE_XSD_ENTRY("date")
6283 DECLARE_XSD_ENTRY("gMonth")
6284 DECLARE_XSD_ENTRY("gYearMonth")
6285 DECLARE_XSD_ENTRY("gYear")
6286 DECLARE_XSD_ENTRY("gMonthDay")
6287 DECLARE_XSD_ENTRY("gDay")
6288 };
6289
6290 __declspec(selectany) CCRTHeap CSoapRootHandler::m_crtHeap;
6291
6292 template <typename THandler>
6293 class CSoapHandler :
6294 public CSoapRootHandler,
6295 public CComObjectRootEx<CComMultiThreadModel>,
6296 public IRequestHandlerImpl<THandler>
6297 {
6298 protected:
6299
6300 HTTP_CODE m_hcErr;
6301 CHttpResponse *m_pHttpResponse;
6302
6303 // heap for SOAP requests
6304 CWin32Heap m_heap;
6305
6306 // default heap is COM heap (SOAP Servers can double as COM objects)
6307 CComHeap m_comHeap;
6308
6309 public:
6310
6311 BEGIN_COM_MAP(CSoapHandler<THandler>)
6312 COM_INTERFACE_ENTRY(ISAXContentHandler)
6313 COM_INTERFACE_ENTRY(IRequestHandler)
6314 END_COM_MAP()
6315
6316 CSoapHandler()
6317 :m_pHttpResponse(NULL), m_hcErr(HTTP_SUCCESS)
6318 {
6319 SetMemMgr(&m_comHeap);
6320 }
6321
6322 void SetHttpError(HTTP_CODE hcErr)
6323 {
6324 m_hcErr = hcErr;
6325 }
6326
6327 HRESULT SoapFault(
6328 SOAP_ERROR_CODE errCode,
6329 const wchar_t *wszDetail,
6330 int cchDetail)
6331 {
6332 ATLASSUME( m_pHttpResponse != NULL );
6333
6334 SetHttpError(AtlsHttpError(500, SUBERR_NO_PROCESS));
6335
6336 m_pHttpResponse->ClearHeaders();
6337 m_pHttpResponse->ClearContent();
6338 m_pHttpResponse->SetContentType("text/xml");
6339 m_pHttpResponse->SetStatusCode(500);
6340
6341 CSoapFault fault;
6342 if (wszDetail != NULL)
6343 {
6344 if (cchDetail < 0)
6345 {
6346 cchDetail = (int) wcslen(wszDetail);
6347 }
6348
6349 _ATLTRY
6350 {
6351 fault.m_strDetail.SetString(wszDetail, cchDetail);
6352 }
6353 _ATLCATCHALL()
6354 {
6355 ATLTRACE( _T("CSoapHandler::SoapFault -- out of memory.\r\n" ) );
6356
6357 return E_OUTOFMEMORY;
6358 }
6359 }
6360
6361 fault.m_soapErrCode = errCode;
6362 fault.GenerateFault(m_pHttpResponse);
6363 return S_OK;
6364 }
6365
6366 HTTP_CODE InitializeHandler(AtlServerRequest *pRequestInfo, IServiceProvider *pProvider)
6367 {
6368 m_hcErr = IRequestHandlerImpl<THandler>::InitializeHandler(pRequestInfo, pProvider);
6369 if (m_hcErr == HTTP_SUCCESS)
6370 {
6371 HRESULT hr = InitializeSOAP(m_spServiceProvider);
6372 if (SUCCEEDED(hr))
6373 {
6374 // try to use the per-thread heap
6375 CIsapiWorker *pWorker = pRequestInfo->pExtension->GetThreadWorker();
6376 if (pWorker != NULL)
6377 {
6378 m_heap.Attach(pWorker->m_hHeap, false);
6379 SetMemMgr(&m_heap);
6380 }
6381
6382 return m_hcErr;
6383 }
6384 }
6385
6386 // some initialization failure
6387 CHttpResponse HttpResponse(pRequestInfo->pServerContext);
6388 m_pHttpResponse = &HttpResponse;
6389
6390 SoapFault(SOAP_E_SERVER, NULL, 0);
6391
6392 m_pHttpResponse = NULL;
6393
6394 return m_hcErr;
6395 }
6396
6397 HTTP_CODE HandleRequest(AtlServerRequest *pRequestInfo, IServiceProvider * /*pProvider*/)
6398 {
6399 // SOAPACTION header is required per the SOAP 1.1
6400 // mainly so firewalls can filter on it.
6401 char szBuf[ATL_URL_MAX_URL_LENGTH+1];
6402 szBuf[0] = '\0';
6403 DWORD dwLen = ATL_URL_MAX_URL_LENGTH;
6404 if ( m_spServerContext->GetServerVariable("HTTP_SOAPACTION", szBuf, &dwLen) != FALSE )
6405 {
6406 if ( dwLen >= 2 )
6407 {
6408 // drop the last "
6409 szBuf[dwLen-2] = '\0';
6410 char *szMethod = strrchr(szBuf, '#');
6411 if (szMethod != NULL)
6412 {
6413 _ATLTRY
6414 {
6415 // ignore return code here
6416 SetSoapMapFromName(CA2W( szMethod+1 ), -1, GetNamespaceUri(), -1, true);
6417 }
6418 _ATLCATCHALL()
6419 {
6420 return AtlsHttpError(500, ISE_SUBERR_OUTOFMEM);
6421 }
6422 }
6423 }
6424 }
6425 else
6426 {
6427 // SOAP requestion that use the HTTP transport
6428 // must have a SOAPACTION header.
6429 return HTTP_ERROR(500, ISE_SUBERR_SOAPNOSOAPACTION);
6430 }
6431
6432 // set the header map
6433 CHttpResponse HttpResponse(pRequestInfo->pServerContext);
6434 m_pHttpResponse = &HttpResponse;
6435
6436 CStreamOnServerContext s(pRequestInfo->pServerContext);
6437
6438 #ifdef _DEBUG
6439
6440 CSAXSoapErrorHandler err;
6441 GetReader()->putErrorHandler(&err);
6442
6443 #endif // _DEBUG
6444
6445 HRESULT hr = BeginParse(&s);
6446
6447 #ifdef _DEBUG
6448 // release the error handler
6449 GetReader()->putErrorHandler(NULL);
6450 #endif // _DEBUG
6451
6452 if (FAILED(hr))
6453 {
6454 Cleanup();
6455 if (m_hcErr == HTTP_SUCCESS)
6456 {
6457 SoapFault(SOAP_E_CLIENT, NULL, NULL);
6458 }
6459
6460 return m_hcErr;
6461 }
6462
6463 _ATLTRY
6464 {
6465 hr = CallFunctionInternal();
6466 }
6467 _ATLCATCHALL()
6468 {
6469 // cleanup before propagating user exception
6470 Cleanup();
6471 HttpResponse.Detach();
6472 _ATLRETHROW;
6473 }
6474
6475 if (FAILED(hr))
6476 {
6477 Cleanup();
6478 HttpResponse.ClearHeaders();
6479 HttpResponse.ClearContent();
6480 if (m_hcErr != HTTP_SUCCESS)
6481 {
6482 HttpResponse.SetStatusCode(HTTP_ERROR_CODE(m_hcErr));
6483 return HTTP_SUCCESS_NO_PROCESS;
6484 }
6485 HttpResponse.SetStatusCode(500);
6486 GenerateAppError(&HttpResponse, hr);
6487 return AtlsHttpError(500, SUBERR_NO_PROCESS);
6488 }
6489
6490 HttpResponse.SetContentType("text/xml");
6491 hr = GenerateResponse(&HttpResponse);
6492 Cleanup();
6493 if (FAILED(hr))
6494 {
6495 SoapFault(SOAP_E_SERVER, NULL, 0);
6496 return m_hcErr;
6497 }
6498
6499 return HTTP_SUCCESS;
6500 }
6501
6502 virtual ATL_NOINLINE HRESULT GenerateAppError(IWriteStream *pStream, HRESULT hr)
6503 {
6504 if (pStream == NULL)
6505 {
6506 return E_INVALIDARG;
6507 }
6508
6509 LPWSTR pwszMessage = NULL;
6510 DWORD dwLen = ::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
6511 NULL, hr, 0, (LPWSTR) &pwszMessage, 0, NULL);
6512
6513 if (dwLen == 0)
6514 {
6515 pwszMessage = L"Application Error";
6516 }
6517
6518 hr = SoapFault(SOAP_E_SERVER, pwszMessage, dwLen ? dwLen : -1);
6519 if (dwLen != 0)
6520 {
6521 ::LocalFree(pwszMessage);
6522 }
6523
6524 return hr;
6525 }
6526
6527 void UninitializeHandler()
6528 {
6529 UninitializeSOAP();
6530 }
6531 };
6532
6533
6534 // client error states
6535 enum SOAPCLIENT_ERROR
6536 {
6537 SOAPCLIENT_SUCCESS=0, // everything succeeded
6538 SOAPCLIENT_INITIALIZE_ERROR, // initialization failed -- most likely an MSXML installation problem
6539 SOAPCLIENT_OUTOFMEMORY, // out of memory
6540 SOAPCLIENT_GENERATE_ERROR, // failed in generating the response
6541 SOAPCLIENT_CONNECT_ERROR, // failed connecting to server
6542 SOAPCLIENT_SEND_ERROR, // failed in sending message
6543 SOAPCLIENT_SERVER_ERROR, // server error
6544 SOAPCLIENT_SOAPFAULT, // a SOAP Fault was returned by the server
6545 SOAPCLIENT_PARSEFAULT_ERROR, // failed in parsing SOAP fault
6546 SOAPCLIENT_READ_ERROR, // failed in reading response
6547 SOAPCLIENT_PARSE_ERROR // failed in parsing response
6548 };
6549
6550 template <typename TSocketClass = ZEvtSyncSocket>
6551 class CSoapSocketClientT
6552 {
6553 private:
6554
6555 CUrl m_url;
6556 CWriteStreamOnCString m_writeStream;
6557 CReadStreamOnSocket<TSocketClass> m_readStream;
6558 DWORD m_dwTimeout;
6559
6560 SOAPCLIENT_ERROR m_errorState;
6561
6562 protected:
6563
6564 virtual HRESULT GetClientReader(ISAXXMLReader **pReader)
6565 {
6566 if (pReader == NULL)
6567 {
6568 return E_POINTER;
6569 }
6570 *pReader = NULL;
6571
6572 CComPtr<ISAXXMLReader> spReader;
6573 HRESULT hr = spReader.CoCreateInstance(ATLS_SAXXMLREADER_CLSID, NULL, CLSCTX_INPROC_SERVER);
6574 if (SUCCEEDED(hr))
6575 {
6576 *pReader = spReader.Detach();
6577 }
6578 return hr;
6579 }
6580
6581 public:
6582
6583 // note : not shared across stock client implementations
6584 CAtlHttpClientT<TSocketClass> m_socket;
6585
6586 CSoapFault m_fault;
6587
6588 // constructor
6589 CSoapSocketClientT(LPCTSTR szUrl)
6590 : m_dwTimeout(0), m_errorState(SOAPCLIENT_SUCCESS)
6591 {
6592 TCHAR szTmp[ATL_URL_MAX_URL_LENGTH];
6593 if(AtlEscapeUrl(szUrl,szTmp,0,ATL_URL_MAX_URL_LENGTH-1,ATL_URL_BROWSER_MODE))
6594 m_url.CrackUrl(szTmp);
6595 }
6596
6597 CSoapSocketClientT(LPCTSTR szServer, LPCTSTR szUri, ATL_URL_PORT nPort=80)
6598 : m_dwTimeout(0), m_errorState(SOAPCLIENT_SUCCESS)
6599 {
6600 ATLASSERT( szServer != NULL );
6601 ATLASSERT( szUri != NULL );
6602
6603 m_url.SetUrlPath(szUri);
6604 m_url.SetHostName(szServer);
6605 m_url.SetPortNumber(nPort);
6606 }
6607
6608 ~CSoapSocketClientT()
6609 {
6610 CleanupClient();
6611 }
6612
6613 SOAPCLIENT_ERROR GetClientError()
6614 {
6615 return m_errorState;
6616 }
6617
6618 void SetClientError(SOAPCLIENT_ERROR errorState)
6619 {
6620 m_errorState = errorState;
6621 }
6622
6623 IWriteStream * GetWriteStream()
6624 {
6625 return &m_writeStream;
6626 }
6627
6628 HRESULT GetReadStream(IStream **ppStream)
6629 {
6630 if (ppStream == NULL)
6631 {
6632 return E_POINTER;
6633 }
6634
6635 *ppStream = &m_readStream;
6636 return S_OK;
6637 }
6638
6639 void CleanupClient()
6640 {
6641 m_writeStream.Cleanup();
6642 m_fault.Clear();
6643 SetClientError(SOAPCLIENT_SUCCESS);
6644 }
6645
6646 HRESULT SendRequest(LPCTSTR szAction)
6647 {
6648 HRESULT hr = E_FAIL;
6649 _ATLTRY
6650 {
6651 // create extra headers to send with request
6652 CFixedStringT<CString, 256> strExtraHeaders(szAction);
6653 strExtraHeaders.Append(_T("Accept: text/xml\r\n"), sizeof("Accept: text/xml\r\n")-1);
6654 CAtlNavigateData navData;
6655 navData.SetMethod(ATL_HTTP_METHOD_POST);
6656 navData.SetPort(m_url.GetPortNumber());
6657 navData.SetExtraHeaders(strExtraHeaders);
6658 navData.SetPostData((LPBYTE)(LPCSTR) m_writeStream.m_str, m_writeStream.m_str.GetLength(), _T("text/xml; charset=utf-8"));
6659
6660 ATLSOAP_TRACE( (LPBYTE)(LPCSTR)m_writeStream.m_str, m_writeStream.m_str.GetLength() );
6661
6662 if (m_dwTimeout != 0)
6663 {
6664 navData.SetSocketTimeout(m_dwTimeout);
6665 }
6666
6667 if (m_socket.Navigate(&m_url, &navData) != false)
6668 {
6669 if (GetStatusCode() == 200)
6670 {
6671 hr = (m_readStream.Init(&m_socket) != FALSE ? S_OK : E_FAIL);
6672 if (hr != S_OK)
6673 {
6674 SetClientError(SOAPCLIENT_READ_ERROR);
6675 }
6676 }
6677 else if (GetStatusCode() == 202)
6678 {
6679 // for one-way methods
6680 hr = S_OK;
6681 }
6682 else
6683 {
6684 SetClientError(SOAPCLIENT_SERVER_ERROR);
6685 }
6686 }
6687 else if (GetStatusCode() == 500)
6688 {
6689 SetClientError(SOAPCLIENT_SOAPFAULT);
6690
6691 // if returned 500, get the SOAP fault
6692 if (m_readStream.Init(&m_socket) != FALSE)
6693 {
6694 CComPtr<ISAXXMLReader> spReader;
6695 if (SUCCEEDED(GetClientReader(&spReader)))
6696 {
6697 CComPtr<IStream> spReadStream;
6698 if (SUCCEEDED(GetReadStream(&spReadStream)))
6699 {
6700 if (FAILED(m_fault.ParseFault(spReadStream, spReader)))
6701 {
6702 SetClientError(SOAPCLIENT_PARSEFAULT_ERROR);
6703 }
6704 }
6705 }
6706 }
6707 }
6708 else
6709 {
6710 SetClientError(SOAPCLIENT_SEND_ERROR);
6711 }
6712 }
6713 _ATLCATCHALL()
6714 {
6715 hr = E_FAIL;
6716 }
6717
6718 return hr;
6719 }
6720
6721 HRESULT SetUrl(LPCTSTR szUrl)
6722 {
6723 TCHAR szTmp[ATL_URL_MAX_URL_LENGTH];
6724 if(!AtlEscapeUrl(szUrl,szTmp,0,ATL_URL_MAX_URL_LENGTH-1,ATL_URL_BROWSER_MODE))
6725 {
6726 return E_FAIL;
6727 }
6728
6729 return (m_url.CrackUrl(szTmp) != FALSE) ? S_OK : E_FAIL;
6730 }
6731
6732 HRESULT GetUrl(__out_ecount_part_z(*pdwLen, *pdwLen) LPTSTR szUrl, __inout LPDWORD pdwLen)
6733 {
6734 if ((szUrl == NULL) || (pdwLen == NULL))
6735 {
6736 return E_INVALIDARG;
6737 }
6738
6739 return (m_url.CreateUrl(szUrl, pdwLen) != FALSE) ? S_OK : E_FAIL;
6740 }
6741
6742 HRESULT SetProxy(LPCTSTR szProxy = NULL, short nProxyPort = 80)
6743 {
6744 BOOL bRet = m_socket.SetProxy(szProxy, nProxyPort);
6745 return (bRet != FALSE) ? S_OK : E_FAIL;
6746 }
6747
6748 void SetTimeout(DWORD dwTimeout)
6749 {
6750 m_dwTimeout = dwTimeout;
6751 }
6752
6753 int GetStatusCode()
6754 {
6755 return m_socket.GetStatus();
6756 }
6757
6758 }; // CSoapSocketClientT
6759
6760 #ifndef ATLSOAP_NOWININET
6761
6762 class CReadStreamOnInet : public IStreamImpl
6763 {
6764 public:
6765
6766 HRESULT __stdcall QueryInterface(REFIID riid, void **ppv)
6767 {
6768 if (ppv == NULL)
6769 {
6770 return E_POINTER;
6771 }
6772
6773 *ppv = NULL;
6774
6775 if (InlineIsEqualGUID(riid, IID_IUnknown) ||
6776 InlineIsEqualGUID(riid, IID_IStream) ||
6777 InlineIsEqualGUID(riid, IID_ISequentialStream))
6778 {
6779 *ppv = static_cast<IStream *>(this);
6780 return S_OK;
6781 }
6782
6783 return E_NOINTERFACE;
6784 }
6785
6786 ULONG __stdcall AddRef()
6787 {
6788 return 1;
6789 }
6790
6791 ULONG __stdcall Release()
6792 {
6793 return 1;
6794 }
6795
6796 private:
6797
6798 HINTERNET m_hFile;
6799
6800 public:
6801
6802 CReadStreamOnInet()
6803 :m_hFile(NULL)
6804 {
6805 }
6806
6807 void Init(HINTERNET hFile)
6808 {
6809 m_hFile = hFile;
6810 }
6811
6812 HRESULT STDMETHODCALLTYPE Read(void *pDest, ULONG dwMaxLen, ULONG *pdwRead)
6813 {
6814 BOOL bRet = InternetReadFile(m_hFile, pDest, dwMaxLen, pdwRead);
6815 return (bRet != FALSE) ? S_OK : E_FAIL;
6816 }
6817
6818 }; // CStreamOnInet
6819
6820 class CSoapWininetClient
6821 {
6822 private:
6823
6824 CUrl m_url;
6825 CWriteStreamOnCString m_writeStream;
6826 CReadStreamOnInet m_readStream;
6827 CString m_strProxy;
6828 DWORD m_dwTimeout;
6829 CFixedStringT<CString, ATL_URL_MAX_URL_LENGTH+1> m_strUrl;
6830 SOAPCLIENT_ERROR m_errorState;
6831
6832 void CloseAll()
6833 {
6834 if (m_hRequest != NULL)
6835 {
6836 InternetCloseHandle(m_hRequest);
6837 m_hRequest = NULL;
6838 }
6839 if (m_hConnection != NULL)
6840 {
6841 InternetCloseHandle(m_hConnection);
6842 m_hConnection = NULL;
6843 }
6844 if (m_hInternet != NULL)
6845 {
6846 InternetCloseHandle(m_hInternet);
6847 m_hInternet = NULL;
6848 }
6849 }
6850
6851 HRESULT ConnectToServer()
6852 {
6853 if (m_hConnection != NULL)
6854 {
6855 return S_OK;
6856 }
6857
6858 m_hInternet = InternetOpen(
6859 ATLSOAPINET_CLIENT,
6860 m_strProxy.GetLength() ? (INTERNET_OPEN_TYPE_PRECONFIG | INTERNET_OPEN_TYPE_PROXY) : INTERNET_OPEN_TYPE_PRECONFIG,
6861 m_strProxy.GetLength() ? (LPCTSTR) m_strProxy : NULL,
6862 NULL, 0);
6863
6864 if (m_hInternet != NULL)
6865 {
6866 if (m_dwTimeout != 0)
6867 {
6868 InternetSetOption(m_hInternet, INTERNET_OPTION_CONNECT_TIMEOUT,
6869 &m_dwTimeout, sizeof(m_dwTimeout));
6870 InternetSetOption(m_hInternet, INTERNET_OPTION_RECEIVE_TIMEOUT,
6871 &m_dwTimeout, sizeof(m_dwTimeout));
6872 InternetSetOption(m_hInternet, INTERNET_OPTION_SEND_TIMEOUT,
6873 &m_dwTimeout, sizeof(m_dwTimeout));
6874 }
6875 m_hConnection = InternetConnect(m_hInternet, m_url.GetHostName(),
6876 (INTERNET_PORT) m_url.GetPortNumber(), NULL, NULL,
6877 INTERNET_SERVICE_HTTP, 0, NULL);
6878
6879 if (m_hConnection != NULL)
6880 {
6881 return S_OK;
6882 }
6883 }
6884 CloseAll();
6885 return E_FAIL;
6886 }
6887
6888 protected:
6889
6890 virtual HRESULT GetClientReader(ISAXXMLReader **pReader)
6891 {
6892 if (pReader == NULL)
6893 {
6894 return E_POINTER;
6895 }
6896 *pReader = NULL;
6897
6898 CComPtr<ISAXXMLReader> spReader;
6899 HRESULT hr = spReader.CoCreateInstance(ATLS_SAXXMLREADER_CLSID, NULL, CLSCTX_INPROC_SERVER);
6900 if (SUCCEEDED(hr))
6901 {
6902 *pReader = spReader.Detach();
6903 }
6904 return hr;
6905 }
6906
6907 public:
6908
6909 // note : not shared across stock client implementations
6910 HINTERNET m_hInternet;
6911 HINTERNET m_hConnection;
6912 HINTERNET m_hRequest;
6913
6914 CSoapFault m_fault;
6915
6916 CSoapWininetClient(LPCTSTR szUrl)
6917 :m_hInternet(NULL), m_hConnection(NULL), m_hRequest(NULL), m_dwTimeout(0), m_errorState(SOAPCLIENT_SUCCESS)
6918 {
6919 TCHAR szTmp[ATL_URL_MAX_URL_LENGTH];
6920 if(AtlEscapeUrl(szUrl,szTmp,0,ATL_URL_MAX_URL_LENGTH-1,ATL_URL_BROWSER_MODE))
6921 {
6922 if (m_url.CrackUrl(szTmp) != FALSE)
6923 {
6924 SetProxy();
6925 _ATLTRY
6926 {
6927 m_strUrl.SetString(m_url.GetUrlPath(), m_url.GetUrlPathLength());
6928 m_strUrl.Append(m_url.GetExtraInfo(), m_url.GetExtraInfoLength());
6929 }
6930 _ATLCATCHALL()
6931 {
6932 }
6933 }
6934 }
6935 }
6936
6937 CSoapWininetClient(LPCTSTR szServer, LPCTSTR szUri, short nPort=80)
6938 :m_hInternet(NULL), m_hConnection(NULL), m_hRequest(NULL), m_dwTimeout(0), m_errorState(SOAPCLIENT_SUCCESS)
6939 {
6940 if (m_url.SetHostName(szServer) != FALSE)
6941 {
6942 if (m_url.SetUrlPath(szUri) != FALSE)
6943 {
6944 if (m_url.SetPortNumber((ATL_URL_PORT) nPort) != FALSE)
6945 {
6946 _ATLTRY
6947 {
6948 m_strUrl.SetString(m_url.GetUrlPath(), m_url.GetUrlPathLength());
6949 m_strUrl.Append(m_url.GetExtraInfo(), m_url.GetExtraInfoLength());
6950 }
6951 _ATLCATCHALL()
6952 {
6953 }
6954 }
6955 }
6956 }
6957 }
6958
6959 virtual ~CSoapWininetClient()
6960 {
6961 CleanupClient();
6962 CloseAll();
6963 }
6964
6965 SOAPCLIENT_ERROR GetClientError()
6966 {
6967 return m_errorState;
6968 }
6969
6970 void SetClientError(SOAPCLIENT_ERROR errorState)
6971 {
6972 m_errorState = errorState;
6973 }
6974
6975 IWriteStream * GetWriteStream()
6976 {
6977 return &m_writeStream;
6978 }
6979
6980 HRESULT GetReadStream(IStream **ppStream)
6981 {
6982 if (ppStream == NULL)
6983 {
6984 return E_POINTER;
6985 }
6986
6987 *ppStream = &m_readStream;
6988 return S_OK;
6989 }
6990
6991 void CleanupClient()
6992 {
6993 m_writeStream.Cleanup();
6994 if (m_hRequest != NULL)
6995 {
6996 InternetCloseHandle(m_hRequest);
6997 m_hRequest = NULL;
6998 }
6999 m_fault.Clear();
7000 SetClientError(SOAPCLIENT_SUCCESS);
7001 }
7002
7003 HRESULT SendRequest(LPCTSTR szAction)
7004 {
7005 if (ConnectToServer() != S_OK)
7006 {
7007 SetClientError(SOAPCLIENT_CONNECT_ERROR);
7008 return E_FAIL;
7009 }
7010
7011 CString strHeaders;
7012 _ATLTRY
7013 {
7014 strHeaders.Append(szAction);
7015 strHeaders.Append(_T("Content-Type: text/xml; charset=utf-8\r\n"));
7016 }
7017 _ATLCATCHALL()
7018 {
7019 return E_OUTOFMEMORY;
7020 }
7021
7022 static LPCTSTR s_szAcceptTypes[] = { _T("text/*"), NULL };
7023 m_hRequest = HttpOpenRequest(m_hConnection, _T("POST"),
7024 m_strUrl, _T("HTTP/1.0"), NULL,
7025 s_szAcceptTypes,
7026 INTERNET_FLAG_NO_UI | INTERNET_FLAG_KEEP_CONNECTION | ((m_url.GetScheme() == ATL_URL_SCHEME_HTTPS) ? INTERNET_FLAG_SECURE : 0)
7027 , NULL);
7028
7029 if (m_hRequest != NULL)
7030 {
7031 if (FALSE != HttpSendRequest(m_hRequest, strHeaders, (DWORD) strHeaders.GetLength(),
7032 (void *)(LPCSTR)m_writeStream.m_str, m_writeStream.m_str.GetLength()))
7033 {
7034 m_readStream.Init(m_hRequest);
7035 if (GetStatusCode() != HTTP_STATUS_SERVER_ERROR)
7036 {
7037 return S_OK;
7038 }
7039 else
7040 {
7041 SetClientError(SOAPCLIENT_SOAPFAULT);
7042
7043 CComPtr<ISAXXMLReader> spReader;
7044 if (SUCCEEDED(GetClientReader(&spReader)))
7045 {
7046 CComPtr<IStream> spReadStream;
7047 if (SUCCEEDED(GetReadStream(&spReadStream)))
7048 {
7049 if (FAILED(m_fault.ParseFault(spReadStream, spReader)))
7050 {
7051 SetClientError(SOAPCLIENT_PARSEFAULT_ERROR);
7052 }
7053 }
7054 }
7055 }
7056 }
7057 }
7058 else
7059 {
7060 SetClientError(SOAPCLIENT_SEND_ERROR);
7061 }
7062
7063 return E_FAIL;
7064 }
7065
7066 HRESULT SetUrl(LPCTSTR szUrl)
7067 {
7068 CloseAll();
7069 TCHAR szTmp[ATL_URL_MAX_URL_LENGTH];
7070 if(!AtlEscapeUrl(szUrl,szTmp,0,ATL_URL_MAX_URL_LENGTH-1,ATL_URL_BROWSER_MODE))
7071 {
7072 return E_FAIL;
7073 }
7074
7075 if (m_url.CrackUrl(szTmp) != FALSE)
7076 {
7077 _ATLTRY
7078 {
7079 m_strUrl.SetString(m_url.GetUrlPath(), m_url.GetUrlPathLength());
7080 m_strUrl.Append(m_url.GetExtraInfo(), m_url.GetExtraInfoLength());
7081 }
7082 _ATLCATCHALL()
7083 {
7084 return E_OUTOFMEMORY;
7085 }
7086 return S_OK;
7087 }
7088 return E_FAIL;
7089 }
7090
7091 HRESULT GetUrl(LPTSTR szUrl, LPDWORD pdwLen)
7092 {
7093 if ((szUrl == NULL) || (pdwLen == NULL))
7094 {
7095 return E_INVALIDARG;
7096 }
7097
7098 return (m_url.CreateUrl(szUrl, pdwLen) != FALSE) ? S_OK : E_FAIL;
7099 }
7100
7101 HRESULT SetProxy(LPCTSTR szProxy = NULL, short nProxyPort = 80)
7102 {
7103 _ATLTRY
7104 {
7105 if (szProxy && szProxy[0])
7106 {
7107 m_strProxy.Format(_T("http=http://%s:%d https=http://%s:%d"), szProxy, nProxyPort, szProxy, nProxyPort);
7108 }
7109 else
7110 {
7111 m_strProxy.Empty();
7112 }
7113 }
7114 _ATLCATCHALL()
7115 {
7116 return E_OUTOFMEMORY;
7117 }
7118
7119 return S_OK;
7120 }
7121
7122 void SetTimeout(DWORD dwTimeout)
7123 {
7124 m_dwTimeout = dwTimeout;
7125 }
7126
7127 int GetStatusCode()
7128 {
7129 DWORD dwLen = 255;
7130 TCHAR szBuf[256];
7131 if (HttpQueryInfo(m_hRequest, HTTP_QUERY_STATUS_CODE, szBuf, &dwLen, NULL))
7132 {
7133 szBuf[dwLen] = '\0';
7134 return _ttoi(szBuf);
7135 }
7136 return 0;
7137 }
7138 }; // CSoapWininetClient
7139 #endif
7140
7141 #ifndef ATLSOAP_NOMSXML_INET
7142 class CSoapMSXMLInetClient
7143 {
7144 private:
7145
7146 CUrl m_url;
7147 CWriteStreamOnCString m_writeStream;
7148 DWORD m_dwTimeout;
7149 SOAPCLIENT_ERROR m_errorState;
7150
7151 HRESULT ConnectToServer()
7152 {
7153 TCHAR szURL[ATL_URL_MAX_URL_LENGTH];
7154 DWORD dwLen = ATL_URL_MAX_URL_LENGTH;
7155 HRESULT hr = E_FAIL;
7156
7157 if (m_spHttpRequest)
7158 return S_OK;
7159
7160 if (!m_url.CreateUrl(szURL, &dwLen))
7161 return E_FAIL;
7162
7163
7164 hr = m_spHttpRequest.CoCreateInstance(__uuidof(ServerXMLHTTP30));
7165 if (hr != S_OK)
7166 return hr;
7167
7168 CComVariant vEmpty;
7169 hr = m_spHttpRequest->open( CComBSTR(L"POST"),
7170 CComBSTR(szURL),
7171 CComVariant(VARIANT_BOOL(VARIANT_FALSE)),
7172 vEmpty,
7173 vEmpty );
7174 if (hr != S_OK)
7175 {
7176 m_spHttpRequest.Release();
7177 return hr;
7178 }
7179
7180 return S_OK;
7181 }
7182
7183 protected:
7184
7185 virtual HRESULT GetClientReader(ISAXXMLReader **pReader)
7186 {
7187 if (pReader == NULL)
7188 {
7189 return E_POINTER;
7190 }
7191 *pReader = NULL;
7192
7193 CComPtr<ISAXXMLReader> spReader;
7194 HRESULT hr = spReader.CoCreateInstance(ATLS_SAXXMLREADER_CLSID, NULL, CLSCTX_INPROC_SERVER);
7195 if (SUCCEEDED(hr))
7196 {
7197 *pReader = spReader.Detach();
7198 }
7199 return hr;
7200 }
7201
7202 public:
7203
7204 // note : not shared across stock client implementations
7205 CComPtr<IServerXMLHTTPRequest> m_spHttpRequest;
7206
7207 CSoapFault m_fault;
7208
7209 CSoapMSXMLInetClient(LPCTSTR szUrl)
7210 :m_dwTimeout(0), m_errorState(SOAPCLIENT_SUCCESS)
7211 {
7212 m_url.CrackUrl(szUrl);
7213 }
7214
7215 CSoapMSXMLInetClient(LPCTSTR szServer, LPCTSTR szUri, short nPort=80)
7216 : m_dwTimeout(0), m_errorState(SOAPCLIENT_SUCCESS)
7217 {
7218 m_url.SetHostName(szServer);
7219 m_url.SetUrlPath(szUri);
7220 m_url.SetPortNumber((ATL_URL_PORT) nPort);
7221 }
7222
7223 virtual ~CSoapMSXMLInetClient()
7224 {
7225 CleanupClient();
7226 }
7227
7228 SOAPCLIENT_ERROR GetClientError()
7229 {
7230 return m_errorState;
7231 }
7232
7233 void SetClientError(SOAPCLIENT_ERROR errorState)
7234 {
7235 m_errorState = errorState;
7236 }
7237
7238 IWriteStream * GetWriteStream()
7239 {
7240 return &m_writeStream;
7241 }
7242
7243 HRESULT GetReadStream(IStream **ppStream)
7244 {
7245 if (ppStream == NULL)
7246 {
7247 return E_POINTER;
7248 }
7249
7250 *ppStream = NULL;
7251 HRESULT hr = E_FAIL;
7252
7253 if (m_spHttpRequest)
7254 {
7255 VARIANT vResponseStream;
7256 VariantInit(&vResponseStream);
7257 hr = m_spHttpRequest->get_responseStream(&vResponseStream);
7258 if (S_OK == hr)
7259 {
7260 hr = E_FAIL;
7261 if ((vResponseStream.vt == VT_UNKNOWN) && (vResponseStream.punkVal != NULL))
7262 {
7263 // we return the refcount with the pointer!
7264 hr = vResponseStream.punkVal->QueryInterface(__uuidof(IStream), (void **)ppStream);
7265 }
7266 else
7267 {
7268 SetClientError(SOAPCLIENT_READ_ERROR);
7269 }
7270 }
7271 VariantClear(&vResponseStream);
7272 }
7273 return hr;
7274 }
7275
7276 void CleanupClient()
7277 {
7278 m_writeStream.Cleanup();
7279 m_spHttpRequest.Release();
7280 m_fault.Clear();
7281 SetClientError(SOAPCLIENT_SUCCESS);
7282 }
7283
7284 HRESULT SendRequest(LPCTSTR szAction)
7285 {
7286 if (ConnectToServer() != S_OK)
7287 {
7288 SetClientError(SOAPCLIENT_CONNECT_ERROR);
7289 return E_FAIL;
7290 }
7291
7292 // set the action header
7293 LPCTSTR szColon = _tcschr(szAction, _T(':'));
7294 if (szColon != NULL)
7295 {
7296 do
7297 {
7298 szColon++;
7299 } while (_istspace(static_cast<unsigned char>(*szColon)));
7300
7301 if (FAILED(m_spHttpRequest->setRequestHeader(
7302 CComBSTR( L"SOAPAction" ), CComBSTR( szColon ))))
7303 {
7304 SetClientError(SOAPCLIENT_SEND_ERROR);
7305 return E_FAIL;
7306 }
7307 } // if SOAPAction header not properly formed, attempt to send anyway
7308
7309 if (FAILED(m_spHttpRequest->setRequestHeader(CComBSTR( L"Content-Type" ), CComBSTR(L"text/xml; charset=utf-8"))))
7310 {
7311 SetClientError(SOAPCLIENT_SEND_ERROR);
7312 return E_FAIL;
7313 }
7314
7315 // set timeout
7316 if (m_dwTimeout != 0)
7317 {
7318 long nTimeout = (long) m_dwTimeout;
7319 m_spHttpRequest->setTimeouts(nTimeout, nTimeout, nTimeout, nTimeout);
7320 // reset timeout
7321 m_dwTimeout = 0;
7322 }
7323
7324 CComVariant vBody(m_writeStream.m_str);
7325 HRESULT hr = m_spHttpRequest->send(vBody);
7326 if ((SUCCEEDED(hr)) && (GetStatusCode() == 500))
7327 {
7328 hr = E_FAIL;
7329 CComPtr<ISAXXMLReader> spReader;
7330 if (SUCCEEDED(GetClientReader(&spReader)))
7331 {
7332 SetClientError(SOAPCLIENT_SOAPFAULT);
7333
7334 CComPtr<IStream> spReadStream;
7335 if (SUCCEEDED(GetReadStream(&spReadStream)))
7336 {
7337 if (FAILED(m_fault.ParseFault(spReadStream, spReader)))
7338 {
7339 SetClientError(SOAPCLIENT_PARSEFAULT_ERROR);
7340 }
7341 }
7342 }
7343 }
7344 else if (FAILED(hr))
7345 {
7346 SetClientError(SOAPCLIENT_SEND_ERROR);
7347 }
7348
7349 return hr;
7350 }
7351
7352 HRESULT SetUrl(LPCTSTR szUrl)
7353 {
7354 CleanupClient();
7355 return (m_url.CrackUrl(szUrl) != FALSE ? S_OK : E_FAIL);
7356 }
7357
7358 HRESULT GetUrl(LPTSTR szUrl, LPDWORD pdwLen)
7359 {
7360 if ((szUrl == NULL) || (pdwLen == NULL))
7361 {
7362 return E_INVALIDARG;
7363 }
7364
7365 return (m_url.CreateUrl(szUrl, pdwLen) != FALSE) ? S_OK : E_FAIL;
7366 }
7367
7368 void SetTimeout(DWORD dwTimeout)
7369 {
7370 m_dwTimeout = dwTimeout;
7371 }
7372
7373 int GetStatusCode()
7374 {
7375 long lStatus;
7376 if (m_spHttpRequest->get_status(&lStatus) == S_OK)
7377 {
7378 return (int) lStatus;
7379 }
7380 return 0;
7381 }
7382
7383 HRESULT SetProxy(LPCTSTR szProxy = NULL, short nProxyPort = 80)
7384 {
7385 (szProxy);
7386 (nProxyPort);
7387
7388 ATLTRACE( _T("CSoapMSXMLInetClient does not support SetProxy") );
7389
7390 return S_OK;
7391 }
7392 }; // CSoapMSXMLInetClient
7393 #endif
7394
7395
7396 class _CSDLGenerator : public ITagReplacerImpl<_CSDLGenerator>
7397 {
7398 private:
7399
7400 typedef CAtlMap<CStringA, const _soapmap *, CStringElementTraits<CStringA> > WSDLMAP;
7401 typedef CAtlMap<CStringA, const _soapmapentry *, CStringElementTraits<CStringA> > HEADERMAP;
7402
7403 HRESULT GenerateWSDLHelper(const _soapmap *pMap, WSDLMAP& structMap, WSDLMAP& enumMap)
7404 {
7405 ATLENSURE_RETURN( pMap != NULL );
7406
7407 const _soapmapentry *pEntries = pMap->pEntries;
7408 ATLENSURE_RETURN( pEntries != NULL );
7409
7410 HRESULT hr = S_OK;
7411
7412 for (int i=0; pEntries[i].nHash != 0; i++)
7413 {
7414 if (pEntries[i].nVal == SOAPTYPE_UNK)
7415 {
7416 ATLENSURE_RETURN( pEntries[i].pChain != NULL );
7417
7418 _ATLTRY
7419 {
7420 POSITION pos = NULL;
7421 CStringA strName(pEntries[i].pChain->szName, pEntries[i].pChain->cchName);
7422 if (pEntries[i].pChain->mapType == SOAPMAP_STRUCT)
7423 {
7424 pos = structMap.SetAt(strName, pEntries[i].pChain);
7425 }
7426 else if (pEntries[i].pChain->mapType == SOAPMAP_ENUM)
7427 {
7428 pos = enumMap.SetAt(strName, pEntries[i].pChain);
7429 }
7430 if (pos == NULL)
7431 {
7432 hr = E_OUTOFMEMORY;
7433 break;
7434 }
7435 }
7436 _ATLCATCHALL()
7437 {
7438 hr = E_OUTOFMEMORY;
7439 break;
7440 }
7441
7442 hr = GenerateWSDLHelper(pEntries[i].pChain, structMap, enumMap);
7443 if (FAILED(hr))
7444 {
7445 break;
7446 }
7447 }
7448 }
7449
7450 return hr;
7451 }
7452
7453 HTTP_CODE IsUDT(const _soapmapentry *pEntry)
7454 {
7455 ATLENSURE( pEntry != NULL );
7456 return (pEntry->nVal != SOAPTYPE_UNK) ? HTTP_S_FALSE : HTTP_SUCCESS;
7457 }
7458
7459 HTTP_CODE GetSoapDims(const _soapmapentry *pEntry)
7460 {
7461 ATLENSURE( pEntry != NULL );
7462 if (pEntry->pDims[0] != 0)
7463 {
7464 if (SUCCEEDED(m_pWriteStream->WriteStream("[", 1, NULL)))
7465 {
7466 for (int i=1; i<=pEntry->pDims[0]; i++)
7467 {
7468 if (m_writeHelper.Write(pEntry->pDims[i]) != FALSE)
7469 {
7470 if (i < pEntry->pDims[0])
7471 {
7472 if (FAILED(m_pWriteStream->WriteStream(", ", 2, NULL)))
7473 {
7474 return HTTP_FAIL;
7475 }
7476 }
7477 }
7478 }
7479 if (SUCCEEDED(m_pWriteStream->WriteStream("]", 1, NULL)))
7480 {
7481 return HTTP_SUCCESS;
7482 }
7483 }
7484 }
7485 return HTTP_FAIL;
7486 }
7487
7488 const _soapmap **m_pFuncs;
7489 const _soapmap **m_pHeaders;
7490 int m_nFunc;
7491 int m_nParam;
7492 int m_nHeader;
7493 WSDLMAP m_structMap;
7494 WSDLMAP m_enumMap;
7495 POSITION m_currUDTPos;
7496 int m_nCurrUDTField;
7497
7498 HEADERMAP m_headerMap;
7499 POSITION m_currHeaderPos;
7500
7501 CWriteStreamHelper m_writeHelper;
7502
7503 CStringA m_strServiceName;
7504 CStringA m_strNamespaceUri;
7505
7506 IWriteStream *m_pWriteStream;
7507
7508 CComPtr<IHttpServerContext> m_spHttpServerContext;
7509
7510 DWORD m_dwCallFlags;
7511
7512 protected:
7513
7514 void SetWriteStream(IWriteStream *pStream)
7515 {
7516 m_pWriteStream = pStream;
7517 m_writeHelper.Attach(m_pWriteStream);
7518 }
7519
7520 void SetHttpServerContext(IHttpServerContext *pServerContext)
7521 {
7522 m_spHttpServerContext = pServerContext;
7523 }
7524
7525 static HTTP_CODE GetSoapType(int nVal, IWriteStream *pStream)
7526 {
7527 return (pStream->WriteStream(CSoapRootHandler::s_xsdNames[nVal].szName,
7528 CSoapRootHandler::s_xsdNames[nVal].cchName, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_FAIL;
7529 }
7530
7531
7532 HRESULT InitializeSDL(CSoapRootHandler *pHdlr)
7533 {
7534 m_pFuncs = pHdlr->GetFunctionMap();
7535
7536 if (m_pFuncs == NULL)
7537 {
7538 return E_FAIL;
7539 }
7540
7541 ATLASSUME( m_pFuncs[0] != NULL );
7542
7543 m_dwCallFlags = m_pFuncs[0]->dwCallFlags;
7544
7545 size_t i;
7546 for (i=0; m_pFuncs[i] != NULL; i++)
7547 {
7548 const _soapmap *pMap = m_pFuncs[i];
7549 HRESULT hr = GenerateWSDLHelper(pMap, m_structMap, m_enumMap);
7550 if (FAILED(hr))
7551 {
7552 return hr;
7553 }
7554 }
7555
7556 m_pHeaders = pHdlr->GetHeaderMap();
7557 if (m_pHeaders != NULL)
7558 {
7559 for (i=0; m_pHeaders[i] != NULL; i++)
7560 {
7561 const _soapmap *pMap = m_pHeaders[i];
7562 HRESULT hr = GenerateWSDLHelper(pMap, m_structMap, m_enumMap);
7563 if (FAILED(hr))
7564 {
7565 return hr;
7566 }
7567 }
7568
7569 for (i=0; m_pHeaders[i] != NULL; i++)
7570 {
7571 const _soapmap *pMap = m_pHeaders[i];
7572 for (size_t j=0; pMap->pEntries[j].nHash != 0; j++)
7573 {
7574 HRESULT hr = S_OK;
7575 _ATLTRY
7576 {
7577 if (m_headerMap.SetAt(pMap->pEntries[j].szField, &pMap->pEntries[j]) == NULL)
7578 {
7579 hr = E_OUTOFMEMORY;
7580 }
7581 }
7582 _ATLCATCHALL()
7583 {
7584 hr = E_OUTOFMEMORY;
7585 }
7586 if (FAILED(hr))
7587 {
7588 return hr;
7589 }
7590 }
7591 }
7592 }
7593
7594 _ATLTRY
7595 {
7596 m_strServiceName = pHdlr->GetServiceName();
7597 m_strNamespaceUri = pHdlr->GetNamespaceUriA();
7598 }
7599 _ATLCATCHALL()
7600 {
7601 return E_OUTOFMEMORY;
7602 }
7603 return S_OK;
7604 }
7605
7606 virtual const char * GetHandlerName() = 0;
7607
7608 public:
7609
7610 _CSDLGenerator()
7611 :m_pFuncs(NULL), m_nFunc(-1), m_nParam(-1),
7612 m_currUDTPos(NULL), m_nCurrUDTField(-1),
7613 m_pWriteStream(NULL), m_nHeader(-1), m_currHeaderPos(NULL)
7614 {
7615 }
7616 virtual ~_CSDLGenerator()
7617 {
7618 }
7619
7620 HTTP_CODE OnGetURL()
7621 {
7622 char szURL[ATL_URL_MAX_URL_LENGTH];
7623 DWORD dwUrlSize = sizeof(szURL);
7624 char szServer[ATL_URL_MAX_HOST_NAME_LENGTH];
7625 DWORD dwServerSize = sizeof(szServer);
7626 char szHttps[16];
7627 DWORD dwHttpsLen = sizeof(szHttps);
7628 char szPort[ATL_URL_MAX_PORT_NUMBER_LENGTH+1];
7629 DWORD dwPortLen = sizeof(szPort);
7630
7631 if (m_spHttpServerContext->GetServerVariable("URL", szURL, &dwUrlSize) != FALSE)
7632 {
7633 if (m_spHttpServerContext->GetServerVariable("SERVER_NAME", szServer, &dwServerSize) != FALSE)
7634 {
7635 bool bHttps = false;
7636 if ((m_spHttpServerContext->GetServerVariable("HTTPS", szHttps, &dwHttpsLen) != FALSE) &&
7637 (!_stricmp(szHttps, "ON")))
7638 {
7639 bHttps = true;
7640 }
7641
7642 if (m_spHttpServerContext->GetServerVariable("SERVER_PORT", szPort, &dwPortLen) != FALSE)
7643 {
7644 _ATLTRY
7645 {
7646 CStringA strUrl;
7647 strUrl.Format("http%s://%s:%s%s?Handler=%s", bHttps ? "s" : "", szServer, szPort, szURL, GetHandlerName());
7648
7649 CA2W wszUrl(strUrl);
7650 wchar_t *pwszUrl = wszUrl;
7651 HRESULT hr = AtlGenXMLValue(m_pWriteStream, &pwszUrl);
7652 return SUCCEEDED(hr) ? HTTP_SUCCESS : HTTP_FAIL;
7653 }
7654 _ATLCATCHALL()
7655 {
7656 return HTTP_FAIL;
7657 }
7658 }
7659 }
7660 }
7661 return HTTP_FAIL;
7662 }
7663
7664 HTTP_CODE OnGetNamespace()
7665 {
7666 return (m_pWriteStream->WriteStream(m_strNamespaceUri,
7667 m_strNamespaceUri.GetLength(), NULL) == S_OK) ? HTTP_SUCCESS : HTTP_FAIL;
7668 }
7669
7670 HTTP_CODE OnGetNextFunction()
7671 {
7672 m_nFunc++;
7673 if (m_pFuncs[m_nFunc] == NULL)
7674 {
7675 m_nFunc = -1;
7676 return HTTP_S_FALSE;
7677 }
7678 return HTTP_SUCCESS;
7679 }
7680
7681 HTTP_CODE OnGetFunctionName()
7682 {
7683 return (m_pWriteStream->WriteStream(m_pFuncs[m_nFunc]->szName,
7684 m_pFuncs[m_nFunc]->cchName, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7685 }
7686
7687 HTTP_CODE OnGetNextParameter()
7688 {
7689 ++m_nParam;
7690 if (m_pFuncs[m_nFunc]->pEntries[m_nParam].nHash != 0)
7691 {
7692 if (m_pFuncs[m_nFunc]->pEntries[m_nParam].dwFlags & SOAPFLAG_NOMARSHAL)
7693 {
7694 return OnGetNextParameter();
7695 }
7696 return HTTP_SUCCESS;
7697 }
7698 m_nParam = -1;
7699 return HTTP_S_FALSE;
7700 }
7701
7702 HTTP_CODE OnIsInParameter()
7703 {
7704 return (m_pFuncs[m_nFunc]->pEntries[m_nParam].dwFlags & SOAPFLAG_IN) ? HTTP_SUCCESS : HTTP_S_FALSE;
7705 }
7706
7707 HTTP_CODE OnGetParameterName()
7708 {
7709 HRESULT hr = S_OK;
7710 if (m_pFuncs[m_nFunc]->pEntries[m_nParam].dwFlags & SOAPFLAG_RETVAL)
7711 {
7712 hr = m_pWriteStream->WriteStream("return", sizeof("return")-1, NULL);
7713 }
7714 else
7715 {
7716 hr = m_pWriteStream->WriteStream(m_pFuncs[m_nFunc]->pEntries[m_nParam].szField,
7717 m_pFuncs[m_nFunc]->pEntries[m_nParam].cchField, NULL);
7718 }
7719
7720 return (hr == S_OK) ? HTTP_SUCCESS : HTTP_FAIL;
7721 }
7722
7723 HTTP_CODE OnNotIsArrayParameter()
7724 {
7725 return (m_pFuncs[m_nFunc]->pEntries[m_nParam].dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR))
7726 ? HTTP_S_FALSE: HTTP_SUCCESS;
7727 }
7728
7729 HTTP_CODE OnIsParameterUDT()
7730 {
7731 return IsUDT(&m_pFuncs[m_nFunc]->pEntries[m_nParam]);
7732 }
7733
7734 HTTP_CODE OnGetParameterSoapType()
7735 {
7736 if (m_pFuncs[m_nFunc]->pEntries[m_nParam].nVal != SOAPTYPE_UNK)
7737 {
7738 return GetSoapType(m_pFuncs[m_nFunc]->pEntries[m_nParam].nVal, m_pWriteStream);
7739 }
7740 ATLASSUME( m_pFuncs[m_nFunc]->pEntries[m_nParam].pChain != NULL );
7741 return (m_pWriteStream->WriteStream(m_pFuncs[m_nFunc]->pEntries[m_nParam].pChain->szName,
7742 m_pFuncs[m_nFunc]->pEntries[m_nParam].pChain->cchName, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7743 }
7744
7745 HTTP_CODE OnIsParameterDynamicArray()
7746 {
7747 return (m_pFuncs[m_nFunc]->pEntries[m_nParam].dwFlags & SOAPFLAG_DYNARR) ? HTTP_SUCCESS: HTTP_S_FALSE;
7748 }
7749
7750 HTTP_CODE OnIsArrayParameter()
7751 {
7752 return (OnNotIsArrayParameter() != HTTP_SUCCESS) ? HTTP_SUCCESS : HTTP_S_FALSE;
7753 }
7754
7755 HTTP_CODE OnIsParameterOneDimensional()
7756 {
7757 return (m_pFuncs[m_nFunc]->pEntries[m_nParam].pDims[0] == 1) ? HTTP_SUCCESS : HTTP_S_FALSE;
7758 }
7759
7760 HTTP_CODE OnGetParameterArraySize()
7761 {
7762 return (m_writeHelper.Write(m_pFuncs[m_nFunc]->pEntries[m_nParam].pDims[1]) != FALSE)
7763 ? HTTP_SUCCESS : HTTP_FAIL;
7764 }
7765
7766 HTTP_CODE OnGetParameterArraySoapDims()
7767 {
7768 return GetSoapDims(&m_pFuncs[m_nFunc]->pEntries[m_nParam]);
7769 }
7770
7771 HTTP_CODE OnIsOutParameter()
7772 {
7773 return (m_pFuncs[m_nFunc]->pEntries[m_nParam].dwFlags & SOAPFLAG_OUT) ? HTTP_SUCCESS : HTTP_S_FALSE;
7774 }
7775
7776 HTTP_CODE OnGetNextEnum()
7777 {
7778 if (m_currUDTPos == NULL)
7779 {
7780 m_currUDTPos = m_enumMap.GetStartPosition();
7781 }
7782 else
7783 {
7784 m_enumMap.GetNext(m_currUDTPos);
7785 }
7786
7787 return (m_currUDTPos != NULL) ? HTTP_SUCCESS : HTTP_S_FALSE;
7788 }
7789
7790 HTTP_CODE OnGetEnumName()
7791 {
7792 const _soapmap *pMap = m_enumMap.GetValueAt(m_currUDTPos);
7793 return (m_pWriteStream->WriteStream(pMap->szName, pMap->cchName, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7794 }
7795
7796 HTTP_CODE OnGetNextEnumElement()
7797 {
7798 const _soapmap *pMap = m_enumMap.GetValueAt(m_currUDTPos);
7799 ++m_nCurrUDTField;
7800 if (pMap->pEntries[m_nCurrUDTField].nHash != 0)
7801 {
7802 return HTTP_SUCCESS;
7803 }
7804 m_nCurrUDTField = -1;
7805 return HTTP_S_FALSE;
7806 }
7807
7808 HTTP_CODE OnGetEnumElementName()
7809 {
7810 const _soapmap *pMap = m_enumMap.GetValueAt(m_currUDTPos);
7811 return (m_pWriteStream->WriteStream(pMap->pEntries[m_nCurrUDTField].szField,
7812 pMap->pEntries[m_nCurrUDTField].cchField, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7813 }
7814
7815 HTTP_CODE OnGetNextStruct()
7816 {
7817 if (m_currUDTPos == NULL)
7818 {
7819 m_currUDTPos = m_structMap.GetStartPosition();
7820 }
7821 else
7822 {
7823 m_structMap.GetNext(m_currUDTPos);
7824 }
7825
7826 return (m_currUDTPos != NULL) ? HTTP_SUCCESS : HTTP_S_FALSE;
7827 }
7828
7829 HTTP_CODE OnGetStructName()
7830 {
7831 const _soapmap *pMap = m_enumMap.GetValueAt(m_currUDTPos);
7832 return (m_pWriteStream->WriteStream(pMap->szName, pMap->cchName, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7833 }
7834
7835 HTTP_CODE OnGetNextStructField()
7836 {
7837 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7838 ++m_nCurrUDTField;
7839 if (pMap->pEntries[m_nCurrUDTField].nHash != 0)
7840 {
7841 return HTTP_SUCCESS;
7842 }
7843 m_nCurrUDTField = -1;
7844 return HTTP_S_FALSE;
7845 }
7846
7847 HTTP_CODE OnGetStructFieldName()
7848 {
7849 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7850 return (m_pWriteStream->WriteStream(pMap->pEntries[m_nCurrUDTField].szField,
7851 pMap->pEntries[m_nCurrUDTField].cchField, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7852 }
7853
7854 HTTP_CODE OnNotIsArrayField()
7855 {
7856 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7857 return (pMap->pEntries[m_nCurrUDTField].dwFlags & (SOAPFLAG_FIXEDARR | SOAPFLAG_DYNARR)) ? HTTP_S_FALSE : HTTP_SUCCESS;
7858 }
7859
7860 HTTP_CODE OnIsFieldUDT()
7861 {
7862 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7863 return IsUDT(&pMap->pEntries[m_nCurrUDTField]);
7864 }
7865
7866 HTTP_CODE OnGetStructFieldSoapType()
7867 {
7868 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7869 if (pMap->pEntries[m_nCurrUDTField].nVal != SOAPTYPE_UNK)
7870 {
7871 return GetSoapType(pMap->pEntries[m_nCurrUDTField].nVal, m_pWriteStream);
7872 }
7873 ATLASSERT( pMap->pEntries[m_nCurrUDTField].pChain != NULL );
7874 return (m_pWriteStream->WriteStream(pMap->pEntries[m_nCurrUDTField].pChain->szName,
7875 pMap->pEntries[m_nCurrUDTField].pChain->cchName, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7876 }
7877
7878 HTTP_CODE OnIsArrayField()
7879 {
7880 return (OnNotIsArrayField() != HTTP_SUCCESS) ? HTTP_SUCCESS : HTTP_S_FALSE;
7881 }
7882
7883 HTTP_CODE OnIsFieldDynamicArray()
7884 {
7885 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7886 return (pMap->pEntries[m_nCurrUDTField].dwFlags & SOAPFLAG_DYNARR) ? HTTP_SUCCESS : HTTP_S_FALSE;
7887 }
7888
7889 HTTP_CODE OnGetFieldSizeIsName()
7890 {
7891 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7892 int nIndex = pMap->pEntries[m_nCurrUDTField].nSizeIs;
7893 ATLASSERT( nIndex >= 0 );
7894 return (m_pStream->WriteStream(pMap->pEntries[nIndex].szField,
7895 pMap->pEntries[nIndex].cchField, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7896 }
7897
7898 HTTP_CODE OnIsFieldOneDimensional()
7899 {
7900 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7901 return (pMap->pEntries[m_nCurrUDTField].pDims[0] == 1) ? HTTP_SUCCESS : HTTP_S_FALSE;
7902 }
7903
7904 HTTP_CODE OnGetFieldArraySize()
7905 {
7906 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7907 return (m_writeHelper.Write(pMap->pEntries[m_nCurrUDTField].pDims[1]) != FALSE) ?
7908 HTTP_SUCCESS : HTTP_S_FALSE;
7909 }
7910
7911 HTTP_CODE OnGetFieldArraySoapDims()
7912 {
7913 const _soapmap *pMap = m_structMap.GetValueAt(m_currUDTPos);
7914 return GetSoapDims(&pMap->pEntries[m_nCurrUDTField]);
7915 }
7916
7917 HTTP_CODE OnGetServiceName()
7918 {
7919 return (m_pWriteStream->WriteStream(m_strServiceName,
7920 m_strServiceName.GetLength(), NULL) == S_OK) ? HTTP_SUCCESS : HTTP_FAIL;
7921 }
7922
7923 HTTP_CODE OnGetNextHeader()
7924 {
7925 if (m_currHeaderPos == NULL)
7926 {
7927 m_currHeaderPos = m_headerMap.GetStartPosition();
7928 }
7929 else
7930 {
7931 m_headerMap.GetNext(m_currHeaderPos);
7932 }
7933
7934 return (m_currHeaderPos != NULL) ? HTTP_SUCCESS : HTTP_S_FALSE;
7935 }
7936
7937 HTTP_CODE OnIsInHeader()
7938 {
7939 return (m_pHeaders[m_nFunc]->pEntries[m_nHeader].dwFlags & SOAPFLAG_IN)
7940 ? HTTP_SUCCESS : HTTP_S_FALSE;
7941 }
7942
7943 HTTP_CODE OnIsOutHeader()
7944 {
7945 return (m_pHeaders[m_nFunc]->pEntries[m_nHeader].dwFlags & SOAPFLAG_OUT)
7946 ? HTTP_SUCCESS : HTTP_S_FALSE;
7947 }
7948
7949 HTTP_CODE OnIsRequiredHeader()
7950 {
7951 return (m_pHeaders[m_nFunc]->pEntries[m_nHeader].dwFlags & SOAPFLAG_MUSTUNDERSTAND)
7952 ? HTTP_SUCCESS : HTTP_S_FALSE;
7953 }
7954
7955 HTTP_CODE OnGetHeaderName()
7956 {
7957 const _soapmapentry *pEntry = m_headerMap.GetValueAt(m_currHeaderPos);
7958 return (m_pWriteStream->WriteStream(pEntry->szField,
7959 pEntry->cchField, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_FAIL;
7960 }
7961
7962 HTTP_CODE OnNotIsArrayHeader()
7963 {
7964 const _soapmapentry *pEntry = m_headerMap.GetValueAt(m_currHeaderPos);
7965 return (pEntry->dwFlags & SOAPFLAG_FIXEDARR) ? HTTP_S_FALSE : HTTP_SUCCESS;
7966 }
7967
7968 HTTP_CODE OnIsHeaderUDT()
7969 {
7970 return IsUDT(m_headerMap.GetValueAt(m_currHeaderPos));
7971 }
7972
7973 HTTP_CODE OnGetHeaderSoapType()
7974 {
7975 const _soapmapentry *pEntry = m_headerMap.GetValueAt(m_currHeaderPos);
7976 if (pEntry->nVal != SOAPTYPE_UNK)
7977 {
7978 return GetSoapType(pEntry->nVal, m_pWriteStream);
7979 }
7980 ATLENSURE( pEntry->pChain != NULL );
7981 return (m_pWriteStream->WriteStream(pEntry->pChain->szName,
7982 pEntry->pChain->cchName, NULL) == S_OK) ? HTTP_SUCCESS : HTTP_S_FALSE;
7983 }
7984
7985 HTTP_CODE OnIsHeaderOneDimensional()
7986 {
7987 const _soapmapentry *pEntry = m_headerMap.GetValueAt(m_currHeaderPos);
7988 return (pEntry->pDims[0] == 1) ? HTTP_SUCCESS : HTTP_S_FALSE;
7989 }
7990
7991 HTTP_CODE OnGetHeaderArraySize()
7992 {
7993 const _soapmapentry *pEntry = m_headerMap.GetValueAt(m_currHeaderPos);
7994 return (m_writeHelper.Write(pEntry->pDims[1]) != FALSE) ?
7995 HTTP_SUCCESS : HTTP_S_FALSE;
7996 }
7997
7998 HTTP_CODE OnGetHeaderArraySoapDims()
7999 {
8000 return GetSoapDims(m_headerMap.GetValueAt(m_currHeaderPos));
8001 }
8002
8003 HTTP_CODE OnGetNextFunctionHeader()
8004 {
8005 ++m_nHeader;
8006 if (m_pHeaders[m_nFunc]->pEntries[m_nHeader].nHash != 0)
8007 {
8008 if (m_pHeaders[m_nFunc]->pEntries[m_nHeader].dwFlags & SOAPFLAG_NOMARSHAL)
8009 {
8010 return OnGetNextHeader();
8011 }
8012 return HTTP_SUCCESS;
8013 }
8014 m_nHeader = -1;
8015 return HTTP_S_FALSE;
8016 }
8017
8018 HTTP_CODE OnGetFunctionHeaderName()
8019 {
8020 return (m_pWriteStream->WriteStream(
8021 m_pHeaders[m_nFunc]->pEntries[m_nHeader].szField,
8022 m_pHeaders[m_nFunc]->pEntries[m_nHeader].cchField,
8023 NULL) == S_OK) ? HTTP_SUCCESS : HTTP_FAIL;
8024 }
8025
8026 HTTP_CODE OnIsArrayHeader()
8027 {
8028 return (OnNotIsArrayHeader() == HTTP_SUCCESS) ? HTTP_S_FALSE : HTTP_SUCCESS;
8029 }
8030
8031 HTTP_CODE OnIsDocumentLiteral()
8032 {
8033 if ((m_dwCallFlags & (SOAPFLAG_DOCUMENT | SOAPFLAG_LITERAL)) ==
8034 (SOAPFLAG_DOCUMENT | SOAPFLAG_LITERAL))
8035 {
8036 return HTTP_SUCCESS;
8037 }
8038 return HTTP_S_FALSE;
8039 }
8040
8041 HTTP_CODE OnIsRpcEncoded()
8042 {
8043 if ((m_dwCallFlags & (SOAPFLAG_RPC | SOAPFLAG_ENCODED)) ==
8044 (SOAPFLAG_RPC | SOAPFLAG_ENCODED))
8045 {
8046 return HTTP_SUCCESS;
8047 }
8048 return HTTP_S_FALSE;
8049 }
8050
8051 #pragma warning (push)
8052 #pragma warning (disable : 4640) // construction of local static object is not thread-safe
8053
8054 BEGIN_REPLACEMENT_METHOD_MAP(_CSDLGenerator)
8055 REPLACEMENT_METHOD_ENTRY("GetNamespace", OnGetNamespace)
8056 REPLACEMENT_METHOD_ENTRY("GetNextFunction", OnGetNextFunction)
8057 REPLACEMENT_METHOD_ENTRY("GetFunctionName", OnGetFunctionName)
8058 REPLACEMENT_METHOD_ENTRY("GetNextParameter", OnGetNextParameter)
8059 REPLACEMENT_METHOD_ENTRY("IsInParameter", OnIsInParameter)
8060 REPLACEMENT_METHOD_ENTRY("GetParameterName", OnGetParameterName)
8061 REPLACEMENT_METHOD_ENTRY("NotIsArrayParameter", OnNotIsArrayParameter)
8062 REPLACEMENT_METHOD_ENTRY("IsParameterUDT", OnIsParameterUDT)
8063 REPLACEMENT_METHOD_ENTRY("GetParameterSoapType", OnGetParameterSoapType)
8064 REPLACEMENT_METHOD_ENTRY("IsParameterDynamicArray", OnIsParameterDynamicArray)
8065 REPLACEMENT_METHOD_ENTRY("IsArrayParameter", OnIsArrayParameter)
8066 REPLACEMENT_METHOD_ENTRY("IsParameterOneDimensional", OnIsParameterOneDimensional)
8067 REPLACEMENT_METHOD_ENTRY("GetParameterArraySize", OnGetParameterArraySize)
8068 REPLACEMENT_METHOD_ENTRY("GetParameterArraySoapDims", OnGetParameterArraySoapDims)
8069 REPLACEMENT_METHOD_ENTRY("IsOutParameter", OnIsOutParameter)
8070 REPLACEMENT_METHOD_ENTRY("GetNextEnum", OnGetNextEnum)
8071 REPLACEMENT_METHOD_ENTRY("GetEnumName", OnGetEnumName)
8072 REPLACEMENT_METHOD_ENTRY("GetNextEnumElement", OnGetNextEnumElement)
8073 REPLACEMENT_METHOD_ENTRY("GetEnumElementName", OnGetEnumElementName)
8074 REPLACEMENT_METHOD_ENTRY("GetNextStruct", OnGetNextStruct)
8075 REPLACEMENT_METHOD_ENTRY("GetStructName", OnGetStructName)
8076 REPLACEMENT_METHOD_ENTRY("GetNextStructField", OnGetNextStructField)
8077 REPLACEMENT_METHOD_ENTRY("GetStructFieldName", OnGetStructFieldName)
8078 REPLACEMENT_METHOD_ENTRY("NotIsArrayField", OnNotIsArrayField)
8079 REPLACEMENT_METHOD_ENTRY("IsFieldUDT", OnIsFieldUDT)
8080 REPLACEMENT_METHOD_ENTRY("GetStructFieldSoapType", OnGetStructFieldSoapType)
8081 REPLACEMENT_METHOD_ENTRY("IsArrayField", OnIsArrayField)
8082 REPLACEMENT_METHOD_ENTRY("IsFieldOneDimensional", OnIsFieldOneDimensional)
8083 REPLACEMENT_METHOD_ENTRY("GetFieldArraySize", OnGetFieldArraySize)
8084 REPLACEMENT_METHOD_ENTRY("GetFieldArraySoapDims", OnGetFieldArraySoapDims)
8085 REPLACEMENT_METHOD_ENTRY("GetServiceName", OnGetServiceName)
8086 REPLACEMENT_METHOD_ENTRY("GetURL", OnGetURL)
8087
8088 REPLACEMENT_METHOD_ENTRY("GetNextHeader", OnGetNextHeader)
8089 REPLACEMENT_METHOD_ENTRY("GetHeaderName", OnGetHeaderName)
8090 REPLACEMENT_METHOD_ENTRY("NotIsArrayHeader", OnNotIsArrayHeader)
8091 REPLACEMENT_METHOD_ENTRY("IsArrayHeader", OnIsArrayHeader)
8092 REPLACEMENT_METHOD_ENTRY("IsHeaderUDT", OnIsHeaderUDT)
8093 REPLACEMENT_METHOD_ENTRY("GetHeaderSoapType", OnGetHeaderSoapType)
8094 REPLACEMENT_METHOD_ENTRY("IsHeaderOneDimensional", OnIsHeaderOneDimensional)
8095 REPLACEMENT_METHOD_ENTRY("GetHeaderArraySize", OnGetHeaderArraySize)
8096 REPLACEMENT_METHOD_ENTRY("GetHeaderArraySoapDims", OnGetHeaderArraySoapDims)
8097 REPLACEMENT_METHOD_ENTRY("GetNextFunctionHeader", OnGetNextFunctionHeader)
8098 REPLACEMENT_METHOD_ENTRY("GetFunctionHeaderName", OnGetFunctionHeaderName)
8099 REPLACEMENT_METHOD_ENTRY("IsInHeader", OnIsInHeader)
8100 REPLACEMENT_METHOD_ENTRY("IsOutHeader", OnIsOutHeader)
8101 REPLACEMENT_METHOD_ENTRY("IsRequiredHeader", OnIsRequiredHeader)
8102
8103 REPLACEMENT_METHOD_ENTRY("IsDocumentLiteral", OnIsDocumentLiteral)
8104 REPLACEMENT_METHOD_ENTRY("IsRpcEncoded", OnIsRpcEncoded)
8105 REPLACEMENT_METHOD_ENTRY("IsFieldDynamicArray", OnIsFieldDynamicArray)
8106 REPLACEMENT_METHOD_ENTRY("GetFieldSizeIsName", OnGetFieldSizeIsName)
8107 END_REPLACEMENT_METHOD_MAP()
8108
8109 #pragma warning (pop)
8110
8111 }; // class _CSDLGenerator
8112
8113 template <class THandler, const char *szHandlerName>
8114 class CSDLGenerator :
8115 public _CSDLGenerator,
8116 public IRequestHandlerImpl< CSDLGenerator<THandler,szHandlerName> >,
8117 public CComObjectRootEx<CComSingleThreadModel>
8118 {
8119 private:
8120
8121 public:
8122 typedef CSDLGenerator<THandler, szHandlerName> _sdlGenerator;
8123
8124 BEGIN_COM_MAP(_sdlGenerator)
8125 COM_INTERFACE_ENTRY(IRequestHandler)
8126 COM_INTERFACE_ENTRY(ITagReplacer)
8127 END_COM_MAP()
8128
8129 HTTP_CODE InitializeHandler(AtlServerRequest *pRequestInfo, IServiceProvider *pServiceProvider)
8130 {
8131 IRequestHandlerImpl<CSDLGenerator>::InitializeHandler(pRequestInfo, pServiceProvider);
8132
8133 CComObjectStack<THandler> handler;
8134 if (FAILED(InitializeSDL(&handler)))
8135 {
8136 return HTTP_FAIL;
8137 }
8138
8139 CStencil s;
8140 HTTP_CODE hcErr = s.LoadFromString(s_szAtlsWSDLSrf, (DWORD) strlen(s_szAtlsWSDLSrf));
8141 if (hcErr == HTTP_SUCCESS)
8142 {
8143 hcErr = HTTP_FAIL;
8144 CHttpResponse HttpResponse(pRequestInfo->pServerContext);
8145 HttpResponse.SetContentType("text/xml");
8146 if (s.ParseReplacements(this) != false)
8147 {
8148 s.FinishParseReplacements();
8149
8150 SetStream(&HttpResponse);
8151 SetWriteStream(&HttpResponse);
8152 SetHttpServerContext(m_spServerContext);
8153
8154 ATLASSERT( s.ParseSuccessful() != false );
8155
8156 hcErr = s.Render(this, &HttpResponse);
8157 }
8158 }
8159
8160 return hcErr;
8161 }
8162
8163 const char * GetHandlerName()
8164 {
8165 return szHandlerName;
8166 }
8167 }; // class CSDLGenerator
8168
8169 } // namespace ATL
8170 #pragma pack(pop)
8171
8172 #pragma warning(pop)
8173
8174 #endif // __ATLSOAP_H__
vsfilter mod based on vsfilter 2.39