I often remark about the Good Ole Days™ where I was a C++ developer doing app server code on Solaris with a Sparc on my desk and the Windows NT machine that was just for email and Word documents.  I have even written a little C in my .Net career: building a DLL to make some very specific P/Invoke action easier.  I haven't written anything significant (read: more than one function) since 1998. 

When one is working on the compact framework, shrink-wrap desktop software, or isntallers for desktop software, often something comes up that is not easy to do in .Net, cannot be done in .NET, or someone on your team balks at requiring the .NET framework in order to install the program.  I have always managed to steer around this issue by building a bootstrap installer (that runs a silent Dotnetfx.exe before the main MSI) or in some other way being convincing that the feature was not needed, .NET is needed, .NET is ubiquitous enough to assume, etc.  This recenty came up again when I built an installer for a non-.NET product we have here and various custom actions were required and written in .NET.  The department for whom I wrote the installer balked, as one of their machiens did not have .NET 1.1 despite claims of being up to date with windows update, etc.  I could have pushed the issue again but this comes up often enough that I really decided I should get back into C++ and be ready for future opportunities to innovate. 

It took me an embarassing amount of time to get the program working, here is a snippet.  I notice DasBlog does NOT have a C++ option under the insert code, harumpf!

using namespace std;


int _tmain(int argc, LPTSTR argv[])
{
        _cputs("COPYING PLUGIN\r\n");        
        HKEY resultKey = NULL;    
        
        LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
            _T("SOFTWARE\\ej-technologies\\install4j\\installations"),
            0,
            KEY_READ | KEY_QUERY_VALUE,
            &resultKey);
        if(ERROR_SUCCESS == result)
        {
            _cputs("Searching for registry value\r\n");
            ///////////////////////////////////////////////////
            //Figure out how many values there are in the key
            ///////////////////////////////////////////////////
            DWORD maxSubKeyLen, numVals, maxValNameLen, maxValLen, numSubKeys;
            DWORD valueNameLen, valueLen, valueType;
            LPTSTR subKeyname, valueName;
            LPBYTE value;
            FILETIME lastWriteTime;

            RegQueryInfoKey(resultKey,
                NULL,
                NULL,
                NULL,
                &numSubKeys,
                &maxSubKeyLen,
                NULL,
                &numVals,
                &maxValNameLen,
                &maxValLen,
                NULL,
                &lastWriteTime);

            valueName = (LPTSTR)malloc (maxValNameLen + 1);
            value = (LPBYTE)malloc (maxValLen);

            ///////////////////////////////////////////////////
            // Enumerate each value to see if it is the one we want
            ///////////////////////////////////////////////////
            for(int i = 0; i < numVals; i++){
                valueNameLen = maxValNameLen + 1;
                valueLen = maxValLen +1;

                RegEnumValue(resultKey,
                    i,
                    valueName,
                    &valueNameLen,
                    NULL,
                    &valueType,
                    value,
                    &valueLen);
                _tprintf(_T("\nValue: %s="), valueName);
                _tprintf(_T("%s\r\n"), (LPTSTR)value);
                LPTSTR compVal = LPTSTR(valueName);
                LPTSTR instdir = _T("instdir");
                
                _tprintf(_T("%s??%s\r\n"), compVal, instdir);
                int compare = _tcsncmp(compVal, instdir , 7);
                if(0 == compare){
                    //now we know "value" is our install dir
                    LPTSTR valueString = (LPTSTR)value;
                    LPTSTR pluginStr = _T("\\plugins\\carspot.jar");
                    
                
                    LPTSTR srcPath = _tfullpath(NULL, _T("./carspot.jar"), _MAX_PATH);
                    _tprintf(_T("srcPath=%s\r\n"), srcPath);

                    LPTSTR destPath = (LPTSTR)malloc(_MAX_PATH);

                    _tcscpy(destPath, valueString);
                    _tprintf(_T("SPARK install dir is %s\r\n"), value);
                    _tcsncat(destPath, pluginStr, _tcslen(pluginStr));
                    _tprintf(_T("Plugin dir is %s\r\n"), destPath);


                    _tprintf(_T("copying..."));
                    if(!CopyFile( srcPath, destPath, FALSE)) {
                        DWORD error = GetLastError();
                        _tprintf(_T("Last error was %i", error));
                    }

Since my C career was on Solaris I was unfamiliar with ALL of the conventions I was confronted with.  Not even main() is the same, where is good ole int main(int argc, char ** argv) ?   What the hell is an LPTSTR or a DWORD?  On Solaris pretty much everyone used the RougeWave String package.  I eventually figured out (using some books Chad Albrecht recommended) that LPTSTR is typedef'd based on whether or not UNICIODE is a #define-d, found the template versions of all the string manipulation libraries (best not to use the ole vanille strcmp etc), realized no one uses "delete" on Win32, and that most predefined types do not use "*" (LPTSTR is defined as TCHAR *) and generally got myself back into C-thinking.  My final head-scratcher was when my program worked fine on my PC but not on any machine I copied it to.  I'm not sure if this is just how my project was set up or not, but it seems the linker functions far differently in debug builds?  Changing to a Release build finally got it working.  Some of my attempts to free() memory crash at runtime so I've obviously got some more reading to do before I can call myself "back in action".