예제 #1
1
// ------------------------------------------------
// 
//  FUNCTION: sys_GetRegKey( PA_PluginParameters params )
//
//  PURPOSE:  Get a key from the registry.
//        
//	DATE:	  MJG 12/4/03 (3.5.6)
//
void sys_GetRegKey( PA_PluginParameters params )
{
	LONG_PTR returnValue, regKey, retErr, dataSize, arraySize, expandDataSize;
	LONG_PTR i, len;
	char regSub[MAXBUF];
	char regName[MAXBUF];
	char *returnDataBuffer, *ptrData;
	HKEY hRootKey;
	HKEY hOpenKey;
	DWORD dwDataType;
	DWORD dwReturnLong;
	PA_Variable	paReturnArray;

	// AMS2 12/9/14 #41400 Initalized the dataSize variable. In 64 bit environments this can be randomly initalized to a size in bytes 
	// that is larger than malloc can allot, causing it to return null and crash when returning to 4D. Remember to always initialize your size variables.
	dataSize = 0;
	returnValue = regKey = retErr = arraySize = expandDataSize = 0; 
	hRootKey = hOpenKey = 0;
	ptrData = returnDataBuffer = NULL;
	memset(regSub, 0, MAXBUF);
	memset(regName, 0, MAXBUF);

	// Get the function parameters.
	regKey = PA_GetLongParameter( params, 1 );
	PA_GetTextParameter( params, 2, regSub );
	PA_GetTextParameter( params, 3, regName );

	// Convert the 4d registry constant into a Windows registry key.
	hRootKey = getRootKey( regKey );

	// Open the registry key.
	retErr = RegOpenKeyEx(hRootKey, regSub, 0, KEY_READ, &hOpenKey);
	
	if(retErr == ERROR_SUCCESS){

		// Get the value type and size.
		retErr = RegQueryValueEx(hOpenKey, regName, NULL, &dwDataType, NULL, &dataSize);

		if(retErr == ERROR_SUCCESS){

			switch(dwDataType){
			case REG_BINARY:
				returnDataBuffer = malloc(dataSize);
				retErr = RegQueryValueEx(hOpenKey, regName, NULL, NULL, (LPBYTE) returnDataBuffer, &dataSize);

				if(retErr == ERROR_SUCCESS){
					PA_SetBlobParameter(params, 4, returnDataBuffer, dataSize);
					returnValue = 1;
				}

				free(returnDataBuffer);
				break;

			case REG_DWORD:
			case REG_DWORD_BIG_ENDIAN:
				dataSize = sizeof(dwReturnLong);
				retErr = RegQueryValueEx(hOpenKey, regName, NULL, NULL, (LPBYTE) &dwReturnLong, &dataSize);

				if(retErr == ERROR_SUCCESS){
					PA_SetLongParameter(params, 4, dwReturnLong);
					returnValue = 1;
				}
				break;

			case REG_EXPAND_SZ:
				returnDataBuffer = malloc(dataSize);
				retErr = RegQueryValueEx (hOpenKey, regName, NULL, NULL, returnDataBuffer, &dataSize);
				
				if(retErr == ERROR_SUCCESS)
				{
					regExpandStr(&returnDataBuffer);
					PA_SetTextParameter(params, 4, returnDataBuffer, strlen(returnDataBuffer));
					returnValue = 1;
				}

				free(returnDataBuffer);
				break;


			case REG_MULTI_SZ:
				returnDataBuffer = malloc(dataSize);
				paReturnArray = PA_GetVariableParameter( params, 4 );

				retErr = RegQueryValueEx(hOpenKey, regName, NULL, NULL, returnDataBuffer, &dataSize);

				if(retErr == ERROR_SUCCESS)
				{
					arraySize = regGetNumElements(returnDataBuffer);
					PA_ResizeArray(&paReturnArray, arraySize);

			
					for(i = 1, ptrData = returnDataBuffer; i <= arraySize; i++)
					{
						len = strlen(ptrData);
						PA_SetTextInArray(paReturnArray, i, ptrData, len);
						ptrData+=len+1;
					} 

					returnValue = 1;
					PA_SetVariableParameter( params, 4, paReturnArray, 0 );
				}

				free(returnDataBuffer);
				break;


			case REG_SZ:
				returnDataBuffer = (char*)malloc(dataSize);
				retErr = RegQueryValueEx(hOpenKey, regName, NULL, NULL, returnDataBuffer, &dataSize);

				if(retErr == ERROR_SUCCESS){
					PA_SetTextParameter(params, 4, returnDataBuffer, dataSize-1);
					returnValue = 1;
				}

				free(returnDataBuffer);
				break;
			} 
		}
	}

	RegCloseKey( hOpenKey );
	PA_ReturnLong( params, returnValue );
}
예제 #2
0
void sys_LogonUser(PA_PluginParameters params)
{
	
	HANDLE hToken = NULL;
	BOOL bStatus = FALSE;
	char chUserID[MAXBUF] = "";   // String to hold the username
	char chDomain[MAXBUF] = "";   // String to hold the domain
	char chPassword[MAXBUF] = ""; // String to hold the password
	
	// Make sure that we've cleared out any previous errors
	SetLastError(0);

	// Get our parameters
	PA_GetTextParameter(params, 1, chUserID);
	PA_GetTextParameter(params, 2, chDomain);
	PA_GetTextParameter(params, 3, chPassword);

  // Authenticate the user
  bStatus = LogonUser(chUserID, chDomain, chPassword, LOGON32_LOGON_NETWORK, 
                      LOGON32_PROVIDER_DEFAULT, &hToken);

  if(bStatus)
	{
    // Authenticated
    // Close the handle
    if (hToken != NULL)
		{
      CloseHandle(hToken);
      hToken = NULL;
    }
  }

  PA_ReturnLong(params, (LONG_PTR)bStatus);
}
예제 #3
0
void sys_DirectoryExists(PA_PluginParameters params){
	char *directory = NULL;
	LONG_PTR length;
	WIN32_FIND_DATA FindFileData;
	HANDLE hFindFile;
	LONG ret = 0; // assume directory doesn't exist // WJF 6/30/16 Win-21 LONG_PTR -> LONG

	// retrieve the directory manual
	length = PA_GetTextParameter(params, 1, 0L);

	if (length > 0) {
		directory = malloc(length + 1); // WJF 7/13/16 Win-21 Removed typecasting on malloc to follow C best practices

		if (directory != NULL) {
			memset(directory, 0, length + 1);
			PA_GetTextParameter(params, 1, directory);
		}
	}

	// if the directory ends with a backslash it will fail and needs to be removed
	// if the directory is a disk root it will fail handle here in special case
	if (NULL != directory){
		if ((':' == directory[1]) && (length <= 3)) { // REB 8/2/10 #24474 Changed ( 3 == length) to (length <= 3)
			// drive since has only 3 chars, handle here
			ret = GetFileAttributes(directory);
			if (ret != INVALID_FILE_ATTRIBUTES){ // REB 8/2/10 #24474 Added check for invalid attributes.
				ret = (0 != (GetFileAttributes(directory) & FILE_ATTRIBUTE_DIRECTORY)); // set exists
				free(directory);
				directory = NULL; // we have a result so avoid to normal handler
			}
		}
		else if ('\\' == directory[length - 1]){
			directory[length - 1] = '\0';
		}
	}

	if (NULL != directory){
		hFindFile = FindFirstFile(directory, &FindFileData);

		// if a valid handle we should test whether it's a directory
		if (INVALID_HANDLE_VALUE != hFindFile){
			ret = (0 != (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)); // set exists
			FindClose(hFindFile);	// close handle
		}
		freeTextParameter(directory);
	}

	PA_ReturnLong(params, ret);
}
예제 #4
0
// ------------------------------------------------
// 
//  FUNCTION: sys_GetEnv( PA_PluginParameters params )
//
//  PURPOSE:  Get the value of an environment variable.
//        
//	DATE:	  MJG 12/2/03 (3.5.6)
//
void sys_GetEnv( PA_PluginParameters params )
{
	LONG_PTR returnValue;
	LONG_PTR envLength;
	char envName[MAXBUF], *envValue;

	envValue = NULL;
	memset(envName, 0, MAXBUF);

	envLength = PA_GetTextParameter( params, 1, envName );
	
	if(envLength > 0)
		envValue = getenv(envName);

	if(envValue == NULL)
	{
		returnValue = 0;
		PA_SetTextParameter(params, 2, "", 0);
	}
	else {
		returnValue = 1;
		PA_SetTextParameter(params, 2, envValue, strlen(envValue));
	}

	PA_ReturnLong( params, returnValue );
}
예제 #5
0
// ------------------------------------------------
// 
//  FUNCTION: sys_GetEnv( PA_PluginParameters params )
//
//  PURPOSE:  Set the value of an environment variable.
//        
//	DATE:	  MJG 12/2/03 (3.5.6)
//
void sys_SetEnv( PA_PluginParameters params )
{
	LONG_PTR returnValue;
	char envName[MAXBUF], envValue[MAXBUF];

	returnValue = 0;
	memset(envName, 0, MAXBUF);
	memset(envValue, 0, MAXBUF);

	PA_GetTextParameter( params, 1, envName );
	PA_GetTextParameter( params, 2, envValue );
	
	strncat(envName, "=", MAXBUF);
	strncat(envName, envValue, MAXBUF);
	
	returnValue = !(putenv(envName));

	PA_ReturnLong( params, returnValue );
}
예제 #6
0
//  FUNCTION:   sys_LoggingStart(PA_PluginParameters params)
//
//  PURPOSE:	Start logging Win32API commands
//
//  COMMENTS:
//
//	DATE:		7/11/16 Win-20
void sys_LoggingStart(PA_PluginParameters params) {
	LONG returnValue = 0; // WJF 7/11/16 Win-20

	PA_GetTextParameter(params, 1, szLogsPath);
	lNumDays = PA_GetLongParameter(params, 2);
	
	returnValue = logOpenFile();

	PA_ReturnLong(params, returnValue); // WJF 7/11/16 Win-20
}
예제 #7
0
// ------------------------------------------------
// 
//  FUNCTION: sys_GetRegType( PA_PluginParameters params )
//
//  PURPOSE:  Get a key from the registry.
//        
//	DATE:	  MJG 12/4/03 (3.5.6)
//
void sys_GetRegType( PA_PluginParameters params )
{
	LONG_PTR returnValue, regKey, retErr;
	char regSub[MAXBUF];
	char regName[MAXBUF];
	char *returnDataBuffer;
	HKEY hRootKey;
	HKEY hOpenKey;
	DWORD dwDataType;

	returnValue = regKey = retErr = 0;
	hRootKey = hOpenKey = 0;
	returnDataBuffer =  NULL;
	memset(regSub, 0, MAXBUF);
	memset(regName, 0, MAXBUF);

	// Get the function parameters.
	regKey = PA_GetLongParameter( params, 1 );
	PA_GetTextParameter( params, 2, regSub );
	PA_GetTextParameter( params, 3, regName );

	// Convert the 4d registry constant into a Windows registry key.
	hRootKey = getRootKey( regKey );

	// Open the registry key.
	retErr = RegOpenKeyEx(hRootKey, regSub, 0, KEY_READ, &hOpenKey);
	
	if(retErr == ERROR_SUCCESS){

		// Get the value type and size.
		retErr = RegQueryValueEx(hOpenKey, regName, NULL, &dwDataType, NULL, NULL);

		if(retErr == ERROR_SUCCESS){

			returnValue = get4dRegType(dwDataType);

		}
	}

	RegCloseKey( hOpenKey );
	PA_ReturnLong( params, returnValue );
}
예제 #8
0
LONG_PTR getTrayIconParams( PA_PluginParameters params, LONG_PTR *pAction, LONG_PTR *pFlags, LONG_PTR *pIconID, LONG_PTR *pProcessNbr,
                            LONG_PTR *pIconHndl, char* szTipParam, char* szBalloonInfo, char* szBalloonTitle )
{
    LONG_PTR							szTipParam_len, szBalloonInfo_len, szBalloonTitle_len, returnValue = 0;

    *pAction     = PA_GetLongParameter( params, 1 );
    if (*pAction != 0) returnValue++;
    *pFlags      = PA_GetLongParameter( params, 2 );
    if (*pFlags != 0) returnValue++;
    *pIconID     = PA_GetLongParameter( params, 3 );
    if (*pIconID != 0) returnValue++;
    *pProcessNbr = PA_GetLongParameter( params, 4 );
    if (*pProcessNbr != 0) returnValue++;
    *pIconHndl   = PA_GetLongParameter( params, 5 );
    if (*pIconHndl != 0) returnValue++;

    szTipParam_len = PA_GetTextParameter( params, 6, szTipParam );
    if (szTipParam_len > 59) {
        szTipParam_len = 60;
    }
    szTipParam[szTipParam_len] = '\0';
    if (szTipParam_len) returnValue++;

    szBalloonInfo_len = PA_GetTextParameter( params, 7, szBalloonInfo );
    if (szBalloonInfo_len > 254) {
        szBalloonInfo_len = 255;
    }
    szBalloonInfo[szBalloonInfo_len] = '\0';
    if (szBalloonInfo_len) returnValue++;

    szBalloonTitle_len = PA_GetTextParameter( params, 8, szBalloonTitle );
    if (szBalloonTitle_len > 59) {
        szBalloonTitle_len = 60;
    }
    szBalloonTitle[szBalloonTitle_len] = '\0';
    if (szBalloonTitle_len) returnValue++;

    return returnValue;
}
예제 #9
0
// ------------------------------------------------
// 
//  FUNCTION: sys_IsAppLoaded( PA_PluginParameters params )
//
//  PURPOSE:	Check if a program is loaded
//
//  COMMENTS:	Win98 uses different approach than NT4 and up
//						Function pointers used for OS specific functions.
//        
//	DATE:			dcc 08/23/02
//
//	MODIFICATIONS: 
//
void sys_IsAppLoaded( PA_PluginParameters params )
{
	LPFNENUMPROC				lpfnEnumProc = NULL;
	LPFNENUMPROCMODS		lpfnEnumProcMods = NULL;
	LPFNGETMODFNAME			lpfnGetModFName = NULL;
	HINSTANCE						hPSapiDLL;
	BOOL								bFuncReturn, bUseToolHelp = FALSE;
	char								appName[100]; 
	LONG_PTR								appName_len;

	appName_len						 = PA_GetTextParameter( params, 1, appName );
	appName[appName_len]	 = '\0';

	hPSapiDLL = (HINSTANCE) getPSapiPointers(&lpfnEnumProc, &lpfnEnumProcMods, &lpfnGetModFName);

	bFuncReturn = reviewProcesses(hPSapiDLL, lpfnEnumProc, lpfnEnumProcMods, lpfnGetModFName,
								appName, bUseToolHelp);

	PA_ReturnLong( params, bFuncReturn);
}
예제 #10
0
// ------------------------------------------------
// 
//  FUNCTION: sys_GetRegEnum( PA_PluginParameters params )
//
//  PURPOSE:  Get a key from the registry.
//        
//	DATE:	  MJG 12/4/03 (3.5.6)
//
void sys_GetRegEnum( PA_PluginParameters params )
{
	LONG_PTR returnValue, regKey, retErr;
	char regSub[MAXBUF];
	LONG_PTR regBufSize = MAX_REG_SIZE;
	CHAR regBuf[MAX_REG_SIZE]; 

	FILETIME ftLastWriteTime;
	HKEY hRootKey;
	HKEY hOpenKey;
	DWORD dwSubKeys;
	DWORD dwValues;
	DWORD i, j;
	PA_Variable paReturnArray1;
	PA_Variable paReturnArray2;

	dwSubKeys = dwValues = 0;
	returnValue = regKey = retErr = 0;
	hRootKey = hOpenKey = 0;
	memset(regSub, 0, MAXBUF);

	// Get the function parameters.
	regKey = PA_GetLongParameter( params, 1 );
	PA_GetTextParameter( params, 2, regSub );
	paReturnArray1 = PA_GetVariableParameter( params, 3 );
	paReturnArray2 = PA_GetVariableParameter( params, 4 );
	
	PA_ResizeArray(&paReturnArray1, 0);
	PA_ResizeArray(&paReturnArray2, 0);

	// Convert the 4d registry constant into a Windows registry key.
	hRootKey = getRootKey( regKey );

	// Open the registry key.
	retErr = RegOpenKeyEx(hRootKey, regSub, 0, KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE , &hOpenKey);
	
	if(retErr == ERROR_SUCCESS){
		
		retErr = RegQueryInfoKey(hOpenKey, NULL, NULL, NULL, &dwSubKeys, NULL, NULL, &dwValues, NULL, NULL, NULL, NULL); 
		
		if( retErr == ERROR_SUCCESS)
		{
			// Enumerate the subkey names.
			
			if (dwSubKeys)
			{
				retErr = ERROR_SUCCESS;
				PA_ResizeArray(&paReturnArray1, dwSubKeys);
				
				for (i=0,j=0; i<dwSubKeys; i++) 
				{ 
					regBufSize = MAX_REG_SIZE;
					retErr = RegEnumKeyEx(hOpenKey, i, regBuf, &regBufSize, NULL, NULL, NULL, &ftLastWriteTime); 
					
					if (retErr == ERROR_SUCCESS) 
					{
						PA_SetTextInArray(paReturnArray1, ++j, regBuf, regBufSize);
					}
				}
			} 
			
			// Enumerate the key value names. 
			if (dwValues) 
			{
				retErr = ERROR_SUCCESS;
				PA_ResizeArray(&paReturnArray2, dwValues);
				
				for (i=0,j=0; i<dwValues; i++) 
				{ 
					regBufSize = MAX_REG_SIZE;
					regBuf[0] = '\0'; 
					retErr = RegEnumValue(hOpenKey, i, regBuf, &regBufSize, NULL, NULL, NULL, NULL);
					
					if (retErr == ERROR_SUCCESS ) 
					{ 
						PA_SetTextInArray(paReturnArray2, ++j, regBuf, regBufSize);
					} 
				}
			}

			returnValue = 1;
		}
	} 
	
	PA_SetVariableParameter( params, 3, paReturnArray1, 0 );
	PA_SetVariableParameter( params, 4, paReturnArray2, 0 );
	
	RegCloseKey( hOpenKey );

	PA_ReturnLong( params, returnValue );
}
예제 #11
0
// ------------------------------------------------
// 
//  FUNCTION: gui_RespectToolBar( PA_PluginParameters params )
//
//  PURPOSE:  Function to intecept maximize event in the 
//						ProToolsProc.  There the window maximized 
//						size is reduced by the number of pixels
//						passed into the function. 
//
//  COMMENTS:	This has been experimented with but should be tested
//						more thoroughly.  Some situations still cause a max'd
//						window to resize under a toolbar. Noticed in particular
//						when a new process window pops up over another process's 
//						max'd window.  This is left for an excersize for some adventurous
//						soul.
//        
//	DATE:			dcc 01/16/03 (3.5.4)
//
//	MODIFICATIONS:
//
void gui_RespectToolBar( PA_PluginParameters params )
{
	LONG_PTR					position_len = 0, tbRestriction = 0;
	LONG_PTR					trackingRestriction = 0, processNbr;
	char					position[2];
	INT_PTR						theChar;


	tbRestriction	 = PA_GetLongParameter( params, 1); 
	position_len			 = PA_GetTextParameter( params, 2, position );
	position[position_len]	 = '\0';
	if (position_len > 1) {
		position[1] = '\0';
	}
	_strlwr(position);

	if (position_len == 0) {	// pass a negative in and turns it all off
		toolBarRestrictions.toolBarOnDeck = 0;
		//restoreOrig4DWindowProcess(); // MJG 3/26/04 The 4D window will remain subclassed until the plug-in is unloaded.
		PA_ReturnLong( params, toolBarRestrictions.toolBarOnDeck);
		return;
	}

	trackingRestriction = PA_GetLongParameter( params, 3);
	toolBarRestrictions.trackingRestriction  = trackingRestriction;

	if ((tbRestriction != 0) &&  (strpbrk(position, "ltrb") != NULL)) {
		toolBarRestrictions.toolBarOnDeck = 1;
		theChar = (INT_PTR) position[0];
	}

	processNbr = PA_GetCurrentProcessNumber();

	switch (theChar)
	{
		case 'l' :
			toolBarRestrictions.left = tbRestriction;
			toolBarRestrictions.leftProcessNbr = processNbr;
			break;

		case 't' :
			toolBarRestrictions.top = tbRestriction;
			toolBarRestrictions.topProcessNbr = processNbr;
			break;
		case 'r' :
			toolBarRestrictions.right = tbRestriction;
			toolBarRestrictions.rightProcessNbr = processNbr;
			break;

		case 'b' :
			toolBarRestrictions.bottom = tbRestriction;
			toolBarRestrictions.bottomProcessNbr = processNbr;
			break;
	}

	toolBarRestrictions.appBeingMaxed = 0;
  
	//if (processHandles.wpFourDOrigProc == NULL) {
	//	processHandles.wpFourDOrigProc = (WNDPROC) SetWindowLong(windowHandles.fourDhWnd, GWL_WNDPROC, (LONG) newProc);
	//}
	// MJG 3/26/04 Replaced code above with function call.
	subclass4DWindowProcess();

	PA_ReturnLong( params, toolBarRestrictions.toolBarOnDeck);
}
예제 #12
0
void sys_KillProcessByName( PA_PluginParameters params )
{
	HANDLE hProcessSnap;              // Handle to the process snapshot
	HANDLE hProcess;                  // Handle to the process itself
	PROCESSENTRY32 pe32;              // ProcessEntry to get info about processes
  char processName[MAXBUF] = "";    // String to hold the printerName param ($1)
	LONG_PTR lMode = 1;                   // Long to hold the working mode ($2)
	                                  // 1 = just first process matching name
	                                  // 2 = all processes matching name
	BOOL bCleanFirst = FALSE;         // Boolean to see if we should try to cleanly close the app
	                                  // before killing it mercilessly
	BOOL bOrigCleanFirst = FALSE;     // Keeps track of original bCleanFirst value
	                                  // to reset between loop iterations ($3)
	BOOL bDone = FALSE;               // This will keep track of whether or not we are finished
	                                  // Looping through processes.
	// Get the function parameters.
	PA_GetTextParameter(params, 1, processName);
	lMode = PA_GetLongParameter(params, 2);
	bOrigCleanFirst = (PA_GetLongParameter(params, 3) == 1 ? TRUE : FALSE);

  // Take a snapshot of all processes in the system.
	// If we fail, return the error code
  hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if(hProcessSnap == INVALID_HANDLE_VALUE)
  {
    PA_ReturnLong(params, (LONG_PTR)GetLastError());
		return;
  }

	// Set the size of the structure before using it.
  pe32.dwSize = sizeof( PROCESSENTRY32 );

  // Retrieve information about the first process,
  // If we can't do it, then return the error code
  if(!Process32First( hProcessSnap, &pe32))
  {
    CloseHandle( hProcessSnap );     // Must clean up the snapshot object!
    PA_ReturnLong(params, (LONG_PTR)GetLastError());
		return;
  }

  // Now walk the snapshot of processes, and
  // display information about each process in turn
  do
  {
    
		// Check the name
		if (strcmp(pe32.szExeFile, processName) == 0)
		{

			bCleanFirst = bOrigCleanFirst;
		  // Get the process
		  // We need to make sure that we have the TERMINATE right
      hProcess = OpenProcess(SYNCHRONIZE|PROCESS_TERMINATE, FALSE, pe32.th32ProcessID);
			
			// Couldn't get the process
			// Clean up the handle
			// and return the error
      if(hProcess == NULL) {
				CloseHandle(hProcessSnap);
        PA_ReturnLong(params, (LONG_PTR)GetLastError());
			  return;
			}

			if(bCleanFirst)
			{
        // TerminateClean() posts WM_CLOSE to all windows whose PID
        // matches your process's.
        EnumWindows((WNDENUMPROC)TerminateClean, (LPARAM) pe32.th32ProcessID) ;

				if(WaitForSingleObject(hProcess, 500)!=WAIT_OBJECT_0)
				{
          bCleanFirst = TRUE;
				}
			}

			if(!bCleanFirst)
			{
        // Kill the process
        if(TerminateProcess(hProcess, 1)) {;
			    // Success!
			    // If we're in mode 1 then we are finished
			    // If not, then we will need to keep going
  			  if(lMode == 1) {
	  			  bDone = TRUE;
					} // end 
				} else {
          // Fail!
				  // Clean up and return the error
          CloseHandle(hProcess);
				  CloseHandle(hProcessSnap);
				  PA_ReturnLong(params, (LONG_PTR)GetLastError());
				  return;
				}
			}

			// Close our handle
      CloseHandle(hProcess);
    } // end if
		Process32Next(hProcessSnap, &pe32); // WJF 6/2/15 #42839 Moved out of while condition

  } while((GetLastError()!=18) && (!bDone)); // WJF 6/2/15 #42839 Added GetLastError Check, corrected logical or syntax, and added inversion to bDone

	// Close the handle and return success
  CloseHandle(hProcessSnap);
  PA_ReturnLong(params, -1 * (LONG_PTR)bCleanFirst);
}
예제 #13
0
void sys_PrintDirect2Driver( PA_PluginParameters params )
{
	PRINTDLG pd;                      // Structure to hold information about printer
	DOCINFO di;                       // Structure to hold "document" information
	char printerName[MAXBUF] = "";    // String to hold the printerName param ($1)
	char data[MAXLABELBUF] = "";      // String to hold the data param ($2) REB 6/5/08 #17022 Changed MAXBUF to MAXLABELBUF which is twice as big.
	char *origDefault;                // String to hold the original default printer
	INT_PTR printerName_len;              // Int to hold maximum length of printer name
	INT_PTR ret;                          // Int to hold return value of functions                 
	INT_PTR iErrCode = 0;                 // Int to hold the error code.
	ULONG_PTR ulBytesNeeded;      // Holds size information

	// Set needed bytes to default value
	ulBytesNeeded = MAXLABELBUF; // REB 6/5/08 #17022 Changed MAXBUF to MAXLABELBUF

	// Set this to 255.
	printerName_len = 255;

	// Get the function parameters.
	PA_GetTextParameter(params, 1, printerName);
	PA_GetTextParameter(params, 2, data);

	// Allocate memory for Storing string for Original Default Printer & pBuf
	origDefault = (char *)malloc(ulBytesNeeded);
	memset(origDefault, 0, ulBytesNeeded);
	
    // Get name of current Default Printer
	GetDefaultPrinter(origDefault, &ulBytesNeeded);
    
	// Set the new Default Printer to our label printer, with the name obtained from the registry
	ret = SetDefaultPrinter((char *)printerName);
	
	// We set the default printer just fine, now let's do the printing.
	if (ret != 0)
	{
		            
  	// Allocate memory for PRINTDLG structure
	  memset( &pd, 0, sizeof( pd ) );

	  // Define properties of the PRINTDLG structure
	  pd.lStructSize = sizeof( pd );

	  // PD_RETURNDEFAULT causes the PrintDlg function to automatically use the properties from
	  // the default printer.  PD_RETURNDC causes the function to return the device context
	  // for the printer.  This device context allows us to print a label
	  pd.Flags = PD_RETURNDEFAULT | PD_RETURNDC;

		// These two structures must be NULL to use the PD_RETURNDC flag.
		// Do this explicitly, just in case
		pd.hDevMode = NULL;
		pd.hDevNames = NULL;
			
	  // Retrieve the Device Context.  It will be accessible as a member of the PRINTDLG structure
	  if(!PrintDlg( &pd ))
		{
			// Get the error from the common dialog box
			// Error code will not work properly with FormatMessage, so use this instead.
		  iErrCode = CommDlgExtendedError();
		}
		
		if(iErrCode == 0)
		{
      // Initialize the DOCINFO structure
      memset(&di, 0, sizeof(di));
      di.cbSize = sizeof(DOCINFO);
	  	di.lpszDocName = "Label"; 
      di.lpszOutput = (LPTSTR) NULL; 
      di.lpszDatatype = "raw";
      di.fwType = 0; 
    	
	  	// Start a document in the print spooler
	  	if(!StartDoc(pd.hDC, &di))
			{
	  	  iErrCode = GetLastError();
			} // end if
		}
					
		if(iErrCode == 0)
		{
		  // Start a new page in the print spooler
	    if(!StartPage(pd.hDC))
			{
			  iErrCode = GetLastError();
			} // end if !
		}

		if(iErrCode == 0)
		{
		  if(!TextOut(pd.hDC, 1, 1, data, strlen(data)))
			{
			  iErrCode = GetLastError();
			}
		}

		// De-allocate commandList
		
		// Let the print spooler know that the page is done
		EndPage(pd.hDC);
			
    // Let the print spooler know that the document is done
	  EndDoc(pd.hDC);
			
		
		// Delete the Device Context
		DeleteDC(pd.hDC);
			
		
		// Now reset our default printer.
    
		// Set the Default Printer back to the original.
  		ret = SetDefaultPrinter(origDefault);

		PA_ReturnLong(params, (LONG_PTR)iErrCode); 
	} else {
	  PA_ReturnLong(params, (LONG_PTR)GetLastError());
	}	// end if
}//end function