//+---------------------------------------------------------------------------- // // Job Object Handler // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1996. // // File: persist.cxx // // Contents: persistent storage methods // // Classes: CJob (continued) // // Interfaces: IPersist, IPersistFile // // History: 24-May-95 EricB created // 19-Jul-97 AnirudhS Rewrote SaveP and LoadP to minimize calls // to ReadFile, WriteFile and LocalAlloc // //----------------------------------------------------------------------------- #include "..\pch\headers.hxx" #pragma hdrstop #include #include "job.hxx" #include "defines.hxx" #if !defined(_CHICAGO_) #include "SASecRPC.h" // Get/SetAccountInformation RPC definition. #endif // !defined(_CHICAGO_) #include "proto.hxx" #include "security.hxx" #include "..\svc_core\lsa.hxx" #define JOB_SIGNATURE_VERSION 1 // data version we write #define JOB_SIGNATURE_CLIENT_VERSION 1 // software version we are #define JOB_SIGNATURE_MIN_CLIENT_VERSION 1 // min s/w version that can // read data we write struct JOB_SIGNATURE_HEADER { WORD wSignatureVersion; WORD wMinClientVersion; }; void GenerateUniqueID(GUID * pUuid); BOOL ReadString(CInputBuffer * pBuf, LPWSTR *ppwsz); // // This array of members is used to iterate through the string fields // of a CJob that are initially held in m_MainBlock. // LPWSTR CJob::* const CJob::s_StringField[] = { &CJob::m_pwszApplicationName, &CJob::m_pwszParameters, &CJob::m_pwszWorkingDirectory, &CJob::m_pwszCreator, &CJob::m_pwszComment }; // IPersist method //+---------------------------------------------------------------------------- // // Member: CJob::IPersist::GetClassID // // Synopsis: supplies VBScript class object CLSID // //----------------------------------------------------------------------------- STDMETHODIMP CJob::GetClassID(CLSID * pClsID) { TRACE(CJob, GetClassID); *pClsID = CLSID_CTask; return S_OK; } // IPersistFile methods //+---------------------------------------------------------------------------- // // Member: CJob::IPersistFile::IsDirty // // Synopsis: checks for changes since it was last saved // //----------------------------------------------------------------------------- STDMETHODIMP CJob::IsDirty(void) { TRACE3(CJob,IsDirty); return (IsFlagSet(JOB_I_FLAG_PROPERTIES_DIRTY) || IsFlagSet(JOB_I_FLAG_TRIGGERS_DIRTY) || IsFlagSet(JOB_I_FLAG_SET_ACCOUNT_INFO)) ? S_OK : S_FALSE; } //+---------------------------------------------------------------------------- // // Member: CJob::IPersistFile::Load // // Synopsis: loads the job object indicated by the given filename // // Arguments: [pwszFileName] - name of the job object file // [dwMode] - open mode, currently ignored. // // Notes: All OLE32 strings are UNICODE, including the filename passed // in the IPersistFile methods. One Win9x, all file names must // be in ANSI strings, thus the conversion and call to LoadP. //----------------------------------------------------------------------------- STDMETHODIMP CJob::Load(LPCOLESTR pwszFileName, DWORD dwMode) { HRESULT hr; #if defined(UNICODE) hr = LoadP(pwszFileName, dwMode, TRUE, TRUE); #else // first convert filename to ANSI CHAR szFileName[MAX_PATH + 1]; hr = UnicodeToAnsi(szFileName, pwszFileName, ARRAY_LEN(szFileName)); if (FAILED(hr)) { return STG_E_INVALIDPARAMETER; } hr = LoadP(szFileName, dwMode, TRUE, TRUE); #endif return hr; } //+---------------------------------------------------------------------------- // // Member: CJob::LoadP, private // // Synopsis: private load method that takes a TCHAR filename // // Arguments: [ptszFileName] - name of the job object file // [dwMode] - open mode, currently ignored. // [fRemember] - save the file name? // [fAllData] - if TRUE, load the entire job. If false, load // only the fixed length data at the head of the // job file + the job command. // //----------------------------------------------------------------------------- HRESULT CJob::LoadP( LPCTSTR ptszFileName, DWORD dwMode, BOOL fRemember, BOOL fAllData ) { TRACE3(CJob, LoadP); HRESULT hr = S_OK; BYTE * HeapBlock = NULL; //WCHAR tszFileName[MAX_PATH + 1] = L""; // // check the file name // //if (!CheckFileName((LPOLESTR)ptszFileName, tszFileName, NULL)) //{ // return E_INVALIDARG; //} // // Save the file name? // if (fRemember) { LPTSTR ptsz = new TCHAR[lstrlen(ptszFileName) + 1]; if (!ptsz) { ERR_OUT("CJob::LoadP", E_OUTOFMEMORY); return E_OUTOFMEMORY; } if (m_ptszFileName) { delete m_ptszFileName; } m_ptszFileName = ptsz; lstrcpy(m_ptszFileName, ptszFileName); } // // Open the file. // HANDLE hFile = CreateFile(ptszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL); if (hFile == INVALID_HANDLE_VALUE) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Load, file open", hr); return hr; } if (fRemember) { m_fFileCreated = TRUE; } // // Get the file size. // DWORD dwFileSize; { DWORD dwFileSizeHigh; DWORD dwError; dwFileSize = GetFileSize(hFile, &dwFileSizeHigh); if (dwFileSize == 0xFFFFFFFF && (dwError = GetLastError()) != NO_ERROR) { hr = HRESULT_FROM_WIN32(dwError); ERR_OUT("CJob::Load, GetFileSize", hr); goto Cleanup; } if (dwFileSizeHigh > 0) { hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA); schDebugOut((DEB_ERROR, "CJob::Load: file too big, SizeHigh = %u\n", dwFileSizeHigh)); goto Cleanup; } } if (dwFileSize < sizeof(FIXDLEN_DATA)) { hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA); schDebugOut((DEB_ERROR, "CJob::Load: file too small, size = %u\n", dwFileSize)); goto Cleanup; } // // Read the entire file into memory. // HeapBlock = new BYTE[dwFileSize]; if (HeapBlock == NULL) { hr = E_OUTOFMEMORY; ERR_OUT("CJob::Load, buffer alloc", hr); goto Cleanup; } DWORD dwBytesRead; if (!ReadFile(hFile, HeapBlock, dwFileSize, &dwBytesRead, NULL)) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Load, read file", hr); delete [] HeapBlock; goto Cleanup; } if (dwBytesRead != dwFileSize) { hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA); ERR_OUT("CJob::Load bytes read", hr); delete [] HeapBlock; goto Cleanup; } // // Close the file. // CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; // // Free old values of properties that we are about to read, and switch // to the new heap block. // FreeProperties(); m_MainBlock.Set(HeapBlock, dwFileSize); // // Get the fixed length Job data. // (We already verified that the file is at least as big as FIXDLEN_DATA.) // { // scope flData and CInputBuffer to avoid "initialization skipped" error const FIXDLEN_DATA& flData = *(FIXDLEN_DATA *)&HeapBlock[0]; CInputBuffer Buf(&HeapBlock[sizeof FIXDLEN_DATA], &HeapBlock[dwFileSize]); // // Check the version. // // Here is where, in future versions, we would look at the version // properties to determine how to read the job properties. // For now, though, we just reject old versions as being invalid. // #ifdef IN_THE_FUTURE if (m_wVersion != flData.wVersion) { fNewVersion = TRUE; // // Add version specific processing here. // } #else // !IN_THE_FUTURE if (m_wFileObjVer != flData.wFileObjVer) { hr = SCHED_E_UNKNOWN_OBJECT_VERSION; ERR_OUT("CJob::Load invalid object version", 0); goto Cleanup; } #endif // !IN_THE_FUTURE //schDebugOut((DEB_TRACE, "Load: job object version: %d.%d, build %d\n", // HIBYTE(flData.wVersion), LOBYTE(flData.wVersion), // flData.wFileObjVer)); m_wVersion = flData.wVersion; m_wFileObjVer = flData.wFileObjVer; m_uuidJob = flData.uuidJob; m_wTriggerOffset = flData.wTriggerOffset; m_wErrorRetryCount = flData.wErrorRetryCount; m_wErrorRetryInterval = flData.wErrorRetryInterval; m_wIdleWait = flData.wIdleWait; m_wIdleDeadline = flData.wIdleDeadline; m_dwPriority = flData.dwPriority; m_dwMaxRunTime = flData.dwMaxRunTime; m_ExitCode = flData.ExitCode; m_hrStatus = flData.hrStatus; m_rgFlags = flData.rgFlags; m_stMostRecentRunTime = flData.stMostRecentRunTime; hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA); if (!Buf.Read(&m_cRunningInstances, sizeof m_cRunningInstances)) { ERR_OUT("CJob::Load, read Running Instance Count", 0); goto Cleanup; } // // Get the variable length Job properties. // // In all cases, retrieve the job application name. // (Notice that flData.wAppNameLenOffset is not honored. We have to // leave it this way now for backward compatibility.) // if (!ReadString(&Buf, &m_pwszApplicationName)) { goto Cleanup; } // // If a full load, retrieve the rest of the variable length data, // including the triggers. // if (fAllData) { // Strings if (!(ReadString(&Buf, &m_pwszParameters) && ReadString(&Buf, &m_pwszWorkingDirectory) && ReadString(&Buf, &m_pwszCreator) && ReadString(&Buf, &m_pwszComment) )) { goto Cleanup; } // User Data size if (!Buf.Read(&m_cbTaskData, sizeof m_cbTaskData)) { goto Cleanup; } // User Data if (m_cbTaskData == 0) { m_pbTaskData = NULL; } else { m_pbTaskData = Buf.CurrentPosition(); if (!Buf.Advance(m_cbTaskData)) { goto Cleanup; } } // Size of reserved data if (!Buf.Read(&m_cReserved, sizeof m_cReserved)) { goto Cleanup; } // Reserved data // // If there is reserved data, it must begin with a structure // that we recognize. In this version we recognize the // TASKRESERVED1 structure. // m_pbReserved = NULL; if (m_cReserved == 0) { // // There is no reserved data. Initialize the members that // we would have read from the reserved data to defaults. // m_hrStartError = SCHED_S_TASK_HAS_NOT_RUN; m_rgTaskFlags = 0; } else if (m_cReserved < sizeof(TASKRESERVED1)) { ERR_OUT("CJob::Load, invalid reserved data", hr); m_cReserved = 0; goto Cleanup; } else { m_pbReserved = Buf.CurrentPosition(); if (!Buf.Advance(m_cReserved)) { goto Cleanup; } // // Copy the portion of the Reserved Data that we understand // into private data members. // It may not be aligned properly, so use CopyMemory. // TASKRESERVED1 Reserved; CopyMemory(&Reserved, m_pbReserved, sizeof Reserved); m_hrStartError = Reserved.hrStartError; m_rgTaskFlags = Reserved.rgTaskFlags; } // // Load trigger data. // hr = this->_LoadTriggersFromBuffer(&Buf); if (FAILED(hr)) { ERR_OUT("Loading triggers from storage", hr); goto Cleanup; } #if !defined(_CHICAGO_) // // If there is more data after the triggers, it must begin with a // signature header and a signature. If there is less data than // that, treat it as though the file has no signature. // If a signature is present, but its "minimum client version" is // greater than our version, treat it as though the file has no // signature. // JOB_SIGNATURE_HEADER SignHead; if (Buf.Read(&SignHead, sizeof SignHead) && SignHead.wMinClientVersion <= JOB_SIGNATURE_CLIENT_VERSION) { m_pbSignature = Buf.CurrentPosition(); if (!Buf.Advance(SIGNATURE_SIZE)) { schDebugOut((DEB_ERROR, "CJob::Load: si too small, ignoring\n")); m_pbSignature = NULL; } } // else m_pbSignature was set to NULL in FreeProperties #endif // !defined(_CHICAGO_) } } // end CInputBuffer and flData scope hr = S_OK; Cleanup: // // Close the file. // if (hFile != INVALID_HANDLE_VALUE) { CloseHandle(hFile); } return hr; } //+---------------------------------------------------------------------------- // // Member: CJob::SaveP, private // // Synopsis: saves the object to storage, takes a TCHAR file name // // Arguments: [ptszFileName] - if null, save to the previously loaded file. // [fRemember] - if TRUE, the object becomes associated with // the new filename. // [flOptions] - can have the following bits set: // SAVEP_VARIABLE_LENGTH_DATA: // if set, saves all job data except the running // instance count. If not set, saves // only the fixed length data at the beginning // of the job. The file must already exist (the // filename must be NULL) in this case. // // SAVEP_RUNNING_INSTANCE_COUNT: // if set, the running instance count is saved // // SAVEP_PRESERVE_NET_SCHEDULE: // if NOT set, the JOB_I_FLAG_NET_SCHEDULE flag // is automatically cleared. // // Returns: HRESULT codes. // //----------------------------------------------------------------------------- HRESULT CJob::SaveP(LPCTSTR ptszFileName, BOOL fRemember, ULONG flOptions) { TRACE3(CJob, SaveP); HRESULT hr = S_OK; HANDLE hFile; #if !defined(_CHICAGO_) BOOL fSetSecurity = FALSE; #endif // !defined(_CHICAGO_) // // Decide which name to save the file as. Use the one passed in if // there is one, otherwise use the previously remembered one. // LPCTSTR ptszFileToSaveAs = ptszFileName ? ptszFileName : m_ptszFileName; if (!(ptszFileToSaveAs && *ptszFileToSaveAs)) { // // Can't do a save if there is no file name. // return E_INVALIDARG; } // // Figure out whether we will create a new file or open an existing one. // If using the passed in filename, then this is a save-as (or if // fRemember is false, a save-copy-as) operation and a new file must // be created. // If using the previously remembered filename, then a new file must // be created iff the file wasn't saved before. // DWORD dwDisposition; DWORD dwAttributes; if (!(ptszFileToSaveAs == m_ptszFileName && m_fFileCreated)) { dwDisposition = CREATE_NEW; if (!(flOptions & SAVEP_VARIABLE_LENGTH_DATA)) { // // Creating a new file is only valid if all the data is to be // saved. Otherwise we would end up with a partial (invalid) file. // return E_INVALIDARG; } dwAttributes = FILE_ATTRIBUTE_NORMAL; if (IsFlagSet(TASK_FLAG_HIDDEN)) { dwAttributes = FILE_ATTRIBUTE_HIDDEN; } // // Always write running instance count on file create. // flOptions |= SAVEP_RUNNING_INSTANCE_COUNT; // // On file creation, generate a unique ID for this job. // Done for Win95 as well as NT. // GenerateUniqueID(&m_uuidJob); #if !defined(_CHICAGO_) // // Set security on file creation. This is done after all writes // have succeeded and the file has been closed. // fSetSecurity = TRUE; #endif // !defined(_CHICAGO_) } else { // // This is a save to an existing file. // dwDisposition = OPEN_EXISTING; dwAttributes = GetFileAttributes(m_ptszFileName); if (dwAttributes == -1) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Save, GetFileAttributes", hr); return hr; } DWORD dwOrgAttributes = dwAttributes; // // Remove the read-only attribute. // dwAttributes &= ~FILE_ATTRIBUTE_READONLY; // // If the hidden flag is set and the hidden attribute has // not been set yet, set it now. // if (IsFlagSet(TASK_FLAG_HIDDEN)) { dwAttributes |= FILE_ATTRIBUTE_HIDDEN; } if (dwAttributes != dwOrgAttributes) { SetFileAttributes(m_ptszFileName, dwAttributes); } } // // Create/Open the file. // hFile = CreateFile(ptszFileToSaveAs, GENERIC_WRITE, 0, NULL, dwDisposition, dwAttributes | FILE_FLAG_SEQUENTIAL_SCAN, NULL); if (hFile == INVALID_HANDLE_VALUE) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Save, file open/create", hr); return hr; } if (fRemember || ptszFileToSaveAs == m_ptszFileName) { m_fFileCreated = TRUE; } // // Initialize the creator property if not already done so. // Set it to the caller's username. // if (m_pwszCreator == NULL) { // // Other than out of memory, if an error occurs, leave the // creator field alone. // TCHAR tszUserName[MAX_USERNAME + 1]; DWORD ccUserName = MAX_USERNAME + 1; if (GetUserName(tszUserName, &ccUserName)) { // NB : GetUserName returned char count includes the null // character. // m_pwszCreator = new WCHAR[ccUserName]; if (m_pwszCreator == NULL) { hr = E_OUTOFMEMORY; CHECK_HRESULT(hr); goto ErrExit; } #if defined(UNICODE) lstrcpy(m_pwszCreator, tszUserName); #else hr = AnsiToUnicode(m_pwszCreator, tszUserName, ccUserName); Win4Assert(SUCCEEDED(hr)); #endif // defined(UNICODE) } } { // scope to avoid "initialization skipped" error BOOL fUpdateJobState = FALSE; // // The disabled flag takes precedence over other states except running. // if (IsFlagSet(TASK_FLAG_DISABLED)) { if (!IsStatus(SCHED_S_TASK_RUNNING)) { SetStatus(SCHED_S_TASK_DISABLED); } } else { if (IsStatus(SCHED_S_TASK_DISABLED)) { // // UpdateJobState will set the correct status if no longer // disabled. // fUpdateJobState = TRUE; } } // // Check to see if the triggers are dirty. If so, update the job status // and flags before writing it out. // if (IsFlagSet(JOB_I_FLAG_TRIGGERS_DIRTY)) { fUpdateJobState = TRUE; } // // The flag value JOB_I_FLAG_RUN_PROP_CHANGE is never written to disk. // Instead, the need for a wait list rebuild is signalled by clearing // JOB_I_FLAG_NO_RUN_PROP_CHANGE. If JOB_I_FLAG_RUN_PROP_CHANGE were to be // written to disk, then CheckDir would see this bit set and do a wait // list rebuild, but it would also need to clear the bit to prevent // successive wait list rebuilds. However, the write to clear the bit // would cause an additional change notification and CheckDir call. So, to // avoid this thrashing, we signal a wait list rebuild by the absence of // the JOB_I_FLAG_NO_RUN_PROP_CHANGE bit. // if (IsFlagSet(JOB_I_FLAG_RUN_PROP_CHANGE)) { ClearFlag(JOB_I_FLAG_RUN_PROP_CHANGE); ClearFlag(JOB_I_FLAG_NO_RUN_PROP_CHANGE); fUpdateJobState = TRUE; } if (fUpdateJobState) { UpdateJobState(FALSE); } // // Regenerate a unique id for the job (a GUID) when the application // changes. This is done for security reasons. // // NB : We need to do this for Win95 as well as NT since we may be // editing an NT job from a Win95 machine. // if (IsFlagSet(JOB_I_FLAG_APPNAME_CHANGE)) { GenerateUniqueID(&m_uuidJob); ClearFlag(JOB_I_FLAG_APPNAME_CHANGE); } if (!(flOptions & SAVEP_PRESERVE_NET_SCHEDULE)) { ClearFlag(JOB_I_FLAG_NET_SCHEDULE); } // // Save Job fixed length data. // // Allocate a stack buffer which will be sufficient if we are not // saving variable length data. // Note that sizeof flStruct > sizeof FIXDLEN_DATA + sizeof WORD, // due to struct packing requirements, so don't use sizeof flStruct // to compute offsets. // struct FLSTRUCT { FIXDLEN_DATA flData; WORD cRunningInstances; } flStruct; // This code depends on flData and cRunningInstances being contiguous schAssert(FIELD_OFFSET(FLSTRUCT, cRunningInstances) == sizeof FIXDLEN_DATA); flStruct.flData.wVersion = m_wVersion; flStruct.flData.wFileObjVer = m_wFileObjVer; flStruct.flData.uuidJob = m_uuidJob; flStruct.flData.wAppNameLenOffset = sizeof(FIXDLEN_DATA) + sizeof(m_cRunningInstances); flStruct.flData.wTriggerOffset = m_wTriggerOffset; flStruct.flData.wErrorRetryCount = m_wErrorRetryCount; flStruct.flData.wErrorRetryInterval = m_wErrorRetryInterval; flStruct.flData.wIdleWait = m_wIdleWait; flStruct.flData.wIdleDeadline = m_wIdleDeadline; flStruct.flData.dwPriority = m_dwPriority; flStruct.flData.dwMaxRunTime = m_dwMaxRunTime; flStruct.flData.ExitCode = m_ExitCode; flStruct.flData.hrStatus = m_hrStatus; // // Don't save the dirty & set account information flags. // flStruct.flData.rgFlags = m_rgFlags & ~NON_PERSISTED_JOB_FLAGS; flStruct.flData.stMostRecentRunTime = m_stMostRecentRunTime; flStruct.cRunningInstances = m_cRunningInstances; // // Compute the number of bytes to write to the file. This will be // the size of the intermediate buffer to be allocated. // BYTE * pSource = (BYTE *) &flStruct; DWORD cbToWrite = sizeof(flStruct.flData); // // Save the running instance data only if (a) the file is being created, // or (b) the SAVEP_RUNNING_INSTANCE_COUNT option is set. // If SAVEP_VARIABLE_LENGTH_DATA is set, allocate temporary space for the // running instance count, regardless of whether we are going to write it. // if (flOptions & (SAVEP_RUNNING_INSTANCE_COUNT | SAVEP_VARIABLE_LENGTH_DATA)) { cbToWrite += sizeof(flStruct.cRunningInstances); } if (flOptions & SAVEP_VARIABLE_LENGTH_DATA) { // // Add the space needed to write the strings and their lengths. // Save the lengths for use later. // WORD acStringLen[ARRAY_LEN(s_StringField)]; // array of string lengths cbToWrite += sizeof acStringLen; for (int i = 0; i < ARRAY_LEN(acStringLen); i++) { LPWSTR pwsz = this->*s_StringField[i]; acStringLen[i] = (pwsz && *pwsz) ? wcslen(pwsz) + 1 : 0; cbToWrite += acStringLen[i] * sizeof WCHAR; } // // Add the space needed to write the user data, the reserved data // and their lengths. // if (m_cReserved < sizeof TASKRESERVED1) { schAssert(m_cReserved == 0); m_cReserved = sizeof TASKRESERVED1; } cbToWrite += sizeof(m_cbTaskData) + m_cbTaskData + sizeof(m_cReserved) + m_cReserved; // // cbToWrite is now the offset to the trigger data. Save it. // schAssert(cbToWrite <= MAXUSHORT); // BUGBUG Do NOT just assert. // Also return a "limit exceeded" error. flStruct.flData.wTriggerOffset = m_wTriggerOffset = (WORD) cbToWrite; // // Add the space needed to write the triggers and their count. // WORD cTriggers = m_Triggers.GetCount(); cbToWrite += sizeof cTriggers + cTriggers * sizeof TASK_TRIGGER; #if !defined(_CHICAGO_) // // If the job has a signature, add the space needed to write it. // if (m_pbSignature != NULL) { cbToWrite += sizeof(JOB_SIGNATURE_HEADER) + SIGNATURE_SIZE; } #endif // !defined(_CHICAGO_) // // We have now computed the required space. Allocate a buffer of // that size. // pSource = new BYTE[cbToWrite]; if (pSource == NULL) { hr = E_OUTOFMEMORY; goto ErrExit; } // // Copy data into the buffer. // BYTE * pCurrent = pSource; // current write position #define WRITE_DATA(pSrc, cbSize) \ CopyMemory(pCurrent, (pSrc), (cbSize)); \ pCurrent += (cbSize); // FIXDLEN_DATA and Running Instance Count WRITE_DATA(&flStruct, sizeof flStruct.flData + sizeof flStruct.cRunningInstances); // Strings for (i = 0; i < ARRAY_LEN(acStringLen); i++) { schAssert(POINTER_IS_ALIGNED(pCurrent, ALIGN_WORD)); *(WORD *) pCurrent = acStringLen[i]; pCurrent += sizeof WORD; WRITE_DATA(this->*s_StringField[i], acStringLen[i] * sizeof WCHAR); } // User data schAssert(POINTER_IS_ALIGNED(pCurrent, ALIGN_WORD)); *(WORD *) pCurrent = m_cbTaskData; pCurrent += sizeof WORD; WRITE_DATA(m_pbTaskData, m_cbTaskData); // Note that pCurrent may no longer be WORD-aligned // Reserved data WRITE_DATA(&m_cReserved, sizeof m_cReserved); // Copy private members into the reserved data block to save TASKRESERVED1 Reserved1 = { m_hrStartError, m_rgTaskFlags }; if (m_pbReserved == NULL) { schAssert(m_cReserved == sizeof Reserved1); WRITE_DATA(&Reserved1, m_cReserved); } else { schAssert(m_cReserved >= sizeof Reserved1); CopyMemory(m_pbReserved, &Reserved1, sizeof Reserved1); WRITE_DATA(m_pbReserved, m_cReserved); } // Triggers WRITE_DATA(&cTriggers, sizeof cTriggers); WRITE_DATA(m_Triggers.GetArray(), sizeof TASK_TRIGGER * cTriggers); #if !defined(_CHICAGO_) // Signature if (m_pbSignature != NULL) { JOB_SIGNATURE_HEADER SignHead; SignHead.wSignatureVersion = JOB_SIGNATURE_VERSION; SignHead.wMinClientVersion = JOB_SIGNATURE_MIN_CLIENT_VERSION; WRITE_DATA(&SignHead, sizeof SignHead); WRITE_DATA(m_pbSignature, SIGNATURE_SIZE); } #endif // !defined(_CHICAGO_) #undef WRITE_DATA schAssert(pCurrent == pSource + cbToWrite); } // // Actually write the data to the file // if ((flOptions & SAVEP_VARIABLE_LENGTH_DATA) && !(flOptions & SAVEP_RUNNING_INSTANCE_COUNT)) { // // Write FIXDLEN_DATA, skip over the running instance count, and // write the variable length data // DWORD cbWritten; if (!WriteFile(hFile, pSource, sizeof FIXDLEN_DATA, &cbWritten, NULL) || cbWritten != sizeof FIXDLEN_DATA) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Save, write of Job fixed length data", hr); goto Cleanup; } DWORD dwNewPos = SetFilePointer(hFile, sizeof(m_cRunningInstances), NULL, FILE_CURRENT); if (dwNewPos == 0xffffffff) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Save, moving past running instance count", hr); goto Cleanup; } cbToWrite -= (sizeof FIXDLEN_DATA + sizeof m_cRunningInstances); if (!WriteFile(hFile, pSource + (sizeof FIXDLEN_DATA + sizeof m_cRunningInstances), cbToWrite, &cbWritten, NULL) || cbWritten != cbToWrite) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Save, write of Job variable length data", hr); goto Cleanup; } } else { // // We can do it all in a single WriteFile. // DWORD cbWritten; if (!WriteFile(hFile, pSource, cbToWrite, &cbWritten, NULL) || cbWritten != cbToWrite) { hr = HRESULT_FROM_WIN32(GetLastError()); ERR_OUT("CJob::Save, write of Job", hr); goto Cleanup; } } if ((flOptions & SAVEP_VARIABLE_LENGTH_DATA) && !SetEndOfFile(hFile)) { ERR_OUT("CJob::Save, SetEOF", HRESULT_FROM_WIN32(GetLastError())); } Cleanup: CloseHandle(hFile); hFile = NULL; if (pSource != (BYTE *) &flStruct) { delete [] pSource; } if (FAILED(hr)) { goto ErrExit; } } // end scope // // Notify the shell of the changes. // if (ptszFileName != NULL) { SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, ptszFileName, NULL); } else { SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, m_ptszFileName, NULL); } // // If doing a Save-As, save the new filename. // if (fRemember && ptszFileName != NULL) { delete m_ptszFileName; m_ptszFileName = new TCHAR[lstrlen(ptszFileName) + 1]; if (!m_ptszFileName) { ERR_OUT("CJob::SaveP", E_OUTOFMEMORY); hr = E_OUTOFMEMORY; goto ErrExit; } lstrcpy(m_ptszFileName, ptszFileName); } if (ptszFileName == NULL || fRemember) { // // BUGBUG: this is not strictly accurate. There could be a dirty // string prop that wouldn't be saved during a light save // (SAVEP_VARIABLE_LENGTH_DATA not specified). This source of // potential error could be alleviated by breaking // JOB_I_FLAG_PROPERTIES_DIRTY into two flags: // JOB_I_FLAG_FIXED_PROPS_DIRTY & JOB_I_FLAG_VAR_PROPS_DIRTY // ClearFlag(JOB_I_FLAG_PROPERTIES_DIRTY); if (flOptions & SAVEP_VARIABLE_LENGTH_DATA) { ClearFlag(JOB_I_FLAG_TRIGGERS_DIRTY); } } #if !defined(_CHICAGO_) // // Set default privileges on the file. This is done only for new // files created as a result of save. // if (fSetSecurity) { // // NB : Logic prior to CreateFile guarantees the file name // will not be NULL. // hr = SetTaskFileSecurity(ptszFileToSaveAs, this->IsFlagSet(JOB_I_FLAG_NET_SCHEDULE)); if (FAILED(hr)) { goto ErrExit; } } #endif // !defined(_CHICAGO_) return S_OK; ErrExit: if (hFile != NULL) CloseHandle(hFile); if (dwDisposition == CREATE_NEW) { if (!DeleteFile(ptszFileToSaveAs)) { ERR_OUT("CJob::SaveP: DeleteFile", GetLastError()); } } return hr; } //+---------------------------------------------------------------------------- // // Member: CJob::IPersistFile::SaveCompleted // // Synopsis: indicates the caller has saved the file with a call to // IPersistFile::Save and is finished working with it // //----------------------------------------------------------------------------- STDMETHODIMP CJob::SaveCompleted(LPCOLESTR pwszFileName) { TRACE(CJob, SaveCompleted); return S_OK; } //+---------------------------------------------------------------------------- // // Member: CJob::IPersistFile::GetCurFile // // Synopsis: supplies either the absolute path of the currently loaded // script file or the default filename prompt, if there is no // currently-associated file // //----------------------------------------------------------------------------- STDMETHODIMP CJob::GetCurFile(LPOLESTR * ppwszFileName) { TRACE(CJob, GetCurFile); HRESULT hr; TCHAR * ptszName, tszDefaultName[SCH_SMBUF_LEN]; WCHAR * pwszName, * pwszBuf = NULL; if (!m_ptszFileName || m_ptszFileName[0] == TEXT('\0')) { // // No file currently loaded, return default prompt 'cause that is // what the OLE spec says to do. // lstrcpy(tszDefaultName, TEXT("*.") TSZ_JOB); ptszName = tszDefaultName; hr = S_FALSE; } else { ptszName = m_ptszFileName; hr = S_OK; } #if defined(UNICODE) pwszName = ptszName; #else // convert ANSI file name to UNICODE int cch = lstrlen(ptszName) + 1; // include null in count pwszBuf = new WCHAR[cch]; if (!pwszBuf) { ERR_OUT("CJob::GetCurFile", E_OUTOFMEMORY); *ppwszFileName = NULL; return E_OUTOFMEMORY; } hr = AnsiToUnicode(pwszBuf, ptszName, cch); if (FAILED(hr)) { CHECK_HRESULT(hr) delete pwszBuf; return E_FAIL; } pwszName = pwszBuf; #endif int size = wcslen(pwszName); LPOLESTR pwz; pwz = (LPOLESTR)CoTaskMemAlloc((size + 1) * sizeof(WCHAR)); if (!pwz) { #if !defined(UNICODE) delete pwszBuf; #endif *ppwszFileName = NULL; return E_OUTOFMEMORY; } wcscpy(pwz, pwszName); *ppwszFileName = pwz; #if !defined(UNICODE) delete pwszBuf; #endif return hr; } //+---------------------------------------------------------------------------- // // Member: CJob::FreeProperties // // Synopsis: Frees variable length property memory // //----------------------------------------------------------------------------- void CJob::FreeProperties(void) { for (int iProperty = 0; iProperty < ARRAY_LEN(s_StringField); iProperty++) { DELETE_CJOB_FIELD(this->*s_StringField[iProperty]) } DELETE_CJOB_FIELD(m_pbTaskData) m_cbTaskData = 0; DELETE_CJOB_FIELD(m_pbReserved) m_cReserved = 0; #if !defined(_CHICAGO_) DELETE_CJOB_FIELD(m_pbSignature) m_pbSignature = 0; #endif } //+---------------------------------------------------------------------------- // // Function: ReadString // // Synopsis: Reads a wide char string in from an in-memory buffer // //----------------------------------------------------------------------------- BOOL ReadString(CInputBuffer * pBuf, LPWSTR *ppwsz) { schAssert(POINTER_IS_ALIGNED(pBuf->CurrentPosition(), ALIGN_WORD)); schAssert(*ppwsz == NULL); // // Read the string length // WORD cch; if (!pBuf->Read(&cch, sizeof cch)) { ERR_OUT("ReadString, file lacks string length", 0); return FALSE; } if (cch != 0) { LPWSTR pwsz = (LPWSTR) pBuf->CurrentPosition(); // // The string length mustn't exceed the buffer size // if (!pBuf->Advance(cch * sizeof WCHAR)) { ERR_OUT("ReadString, string overruns file size", 0); return FALSE; } // // Verify null termination // if (pwsz[cch-1] != L'\0') { ERR_OUT("ReadString, string not null terminated", 0); return FALSE; } *ppwsz = pwsz; } return TRUE; } //+---------------------------------------------------------------------------- // // Function: GenerateUniqueID // // Synopsis: Intialize the UUID passed to a unique ID. On NT, UuidCreate // initializes it. If UuidCreate fails, default to our custom // ID generation code which is used always on Win95. // // Arguments: [pUuid] -- Ptr to UUID to initialize. // // Returns: None. // // Notes: None. // //----------------------------------------------------------------------------- void GenerateUniqueID(GUID * pUuid) { schAssert(pUuid != NULL); #if !defined(_CHICAGO_) // // Call UuidCreate only on NT. If this should fail, drop down to // our own id generation. // if (UuidCreate(pUuid) == RPC_S_OK) { return; } #endif // !defined(_CHICAGO_) // // Must generate our own unique id. // // Set Data 1 to the windows tick count. // pUuid->Data1 = GetTickCount(); // // Set Data2 & Data3 to the current system time milliseconds // and seconds values respectively. // SYSTEMTIME systime; GetSystemTime(&systime); pUuid->Data2 = systime.wMilliseconds; pUuid->Data3 = systime.wSecond; // // Write the passed uuid ptr address into the first 4 bytes of // Data4. Then write the current system time minute value into // the following 2. The remaining 2 we'll leave as-is. // CopyMemory(&pUuid->Data4, &pUuid, sizeof(GUID *)); CopyMemory((&pUuid->Data4) + sizeof(GUID *), &systime.wMinute, sizeof(systime.wMinute)); }