C++博客-beautykingdom-随笔分类-VC_MFC

在XP下用vc6调试ISAPI Project<转载加改写>

chatler — Sat, 19 Jul 2008 10:24:00 GMT

关于ISAPI调试的文章，网上已经有很多。今天之所以还要写这篇文章，原因有三：一是网上关于调试 ISAPI的方法大多数都是在Win2K；二是网上的例子虽然多，大部分都是转载，大部分作者自己从未亲自试过，就直接把别人的东西粘贴过来，往往影响了网上搜索又误导了其他寻找答案的人；三是网上的例子有些并不详细，有些也不正确，这样不但不能帮助解决问题，还容易把人带入歧途。



    今天得了一点空闲，在这里详细写下ISAPI在Xp环境下的调试方法，希望初次接触到ISAPI的程序员们少一些郁闷。

    首先我的操作系统环境是Microsoft Windows Xp Professional。我的编译环境是Virsual C++6.0。VC的补丁主要有SP6。

接下来按照下面的步骤：
1、IIS的目录（根目录、虚拟目录）运行级别改为低（默认为中）
控制面板->管理工具->Internet信息服务。在默认站点上单击右键->属性->主目录（标签）->应用程序保护(N)，将中(共用)改为低(IIS进程)。执行权限改为“教本和可执行文件”。
用同样的方法修改你新建的虚拟目录的运行级别。

2、修改本地安全策略属性
控制面板->管理工具->本地安全策略->本地策略->用户权利指派。
a、找到“以操作系统方式操作”，双击或者右键选属性，弹出对话框后，点“添加用户或组”按钮，在输入文字区域中输入管理员帐户（又称中超级用户），“检查名称”，“确定”添加。比如我现在登陆的帐号是Guyue，“检查帐号”之后就出现A7B4931A85554A0\Guyue， A7B4931A85554A0是我的计算机名称，Guyue是当前登陆帐户，是除Administrator之外的我的管理员帐户。“确定”添加。
b、找到“允许计算机和用户帐户被信任以便于委托”，照a的方法添加管理员帐户。
注：这里我没有加用户，直接用的管理员用户。

3、打开VC6.0，不需要打开任何工程。
菜单栏[Build]->[Start Debug]->Attach To Process
勾选“Show System Process”，找到inetinfo,按OK键添加到该进程。
在菜单栏[Project]->[Settings]或者直接按快捷键Alt+F7。
会看到一个General和一个Debug标签，选择Debug标签。Category下拉列中有两个选项，General和Additional DLLs，选择Additional DLLs。在Modules中加入你要调试的DLL，勾选Try to locate others DLLs，按OK确定保存。

4、打开你的ISAPI工程中的一个CPP文件，看能不能设置断点，如果不能，按shift+F5键退出调试状态。进入下一步。如果退出之后继续[Build]->[Start Debug]->Attach To Process，这个时候会提示，该工程不包含任何调试信息。如果能设置断点，则直接进入第六步。
注：这一步没有成功，无法attach to process，点了按钮以后process list还是空的。我是用
msdev -p 生成的一个VC6环境，在运行IE后会在异常抛出位置停止。

5、打开你的ISAPI工程中，确定你的编译状态为Debug状态，确定你Link（输出）的DLL和你在第三步Modules中保存的DLL为同一个文件。Rebuild一下。

6、菜单栏[Build]->[Start Debug]->Attach To Process
勾选“Show System Process”，找到inetinfo,按OK键附加到inetinfo进程。打开ISAPI工程中的一个CPP文件，最好是程序的入口文件，在程序的入口处设置断点，比如我设置的就是CIsapiWtExtension::InitInstance(...)和DWORD CIsapiWtExtension::HttpExtensionProc(...)程序一旦开始运行，马上就可以在这里截获。
注：既然步骤4里看不到process list，断点设置自然也就不管用了。

7、打开IE，打开你调用该DLL的站点，发出IE请求，VC应该就会在你设置断点的地方拦截到这个请求对当前DLL的操作了。
注：正如我在步骤4中讲到的那样，程序在异常位置会停住，可以看到函数的调用顺序；再就是有个小trick，可以加个ASSERT在异常附近位置，这样程序就可以停止在那儿，这样也就可以使用断点了。

chatler 2008-07-19 18:24 发表评论

仿真VC++提供的关键字__uuidof<转>

chatler — Sat, 19 Jul 2008 08:01:00 GMT

这个技巧不是针对VC++ 6.0缺陷的，而是针对VC++扩展语法的。这个技巧的来由，是为了某些希望有一天有可能要脱离Visual C++环境进行开发的人员。为了脱离VC++，你需要谨慎使用它的所有扩展语法。例如本文讨论的__uuidof。我们先来看看一个例子：

    class __declspec(uuid("B372C9F6-1959-4650-960D-73F20CD479BA")) Class;   
    struct __declspec(uuid("B372C9F6-1959-4650-960D-73F20CD479BB")) Interface;   
        
    void test()   
    {   
        CLSID clsid=__uuidof(Class);   
        IID iid=__uuidof(Interface);   
        ...   
    }

　　这比起你以前定义uuid的方法简单多了吧？可惜，这样好用的东西，它只在VC++中提供。不过没有关系，我们这里介绍一个技巧，可以让你在几乎所有C++编译器中都可以这样方便的使用__uuidof。这里没有说是所有，是因为我们使用了模板特化技术，可能存在一些比较“古老”的 C++编译器，不支持该特性。

　　也许你已经迫不及待了。好，让我们来看看：

    #include    
    #include    
        
    inline STDMETHODIMP_(GUID) GUIDFromString(LPOLESTR lpsz)   
    {   
       HRESULT hr;   
       GUID guid;   
       if (lpsz[0]=='{')   
       {  
            hr=CLSIDFromString(lpsz,&guid);  
        }  
        else  
        {  
            std::basic_string strGuid;  
            strGuid.append(1,'{');  
            strGuid.append(lpsz);  
            strGuid.append(1,'}');  
            hr = CLSIDFromString((LPOLESTR)strGuid.c_str(),&guid);  
        }  
        assert(hr==S_OK);  
        return guid;  
    }  
       
    template   
    struct _UuidTraits {  
    };  
       
    #define _DEFINE_UUID(Class,uuid)                                    \  
        template <>                                                     \  
    struct _UuidTraits{                                          \  
        static const GUID& Guid(){                                      \  
        static GUID guid=GUIDFromString(L## uuid);                      \  
        return guid;                                                    \  
    }                                                                   \  
    }  
       
    #define __uuidof(Class)   _UuidTraits::Guid()  
       
    #define DEFINE_CLSID(Class,guid)                                    \  
    class Class;                                                        \  
        _DEFINE_UUID(Class,guid)  
       
    #define DEFINE_IID(Interface,iid)                                   \  
    struct Interface;                                                   \  
        _DEFINE_UUID(Interface,iid)


　　这样一来，就已经模拟出一个__uuidof关键字。我们可以很方便进行uuid的定义。举例如下：

    void test()   
    {   
        CLSID clsid=__uuidof(Class);   
        IID iid=__uuidof(Interface);   
        ...   
    }

　　在VC++中，为了与其他编译器以相同的方式来进行uuid的定义，我们不直接使用__declspec(uuid)，而是也定义DEFINE_CLSID, DEFINE_IID宏：

    #define DEFINE_CLSID(Class,clsid)           \   
        class __declspec(uuid(clsid)) Class   
        
    #define DEFINE_IID(Interface,iid)           \   
        struct __declspec(uuid(iid)) Interface

　　这样一来，我们已经在所有包含VC++在内的支持模板特化技术的编译器中，提供了__uuidof关键字。通过它可以进一步简化你在C++语言中实现COM组件的代价。

　　附注：关于本文使用的C++模板的特化技术，详细请参阅C++文法方面的书籍，例如《C++ Primer》。其实这个技巧在C++标准库——STL中有一个专门的名字：traits（萃取），你可以在很多介绍STL的书籍中见到相关的介绍。

　　转注：因为自己以后写的文章需要用到类似的技巧，因此先搬过来放这。

chatler 2008-07-19 16:01 发表评论

更好地仿真VC++关键字__uuidof

chatler — Sat, 19 Jul 2008 06:03:00 GMT

出处　http://www.cppblog.com/cexer/archive/2008/07/05/55419.html

世界上有个叫__uuidof的关键字。这是一个家喻户晓且其被广泛使用的关键字，几乎可以说，有COM程序员的地方，就有它 __uuidof的存在。其很好很强大的程度是人所共见的，夸张一点比喻：离开它的COM程序员，就像失去了点火器的火箭，虽然可以人工点火，但是不安全且无效率。

　　不过很多人并不知道，这其实是一个编译器扩展关键字，提供了此关键字的仅VC一家别无它店。幸运的是，强大的C++让我们能够轻易仿真出这个关键字的大部分功能。

　　网上能够找到一种仿真的方法，见许式伟:《仿真VC++提供的关键字__uuidof》。该方法的实现是：特化模板类的成员函数，然后运行时调用函数根据UUID字符串产生出UUID，由于是生成于运行时，所以它无可避免地有两个缺点：

存在运行时消耗。
无法作为非类型模板参数传递给模板。

　　那些整天流着口水追求效率的C++程序员们，是不能忍受任何不必要的运行时消耗的。对于第二点，VC的关键字__uuidof取出来的UUID 是能够作为非类型模板参数传递的，ATL中就大量地使用了这样的参数传递形式，所以目前的这种实现功能有限，仿真度还不够高。

　　其实只要能让它能够编译期决定UUID的值，那么这两个问题就迎刃而解了。而这是肯定可以实现的，并且很简单。我曾经在自己写的一个COM库里实现过这样的方法，虽然那个库已经不知丢到哪里去了，不过那个方法还记得。

　　解决的途径还是离不开模板特化。类的成员包括成员函数和成员变量，函数是运行时作用的，然而static const的成员变量可以是编译期就决定。所以解决的方法就在眼前了：特化模板的成员变量。

　　以下是我的实现方法。

　　先定义一个类模板，它有一个static const ,UUID类型的成员变量：

    template<typename T>   
    struct _uuid_of_impl   
    {   
        static const UUID id;   
    };   
    template<typename T>   
    const UUID _uuid_of_impl::id=GUID_NULL;

　　有了这个简单的东西就好办了，只需要针对某个接口特它的成员变量就行了，如：

    template<>    
    const UUID _uuid_of_impl::id=IID_IUnknown;   
        
    template<>   
    const UUID _uuid_of_impl::id=IID_IDispatch;

　　然后我们就可以这样取得接口的UUID：

    IID IunknownID=_uuid_of_impl::id;   
    IID IdispatchID=_uuid_of_impl::id;

　　作为非类型模板参数传递：

    template<const IID* t_iid>   
    struct __uuid_of_test   
    {   
        __uuid_of_test()   
        {}   
        
        void test()   
        {   
            t_iid;  
         }  
     };  
        
     __uuid_of_test<&(_uuid_of_impl::id) > obj;

　　不过现在这种实现还有一些问题，看以下代码：

    IID ITypelibID=_uuid_of_impl::id;

　　注意我们并没有事先对模板__uuid_of_impl特化ITypeLib的版本。但是以上语句却能够编译通过，在运行时， __uuid_of_impl的值将会是错误的值GUID_NULL。这是因为，我们定义模板的时候，同时在模板外定义了模板的静态成员变量并赋值为GUID_NULL，所以没有用特化的方法定义UUID的接口，都将使用GUID_NULL这个通用值。这当然不是我们想要的。所以我们想在没有定义UUID的时候让编译器警告我们，要达到这样的效果只需要去掉上面那句：

    template<typename T>   
    const UUID _uuid_of_impl::id=GUID_NULL;

　　现在再进行编译，编译器会告诉你，有一个无法解析的符号。根据编译器提供的相关信息，很容易就能确定问题所在。这样能够在编译期极大地减小安全隐患。

　　最后加上我们定义的几个宏，这是最后的全部实现：

    template<typename T>   
    struct _uuid_of_impl   
    {   
        static const UUID id;   
    };   
        
    #define uuid_of(x)    _uuid_of_impl::id   
    #define DEFINE_UUID(x,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8)    \   
        template<>    \  
         const UUID _uuid_of_impl::id={l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}

　　用以下代码测试通过：

    struct ITest{};   
        
    DEFINE_UUID(ITest,0x96289151,0xf059,0x4049,0x88,0x19,0x61,0xa6,0xe9,0x79,0xc,0xf1);
        
    template<const IID* t_iid>   
    struct uuid_of_test   
    {   
        uuid_of_test(){}   
    };  
        
    int main()  
    {  
        IID xxxxID=uuid_of(ITest);  
        uuid_of_test<&(uuid_of(ITest))> obj;  
        
        return 0;  
    }

　　需要注意的是DEFINE_UUID应该在实现文件（*.cpp，*.cxx，……）当中使用。到这里，仍有一些使用方法与VC的关键字是不一样的，所以仍没做到仿真度100%。不过我相信通过预处理元编程，能够相当程度地逼近它，只是我对预处理元编程不是很了解，所以就不在这里献丑了。

chatler 2008-07-19 14:03 发表评论

C++编译期函数/变量检测技术，仿真VC关键字__if_exists<转>

chatler — Sat, 19 Jul 2008 05:50:00 GMT

出处　http://www.cppblog.com/cexer/archive/2008/07/06/55484.html

　　VC当中有一个鲜为人知的关键字，除了微软自己的代码，我从未在任何地方看到有人用过它。虽然它的功能很强大，不过除非设计上的问题或是一些无法排除的困难，否则几乎从不会需要用到它的功能。但是有时候，它确实能作为一个最简单的解决方案而让某些设计过程事半功倍。

　　借用 CCTV10《走近科学》的语气：那么这个神秘的关键关键字到底是什么呢？它又实现了什么神奇的功能呢？带着这一连串的疑问，让我们先来看一个具体的例子。

　　我在自己曾经写的一个GUI框架当中，为了实现消息与处理函数自动映射的，就需要求助于这种功能。比如说有一个窗口类，它包含若干消息处理函数和一个消息与处理函数的映射 map：（请无视当中的 show() 和 create() 函数，与主题无关）

    class Window
    {
        typedef UINT _Message;
        typedef LRESULT (Window::*_Handler)(_Message);
    
        map<_Message,_Handler> m_handlerMap;
    
    public:
        bool show();
        bool create();
    
    public:
        LRESULT onEvent( WindowEvent );
        LRESULT onEvent( WindowEvent );
    };

　　
　　我需要利用模板元编程从 0 到 WM_USER 进行循环检测，检测 Window 类是否存在该消息对应的处理函数。如果消息对应的处理函数存在，那么就将消息与函数的映射放进 m_handlerMap 当中。比如说消息 WM_CREATE，我检测类 Window是否存在 LRESULT onEvent( WindowEvent ) 成员函数，在上例代码中是存在的，于是我将这样一个映射放进m_handlerMap：（真正实现的时候，还要考虑函数的类型。不同类型的函数，是不能直接装进 map 当中的。不过在这里请无视例子当中涉及的所有类型转换，与主题无关）

    pair

　　这样就达到了消息自动映射的目的。而不用像MFC一样手写宏去映射。（最后通过努力的确达到了我的目的，我的GUI框架能够进行自动消息映射了，然而可以预见，由于几千个（0－WM_USER）循环，编译期的速度受到极大影响。所以最终我还是抛弃了这种自动映射实现，而采用了更高效神奇的方法，这是后话也与本主题无关就先不提）。

　　要实现以上的自动映射功能就引出了这样一个难题：如何编译期检测类的某特定名字的成员是否存在。

　　功能不负有心人，经过爬山涉水翻山越岭，我终于在 MSDN 一个偏远角落里找着了传说当中那个神秘的关键字：__if_exists（其实还有一个 __if_not_exists）。MSDN 当中这样说明：__if_exists （__if_not_exists）允许你针对某符号的存在与否条件性地执行语句。使用语法：（注意检测的是“存在性”，而不是值）

    __if_exists ( /*你要检测存在性的函数或变量的名字*/ ) { 
    　//做些有用的事
    }

　　MSDN当中的示例代码如下:

    // the__if_exists_statement.cpp
    // compile with: /EHsc
    #include 
    
    template<typename T>
    class X : public T {
    public:
       void Dump() {
          std::cout << "In X::Dump()" << std::endl;
    
          __if_exists(T::Dump) {
             T::Dump();
          }
    
          __if_not_exists(T::Dump) {
             std::cout << "T::Dump does not exist" << std::endl;
          }
       }   
    };
    
    class A {
    public:
       void Dump() {
          std::cout << "In A::Dump()" << std::endl;
       }
    };
    
    class B {};
    
    bool g_bFlag = true;
    
    class C {
    public:
       void f(int);
       void f(double);
    };
    
    int main() { 
       X x1;
       X x2;
    
       x1.Dump();
       x2.Dump();
    
       __if_exists(::g_bFlag) {
          std::cout << "g_bFlag = " << g_bFlag << std::endl;
       }
    
       __if_exists(C::f) {
          std::cout << "C::f exists" << std::endl;
       }
    
       return 0;
    }

　　以上代码的输出如下：（未测试，此输出为MSDN的说明文档当中的）

In X::Dump()
In A::Dump()
In X::Dump()
T::Dump does not exist
g_bFlag = 1
C::f exists

　　大概很少人见过这个关键字吧。虽然它们的功能与我的需求是如此的接近，但是面对如此强憾的关键字，我还是只能摇头叹息。我伤心地在文档里看到说明，__if_exists（__if_not_exists）关键字用于函数的时候，只能根据函数名字进行检测，而会忽略对参数列表的检测，因此没有对重载函数的分辨能力，而正是我需要的。比如类 Window 有一个函数：

LRESULT Window::onEvent( WindowEvent )
{
//做些有用的事
}

　　我用以下代码来检测 WM_CREATE 消息是否存在处理函数：

    __if_exists(Window::onEvent)
　　{
      //添加消息映射
   }

　　即使 Window 类当中不存在 LRESULT onEvent ( WindowEvent )，以上测试也能通过。这是因为 __if_exists 关键字是不管函数重载的，如果存在一个 onEvent ，那么所有的检测都能通过。这不是我想要的。我需要比 __if_exists 更强憾的检测功能，强憾到能够针对不同参数列表的同名函数（重载函数）做出正确的存在性测试。

　　于是我继续翻山越岭地寻找，从 CSDN 到 MSDN，从 SourceForge 到 CodeProject。要相信那句老话：“有心人天不负”。最后我在 CodeProject 上面看到一篇让我醍醐灌顶的文章：
　　Interface Detection by Alexandre Courpron

　　这篇文章从原理到实现，很详细地说明地一种编译期检测技术，先说明一下，由于VC7.1数千个bug当中的一个，以下技术不能在VC++7.1或更低版本上使用。具体的实现在那篇文章当中说得很详尽了，还是在这儿赘述一下。

　　Alexandre Courpron的实现方式基于C++的这样一个规则：Substitution Failure Is Not An Error （简称SFINAE）。它的含义我也理解得比较含糊，不过它作用于重载函数的时候，可以这样理解：对于一个函数调用，在匹配函数的过程当中，如果最终能够有一个函数匹配成功，那么对其余函数的匹配如果失败，编译器也不会视为错误。听起来有些麻烦，看Alexandre Courpron给出的例子：

struct Test
{
typedef int Type;
};

template < typename T >
void f(typename T::Type) {} // definition #1

template<typename T>
void f(T){} // definition #2

f(10); //call #1

f<int>(10); //call #2

　　
　　对于 call#1 编译器直接匹配 definition#1 成功。对于 call#2，编译器先用 definition#1 匹配如下：

void f( typename int::Type ) {}

　　这显然是不正确的。不过编译器并没有编译失败报告错误，因为下面的 definition#2 匹配成功，根据 SFINAE的规则，编译器有权保持沉默。

　　虽然是个小小的规则，在平时几乎不会注意它。然而在这儿，我们却可以利用它实现编译期检测的强大功能了，一个最简单的示例：

#include
using namespace std;
//
struct TestClass
{
void testFun();
};

struct Exists { char x;};
struct NotExists { char x[2]; };

template <void (TestClass::*)()>
struct Param ;

template <class T>
Exists isExists( Param<&T::testFun>* );

template <class T>
NotExists isExists( ... );
//
int main()
{
cout<<sizeof(isExists(0))< }

　　上面的代码会输出１。说明一下检测的过程：

编译器遇到 isExists(0) 这一句，会去匹配 isExists 的两个重载函数。不定长的参数优先级更低，因此先匹配第一个函数。

第一个函数参数类型为 Param<&T::testFun>*，在这里是 Param<&TestClass::testFun>，编译器在匹配这个参数类型的时候会尝试实例化模板类 Param。

编译器尝试用 &TestClass::testFun 去实例化 Param，因为 TestClass 确实存在一个 void (TestClass::*)() 类型，且名为 testFun 的成员函数。所以 Param 的实例化成功，因此参数匹配成功。

匹配第一个函数成功。编译器决定 isExists(0) 这一句调用就是调用的第一个函数。

因为第一个函数返回的类型为 Exists，用 sizeof 取大小就是 1。

　　如果是我们把 TestClass 的定义修改为：（仅把函数的参数类型改为 int ）

struct TestClass
{
void testFun(int);
};

　　这一次代码会输出２。因为在第３步的时候，由于 TestClass 没有类型为 void (TestClass::*)()，且名为 testFun 的函数，所以实例化 Param 会失败，因此匹配第一个函数失败。然后编译器去匹配第二个函数。因为其参数类型是任意的，自然会匹配成功。结果会输出 2。

　　当然这只是个最简单的示例，通过模板包装类。可以实现更灵活更强大的功能。比如回到那个自动消息映射的例子，用以下代码就能够实现了：

//c++std
#include
using namespace std;

//windows
#include

//detector
template<typename TWindow,UINT t_msg>
struct MessageHandlerDetector
{
typedef WindowEvent _Event;

struct Exists {char x;};
struct NotExists {char x[2];};

template
struct Param;

template<typename T>
static Exists detect( Param<&T::onEvent>* );

template<typename T>
static NotExists detect( ... );

public:
enum{isExists=sizeof(detect(0))==sizeof(Exists)};
};

//test classes
struct Window
{
LRESULT onEvent( WindowEvent );
};

struct Button
{
LRESULT onEvent( WindowEvent );
};

//main
int main()
{
cout<::isExists< cout<::isExists< cout<::isExists< cout<::isExists<
return 0;
}

　　以上代码会输出：

1
0
0
1

　　以上的示例代码再加上模板元编程，可以很轻易地实现消息的自动映射，具体实现这个已不在本贴的讨论范围并且这种自动映射的实现，太过复杂，在编译期没有效率，且不够灵活。不过在消息映射机制上来说，已称得上是一种革命性的尝试。

　　在说完了这所有一切之后，再告诉你一个我最近才知道的秘密（不准笑我孤陋寡闻）：其实 boost 库当中已有相关功能的 MPL 工具存在，叫做 has_xxx。

　　源文件：

　　文档：http://www.boost.org/doc/libs/1_35_0/libs/mpl/doc/refmanual/has-xxx-trait-def.html。

chatler 2008-07-19 13:50 发表评论