.net console registering

[lanman92]

I'm using Apoc's library and have my module in and working fine, except for registering functions. I'm keeping a list<IntPtr> of all the function pointers that I create to prevent garbage collection, but it is still hanging when I type the command in the console. It's not invalid function pointer, I patched it. Here's how I'm registering.

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ConsoleRegisterDelegate(IntPtr txt, IntPtr cb, uint unk, uint unk2);
public delegate void ConsoleRegisterCallbackDelegate();
...
private void ConsoleRegTest()
{
            return;
}
...
_console.RegisterConsoleCommand("testreg", ConsoleRegTest);
...
public void RegisterConsoleCommand(string name, ConsoleRegisterCallbackDelegate callback)
{
            IntPtr _cb = Marshal.GetFunctionPointerForDelegate(callback);
            IntPtr _nm = Marshal.StringToHGlobalAnsi(name);
            _callbacks.Add(_cb);
            _callbackDels.Add(callback);

            dConsoleRegister(_nm, _cb, 0, 0);
}

Any ideas?

[MaiN]

I'm using Apoc's library and have my module in and working fine, except for registering functions. I'm keeping a list<IntPtr> of all the function pointers that I create to prevent garbage collection, but it is still hanging when I type the command in the console. It's not invalid function pointer, I patched it. Here's how I'm registering.

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ConsoleRegisterDelegate(IntPtr txt, IntPtr cb, uint unk, uint unk2);
public delegate void ConsoleRegisterCallbackDelegate();
...
private void ConsoleRegTest()
{
            return;
}
...
_console.RegisterConsoleCommand("testreg", ConsoleRegTest);
...
public void RegisterConsoleCommand(string name, ConsoleRegisterCallbackDelegate callback)
{
            IntPtr _cb = Marshal.GetFunctionPointerForDelegate(callback);
            IntPtr _nm = Marshal.StringToHGlobalAnsi(name);
            _callbacks.Add(_cb);
            _callbackDels.Add(callback);

            dConsoleRegister(_nm, _cb, 0, 0);
}

Any ideas?

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int ConsoleRegisteredFuncDelegate(int a1, IntPtr a2);

Try that one - just return 1.

[lanman92]

For what? The prototype for my functions or what?

EDIT: I changed my callback function to that prototype and it's still not working.

[lanman92]

Sorry for double-post, but anyway. How do you guys debug your .NET code when it's injected? Will VS do it? Olly doesn't, it shows random stuff for the IL code.

[Cypher]

Sorry for double-post, but anyway. How do you guys debug your .NET code when it's injected? Will VS do it? Olly doesn't, it shows random stuff for the IL code.

Visual Studio ftw?

[lanman92]

Guess I'll have to turn off the driver debugging thing then. We'll see how this works.

[Apoc]

Oi; what's the current RegisterConsoleCmd addr? Cba to find it.

Edit: Nevermind.

[Apoc]

signed int __cdecl ConsoleCommandRegister(char *pszCommandName, int pCallback, int category, int unk)

So; the actual register command would be:

public delegate int ConsoleCommandRegisterDelegate(string commandName, IntPtr callback, int category, int unk);

And the actual callback prototype:

public delegate int ConsoleCommandCallbackDelegate();

Though; the callback can take arguments as well. So you can do it the easier way and just make sure the callback returns an int, and takes an arbitrary number of params.

public delegate int ConsoleCommandCallbackDelegate(int arg1, string arg2);

Etc.

        public static bool HasReturnType(Delegate d, Type returnType)
        {
            return d.Method.ReturnType == returnType;
        }

if (HasReturnType(callback, typeof(int))
    RegisterCommand(commandName, Marshal.GetFunctionPointerForDelegate(callback), category, 0);

[SKU]

signed int __cdecl ConsoleCommandRegister(
   char *pszCommandName, 
   int pCallback, 
   int category, 
   char* pszHelpMessage)

help MyCommand will then print that message if memory serves right (ty to nesox), haven't done anything wow related in a while.

[Cypher]

Here's a simple console class I started writing for something. It still needs work and I can't remember if there are any known problems, but it should be a start:

// Preprocessor header guard to stop multiple includes
#ifndef WOWNINJA__WOWCONSOLE_H
#define WOWNINJA__WOWCONSOLE_H

// C++ Standard Library
#include <set>
#include <string>
#include <memory>

// WoWConsole pointer type
typedef std::tr1::shared_ptr<class WoWConsole> WoWConsolePtr;

// Wrapper class for WoW's console
class WoWConsole
{
public:
  // Get singleton
  static WoWConsolePtr Get()
  {
    static WoWConsolePtr pConsole;
    if (pConsole == 0)
      pConsole.reset(new WoWConsole());
    return pConsole;
  }

  // WoW engine console command groups
  enum ConsoleCmdGroup
  {
    Debug,
    Graphics,
    Console,
    Combat,
    Game,
    Default,
    Net,
    Sound,
    Gm
  };

  // WoW engine console callback function type
  typedef long (__cdecl* tCallback)(long Unknown, char const* Params);

  // Register a console command
  // Note: Neither 'Name' nor 'Help' are copied internally and hence the 
  // pointers must remain valid for the lifetime of the command.
  // Note: 'Help' is optional (null pointer is valid)
  long CommandRegister(char const* Name, tCallback Callback, 
    ConsoleCmdGroup Group, char const* Help)
  {
    m_CmdNames.insert(Name);
    return m_pCmdRegister(Name, Callback, Group, Help);
  }

  // Unregister a console command
  long CommandUnregister(std::string const& Name)
  {
    std::set<std::string>::iterator i = m_CmdNames.find(Name);
    if (i != m_CmdNames.end())
      m_CmdNames.erase(i);
    m_pCmdUnregister(Name.c_str());
  }

  // Output string to console
  void Output(std::string const& OutputStr)
  {
    m_pOutput(OutputStr.c_str(), 0);
  }

  // Destructor
  ~WoWConsole()
  {
    // Unregister all registered commands
    for (std::set<std::string>::const_iterator i = m_CmdNames.begin(); 
      i != m_CmdNames.end(); ++i)
    {
      m_pCmdUnregister(i->c_str());
    }
  }

protected:
  // Constructor (protected to enforce singleton)
  WoWConsole() 
    // Initialize engine global/function pointers
    : m_pConsoleEnabled(reinterpret_cast<unsigned long*>(0x012A2408)), 
    m_pCmdRegister(reinterpret_cast<tCmdRegister>(0x006DD780)), 
    m_pCmdUnregister(reinterpret_cast<tCmdUnregister>(0x006DD060)), 
    m_pOutput(reinterpret_cast<tOutput>(0x006DB9E0)), 
    m_CmdNames()
  {
    // Enable console
    *m_pConsoleEnabled = 1;
  }

  // Disable copying and assignment
  WoWConsole(WoWConsole const&);
  WoWConsole& operator= (WoWConsole const&);

private:
  // WoW engine flag to enable console 'on-the-fly'
  unsigned long* m_pConsoleEnabled;

  // WoW engine function to register a console callback
  typedef long (__cdecl* tCmdRegister)(char const* Name, tCallback Callback, 
    ConsoleCmdGroup Group, char const* Help);
  tCmdRegister m_pCmdRegister;

  // WoW engine function to unregister a console callback
  typedef long (__cdecl* tCmdUnregister)(char const* CmdName);
  tCmdUnregister m_pCmdUnregister;

  // WoW engine console output function
  typedef void (__cdecl* tOutput)(char const* Output, long Unknown);
  tOutput m_pOutput;

  // List of callbacks registered (needed so they can be unregistered 
  // in the destructor)
  std::set<std::string> m_CmdNames;
};

#endif // WOWNINJA__WOWCONSOLE_H

[Apoc]

help MyCommand will then print that message if memory serves right (ty to nesox), haven't done anything wow related in a while.

Correct. :P

Though; I haven't seen any functions make use of the 4th param. May just be me however.

[Cypher]

Correct. :P

Though; I haven't seen any functions make use of the 4th param. May just be me however.

The fourth pram is indeed the help string.

You fail.

[lanman92]

Well. I have been able to make this work using same prototypes and etc in C++, it's just not working in C#.

IntPtr _cb = Marshal.GetFunctionPointerForDelegate(callback);
IntPtr _nm = Marshal.StringToHGlobalAnsi(name);
_callbacks.Add(_cb);
_callbackDels.Add(callback);
this.Write("Registering function: \"{0}\" at: 0x{1}", name, _cb.ToString("X"));

dConsoleRegister(_nm, _cb, 5, 0);
...
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void ConsoleRegisterDelegate(IntPtr txt, IntPtr cb, uint unk, uint unk2);

This is right, correct?