Category list

7.9 Checking and Modifying the Set of Tasks Windows Automatically Runs at Logon

Credit: Daniel Kinnaer

7.9.1 Problem

You need to check which tasks Windows is set to automatically run at logon and possibly change these tasks.

7.9.2 Solution

When administering Windows machines, it's crucial to keep track of the tasks each machine runs at logon. Like so many Windows tasks, this requires working with the registry, and standard Python module _winreg enables this:

from _winreg import *

aReg = ConnectRegistry(None, HKEY_LOCAL_MACHINE)

try:
    targ = r'SOFTWARE\Microsoft\Windows\CurrentVersion\Run'
    print "*** Reading from", targ, "***"
    aKey = OpenKey(aReg, targ)
    try:
        for i in range(1024):
            try:
                n, v, t = EnumValue(aKey, i)
                print i, n, v, t
            except EnvironmentError:
                print "You have", i, "tasks starting at logon"
                break
    finally:
        CloseKey(aKey)

    print "*** Writing to", targ, "***"
    aKey = OpenKey(aReg, targ, 0, KEY_WRITE)
    try:
        try:
            SetValueEx(aKey, "MyNewKey", 0, REG_SZ, r"c:\winnt\explorer.exe")
        except EnvironmentError:
            print "Encountered problems writing into the Registry..."
            raise
    finally:
        CloseKey(aKey)
finally:
    CloseKey(aReg)

7.9.3 Discussion

The Windows registry holds a wealth of crucial system-administration data, and the Python standard module _winreg makes it feasible to read and alter data held in the registry. One of the items held in the Windows registry is a list of tasks to be run at logon. This recipe shows how to examine this list and how to add a task to the list so it is run at logon.

If you want to remove the specific key added by this recipe, you can use the following simple script:

from _winreg import *
aReg = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
targ = r'SOFTWARE\Microsoft\Windows\CurrentVersion\Run'
aKey = OpenKey(aReg, targ, 0, KEY_WRITE)
DeleteValue(aKey, "MyNewKey")
CloseKey(aKey)
CloseKey(aReg)

The try / finally constructs used in the recipe are far more robust than this simple sequence of function calls, since they ensure everything is closed correctly regardless of whether the intervening calls succeed or fail. This is strongly advisable for scripts that will be run in production, particularly for system-administration scripts that will generally run with administrator privileges and therefore might potentially harm a system's setup if they don't clean up after themselves properly. However, you can omit the try / finally when you know the calls will succeed or don't care what happens if they fail. In this case, if you have successfully added a task with the recipe's script, the calls in this simple cleanup script should work.

7.9.4 See Also

Documentation for the standard module _winreg in the Library Reference ; Windows API documentation available from Microsoft (http://msdn.microsoft.com); information on what is where in the registry tends to be spread among many sources, but for some collections of such information, see http://www.winguides.com/registry and http://www. activewin .com/tips/reg/index.shtml.

7.10 Examining the Microsoft Windows Registry for a List of Name Server Addresses

Credit: Wolfgang Strobl

7.10.1 Problem

You need to find out which DNS name servers are being used, but you're on Microsoft Windows, so you can't just parse the resolv.conf file, as you might do on Unix and Unix-like platforms.

7.10.2 Solution

On Windows, DNS servers (like much other information) can be found in the registry, which can be accessed with the standard module _winreg :

import string
import _winreg

def binipdisplay(s):
    "convert a binary array of ip addresses to a python list"
    if len(s)%4!= 0:
        raise EnvironmentError # well ...
    ol=[]
    for i in range(len(s)/4):
        s1=s[:4]
        s=s[4:]
        ip=[]
        for j in s1:
            ip.append(str(ord(j)))
        ol.append(string.join(ip,'.'))
    return ol

def stringdisplay(s):
    'convert "d.d.d.d,d.d.d.d" to ["d.d.d.d","d.d.d.d"]'
    return string.split(s,",")

def RegistryResolve(  ):
    """ Return the list of dotted-quads addresses of name servers found in
    the registry -- tested on NT4 Server SP6a, Win/2000 Pro SP2, XP, ME
    (each of which has a different registry layout for nameservers!) """

    nameservers=[]
    x=_winreg.ConnectRegistry(None,_winreg.HKEY_LOCAL_MACHINE)
    try:
        y= _winreg.OpenKey(x,
         r"SYSTEM\CurrentControlSet\Services\Tcpip\Parameters")
    except EnvironmentError: # so it isn't NT/2000/XP
        # Windows ME, perhaps?
        try: # for Windows ME
            y = _winreg.OpenKey(x,
              r"SYSTEM\CurrentControlSet\Services\VxD\MSTCP")
            nameserver, dummytype = _winreg.QueryValueEx(y,'NameServer')
            if nameserver and not (nameserver in nameservers):
                nameservers.extend(stringdisplay(nameserver))
        except EnvironmentError:
            pass # Must be another Windows dialect, so who knows?
        return nameservers

    nameserver = _winreg.QueryValueEx(y,"NameServer")[0]
    if nameserver:
        nameservers = [nameserver]
    _winreg.CloseKey(y)
    try: # for win2000
        y = _winreg.OpenKey(x, r"SYSTEM\CurrentControlSet\Services\Tcpip"
                               r"\Parameters\DNSRegisteredAdapters")
        for i in range(1000):
            try:
                n = _winreg.EnumKey(y,i)
                z = _winreg.OpenKey(y,n)
                dnscount,dnscounttype = _winreg.QueryValueEx(z,
                    'DNSServerAddressCount')
                dnsvalues,dnsvaluestype = _winreg.QueryValueEx(z,
                    'DNSServerAddresses')
                nameservers.extend(binipdisplay(dnsvalues))
                _winreg.CloseKey(z)
            except EnvironmentError:
                break
        _winreg.CloseKey(y)
    except EnvironmentError:
        pass

    try: # for XP
        y = _winreg.OpenKey(x,
         r"SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces")
        for i in range(1000):
            try:
                n = _winreg.EnumKey(y,i)
                z = _winreg.OpenKey(y,n)
                try:
                    nameserver,dummytype = _winreg.QueryValueEx(z,'NameServer')
                    if nameserver and not (nameserver in nameservers):
                        nameservers.extend(stringdisplay(nameserver))
                except EnvironmentError:
                    pass
                _winreg.CloseKey(z)
            except EnvironmentError:
                break
        _winreg.CloseKey(y)
    except EnvironmentError:
        # Print "Key Interfaces not found, just do nothing"
        pass

    _winreg.CloseKey(x)
    return nameservers

if _ _name_ _=="_ _main_ _":
    print "Name servers:",RegistryResolve(  )

7.10.3 Discussion

RegistryResolve returns a list of IP addresses (dotted quads) by scanning the registry for interfaces with name server entries. This is useful when porting utilities that scan resolv.conf from Unix-based systems to Microsoft Windows. As shown, the code handles differences between NT, 2000, XP, and ME (I haven't tried it on Windows 95/98, but it should work), and is thus a good example of the many huge differences under the cover that the system administrator must handle for systems that may appear to end users to be reasonably close to each other.

Checking which name servers each given machine is using is quite useful when administering that machine, or a whole network. Basically, all user access to the network is mediated by DNS. Since no user wants to work with dotted quads, almost all URLs use hostnames and not IP addresses. From the user 's viewpoint, if a DNS server is down, or if name service is misconfigured for a given machine, it's almost as bad as if there is no network access at all. This recipe makes it feasible for you to keep an eye on this crucial aspect of networking service, available from Python scripts, for client machines running Windows (client machines running Unix or Unix-like systems are easy to use from this point of view, since /etc/resolv.conf is a text file, and a pretty easy one to parse).

7.10.4 See Also

Documentation for the standard module _winreg in the Library Reference ; Windows API documentation available from Microsoft (http://msdn.microsoft.com).

Buy on amazon.com >>

Martelli A., Ascher D.

<< Previous page

Table of contents

Next page >>