baznalptadresa.cpp

pc paralel port programming

// BaznaLPTAdresa.cpp: implementation of the CBaznaLPTAdresa class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "BaznaLPTAdresa.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBaznaLPTAdresa::CBaznaLPTAdresa()
{

}

CBaznaLPTAdresa::~CBaznaLPTAdresa()
{

}

int CBaznaLPTAdresa::GetAddressLptPort(int myPort)
{
    int address = -1;

    if (myPort>=1 && myPort<=3) {
        if (IsWindowsNT()) {
            address = GetAddressLptPortInTheRegistry(myPort);
        }
        else {
            address = GetAddressLptPortInTheMemory(myPort);
        }
    }

    return address;
}

bool CBaznaLPTAdresa::IsWindowsNT( void )
{
    return !(GetVersion() & 0x80000000);
}

int CBaznaLPTAdresa::GetAddressLptPortInTheRegistry(int myPort)
{
    HKEY phkResult;
    char myKey[255];
    char myData[255];
    LONG res;
    DWORD mySize;
    DWORD myType;

    res = GetParallelControllerKey(myKey);
    if (res < 0)
    return (-1);

    sprintf(myData,"%s\\%d",myKey,myPort-1);

    res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, myData, 0, KEY_READ, &phkResult);
    if (res != ERROR_SUCCESS)
    return(-1);

    mySize=sizeof(myData);
    myType=REG_BINARY;

    res=RegQueryValueEx
    (
        phkResult,					// handle to key to query
        "Configuration Data",		// address of name of value to query
        NULL,						// reserved
        &myType,					// address of buffer for value type
        (unsigned char *)myData,	// address of data buffer
        &mySize						// address of data buffer size
    );
    if (res != ERROR_SUCCESS)
    return(-1);

    //printf("config data port %d 0x14 = 0x%02X 0x15 = 0x%02X\n",myPort,myData[0x14],myData[0x15]);
    return(myData[0x14] | myData[0x15]<<8 );
}

int CBaznaLPTAdresa::GetAddressLptPortInTheMemory(int myPort)
{
    HINSTANCE hDLL=NULL; // Handle to DLL
    PROCTYPE_Toolhelp32ReadProcessMemory myProcPointer=NULL;

    hDLL = LoadLibrary("kernel32");
    if (hDLL==NULL)
    return(-1);

    myProcPointer=(PROCTYPE_Toolhelp32ReadProcessMemory)GetProcAddress(hDLL,"Toolhelp32ReadProcessMemory");
    if (myProcPointer==NULL) //handle the error
    { 
        FreeLibrary(hDLL); 
        return -1;
    }

    int portAddresses[]={0,0,0,0,0};
    BOOL rtn=0;
    DWORD cbLen=0;
    //rtn = Toolhelp32ReadProcessMemory 
    rtn = myProcPointer
        (
        0,
        (LPCVOID *) 0x408,
        portAddresses,
        8,
        NULL
        );

    FreeLibrary(hDLL); 

    if (rtn==0)
    return(-1);

    // Ovo sam ja dodao ( da bi radilo na Windows 98 )
    int portAddr;
    if      ( myPort == 1 ) {
        portAddr = portAddresses[0] & 0x0000FFFF;
    }
    else if ( myPort == 2 ) {
        portAddr = portAddresses[0] & 0xFFFF0000;
        portAddr >>= 16;
    }
    else if ( myPort == 3 ) { 
        portAddr = portAddresses[1] & 0x0000FFFF;
    }
    else {
        portAddr = -1;
    }

    if (portAddr<=0)
    return(-1);

    if (portAddr>=0x1000)
    return(-1);

    return portAddr;
/*
    if (portAddresses[myPort-1]<=0)
    return(-1);

    if (portAddresses[myPort-1]>=0x1000)
    return(-1);

    return(portAddresses[myPort-1]);
*/
}

int CBaznaLPTAdresa::GetParallelControllerKey(char *parKey)
{
    HKEY hKey;
    char myData[255];
    LONG res;
    DWORD mySize;
    FILETIME ftLastWriteTime;

    if (NULL == parKey)
    return(-1);

    *parKey=0;

    char myKey[255];
    sprintf(myKey, "HARDWARE\\DESCRIPTION\\System");

    res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, myKey, 0, KEY_READ, &hKey);

    if (res!=ERROR_SUCCESS)
    return (-1);

    DWORD dwIndex1;
    char myKey1[255];
    for ( dwIndex1=0; dwIndex1<=10; dwIndex1++ )
    {
    	mySize=sizeof(myData);
    	res = RegEnumKeyEx(hKey,dwIndex1, myData, &mySize, NULL, NULL, NULL, &ftLastWriteTime);

    	if (res==ERROR_SUCCESS) // ERROR_SUCCESS 1
    	{
    		strcpy(myKey1,myKey);
    		strcat(myKey1,"\\");
    		strcat(myKey1,myData);

    		HKEY hKey1;
    		res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, myKey1, 0, KEY_READ, &hKey1);

    		if (res!=ERROR_SUCCESS)
    		return(-1);

            DWORD dwIndex2;
    		char myKey2[255];
    		for (dwIndex2=0; dwIndex2<=10; dwIndex2++)
    		{
    			mySize=sizeof(myData);
    			res = RegEnumKeyEx(hKey1, dwIndex2, myData, &mySize, NULL, NULL, NULL, &ftLastWriteTime);

    			if (res==ERROR_SUCCESS) // ERROR_SUCCESS 2
    			{
    				strcpy(myKey2,myKey1);
    				strcat(myKey2,"\\");
    				strcat(myKey2,myData);
    				
    				HKEY hKey2;
    				res = 
    				RegOpenKeyEx(HKEY_LOCAL_MACHINE,myKey2, 0, KEY_READ, &hKey2);
    				
    				if (res!=ERROR_SUCCESS)
    				return(-1);
    				
    				DWORD dwIndex3;
    				for (dwIndex3=0;dwIndex3<=10;dwIndex3++)
    				{
    					mySize=sizeof(myData);
    					res = 
    					RegEnumKeyEx(hKey2,dwIndex3,myData,&mySize,NULL,NULL,NULL,&ftLastWriteTime);
    					
    					if (res==ERROR_SUCCESS) // ERROR_SUCCESS 3
    					{
    						if (0==strcmp(myData,"ParallelController") )
    						{
    							strcpy(parKey,myKey2);
    							strcat(parKey,"\\");
    							strcat(parKey,myData);
    							return(0);
    						}
    					} // ERROR_SUCCESS 3
    				
    				} // for (dwIndex3
    			
    			} // // ERROR_SUCCESS 2
    		
    		} // for (dwIndex2
    		
    	} // ERROR_SUCCESS 1
    	
    } // for (dwIndex1

    return(-1);
} //GetParallelControllerKey