|
|
/**************************************************************************
* * FILECOPY.C * * Copyright (C) Microsoft, 1990, All Rights Reserved. * * Control Panel Applet for installing installable driver. * * This file contains hooks to SULIB, COMPRESS libraries, and the dialogs * from the display applet to prompt for insert disk, error action... * * Note SULIB.LIB, COMPRESS.LIB, SULIB.H come from the display applet * and are updated here if/when updated there. * * History: * * Sat Oct 27 1990 -by- MichaelE * Munged from display applet's DLG.C. * **************************************************************************/
#include <windows.h>
#include <mmsystem.h>
#include <string.h>
#include "drivers.h"
#include "sulib.h"
#include <cphelp.h>
// Hidden parameter between wsSingleCopyStatus and wExistDlg
static char szErrMsg[MAXSTR];
// Hidden parameters passed from wsInsertDisk to wDiskDlg
static char CurrentDisk[MAX_PATH];static LPSTR szEdit;
// Function prototypes
BOOL wsInfParseInit (void);int fDialog (int, HWND, DLGPROC);UINT wsCopyError (int, LPSTR);UINT wsInsertDisk (LPSTR, LPSTR);BOOL wsDiskDlg (HWND, UINT, WPARAM, LPARAM);BOOL wsExistDlg (HWND, UINT, WPARAM, LPARAM);
/*
* Load the description from the inf file or the driver file. * * The type of file is also returned in the driver structure. * * Parameters : * pIDriver - Pointer to driver data - in particular the driver file name * pstrKey - The ini file key under which the driver should be found * pstrDesc - Where to return the description */
int LoadDesc(PIDRIVER pIDriver, PSTR pstrKey, PSTR pstrDesc) { PINF pinf; CHAR szFileName[MAX_INF_LINE_LEN]; PSTR pstrFile = pIDriver->szFile; CHAR ExpandedName[MAX_PATH]; PSTR FilePart;
/*
* See if the file can be found */
if (SearchPath(NULL, pstrFile, NULL, MAX_PATH, ExpandedName, &FilePart) == 0) { return(DESC_NOFILE); }
/*
* -jyg- Let's look in the mmdriver.inf first! */
for (pinf = FindInstallableDriversSection(NULL); pinf; pinf = infNextLine(pinf)) { infParseField(pinf, 1, szFileName); // compare filename
/*
* FileName strips of drive and path */
if (lstrcmpi(FileName(pstrFile), FileName(szFileName)) == 0) { infParseField(pinf, 3, pstrDesc); // get Description Field
return DESC_INF; } }
/*
* If that failed try to get the description from the file */
if (!GetFileTitle(ExpandedName, pstrDesc, MAXSTR)) { return DESC_EXE; } else { return DESC_NOFILE; } }
/*
* Find the install path from the registry if there is one there */
BOOL GetInstallPath(LPSTR szDirOfSrc) { HKEY RegHandle; DWORD Type; DWORD Length = MAX_PATH - 1; BOOL Found = FALSE;
if (MMSYSERR_NOERROR == RegOpenKey(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion"), &RegHandle)) {
if (MMSYSERR_NOERROR == RegQueryValueEx(RegHandle, TEXT("SourcePath"), NULL, &Type, szDirOfSrc, &Length) && Type == REG_SZ) {
Found = TRUE; }
RegCloseKey(RegHandle);
}
return Found; }
/*
* Initialize the SULIB library stuff which loads the mmdriver.inf file * into RAM and parses it all over the place. */
BOOL wsInfParseInit(void) { OFSTRUCT os; PINF pinf; char szNoInf[MAXSTR]; int iDrive; static BOOL bChkCDROM = FALSE;
/*
* put up an hour glass here */
wsStartWait();
if (OpenFile(szSetupInf, &os, OF_EXIST) == -1) {
wsEndWait(); LoadString(myInstance, IDS_NOINF, szNoInf, sizeof(szNoInf)); MessageBox(hMesgBoxParent, szNoInf, szDrivers, MB_OK | MB_ICONEXCLAMATION); return FALSE; }
pinf = infOpen(os.szPathName);
wsEndWait();
GetWindowsDirectory(szSetupPath, sizeof(szSetupPath));
if (bChkCDROM == FALSE) {
/*
* Use the setup path from the registry if there is one */
if (!GetInstallPath(szDirOfSrc)) { /*
* use the CD ROM drive as the default drive (if there is one) */
for ( iDrive='A'; iDrive <= 'Z'; iDrive++ ) { szDirOfSrc[0] = iDrive;
if ( GetDriveType(szDirOfSrc) == DRIVE_CDROM) { break; } /*
* If we didn't find a CD ROM default to the A drive */
if (iDrive == 'Z') { szDirOfSrc[0] = 'A'; } } }
bChkCDROM = TRUE; }
lstrcpy(szDiskPath, szDirOfSrc);
return TRUE; }
/*----------------------------------------------------------------------------*\
| wsStartWait() || || Turn the WinSetup cursor to a hour glass || |\*----------------------------------------------------------------------------*/void wsStartWait(){ SetCursor(LoadCursor(NULL,IDC_WAIT));}
/*----------------------------------------------------------------------------*\
| wsEndWait() || || Turn the WinSetup cursor back to what it was || |\*----------------------------------------------------------------------------*/void wsEndWait(){ SetCursor(LoadCursor(NULL,IDC_ARROW));}
/*----------------------------------------------------------------------------*\
| fDialog(id,hwnd,fpfn) || || Description: || This function displays a dialog box and returns the exit code. || || Arguments: || id resource id of dialog to display || hwnd parent window of dialog || fpfn dialog message function || || Returns: || exit code of dialog (what was passed to EndDialog) || |\*----------------------------------------------------------------------------*/int fDialog(int id, HWND hwnd, DLGPROC fpfn){ return ( (int)DialogBox(myInstance, MAKEINTRESOURCE(id), hwnd, fpfn) );}
/****************************************************************************
* | *wsCopyError() | * | * Handles errors, as the result of copying files. | * | * This may include net contention errors, in which case the user must | * retry the operation. | * | * Parameters : * * n - Copy error number * * szFile - the fully qualified name of the file we are copying * * Returns * * Always returns FC_ABORT * ****************************************************************************/ UINT wsCopyError(int n, LPSTR szFile) { char strBuf[MAXSTR]; int i = 0;
/*
* We do not want to report any errors that occur while installing * related drivers to the user */
if (bCopyingRelated) return(FC_ABORT);
/*
* check for out of disk space */
if (n == ERROR_DISK_FULL) {
LoadString(myInstance, IDS_OUTOFDISK, strBuf, MAXSTR);
} else {
/*
* Check to see if a copy has been done on a file that is currently * loaded by the system. * * n is the return code from VerInstallFile after translating * by ConvertFlagToValue */
if (n == FC_ERROR_LOADED_DRIVER) { int iIndex; BOOL bFound = FALSE; PIDRIVER pIDriver;
iIndex = (int)SendMessage(hlistbox, LB_GETCOUNT, 0, 0L);
/*
* The driver is in use : * * Search the list of curently installed drivers to see * if this file is one of them. If so tell the user to * de-install and re-start. */
while ( iIndex-- > 0 && !bFound) {
if ( (int)(pIDriver = (PIDRIVER)SendMessage(hlistbox, LB_GETITEMDATA, iIndex, 0L)) != LB_ERR) { if (!lstrcmpi(pIDriver->szFile, FileName(szFile))) { char sztemp[MAXSTR];
/*
* Found the driver description. * * Tell the user to un-install it and restart * windows so that it's not loaded. */
LoadString(myInstance, IDS_FILEINUSEREM, sztemp, sizeof(sztemp));
wsprintf(strBuf, sztemp, (LPSTR)pIDriver->szDesc); bFound = TRUE; } } } // while ( iIndex-- > 0 && !bFound)
/*
* If the driver is not currently installed then tell * the user to re-start in the hope that it will then * not be loaded (and so in use) * * Note that there is another case not catered for that * this is just a file in the driver's copy list which * failed to copy because it was 'in use'. */
if (!bFound) { iRestartMessage = IDS_FILEINUSEADD; DialogBox(myInstance, MAKEINTRESOURCE(DLG_RESTART), hMesgBoxParent, RestartDlg);
return(FC_ABORT); }
} else {
/*
* Tell the user there is a problem which we don't * understand here. */
LoadString(myInstance, IDS_UNABLE_TOINSTALL, strBuf, MAXSTR); } }
/*
* Put up the message box we have selected. */
MessageBox(hMesgBoxParent, strBuf, szFileError, MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
return (FC_ABORT);
}
/*----------------------------------------------------------------------------*\
| || wsInsertDisk() || || Handles errors, as the result of copying files. || |\*----------------------------------------------------------------------------*/UINT wsInsertDisk(LPSTR Disk, LPSTR szSrcPath){ UINT temp; int i;
/*
* Create the real disk letter */ for (i = 0; Disk[i] != '\0' && Disk[i] != ':'; i++) { CurrentDisk[i] = Disk[i]; } CurrentDisk[i] = '\0'; // Null terminate
szEdit = szSrcPath;
bFindOEM = TRUE; temp = (UINT)fDialog(DLG_INSERTDISK, GetActiveWindow(), wsDiskDlg); bFindOEM = FALSE; return(temp);}
/*----------------------------------------------------------------------------*
| wsDiskDlg( hDlg, uiMessage, wParam, lParam ) || || Arguments: || hDlg window handle of about dialog window || uiMessage message number || wParam message-dependent || lParam message-dependent || || Returns: || TRUE if message has been processed, else FALSE || |\*----------------------------------------------------------------------------*/
BOOL wsDiskDlg(HWND hDlg, UINT uiMessage, UINT wParam, LPARAM lParam){
switch (uiMessage) { case WM_COMMAND: switch (LOWORD(wParam)) { case IDH_DLG_INSERT_DISK: goto DoHelp;
case IDS_BROWSE:
/*
* Call the browse dialog to open drivers */
BrowseDlg(hDlg, 3); // index 3 points to no filter
// - see szFilter
break;
case IDOK:
/*
* szEdit points to the path that will be retried * if the copy fails */
GetDlgItemText(hDlg, ID_EDIT, szEdit, MAX_PATH); RemoveSpaces(szDiskPath, szEdit); lstrcpy(szEdit, szDiskPath); EndDialog(hDlg, FC_RETRY); UpdateWindow(hMesgBoxParent); break;
case IDCANCEL: EndDialog(hDlg, FC_ABORT); break; } return TRUE;
case WM_INITDIALOG: {
char DisksSection[MAXSTR];
/*
* now look in the [disks] section for the disk name * the disk name is the second field. */
char buf[MAXSTR]; char buf2[MAXSTR]; char bufout[MAXSTR];
*buf = '\0';
/*
* See what the name of the section should be */
LoadString(myInstance, IDS_DISKS, DisksSection, sizeof(DisksSection));
infGetProfileString(NULL, DisksSection, CurrentDisk, (LPSTR)buf);
if (*buf) {
/*
* Position of description in Windows NT */
infParseField(buf, 1, buf2); } else {
/*
* Didn't find the section we were looking for so try * the old names */
infGetProfileString(NULL, "disks", CurrentDisk, (LPSTR)buf); if (!*buf) infGetProfileString(NULL, "oemdisks", CurrentDisk, (LPSTR)buf);
if (!*buf) { return FALSE; }
infParseField(buf, 2, buf2); }
wsprintf(bufout, szKnown, (LPSTR)buf2, (LPSTR)szDrv); SetDlgItemText(hDlg,ID_TEXT,bufout); SetDlgItemText(hDlg,ID_EDIT,szEdit);
return TRUE; } default: if (uiMessage == wHelpMessage) {DoHelp: WinHelp(hDlg, szDriversHlp, HELP_CONTEXT, IDH_DLG_INSERT_DISK); return TRUE; } else return FALSE; break; }}
/*--------------------------------------------------------------------------
* * Function : wsCopySingleStatus * File copying callback routine * * Parameters : * msg - Which callback function * n - various * szFile - which file * * this call back only copies it's file if it does not exist in the * path. * *--------------------------------------------------------------------------*/
UINT wsCopySingleStatus(int msg, DWORD n, LPSTR szFile) { OFSTRUCT ofs; char szFullPath[MAX_PATH]; char szDriverExists[MAXSTR];
switch (msg) { case COPY_INSERTDISK: return wsInsertDisk((LPSTR)n, szFile);
case COPY_ERROR: return wsCopyError((int)n, szFile);
case COPY_QUERYCOPY:
/*
* See if the file already exists in the windows system * directory */
GetSystemDirectory(szFullPath, MAX_PATH);
if (IsFileKernelDriver(szFile)) { lstrcat(szFullPath, "\\drivers"); }
lstrcat(szFullPath, "\\");
lstrcat(szFullPath, RemoveDiskId(szFile));
if (OpenFile(szFullPath, &ofs, OF_EXIST|OF_SHARE_DENY_NONE) >= 0) { /*
* DriverCopy remembers whether to copy from * current or new after we have queried the user * once */
static int DriverCopy;
if (bQueryExist) { bQueryExist = FALSE;
LoadString(myInstance, IDS_DRIVER_EXISTS, szDriverExists, sizeof(szDriverExists));
wsprintf(szErrMsg, szDriverExists, FileName(szFile));
/*
* Ask the user whether to copy or not ? */
DriverCopy = DialogBox(myInstance, MAKEINTRESOURCE(DLG_EXISTS), hMesgBoxParent, wsExistDlg); }
return DriverCopy; } else {
return CopyNew; }
case COPY_START: case COPY_END: SetErrorMode(msg == COPY_START); // don't crit error on us
break; } return FC_IGNORE; }
/*
* Function : wsExistDlg - 'File exists' dialog */
BOOL wsExistDlg(HWND hDlg, UINT uiMessage, UINT wParam, LPARAM lParam) { switch (uiMessage) { case WM_COMMAND: switch (LOWORD(wParam)) { case ID_CURRENT:
EndDialog(hDlg, CopyCurrent); break;
case ID_NEW:
/*
* User selected to copy the new files over the * existing ones */
EndDialog(hDlg, CopyNew); break;
case IDCANCEL: EndDialog(hDlg, CopyNeither); // Cancel
break; } return TRUE;
case WM_INITDIALOG: SetDlgItemText(hDlg, ID_STATUS2, szErrMsg); return TRUE;
default: break; } return FALSE; }
/*
* Function : RemoveSpaces * Copies a string removing leading and trailing spaces but allowing * for long file names with internal spaces. * * Parameters : * szPath - The output result * szEdit - The input path */
VOID RemoveSpaces(LPTSTR szPath, LPTSTR szEdit) { LPTSTR szLastSpaceList;
while (*szEdit == ' ') { szEdit = CharNext(szEdit); }
lstrcpy(szPath, szEdit);
for (szLastSpaceList = NULL; *szPath != TEXT('\0'); szPath = CharNext(szPath)) {
if (*szPath == ' ') { if (szLastSpaceList == NULL) { szLastSpaceList = szPath; } } else { szLastSpaceList = NULL; }
}
if (szLastSpaceList != NULL) { *szLastSpaceList = TEXT('\0'); } }
|
