cluberti

The entire task sequence UI is customizable, for what it's worth - it's just an HTA with wsf scripts behind it. However, if it doesn't work for you, that's perfectly fine. You will need to automate the OOBE via your unattend - I'll ask tripredacus to come have a look at this thread.

I must ask - is there any specific reason you're attempting to accomplish this? Maybe there's a better way to get at the "this" than disabling something built-into the OS?

Look into using MDT 2010 for your build engineering - Sysprep in Windows 7 is indeed more complex, but it's also more powerful and is much more flexible. Using a tool like MDT as a front-end removes some of the complexity and makes it easier to create repeatable deployments that do what you want. I know I answered your question with a "go do this other thing", because while you can modify your unattend.xml to work around some of those things you're still going to run into issues. My response was more of a long-term solution.

Could be any number of reasons. Open a cmd prompt, run winsat /?, and look at the graphics sub-assessment options you can run for hints.

Well, SCCM really does have trouble with doing certain things as system (which is why a lot of SCCM 2007 functions got away from using the system account in the first place, like previous versions of SMS used to do). Part of the problem of using WMI as system is that WMI has it's own permissions above and beyond local filesystem or registry perms, so proper impersonation is paramount. You probably might have had better luck in using something like psexec to run the command as a real user account.

Using this as an image engineering solution via your role as a sysadmin for a college technically would be a violation of the nLite or vLite EULA - the college *may* pass the non-commercial clause depending on whether or not it's for profit, and/or whether or not it's a private enterprise or a public institution, but that is all fairly elementary as this most certainly fails the "personal-use" clause if this is being done on any scale larger than an installation for one singular PC to be used primarily, or only, by that sysadmin; I know this is not the case by reading this thread and noting the following: It is also worth stating that modification of Windows using nLite or vLite will void any supportability contract you have with Microsoft for that installation of Windows, and if the school is large enough it probably does have a volume license and/or academic licensing scheme for MS software that includes support - doing this would put you in violation of that agreement (and possibly the Windows EULA itself), so it's not just the nLite licensing you and your management should be aware of. This discussion was taken offline, but the nLite and vLite EULAs are *VERY* specific about this particular point, and I'm just not sure why some folks are having such a hard time with it. It's only legally licensed for use for personal non-commercial purposes and any company or business purposes are explicitly called out as a violation of the license (this is stated explicitly in the EULA itself, I am not taking this out of context or paraphrasing it); you have to pass *both* tests to meet licensing criteria. Just because you are using it for an organization that is non-commercial or not-for-profit does not absolve you of being in compliance with the other 50% of the requirement that the tool only be used for personal use. If you're unsure, ask if this is going to be used to assist you in doing a job for your employer, or if you are going to be using it to create an image that will go somewhere other than *only* your own personal PC. If you answer "yes" to either of those questions, you cannot use nLite or vLite, period, and be in compliance with the EULA. Also, an additional question - if the copies of Windows you're modifying are licensed under any sort of volume licensing deal with Microsoft (whether that be academic, charity, or business), or if you have a support contract with Microsoft for those copies of Windows, you will be violating the agreements for those if you use nLite or vLite to modify the Windows source, so avoid it at that point as well.

WMI would work, but you'd have to do some trial and error on impersonate to see what worked and what didn't. However, if you're using SCCM for it (and not using an installation "admin" account to run the script), your current method is probably the easiest to maintain, that is certain .

No worries, just thought it was amusing...

How about the sticky in this very section titled "setting/locking the explorer view"?

Slightly OT but still relevant, there are better ways to do permissions than using cacls, and those are xcacls.vbs, subinacl, or setacl, for what it's worth. It won't help you fix your script, but you should consider these alternatives if you do this often.

One thing to consider - vLite is for personal use only, so if you're using it in your PC shop you're probably violating the EULA. Plus, what you want to do can be easily replicated using other free tools with no such restrictions like MDT 2010.

You need to use the App Compat toolkit to create a custom .sdb database for the file if you're not going to use the GUI to install it - there's no command line parameter to enable compat mode. See this.

Moving images around could be done with the WAIK tools themselves (imagex), or with other tools like gimagex. If you're just exporting or importing images in a WIM, you don't need to use vLite.

Moved to nLite section where this question belongs.

What part is slow? Driver installation, print job queueing, print job actual printing, etc.??? More info, please.

Yes, that's at least using the MSI engine, which has very good logging capabilities. You can enable MSI package logging via the registry as per this KB article (it's for XP, but this also works on 2000, Vista, Win7, etc. - just fyi).

Well, you could write a filter driver to do just about anything - I was talking about a supported way of doing it out of the box. Leave it to you to find some crazy driver to do it .

Increasing the priority just means you're giving more CPU execution time to that process compared to others at a lower priority (which is basically anything but core windows system functions if we're talking about increasing a process priority to anything above normal priority). To give you some insight into how Windows works, and possible reasons why your changes are "fixing" things, you need to understand how Windows schedules threads to run on the processors available to it. It is important to remember that Windows deals in threads when it comes to scheduling, not processes - that means that when you increase the priority of a process, you are also increasing the default priority of each thread running in that process to the same priority as the process itself (well, in most situations - I'm avoiding some more obscure thread scheduling scenarios that change this in order to keep this simple). On a Windows system, each running thread gets a quantum that tells how long it can run on the CPU before it's swapped out for another thread. When a thread's current quantum has ended, if there's another thread that has a higher priority, or an equal priority and has not run in a set amount of time, it's context will be saved, and then swapped out for the context of a different thread - that thread then starts it's quantum on the CPU, and the cycle continues. When a thread reaches the end of it's current quantum, the scheduler checks to see if there are any other threads that have a higher priority that are ready to execute (and again, on Windows, really only critical base system functions run above normal priority). Anything with a higher priority will be scheduled to run, and the current thread's context will be swapped out and saved until the next time it has a chance to run. If nothing is found ready with a higher priority, the next check is made. The scheduler then checks to see if any threads at the same priority level that are ready to execute - any other thread on the ready list at the same priority at this time is scheduled, and the current thread's context is swapped out and saved until the next time it has a chance to run. If nothing is found ready with a higher priority, the next check is made. If nothing is found ready with the same priority level, the last check is made. The scheduler last checks to see if there are threads at any priority level that have not executed in some length of time, and need their priority boosted so that they're given time to run (otherwise, low priority threads would never run). If anything is found on the list to have not executed in a long length of time, it's priority is temporarily boosted to a higher one, the current thread's context is swapped out and saved, and that new thread is scheduled. Since most things on a Windows system will run normal priority, this doesn't happen often on a system that isn't incredibly busy. If all three of those checks find no threads that supersede this one at that time, it gives the currently running thread another quantum and it continues running. I'm postulating, along the lines Tripredacus is, that this might come down to something other than just a processor or system difference, especially if the new hardware replacing the older hardware is at least as powerful - this is likely more to do with things running on the box at the same time (if increasing the priority of a process "fixes" a performance issue, this is 99% of the time the most likely culprit).

Yeah, I remember that. I think you might want to find a new MCT.

I was helping you find the user that matched that SID, not finding the file. If you've got the file on disk in the $recycler folder under a SID, it's in that user's recycle bin (or was, and hasn't been deleted yet from disk). If logging on as that user doesn't show the file in the recycle bin to be restored, then the next safest way to get at it is to boot from a bootable environment on a DVD or USB key (like WinPE or a rescue CD) and copy the file off to a remote location, like an external hard disk drive. I generally work on the teach a man to fish model, for what it's worth . Also, I must ask that you please do not quote a large block of text in a reply if you're not going to specifically comment on it's contents - a simple reply would have sufficed. I've edited your previous post to remove the code you quoted to minimize the wasted space in the thread, as well as to be kind to those folks who visit here who are on slow internet connections.

I know of applications that can run on firewalls and proxies (like bandwidthsplitter for ISA/TMG), but perhaps others can provide more insight on host-based apps.

Hard to say, as I don't know how that app was written. I don't think it could hurt any worse, though .

Looks like a driver called Tpkd.sys is causing the crash by passing an invalid handle to a filter request: 2: kd> !thread fffffa800a53cb60 THREAD fffffa800a53cb60 Cid 1584.0efc Teb: 000000007efdb000 Win32Thread: fffff900d0d08c30 RUNNING on processor 2 IRP List: fffff98063164ee0: (0006,0118) Flags: 40060070 Mdl: 00000000 Not impersonating DeviceMap fffff8a0024bd210 Owning Process fffffa8007cdd060 Image: Authorization Wizard.exe Attached Process N/A Image: N/A Wait Start TickCount 107196 Ticks: 0 Context Switch Count 26232 LargeStack UserTime 00:00:00.093 KernelTime 00:00:02.839 Win32 Start Address 0x00000000007aed19 Stack Init fffff8800a3fcdb0 Current fffff8800a3fb830 Base fffff8800a3fd000 Limit fffff8800a3f4000 Call 0 Priority 9 BasePriority 8 UnusualBoost 0 ForegroundBoost 0 IoPriority 2 PagePriority 5 Child-SP RetAddr : Args to Child : Call Site fffff880`0a3fbe98 fffff800`03d4b3dc : 00000000`000000c4 00000000`000000f6 00000000`00000208 fffffa80`07cdd060 : nt!KeBugCheckEx fffff880`0a3fbea0 fffff800`03d60ae4 : 00000000`00000208 fffffa80`07cdd060 00000000`00000004 00000000`00000000 : nt!VerifierBugCheckIfAppropriate+0x3c fffff880`0a3fbee0 fffff800`03b1d580 : fffff880`02f64180 fffff880`0a3fc0e8 fffff880`0a3fc300 fffff880`0a3fc518 : nt!VfCheckUserHandle+0x1b4 fffff880`0a3fbfc0 fffff800`03bdd22c : 00000000`00000000 00000000`00000000 fffffa80`0744b750 fffffa80`07cdd000 : nt!ObReferenceObjectByHandleWithTag+0xffffffff`fff66d40 fffff880`0a3fc090 fffff800`03bddf16 : fffff880`0a3fcc20 00000000`00000000 00000000`00000000 00000000`00000000 : nt!IopXxxControlFile+0x17c fffff880`0a3fc1c0 fffff800`038c0853 : fffffa80`0a53cb60 fffff780`00001000 00000000`00000000 fffffa80`0a53cb60 : nt!NtDeviceIoControlFile+0x56 fffff880`0a3fc230 fffff800`038bcdf0 : fffff880`013e1072 fffffa80`034503f0 fffff781`c0000000 fffff800`03a4db40 : nt!KiSystemServiceCopyEnd+0x13 (TrapFrame @ fffff880`0a3fc2a0) fffff880`0a3fc438 fffff880`013e1072 : fffffa80`034503f0 fffff781`c0000000 fffff800`03a4db40 fffff800`038f9dd2 : nt!KiServiceLinkage fffff880`0a3fc440 fffff880`013e46a5 : fffff880`013f3840 00000000`00000208 00000000`00000000 00000000`00000000 : Tpkd+0x6072 fffff880`0a3fc4a0 fffff880`013e7453 : fffff880`013f5d80 fffff980`63164e01 fffff980`6314ae20 00000000`00000004 : Tpkd+0x96a5 fffff880`0a3fc540 fffff880`013ef195 : fffffa80`0854bb60 fffff980`63164ee0 00000000`00000001 00000000`00000001 : Tpkd+0xc453 fffff880`0a3fc900 fffff880`013e90e6 : fffffa80`0854bb60 fffff980`63164ee0 fffff880`0a3fca28 fffff800`03d542a7 : Tpkd+0x14195 fffff880`0a3fc960 fffff800`03d67c16 : fffffa80`0854ba10 fffff980`63164ee0 fffffa80`0829f4a0 fffffa80`06ada898 : Tpkd+0xe0e6 fffff880`0a3fc9b0 fffff800`03bdd6b7 : fffffa80`0829f4a0 fffff880`0a3fcca0 fffffa80`0829f4a0 fffffa80`091ab750 : nt!IovCallDriver+0x566 fffff880`0a3fca10 fffff800`03bddf16 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : nt!IopXxxControlFile+0x607 fffff880`0a3fcb40 fffff800`038c0853 : ffffffff`ffffffff 00000000`00000001 00000000`0018edc8 fffff800`00000004 : nt!NtDeviceIoControlFile+0x56 fffff880`0a3fcbb0 00000000`73ce2dd9 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : nt!KiSystemServiceCopyEnd+0x13 (TrapFrame @ fffff880`0a3fcc20) 00000000`0008e548 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : 0x73ce2dd9 2: kd> !irp fffff98063164ee0 Irp is active with 1 stacks 1 is current (= 0xfffff98063164fb0) No Mdl: System buffer=fffff9806314ae20: Thread fffffa800a53cb60: Irp stack trace. cmd flg cl Device File Completion-Context >[ e, 0] 0 0 fffffa800854ba10 fffffa800829f4a0 00000000-00000000 \Driver\Tpkd Args: 000001e0 00000004 00070660 00000000 2: kd> lmvm Tpkd start end module name fffff880`013db000 fffff880`013fe000 Tpkd (no symbols) Loaded symbol image file: Tpkd.sys Image path: \SystemRoot\System32\Drivers\Tpkd.sys Image name: Tpkd.sys Timestamp: Wed Dec 23 14:32:16 2009 (4B327040) CheckSum: 000287EA ImageSize: 00023000 Translations: 0000.04b0 0000.04e4 0409.04b0 0409.04e4 It appears to be some sort of driver to handle whether or not a dongle is attached, and beyond that I'm not sure what it does. I believe that driver is from this company, so contacting them about this is probably best. This would explain why it works in safe mode though, as this driver doesn't appear to be boot-critical, so it wouldn't load with the kernel in safe-mode.

I learned most of it when I was younger in the school of hard knocks. The library, a spare PC or two, and lots of free time. I've been doing this for almost 20 years now, and I still feel like I've not really scratched the surface.

Hadn't heard that one in awhile... /files back into available memory resources...