back for questions.
"Joseph M. Newcomer" wrote:
See below..
On Wed, 28 Nov 2007 08:47:00 -0800, Tailai Chen <TailaiChen@discussions.microsoft.com>
wrote:
Sorry for not seeing that....
Here is the only function exported in dll
----------------------------------
void CUesOastplsubApp::CreateInstance(char* sDsn, char* lpszDriver, int
fRequest, char* szResPath)
***
Why the obsolete 'char *' instead of the proper LPTSTR? For that matter, unless you are
modifying the buffers, good programming practice demands these be written as const
declarations, and you should use LPCTSTR, not char * or const char *.
We are no longer programming 16-bit windows in an 8-bit character world, Petzold's 1.0
book is no longer useful as a guide to best programming style (actually, it never was, in
any edition), and you should follow modern practice in programming. Your code looks like
it was written for a PDP-11 in 1975, with obsolete data types, obsolete functions, and
dangerous practices.
***
{
CDsnPropertyDlg dlg;
INT_PTR nResponse = dlg.DoModal(sDsn, lpszDriver, fRequest, szResPath);
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
}
----------------------------------
Here is my test exe
---------------------------------
typedef void (WINAPI*CreateInstancePtr)(char*, char*, int, char*);
****
You really have to forget that char * is a data type except in very, very rare and exotic
circumstances, which I don't see here. Use _T() around all literals, EXCEPT the
GetProcAddress (one of the aforementioned very, very rare and exotic circumstances). Use
LPTSTR instead of char*. Modern programming requires Unicode-aware programming. And the
string arguments should probably be LPCTSTR, that is, const parameters.
****
{
HINSTANCE loadDll;
loadDll = LoadLibrary("path\\to\\my.dll");
if(loadDll == NULL)
MessageBox("Load Dll NONOK !","Info",MB_OK);
else
MessageBox("Load Dll OK !","Info",MB_OK);
//retrive the dll function
CreateInstancePtr pCreateInstance;
pCreateInstance =
(CreateInstancePtr)GetProcAddress(loadDll,"?CreateInstance@CSubApp@@QEAAXPEAD0_K0@Z");
****
This is deeply suspect. Why are you going for C++ names; you should declare this as
extern "C" CreateInstance(LPCTSTR Dsn, LPCTSTR driver, int fRequest, LPCTSTR
ResPath);
rather than as a static class member so you don't have to get the mangled name. Show the
declaration of the function itself, in context (meaning show the surrounding class
declaration if there is one). You have still given us insufficient information; you only
gave us the implementation of the function, not its declaration! It could have been
void CreateInstance(char* sDsn, char* lpszDriver, int
fRequest, char* szResPath);
or
static void CreateInstance(char* sDsn, char* lpszDriver, int
fRequest, char* szResPath);
and it is impossible to tell from your above code which declaration was used. If it is
not static, then you are in very deep trouble. If it *is* static, you should have added
the
extern "C"
to the declaration. You cannot add this to a method inside a class, but the name you are
using depends critically on how the name mangling works, and that is potentially subject
to change, and is not compiler-independent (for all we know, it might be different in
64-bit compilers!)
Why did you declare the pointer as WINAPI when it is clear that the function itself is NOT
declared WINAPI? That would certainly lead to fatal access faults!
Please supply ALL necessary information in asking a question!
*****
if(pCreateInstance == NULL)
MessageBox("Dll Error - Fail to load function","Info",MB_OK);
else
{
GetDlgItemText(IDC_EDITDSN, m_Dsn);
****
Use member variables and call
c_EditDSN.GetWindowText(m_Dsn);
Forget GetDlgItem, GetDlgItemInt and GetDlgItemText exist!
****
//cast the CString to char*
char temp[512];
strcpy(temp,m_Dsn);
****
This makes no sense, is highly dangerous, and is essentially a fundamental programming
error! Why do you presume that the string cannot exceed 511 characters? Why are you
using something as obsolete as char? Or as dangerous as strcpy, whose use should be
banned!
If the string is not modified, the string parameters to pCreateInstance should be declared
as LPCTSTR. You should always use a const qualifier for constant strings, and it is
essentially an extremely poor practice to not do so.
If you really need a modifiable buffer, the notion of copying the string to a fixed-size
buffer without doing any bounds checking is deadly (unless you like being featured in the
headlines as the program that enabled some massive security attack). To get a writeable
buffer, you would do
LPTSTR p = m_Dsn.GetBuffer(SOME_MAX_SIZE_OF_YOUR_CHOICE);
where that parameter can be 0 if the called function does not modify the string. If it
DOES modify the string, you would typically need to pass the length to it; in the code
above, since I don't see the length being passed, I am guessing that either the
subroutines don't modify the data (in which case it should be declared as LPCTSTR) or the
code is deadly dangerous and needs to be rewritten to accept buffer lengths. After you do
a GetBuffer, you would call ReleaseBuffer after the buffer has been used.
But I think your fundamental problem is that you have failed to excercise good programming
practice and declare const pointers to values that are not modified.
****
pCreateInstance(temp, "ODBC Driver Name", ODBC_CONFIG_DSN,
"path\\to\\resource.dll");
****
Had you declared the parameters as LPCTSTR, then you could have written
pCreateInstance(m_Dsn, _T("ODBC Driver Name", ODBC_CONFIG_DSN,
_T("path\\to\\resource.dll");
Also, since this is a void function, how do you know if it worked? Does it throw an
exception?
joe
****
}
}
---------------------------------
Thanks
Joseph M. Newcomer [MVP]
email: newcomer@flounder.com
Web: http://www.flounder.com
MVP Tips: http://www.flounder.com/mvp_tips.htm