多线程脑袋

用hash算法加密用户名对应的密码，存入数据库中，使密码不能直观可见，增强密码的安全性能。哈希算法是单向的，可以将字符串转换成某个某个输出，但无法从输出确定输入值，确保即使加密后的字符泄漏，也无法获得原输入值。本系统中使用的hash算法是MD5.

  /// <summary>
        /// 对字符串进行md5哈希算法加密。
        /// </summary>
        /// <param name="unencryptPassword">待加密的字符串</param>
        /// <returns>返回一个包含哈希密码的字符串</returns>
        public string Encrypt(string unencryptPassword)
        {
            //添加对应加密算法
            string hashedPassword = FormsAuthentication.HashPasswordForStoringInConfigFile(unencryptPassword, "md5");
            return hashedPassword;
        }

  /// <summary>
        /// 检查密码是否正确
        /// </summary>
        /// <param name="userID"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public bool CheckUserPassword(decimal userID, string password)
        {
            return iL.CheckUserPassword(userID,Encrypt(password));
        }

===================================================================
best way to handle user id hash common to all rails requests

Q:
Each client is identified by a hash, passed along with every request to the server. What's the best way to handle tracking a users session in this case?

class ApplicationController < ActionController::Base

def require_login

　　if params[:access_key]

　　@current_user = User.find_by_access_key(params[:access_key]) || restrict_access

　　else

　　　　restrict_access

　　end

end



def restrict_access

　　flash[:error] = "You have to log in to access that."

　　redirect_to root_path

　　end

end

Then, do a before_filter :require_login in the controllers where login is required for access.

=====================================================================================

Hash表和TList的结合使用

试想一下，如果在游戏中如果突然有哪个玩家断线，那么即便是我们知道这个玩家的Socket，但是要从所有玩家中检索出他的信息，

也不是一件容易的事。

那我们为什么不能将Hash表和Tlist结合使用呢。在我开发的游戏中，我就是将Hash表和Tlist同时使用，来对玩家断线做相关的处理。

今天我就简单的写一下我是如何处理的。



假定有一个Tlist中（UserList）保存着游戏中某房间的所有玩家信息。玩家的信息结构如下：

RuserInfo = record

Socket;Tsocket;

UserID:String[20];

Face:Byte;

Sex:Boolean;

Socre:Integer;

CurrStatus:Integer;

End;

PuserInfo = ^ RuserInfo;



我们来创建一个Hash表和一个Tlist表：

ScHash:= THashedStringlist.Create;

UserList:=Tlist.Create;

当某一玩家加入游戏时这样处理。

New(P_User)

P_User.Socket：=3500；

P_User.UserID:=’fxh7622’;

P_User.Face:=3;

P_User.Sex:=true;

P_User.Socre:=1000;

P_User.CurrStatus:=0;

Index:=ScHash.IndexOf(IntToStr(p_User.Socket));

if Index=-1 then

begin

ScHash.AddObject(IntToStr(p_User^.Socket),TObject(Integer(p_User)));

end;



//这里将玩家的信息以Socket作为KEY来放入Hash表中。

UserList.Add(P_User);



//在这里将玩家的信息保存在一个Tlist表中。通过前面我的文章中介绍，大家可以知道在HASH表中和在Tlist表中保存的是

//同一个内容，也就是说：如果修改了某玩家在Tlist中保存的信息那么他在Hash表中保存的信息也将随着修改。

这样当玩家断线以后，我们可以快速的使用Hash表来检索出是哪个玩家断线。

function TUserBaseControl.Sel_Hash(sc:TSOCKET;var p_User:PUserSocket): Boolean;



var

t_User:PUserSocket;

t_Object:TObject;

Index:Integer;



begin

Result:=false;

Index:=ScHash.IndexOf(IntToStr(sc));

if Index<>-1 then

begin

t_Object:=ScHash.Objects[Index];

p_User:=PUserSocket(t_Object);

Result:=true;

end;

end;

检索出玩家信息以后可以将玩家信息中的相关信息进行修改。



例如：p_User.CurrStatus:=5;

以上的例子只是对Hash表和Tlist使用的一个小小的窍门，但是的确可以加快服务器的处理速度。希望也对大家有一个帮助。 

要求

• Microsoft Visual Studio.NET 或 Microsoft Visual Studio 2005
• Microsoft Internet Information Services (IIS) 5.0 或更高版本
• Microsoft 脚本调试器

• Web 应用程序
• ASP.NET
• Visual Basic.NET 或 Visual Basic 2005

  调试客户端-脚本在 Visual Basic.NET 或 Visual Basic 2005

  在早期版本 Microsoft Active Server Pages (ASP) 中, 应用程序很难进行调试，尤其在客户端脚本代码中出现的错误。 Visual Studio.NET 可以更好地控制在调试客户端脚本通过集成的调试器和该局部变量时窗口。
  
  

  创建应用程序

  在本节，您可以创建一个显示和与计算输入的 按钮 控件的三个 HTML 文本框 控件的 ASP.NET Web 应用程序 （在 Visual Studio 2005 中的 ASP.NET Web 站点）。 此示例使用 JavaScript 进行编程 Button 控件。
  1. 客户端 JavaScript 使用调试器，您必须首先启用脚本调试为浏览器。 要这样做，请按下列步骤操作：
     1. 打开 Microsoft Internet Explorer。
     2. 在 工具 菜单上单击 Internet 选项 。
     3. 在 高级 选项卡上找到 浏览 部分，清除 禁用脚本调试 复选框，然后单击 确定 。
     4. 关闭 Internet Explorer。
  2. 在 Visual Basic.NET （在 Visual Studio 2005 中的 ASP.NET Web 站点） 中创建新的 ASP.NET Web 应用程序，请按照下列步骤操作：
     1. 打开 Visual Studio.NET 或 Visual Studio 2005。
     2. 在 文件 菜单上指向 新建 ，然后单击 项目 。
        
        请注意 在 Visual 的 Studio 2005 中指向 文件 菜单上的 新建 ，然后单击 网站 。
     3. 在， 新建项目 对话框中单击 项目类型 下的 Visual Basic 项目 ，然后单击 模板 下的 ASP.NET Web 应用程序 。
        
        请注意 在 Visual 的 Studio 2005 中单击 模板 下的 ASP.NET Web 站点 。
     4. 在 名称 文本框中，键入 ScriptDebuggingExample 。
  3. 切换到 HTML 视图，WebForm 1.aspx 的文件。
     
     请注意 在 Visual 的 Studio 2005 切换到 Default.aspx 文件的 HTML 视图。
  4. 复制并粘贴下面的代码在 <form> 内部标记：

     <table>
             <tr>
             <td width="100">
             <asp:label id="lblFirstNumber" runat="server" Width="125">
             First Number:
             </asp:label>
             </td>
             <td width="50">
             <input id="txtNumber1" type="text" maxLength="3"
             size="5" name="txtNumber1">
             </td>
             </tr>
             <tr>
             <td width="100">
             <asp:label id="lblSecondNumber" runat="server" Width="125">
             Second Number:
             </asp:label>
             </td>
             <td width="50">
             <input id="txtNumber2" type="text" maxLength="3"
             size="5" name="txtNumber2">
             </td>
             </tr>
             <tr>
             <td width="100">
             <asp:Label id="lblResult" runat="server" Width="125">
             Result:
             </asp:Label>
             </td>
             <td width="50">
             <input id="txtResult" type="text" size="5" maxlength="5"
             NAME="txtResult" readonly>
             </td>
             </tr>
             </table>
             <br>
             <table>
             <tr>
             <td width="150" align="center">
             <input id="btnDivide" onclick="return btnDivide_Clicked()"
             type="submit" value=" Divide " name="btnDivide">
             </td>
             </tr>
             </table>
             

  1. 此代码将创建两个输入的文本框、 一个计算按钮以及一个显示结果的第三个文本框。
• 1. 复制并将以下代码粘贴到您的页 ； 确保要将代码块放置在第一个 <body> 标记之前：

  2. <SCRIPT language="javascript">
             function btnDivide_Clicked()
             {    var intNumber1 = 0;
             var intNumber2 = 0;
             var intResult = 0;
             intNumber1 = document.all('txtNumber1').value;
             intNumber2 = document.all('txtNumber1').value;
             intResult = intNumber1/intNumber2;
             document.all('txtResult').value = intResult;
             return false;
             }
             </SCRIPT>
             

  3. 此代码程序按钮，以便单击按钮时发生的以下功能：
  4. 检索输入的值。
  • 计算输入。
  • 显示结果。
  
  
• 1. 单击 保存 。
  2. 要测试项目，请按照下列步骤操作：
  3. 在 调试 菜单中上, 单击 开始 生成并运行该应用程序。 WebForm 1 在浏览器中打开，并显示两个输入的文本框、 结果文本框和按钮。
  4. 在将 第一个号码 文本框中，键入 16 。
  5. 在 第二个号码 文本框中，键入 2 。
  6. 单击 除 。 请注意 结果 文本框不显示 8 正如您所期望的那样。
  7. 关闭 Internet Explorer。

  调试应用程序

  Microsoft 脚本调试程序可用于调试在 ASP.NET 应用程序中的客户端脚本。 您可以使用"调试器"关键字来调用 Microsoft 脚本调试器以编程方式在脚本代码。
  1. 与第一个代码 btnDivide_Clicked 过程中添加以下代码：

        debugger
             

     此关键字指示脚本调试器应在此停止执行和启动调试器。 此关键字允许您跟踪在例程的其余部分变量的值。
  2. 单击 保存 。
  3. 要运行该项目，请按下列步骤操作：
     1. 在 调试 菜单中上, 单击 开始 生成并运行该应用程序。
     2. 当页打开在浏览器类型 16 在 第一个号码 文本框中。
     3. 在 第二个号码 文本框中，键入 2 。
     4. 单击 除 。 请注意执行停止在该调试器关键字和该控制将转到 Visual Studio.NET 或 Visual Studio 2005 集成开发环境 (IDE)。
     5. 关闭 Internet Explorer。
  4. 右键单击下面的代码行：

        intResult = intNumber1/intNumber2;
             

     然后单击 插入断点 。
  5. 在 调试 菜单中上, 单击 继续 。
  6. 在 调试 菜单上指向 Windows ，然后单击 局部变量 。 请注意这为 16 设置 intNumber 1 的值按预期方式。 但是，请注意这也设置的值 intNumber 2 为 16，它不对应于您键入的值。 intNumber 2 变量已赋值相同 intNumber 1 的值。
  7. 在 调试 菜单中上, 单击以关闭调试器和浏览器窗口的 停止调试 。 在控制返回到 IDE。

  修改代码

  1. 将代码

        intNumber2 = document.all('txtNumber1').value;
             

     使用下面的代码向 intNumber 2 变量分配正确的值：

        intNumber2 = document.all('txtNumber2').value;
             

  2. 单击 保存 。
  3. 要再次测试项目，请请按照下列步骤操作：
     1. 在 调试 菜单中上, 单击 开始 生成并运行该应用程序。
     2. 当页打开在浏览器类型 16 在 第一个号码 文本框中。
     3. 在 第二个号码 文本框中，键入 2 。
     4. 单击 除 。 请注意执行将在 btnDivide_Clicked 例程的开头处停止。
     5. 确保局部变量窗口是打开状态。 在 调试 菜单中上, 单击 逐语句 逐句通过代码行的行，直到到达 返回 语句。 请注意 intNumber 1 和 intNumber 2 变量显示正确的值。
     6. 在 调试 菜单中上, 单击 继续 。 控制返回到浏览器，并在 结果 文本框显示正确结果。
           g. 关闭 Internet Explorer。


完整代码列表

创建应用程序

<%@ Page Language="vb" AutoEventWireup="false" Codebehind = "WebForm1.aspx.vb"
    Inherits="ScriptDebuggingExample.WebForm1"%>
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    <HTML>
    <HEAD>
    <title>WebForm1</title>
    <meta content="Microsoft Visual Studio.NET 7.0" name="GENERATOR">
    <meta content="Visual Basic 7.0" name="CODE_LANGUAGE">
    <meta content="JavaScript" name="vs_defaultClientScript">
    <meta content="http://schemas.microsoft.com/intellisense/ie5" name="vs_targetSchema">
    <SCRIPT language="javascript">
    function btnDivide_Clicked()
    {  var intNumber1 = 0;
    var intNumber2 = 0;
    var intResult = 0;
    intNumber1 = document.all('txtNumber1').value;
    intNumber2 = document.all('txtNumber1').value;
    intResult = intNumber1/intNumber2;
    document.all('txtResult').value = intResult;
    return false;
    }
    </SCRIPT>
    </HEAD>
    <body MS_POSITIONING="GridLayout">
    <form id="Form1" method="post">
    <table>
    <tr>
    <td width="100">
    <asp:label id="lblFirstNumber" runat="server" Width="125">
    First Number:
    </asp:label>
    </td>
    <td width="50">
    <input id="txtNumber1" type="text" maxLength="3"
    size="5" name="txtNumber1">
    </td>
    </tr>
    <tr>
    <td width="100">
    <asp:label id="lblSecondNumber" runat="server" <BR/>
    Width="125">
    Second Number:
    </asp:label>
    </td>
    <td width="50">
    <input id="txtNumber2" type="text" maxLength="3"
    size="5" name="txtNumber2">
    </td>
    </tr>
    <tr>
    <td width="100">
    <asp:Label id="lblResult" runat="server" Width="125">
    Result:
    </asp:Label>
    </td>
    <td width="50">
    <input id="txtResult" type="text" size="5" maxlength="5"
    NAME="txtResult" readonly>
    </td>
    </tr>
    </table>
    <table>
    <tr>
    <td width="75" align="center">
    <input id="btnDivide" value=" Divide "
    onclick="return btnDivide_Clicked()"
    type="submit" size="50" name="btnDivide">
    </td>
    </tr>
    </table>
    </form>
    </body>
    </HTML>
    

调试应用程序

<%@ Page Language="vb" AutoEventWireup="false" Codebehind = "WebForm1.aspx.vb"
    Inherits="ScriptDebuggingExample.WebForm1"%>
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    <HTML>
    <HEAD>
    <title>WebForm1</title>
    <meta content="Microsoft Visual Studio.NET 7.0" name="GENERATOR">
    <meta content="Visual Basic 7.0" name="CODE_LANGUAGE">
    <meta content="JavaScript" name="vs_defaultClientScript">
    <meta content="http://schemas.microsoft.com/intellisense/ie5"
    name="vs_targetSchema">
    <SCRIPT language="javascript">
    function btnDivide_Clicked()
    {  debugger
    var intNumber1 = 0;
    var intNumber2 = 0;
    var intResult = 0;
    intNumber1 = document.all('txtNumber1').value;
    intNumber2 = document.all('txtNumber1').value;
    intResult = intNumber1/intNumber2;
    document.all('txtResult').value = intResult;
    return false;
    }
    </SCRIPT>
    </HEAD>
    <body MS_POSITIONING="GridLayout">
    <form id="Form1" method="post">
    <table>
    <tr>
    <td width="100">
    <asp:label id="lblFirstNumber" runat="server"
    Width="125">
    First Number:
    </asp:label>
    </td>
    <td width="50">
    <input id="txtNumber1" type="text" maxLength="3"
    size="5" name="txtNumber1">
    </td>
    </tr>
    <tr>
    <td width="100">
    <asp:label id="lblSecondNumber" runat="server"
    Width="125">
    Second Number:
    </asp:label>
    </td>
    <td width="50">
    <input id="txtNumber2" type="text" maxLength="3"
    size="5" name="txtNumber2">
    </td>
    </tr>
    <tr>
    <td width="100">
    <asp:Label id="lblResult" runat="server" Width="125">
    Result:
    </asp:Label>
    </td>
    <td width="50">
    <input id="txtResult" type="text" size="5" maxlength="5"
    NAME="txtResult" readonly>
    </td>
    </tr>
    </table>
    <br>
    <table>
    <tr>
    <td width="75" align="center">
    <input id="btnDivide" value=" Divide "
    onclick="return btnDivide_Clicked()"
    type="submit" size="50" name="btnDivide">
    </td>
    </tr>
    </table>
    </form>
    </body>
    </HTML>
    

修改代码

<%@ Page Language="vb" AutoEventWireup="false" Codebehind = "WebForm1.aspx.vb"
    Inherits="ScriptDebuggingExample.WebForm1"%>
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    <HTML>
    <HEAD>
    <title>WebForm1</title>
    <meta content="Microsoft Visual Studio.NET 7.0" name="GENERATOR">
    <meta content="Visual Basic 7.0" name="CODE_LANGUAGE">
    <meta content="JavaScript" name="vs_defaultClientScript">
    <meta content="http://schemas.microsoft.com/intellisense/ie5"
    name="vs_targetSchema">
    <SCRIPT language="javascript">
    function btnDivide_Clicked()
    {  debugger
    var intNumber1 = 0;
    var intNumber2 = 0;
    var intResult = 0;
    intNumber1 = document.all('txtNumber1').value;
    intNumber2 = document.all('txtNumber2').value;
    intResult = intNumber1/intNumber2;
    document.all('txtResult').value = intResult;
    return false;
    }
    </SCRIPT>
    </HEAD>
    <body MS_POSITIONING="GridLayout">
    <form id="Form1" method="post">
    <table>
    <tr>
    <td width="100">
    <asp:label id="lblFirstNumber" runat="server"
    Width="125">
    First Number:
    </asp:label>
    </td>
    <td width="50">
    <input id="txtNumber1" type="text" maxLength="3"
    size="5" name="txtNumber1">
    </td>
    </tr>
    <tr>
    <td width="100">
    <asp:label id="lblSecondNumber" runat="server"
    Width="125">
    Second Number:
    </asp:label>
    </td>
    <td width="50">
    <input id="txtNumber2" type="text" maxLength="3"
    size="5" name="txtNumber2">
    </td>
    </tr>
    <tr>
    <td width="100">
    <asp:Label id="lblResult" runat="server" Width="125">
    Result:
    </asp:Label>
    </td>
    <td width="50">
    <input id="txtResult" type="text" size="5" maxlength="5"
    NAME="txtResult" readonly>
    </td>
    </tr>
    </table>
    <br>
    <table>
    <tr>
    <td width="75" align="center">
    <input id="btnDivide" value=" Divide "
    onclick="return btnDivide_Clicked()"
    type="submit" size="50" name="btnDivide">
    </td>
    </tr>
    </table>
    </form>
    </body>
    </HTML>
    

Environment: MSVC6, Borland C++ 5.02, Borland C++ Builder 6, NT4, Win2000

In this essay, I am going to show you how the most commonly used C++ compilers (MSVC and Borland) use the stack. Beginners will learn how the stack is used, what the function stack frame is, what the stack frame pointer is, and how to use this information to get a function stack trace. I hope that the more advanced readers will find some interesting information, too.

As an example, a simple class named StackDumper is described. The class StackDumper has a method that browses the thread's stack and allows you to save in a text file the names (or addresses in the worst case) of all functions executed before the foo is called. As a side effect of this functionality, you will be able to ask the StackDumper whether foo is called from foo1.

The task became a little bit complicated by my intention to create a class that is not dependent on any particular compiler. If you download the article demo, you will find three projects—for MSVC++ 6, for Borland C++ 5.02, and for Borland C++ Builder 6.

This is the main idea. You can download the essay from here. Obviously, this approach uses a Microsoft-specific compiler switch. Due to the parallel stack support, special attention should be paid to the case when an exception occurs in one of the profiled functions.

The compiler generates a hidden call to the _penter function in all user functions; this is not very flexible because you may not want to collect information about every function.

The same functionality can be implemented by the well-known concept of stack backtrace. The idea is to use the stack frame that each function builds on the stack to trace the calling sequence. This approach is compiler independent (at least it works with both MSVC and Borland compilers), but it also imposes some limitations. Most compilers provide options to compile a function without prolog and epilog code. For example, functions declared with the __declspec(naked) attribute will be compiled by MSVC++ and Borland C++ compilers without prolog and epilog code. The same effect can be reached by specifying some compiler options for optimizations. For example, the /Oy switch of the Microsoft compiler suppresses the creation of frame pointers on the call stack.

In this essay, I take for granted that the program is compiled without any optimisations or "special" compiler switches.

1. How the Stack Is Used

1.1. Stack Frame and Frame Pointer

Here is a brief explanation for those of you who are not familiar with the way the stack is used during function calls.
The more advanced readers can skip this section. When a function is called, its arguments are pushed first on the stack, depending on the calling convention.

Then, the call instruction is executed. It pushes the return address on the stack. The first instruction of the function is push ebp—the base pointer is pushed. The stack pointer is moved in the ebp, than esp is decremented to make room on the stack for the local variables of the function. So, for every called function, the following information is built on the stack:

Figure 1.

This information is called the "stack frame." The register ebp has a special meaning. It is called the "frame pointer." The frame pointer is initialized at the function start by the standard prolog code and stays unchanged during function execution.

The value of the previous function frame pointer is restored when the current function exits (epilog). How is the frame pointer used? The compiler uses the frame pointer to refer to local variables and parameters of a function (if any).

1. *(ebp) is the value of the frame pointer of the caller;
2. *(ebp+4) is the return address (the place in the caller body where execution will continue after the callee returns);
3. *(ebp+4+4*i) is the value of i-th function argument (1 based, assuming that each argument takes 4 bytes);
4. *(ebp-offset) refers to local variables.

You can see this operation in the following simple example:

int func(int nArg1, int nArg2)

{

int n[3];

return nArg1;

}



int main()

{

func(0,1);



return 1;

}

The Borland C++ 5.02 compiler generates the following assembly code(__cdecl calling convention—the arguments are pushed on the stack from right to left, the caller cleans the stack. More information about calling convention can be found here):

1.2. Callstack

It is not very hard to see how the stack frame of a function can be used to get the caller address of this function. As I have mentioned before, *(ebp+4) points to the return address of the function. This address is inside the body of the caller.

1.2.1. How to Get the Starting Address of the Caller

Approach 1: Prolog searching

We supposed that all functions are compiled with a prolog and an epilog. Having an address inside the function, we just have to search for the byte sequence 55 8B EC. As you can see from the dissassembly above, these are the opcodes of the prolog. Let's call them the "prolog signature."

Unfortunately, there is a problem. The same sequence of bytes could appear in an instruction encoding. For example, the instruction mov eax, EC8B55h has the following instruction encoding: B8 55 8B EC 00.

Obviously, when we are searching the prolog signature byte by byte we will find the signature somewhere inside the mov instruction.

Note: In my experience, the method of searching the prolog signature in most cases works fine. To keep things simple, you can skip the next section.

Well, I don't have an elegant solution to the above described problem. For that reason, I am going to kill a mosquito with a nuclear bomb.

Approach 2: Backwards disassembling

Given an address inside the body of a function, it is quite enough to find the address of the previous instruction. This task cannot be solved without knowing the instruction format. We need a disassembler to do this. You can find in the source a function called FindAddressOfPrevInstruction:

#define  MAX_INTEL_INSTRUCTION_LEN 15

DWORD FindAddressOfPrevInstruction(DWORD EIP, PUCHAR instr)

{

DWORD Addr = EIP-MAX_INTEL_INSTRUCTION_LEN;

DWORD PrevAddr;

unsigned long res;



do

{

PrevAddr=Addr;

res = Disasm32(&Addr, instr);

} while(Addr < EIP);



EIP=PrevAddr;



return EIP;

}

I think this function is straightforward. Having this function, it is easy to find the prolog signature in a more precise way—you just have to disassemble backwards until you find the prolog signature.

1.2.2. Tracing the Stack

As you can see from Figure 1, every function stack frame contains a pointer to the caller's frame that contains a pointer to its caller frame, and so on. In fact, we have a list of stack frames which can be used to find the callstack of every called function. But still there is an important question: When do we have to stop stack browsing, or, in other words, when does this list begin?

I think we can find the answer if we take a look at the process and thread starting routines which resides in kernel32.dll. When Windows creates a process and its main thread, it performs an internal call to the CreateProcess API. CreateProcess, on the other hand, invokes an internal routine in kernel32.dll named BaseProcessStart. Here is the disassembly (under the condition that you have kernel32.pdb):

Similar things are happening in each call to the CreateThread API:

Judging from the examples above, I think we can conclude that stack frames tracing can stop when either the return address or the old ebp turns to zero.

1.3. "Called from" Functionality

Up to now, we know how to create a callstack list (a list of addresses of functions). I would like to say a few words about the following question: Is it possible to implement a method that will allow the following C++ functionality?

retType foo(arguments)

{

if (foo_is_called_from_functionX)

doThings

else

doOtherThings



return whateverHasToBeReturned

}

Two additional questions arise here:

1.3.1 Do We Need Such a Functionality?

This functionality could be considered as a new type of C++ runtime information. Because it is not implemented in the C++ standard, it is probably useless.... In my opinion, this is a theoretical question and it should be the subject of a separate discussion.

1.3.2. How to Implement This Functionality

Because we know the call stack of foo, it may seems trivial to browse the caller addresses searching for the address of functionX. Unfortunately, things are not so simple. The main difficulty is how to get the address of functionX. functionX can be a class member (virtual or nonvirtual) function.

There is no way to get the "real" address of a function from inside a C++ program. By "real address," I mean the relative virtual address where the compiler placed the function body. In most cases, when you get a function address from inside a C++ program, it does not appear to be a real address, but rather an address in some virtual or thunking table.

On the other hand, it is definitely clear that callstack addresses are real addresses. So, what can we do in this case? The only simple solution I have found is to use function names instead of their addresses. This is because there is a relatively easy way(s) to find the address of a function, having been given its name. This will allow us to implement the above function as follows:

retType foo(arguments)

{

if (IsCalledFrom("functionX") || IsCalledFrom("A::member1"))

doThings

else

doOtherThings



return whateverHasToBeReturned

}

Now the question is how to find the address of a function given its name. There are two common ways to do this:

1. The development environment provides libraries that allow working with symbolic information.

For example, Microsoft provides the debug help library named DbgHelp (prior to Windows 2000, the library was known as the Image Help Library). The library contains functions for working with symbolic information; for example SymGetSymFromName, SymFromName, and so forth. As an example of using the DbgHelp library, here is the function getFuncInfo you can find in the source. As far as I know, Borland provides a similar library named Borland Debug Hook Library, that can be used to extract information from Borland debug symbol (.tds) files. Unfortunately, there is not much information on the Net about how to use this library. You can download it from here.

2. Working with .map files

Both the Microsoft VC++ and Borland C++ compilers are able to generate .map files. Generally speaking, .map files are text files that contain information about functions (and variables) in a module and their addresses. For example, here is a snippet of a .map file generated by the Borland C++ 5.02 compiler:

 0001:000006F5      StackDumper::DumpStack(unsigned int)

0001:00000694      StackDumper::GetCallerAddr(long)

0001:000006C5      StackDumper::GetFuncAddr(unsigned long)

0001:000005FC      StackDumper::StackDumper()

0001:00000639      StackDumper::~StackDumper()

The important thing here is that the addresses are logical addresses. For example, 0001:00000639 means that the destructor StackDumper::~StackDumper() resides in the first section in the PE file at offset 0x639 in that section. In the source, you can find a simple function (written by Matt Pietrek) that converts linear addresses to logical addresses. Using this function, you can convert the addresses from the stack trace into logical addresses that can be found in the .map file. Having the logical address you just have to parse the .map file to find the function name.

As a conclusion, I have to say that I don't have any idea about how to implement the IsCalledFrom functionality in your release builds—when you have neither debug information nor a .map file generated (or you don't want to distribute such information with your program).

2. Exit Thunks

In this section, I will describe how to use the stack frame information in order to implement exit thunks. An exit thunk is a function that is invoked immediately after the ret instruction of the function for which the thunk is installed. Exit thunks can be used, for example, in profiling applications. Here they are implemented just as another example of how to use the stack frame information. The idea is very simple—to install an exit thunk we just have to declare a local variable: StackDumper varName(true) (true means "use exit thunk") in the body of the function for which we want to install the thunk. The destructor StackDumper::~StackDumper() first saves the original return address of the function(for example, foo) where StackDumper is declared in a static local variable in StackDumper.

Afterwards, it replaces the return address of foo with the address of the ExitThunk. This causes the ret instruction of foo to pass the control to the beginning of the ExitThunk. (Note that the destructor is the right place to perform this replacement. If we replace the function return address in the constructor (for instance), subsequent calls to the DumpStack function will generate erroneous stack trace information.) This is not a common function call—the ret instruction has popped the return address from the stack (which is now the address of ExitThunk) and a jump is performed. So, if ExitThunk builds a standard stack frame, this frame will not contain a return address.

Another problem is that ExitThunk has to be "invisible"—it should not touch the registers, especially eax—where the foo has placed its return value (if any). If ExitThunk is a standard function, it will have something like this at the beginning(MSVC, Debug):

50:   void main()

51:   {

004010F2 55                   push      ebp

004010F3 8B EC                mov       ebp,esp

004010F5 6A FF                push      0FFh

004010F7 68 F0 30 41 00       push      offset $L49591 (004130f0)

004010FC 64 A1 00 00 00 00    mov       eax,fs:[00000000]

// Look here: The eax register is changed and there is nothing you

// can do!!!

00401102 50                   push      eax

00401103 64 89 25 00 00 00 00 mov       dword ptr fs:[0],esp

...

You see that ExitThunk could not be a normal function. This is the reason for which this function must be declared naked. From MSDN: "For functions declared with the naked attribute, the compiler generates code without prolog and epilog code. You can use this feature to write your own prolog/epilog code using inline assembler code." Fortunately, the three compilers I have tested the examples with (BC++ 5.02, BCB6, MSVC6) support naked function calls. (For Borland C++ 5.02 users, this is probably a surprise. This was not documented. ;-))).

This is the solution of the above-mentioned problems. So, the implementation of ExitThunk could be the following:

/* static  */

void __declspec(naked) StackDumper::ExitThunk()

{

__asm

{

push ebp

mov ebp, esp

sub esp, 4      //make room for one local variable

pushad

}



DoTheWork();



long temp;

temp = origRetAddr;

__asm{

popad

mov esi, temp

mov esp,ebp

pop ebp

jmp esi //I don't have return value on the stack

//-> can not use ret here.

}

}

Well, that's all, folks!

Acknowledgements

I would like to thank mamaich for his help on disassembling issues!

Note about the source compilation. To compile inline assembler source code with the Borland C++ 5.02, you will need the Turbo Assembler (tasm32.exe). The tasm32.exe is not included in Borland C++ 5.02 distribution. If you have BC++ Builder, you will find the tasm32.exe in the bin folder.

Downloads

Tread is a map editor for Quake 1/2/3 based on MFC and OpenGL that runs on Windows XP and Vista. (If anyone has the chance, let me know if it works under Wine or anything similiar just curious...).

This version of the editor is completely new, and is in no way similar or based on the older versions of the editor that have been around since the late 90's.

Forums

Installation

Tread does not need to be installed (there is no installer). Simply unzip the binaries wherever you want and run the Tread executable. Currently the editor supports Quake 1, 2, and 3. The configuration of the editor should be straightforward.

Steam

If you purchased Quake 1, 2 or 3 from Steam, then there are a couple tricks you need to do to get your maps to build and run in an integrated fashion with the editor.

For Quake, I recommend you download GLQuake and put it into your Quake folder, and point the editor to that. If you don't want to do that then point the editor to your Steam.exe and add the following in your game command line in the editor minus the quotes: "-applaunch 2310"

For Quake2, point the editor to your Steam.exe and add "-applaunch 2320" minus the quotes to your game command line in the editor.

For Quake3, point the editor to your Steam.exe and add "-applaunch 2200 +sv_pure 0".

In all cases make sure that you set the game directory to the correct spot.

Basic Navigation and Shortcut Keys

This new version of Tread is totally different from the older versions. People that have used the older versions won't find anything familiar here. This version of the editor is focused towards a fast workflow, and more intuitive and fluid editing (there are no "modes" like in WorldCraft and Tread3D2).