client fixerrors, working configuration made

build/pip-delete-this-directory.txt

+This file is placed here by pip to indicate the source was put
+here by pip.
+
+Once this package is successfully installed this source code will be
+deleted (unless you remove this file).

build/psutil/CREDITS

+Intro
+=====
+
+We would like to recognize some of the people who have been instrumental in the
+development of psutil.
+I'm sure we are forgetting some people (feel free to email us), but here is a
+short list.
+It's modeled after the Linux CREDITS file where the fields are:
+name (N), e-mail (E), web-address (W), country (C), description (D), (I) issues
+(issue tracker is at http://code.google.com/p/psutil/issues/list).
+Really thanks to all of you.
+
+Author
+======
+
+N: Giampaolo Rodola'
+C: Italy
+E: g.rodola@gmail.com
+W: http://www.linkedin.com/in/grodola
+
+Contributors
+============
+
+N: Jay Loden
+C: NJ, USA
+E: jloden@gmail.com
+D: original co-author, initial design/bootstrap and continuing bug fixes
+W: http://www.jayloden.com
+
+N: Jeremy Whitlock
+E: jcscoobyrs@gmail.com
+I: 125, 150, 174, 206
+
+N: wj32
+E: wj32.64@gmail.com
+D: process username() and get_connections() on Windows
+I: 114, 115
+
+N: Yan Raber
+C: Bologna, Italy
+E: yanraber@gmail.com
+D: help on Windows development
+
+N: Justin Venus
+E: justin.venus@gmail.com
+D: Solaris support
+I: 18
+
+N: Dave Daeschler
+C: USA
+E: david.daeschler@gmail.com
+D: initial design/bootstrap and continuing bug fixes
+
+N: cjgohlke
+E: cjgohlke@gmail.com
+D: Windows 64 bit support
+I: 107
+
+N: Jeffery Kline
+E: jeffery.kline@gmail.com
+I: 130
+
+N: Grabriel Monnerat
+E: gabrielmonnerat@gmail.com
+I: 146
+
+N: Philip Roberts
+E: philip.roberts@gmail.com
+I: 168
+
+N: jcscoobyrs
+E: jcscoobyrs@gmail.com
+I: 125
+
+N: Sandro Tosi
+E: sandro.tosi@gmail.com
+I: 200, 201
+
+N: Andrew Colin
+E: andrew.colin@gmail.com
+I: 248
+
+N: Amoser
+E: amoser@google.com
+I: 266, 267, 340
+
+N: Matthew Grant
+E: matthewgrant5@gmail.com
+I: 271
+
+N: oweidner
+E: oweidner@cct.lsu.edu
+I: 275
+
+N: Tarek Ziade
+E: ziade.tarek
+I: 281
+
+N: Luca Cipriani
+C: Turin, Italy
+E: luca.opensource@gmail.com
+I: 278
+
+N: Maciej Lach,
+E: maciej.lach@gmail.com
+I: 294
+
+N: James Pye
+E: james.pye@gmail.com
+I: 305, 306
+
+N: Stanchev Emil
+E: stanchev.emil
+I: 314
+
+N: Kim Gräsman
+E: kim.grasman@gmail.com
+D: ...also kindly donated some money.
+I: 316
+
+N: Riccardo Murri
+C: Italy
+I: 318
+
+N: Florent Xicluna
+E: florent.xicluna@gmail.com
+I: 319
+
+N: Michal Spondr
+E: michal.spondr
+I: 313
+
+N: Jean Sebastien
+E: dumbboules@gmail.com
+I: 344
+
+N: Rob Smith
+W: http://www.kormoc.com/
+I: 341
+
+N: Youngsik Kim
+W: https://plus.google.com/101320747613749824490/
+I: 317
+
+N: Gregory Szorc
+W: https://plus.google.com/116873264322260110710/posts
+I: 323
+
+N: André Oriani
+E: aoriani@gmail.com
+I: 361
+
+N: clackwell
+E: clackwell@gmail.com
+I: 356
+
+N: m.malycha
+E: m.malycha@gmail.com
+I: 351
+
+N: John Baldwin
+E: jhb@FreeBSD.org
+I: 370
+
+N: Jan Beich
+E: jbeich@tormail.org
+I: 325
+
+N: floppymaster
+E: floppymaster@gmail.com
+I: 380
+
+N: Arfrever.FTA
+E: Arfrever.FTA@gmail.com
+I: 369, 404
+
+N: danudey
+E: danudey@gmail.com
+I: 386
+
+N: Adrien Fallou
+I: 224
+
+N: Gisle Vanem
+E: gisle.vanem@gmail.com
+I: 411
+
+N: thepyr0
+E: thepyr0@gmail.com
+I: 414
+
+N: John Pankov
+E: john.pankov@gmail.com
+I: 435

build/psutil/LICENSE

+psutil is distributed under BSD license reproduced below.
+
+Copyright (c) 2009, Jay Loden, Dave Daeschler, Giampaolo Rodola'
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of the psutil authors nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

build/psutil/MANIFEST.in

+include CREDITS
+include HISTORY
+include LICENSE
+include MANIFEST.in
+include README
+include TODO
+include setup.py
+recursive-include psutil *.py *.c *.h
+recursive-include test *.py
+recursive-include examples *.py

build/psutil/README

+===========
+Quick links
+===========
+
+* `Home page <http://code.google.com/p/psutil>`_
+* `Download <https://pypi.python.org/pypi?:action=display&name=psutil#downloads>`_
+* `Documentation <http://code.google.com/p/psutil/wiki/Documentation>`_
+* `Forum <http://groups.google.com/group/psutil/topics>`_
+* `What's new <https://psutil.googlecode.com/hg/HISTORY>`_
+
+=======
+Summary
+=======
+
+psutil is a module providing an interface for retrieving information on all
+running processes and system utilization (CPU, memory, disks, network, users) in
+a portable way by using Python, implementing many functionalities offered by
+command line tools such as:  **ps, top, df, kill, free, lsof, free, netstat,
+ifconfig, nice, ionice, iostat, iotop, uptime, pidof, tty, who, taskset, pmap**.
+
+It currently supports **Linux**, **Windows**, **OSX**, **FreeBSD**,
+**Sun Solaris** both **32-bit** and **64-bit** with Python versions from **2.4**
+to **3.3** by using a single code base.
+
+==============
+Example usages
+==============
+
+CPU
+===
+
+>>> import psutil
+>>> psutil.cpu_times()
+cputimes(user=3961.46, nice=169.729, system=2150.659, idle=16900.540,
+         iowait=629.509, irq=0.0, softirq=19.422, steal=0.0, guest=0, nice=0.0)
+>>>
+>>> for x in range(3):
+...     psutil.cpu_percent(interval=1)
+...
+4.0
+5.9
+3.8
+>>>
+>>> for x in range(3):
+...     psutil.cpu_percent(interval=1, percpu=True)
+...
+[4.0, 6.9]
+[7.0, 8.5]
+[1.2, 9.0]
+>>>
+>>> for x in range(3):
+...     psutil.cpu_times_percent(interval=1, percpu=False)
+...
+cpupercent(user=1.5, nice=0.0, system=0.5, idle=96.5, iowait=1.5, irq=0.0,
+           softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+cpupercent(user=1.0, nice=0.0, system=0.0, idle=99.0, iowait=0.0, irq=0.0,
+           softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+cpupercent(user=2.0, nice=0.0, system=0.0, idle=98.0, iowait=0.0, irq=0.0,
+           softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+
+Memory
+======
+
+>>> psutil.virtual_memory()
+vmem(total=8374149120L, available=2081050624L, percent=75.1, used=8074080256L,
+     free=300068864L, active=3294920704, inactive=1361616896, buffers=529895424L,
+     cached=1251086336)
+>>> psutil.swap_memory()
+swap(total=2097147904L, used=296128512L, free=1801019392L, percent=14.1,
+     sin=304193536, sout=677842944)
+>>>
+
+
+Disks
+=====
+
+>>> psutil.disk_partitions()
+[partition(device='/dev/sda1', mountpoint='/', fstype='ext4', opts='rw,nosuid'),
+ partition(device='/dev/sda2', mountpoint='/home', fstype='ext, opts='rw')]
+>>>
+>>> psutil.disk_usage('/')
+usage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
+>>>
+>>> psutil.disk_io_counters()
+iostat(read_count=719566, write_count=1082197, read_bytes=18626220032,
+       write_bytes=24081764352, read_time=5023392, write_time=63199568)
+>>>
+
+
+Network
+=======
+
+>>> psutil.net_io_counters(pernic=True)
+{'lo': iostat(bytes_sent=799953745, bytes_recv=799953745,
+              packets_sent=453698, packets_recv=453698),
+ 'eth0': iostat(bytes_sent=734324837, bytes_recv=4163935363,
+                packets_sent=3605828, packets_recv=4096685)}
+>>>
+
+Other system info
+=================
+
+>>> psutil.get_users()
+[user(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0),
+ user(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0)]
+>>>
+>>> psutil.get_boot_time()
+1365519115.0
+
+
+Process management
+==================
+
+>>> import psutil
+>>> psutil.get_pid_list()
+[1, 2, 3, 4, 5, 6, 7, 46, 48, 50, 51, 178, 182, 222, 223, 224,
+268, 1215, 1216, 1220, 1221, 1243, 1244, 1301, 1601, 2237, 2355,
+2637, 2774, 3932, 4176, 4177, 4185, 4187, 4189, 4225, 4243, 4245,
+4263, 4282, 4306, 4311, 4312, 4313, 4314, 4337, 4339, 4357, 4358,
+4363, 4383, 4395, 4408, 4433, 4443, 4445, 4446, 5167, 5234, 5235,
+5252, 5318, 5424, 5644, 6987, 7054, 7055, 7071]
+>>>
+>>> p = psutil.Process(7055)
+>>> p.name
+'python'
+>>> p.exe
+'/usr/bin/python'
+>>> p.getcwd()
+'/home/giampaolo'
+>>> p.cmdline
+['/usr/bin/python', 'main.py']
+>>>
+>>> str(p.status)
+'running'
+>>> p.username
+'giampaolo'
+>>> p.create_time
+1267551141.5019531
+>>> p.terminal
+'/dev/pts/0'
+>>>
+>>> p.uids
+user(real=1000, effective=1000, saved=1000)
+>>> p.gids
+group(real=1000, effective=1000, saved=1000)
+>>>
+>>> p.get_cpu_times()
+cputimes(user=1.02, system=0.31)
+>>> p.get_cpu_percent(interval=1.0)
+12.1
+>>> p.get_cpu_affinity()
+[0, 1, 2, 3]
+>>> p.set_cpu_affinity([0])
+>>>
+>>> p.get_memory_percent()
+0.63423
+>>>
+>>> p.get_memory_info()
+meminfo(rss=7471104, vms=68513792)
+>>> p.get_ext_memory_info()
+meminfo(rss=9662464, vms=49192960, shared=3612672, text=2564096, lib=0, data=5754880, dirty=0)
+>>> p.get_memory_maps()
+[mmap(path='/lib/x86_64-linux-gnu/libutil-2.15.so', rss=16384, anonymous=8192, swap=0),
+ mmap(path='/lib/x86_64-linux-gnu/libc-2.15.so', rss=6384, anonymous=15, swap=0),
+ mmap(path='/lib/x86_64-linux-gnu/libcrypto.so.1.0.0', rss=34124, anonymous=1245, swap=0),
+ mmap(path='[heap]', rss=54653, anonymous=8192, swap=0),
+ mmap(path='[stack]', rss=1542, anonymous=166, swap=0),
+ ...]
+>>>
+>>> p.get_io_counters()
+io(read_count=478001, write_count=59371, read_bytes=700416, write_bytes=69632)
+>>>
+>>> p.get_open_files()
+[openfile(path='/home/giampaolo/svn/psutil/somefile', fd=3)]
+>>>
+>>> p.get_connections()
+[connection(fd=115, family=2, type=1, laddr=('10.0.0.1', 48776),
+            raddr=('93.186.135.91', 80), status='ESTABLISHED'),
+ connection(fd=117, family=2, type=1, laddr=('10.0.0.1', 43761),
+            raddr=('72.14.234.100', 80), status='CLOSING'),
+ connection(fd=119, family=2, type=1, laddr=('10.0.0.1', 60759),
+            raddr=('72.14.234.104', 80), status='ESTABLISHED'),
+ connection(fd=123, family=2, type=1, laddr=('10.0.0.1', 51314),
+            raddr=('72.14.234.83', 443), status='SYN_SENT')]
+>>>
+>>> p.get_num_threads()
+4
+>>> p.get_num_fds()
+8
+>>> p.get_threads()
+[thread(id=5234, user_time=22.5, system_time=9.2891),
+ thread(id=5235, user_time=0.0, system_time=0.0),
+ thread(id=5236, user_time=0.0, system_time=0.0),
+ thread(id=5237, user_time=0.0707, system_time=1.1)]
+>>>
+>>> p.get_num_ctx_switches()
+amount(voluntary=78, involuntary=19)
+>>>
+>>> p.get_nice()
+0
+>>> p.set_nice(10)
+>>>
+>>> p.set_ionice(psutil.IOPRIO_CLASS_IDLE)  # IO priority (Windows and Linux only)
+>>> p.get_ionice()
+ionice(ioclass=3, value=0)
+>>>
+>>> p.set_rlimit(psutil.RLIMIT_NOFILE, (5, 5))  # resource limits (Linux only)
+>>> p.get_rlimit(psutil.RLIMIT_NOFILE)
+(5, 5)
+>>>
+>>> p.suspend()
+>>> p.resume()
+>>>
+>>> p.terminate()
+>>> p.wait(timeout=3)
+0
+>>>
+>>> psutil.test()
+USER         PID %CPU %MEM     VSZ     RSS TTY        START    TIME  COMMAND
+root           1  0.0  0.0   24584    2240 ?          Jun17   00:00  init
+root           2  0.0  0.0       0       0 ?          Jun17   00:00  kthreadd
+root           3  0.0  0.0       0       0 ?          Jun17   00:05  ksoftirqd/0
+...
+giampaolo  31475  0.0  0.0   20760    3024 /dev/pts/0 Jun19   00:00  python2.4
+giampaolo  31721  0.0  2.2  773060  181896 ?          00:04   10:30  chrome
+root       31763  0.0  0.0       0       0 ?          00:05   00:00  kworker/0:1
+>>>

build/psutil/TODO

+TODO
+====
+
+A collection of ideas and notes about stuff to implement in future versions.
+"#NNN" occurrences refer to bug tracker issues at:
+https://code.google.com/p/psutil/issues/list
+
+
+HIGHER PRIORITY
+===============
+
+ * #387: system-wide connections (netstat).
+ * OpenBSD support.
+
+ * #371: CPU temperature (apparently OSX and Linux only; on Linux it requires
+   lm-sensors lib).
+
+ * #250: net ifaces speed.
+
+ * Process.name on Windows is slow:
+   http://stackoverflow.com/questions/6587036/
+
+ * Windows binary for Python 3.3 64-bit.
+
+ * #269: expose network ifaces RX/TW queues.
+
+
+LOWER PRIORITY
+==============
+
+ * #355: Android support.
+
+ * #276: GNU/Hurd support.
+
+ * NetBSD support?
+
+ * DranflyBSD support?
+
+ * AIX support?
+
+ * examples/pidof.py (same as 'pidof' cli tool)
+
+ * examples/pstree.py (same as 'pstree' cli tool)
+    * get_threads() should also return thread names in order to implement it
+
+ * examples/taskmgr-gui.py (using tk).
+
+ * system-wide # open file descriptors:
+    * https://jira.hyperic.com/browse/SIGAR-30
+    * http://www.netadmintools.com/part295.html
+
+ * Number of system threads.
+    * Windows: http://msdn.microsoft.com/en-us/library/windows/desktop/ms684824(v=vs.85).aspx
+
+ * #357: what CPU a process is on.
+
+ * thread names:
+    * https://code.google.com/p/plcrashreporter/issues/detail?id=65
+
+
+DEBATABLE
+=========
+
+ * [Linux]: process cgroups (http://en.wikipedia.org/wiki/Cgroups). They look
+   similar to prlimit() in terms of functionality but uglier (they should allow
+   limiting per-process network IO resources though, which is great). Needs
+   further reading.
+
+ * cpu_percent(): current default interval is 0.1 so that by default it will
+   produce a meaningful value. It represents a trap in case the user iterates
+   over multiple processes though, as it introduces a big slowdown.
+   Should it default to 0.0?
+
+ * Rename connection ntuple's fields 'local_address', 'remote_address' to
+   'laddr', 'raddr'  (note in accordance with http://bugs.python.org/issue17675)
+
+ * Process per-cpus percent (XXX Windows only?), see:
+   https://groups.google.com/forum/?fromgroups#!topic/psutil/ErrKTxAbu50
+
+ * Should we expose OS constants (psutil.WINDOWS, psutil.OSX etc.)?
+
+ * Python 3.3. exposed different sched.h functions:
+   http://docs.python.org/dev/whatsnew/3.3.html#os
+   http://bugs.python.org/issue12655
+   http://docs.python.org/dev/library/os.html#interface-to-the-scheduler
+   It might be worth to take a look and figure out whether we can include some
+   of those in psutil.
+   Also, we can probably reimplement wait_pid() on POSIX which is currently
+   implemented as a busy-loop.
+
+ * Certain systems (XXX figure out which ones exactly) provide CPU times about
+   process children. On those systems Process.get_cpu_times() might return
+   a (user, system, user_children, system_children) ntuple.
+
+ * Enrich exception classes hierarchy on Python >= 3.3 / post PEP-3151 so that:
+   - NoSuchProcess inherits from ProcessLookupError
+   - AccessDenied inherits from PermissionError
+   - TimeoutExpired inherits from TimeoutError (debatable)
+   See: http://docs.python.org/3/library/exceptions.html#os-exceptions
+
+ * Process.get_threads() might grow an extra "id" parameter so that it can be
+   used as such:
+
+    >>> p = psutil.Process(pid)
+    >>> p.get_threads(id=psutil.get_current_thread_id())
+    thread(id=2539, user_time=0.03, system_time=0.02)
+    >>>
+
+   note: this leads to questions such as "should we have a custom NoSuchThread
+   exception? Also see issue #418.
+
+  * should psutil.TimeoutExpired exception have a 'msg' kwarg similar to
+    NoSuchProcess and AccessDenied? Not that we need it, but currently we
+    cannot raise a TimeoutExpired exception with a specific error string.
+    Side note: tests' call_until() should raise TimeoutExpired instead of
+    RuntimeError.

build/psutil/build/lib.linux-x86_64-2.7/psutil/_common.py

+#/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Common objects shared by all _ps* modules."""
+
+from __future__ import division
+import sys
+import os
+import stat
+import errno
+import warnings
+
+from psutil._compat import namedtuple, long, wraps
+
+# --- functions
+
+def usage_percent(used, total, _round=None):
+    """Calculate percentage usage of 'used' against 'total'."""
+    try:
+        ret = (used / total) * 100
+    except ZeroDivisionError:
+        ret = 0
+    if _round is not None:
+        return round(ret, _round)
+    else:
+        return ret
+
+def memoize(f):
+    """A simple memoize decorator for functions."""
+    cache= {}
+    def memf(*x):
+        if x not in cache:
+            cache[x] = f(*x)
+        return cache[x]
+    return memf
+
+class cached_property(object):
+    """A memoize decorator for class properties."""
+    enabled = True
+
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, type):
+        ret = self.func(instance)
+        if self.enabled:
+            instance.__dict__[self.func.__name__] = ret
+        return ret
+
+# http://goo.gl/jYLvf
+def deprecated(replacement=None):
+    """A decorator which can be used to mark functions as deprecated."""
+    def outer(fun):
+        msg = "psutil.%s is deprecated" % fun.__name__
+        if replacement is not None:
+            msg += "; use %s instead" % replacement
+        if fun.__doc__ is None:
+            fun.__doc__ = msg
+
+        @wraps(fun)
+        def inner(*args, **kwargs):
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            return fun(*args, **kwargs)
+
+        return inner
+    return outer
+
+
+def isfile_strict(path):
+    """Same as os.path.isfile() but does not swallow EACCES / EPERM
+    exceptions, see:
+    http://mail.python.org/pipermail/python-dev/2012-June/120787.html
+    """
+    try:
+        st = os.stat(path)
+    except OSError:
+        err = sys.exc_info()[1]
+        if err.errno in (errno.EPERM, errno.EACCES):
+            raise
+        return False
+    else:
+        return stat.S_ISREG(st.st_mode)
+
+
+# --- constants
+
+STATUS_RUNNING = "running"
+STATUS_SLEEPING = "sleeping"
+STATUS_DISK_SLEEP = "disk-sleep"
+STATUS_STOPPED = "stopped"
+STATUS_TRACING_STOP = "tracing-stop"
+STATUS_ZOMBIE = "zombie"
+STATUS_DEAD = "dead"
+STATUS_WAKE_KILL = "wake-kill"
+STATUS_WAKING = "waking"
+STATUS_IDLE = "idle"  # BSD
+STATUS_LOCKED = "locked"  # BSD
+STATUS_WAITING = "waiting"  # BSD
+
+CONN_ESTABLISHED = "ESTABLISHED"
+CONN_SYN_SENT = "SYN_SENT"
+CONN_SYN_RECV = "SYN_RECV"
+CONN_FIN_WAIT1 = "FIN_WAIT1"
+CONN_FIN_WAIT2 = "FIN_WAIT2"
+CONN_TIME_WAIT = "TIME_WAIT"
+CONN_CLOSE = "CLOSE"
+CONN_CLOSE_WAIT = "CLOSE_WAIT"
+CONN_LAST_ACK = "LAST_ACK"
+CONN_LISTEN = "LISTEN"
+CONN_CLOSING = "CLOSING"
+CONN_NONE = "NONE"
+
+# --- Process.get_connections() 'kind' parameter mapping
+
+import socket
+from socket import AF_INET, SOCK_STREAM, SOCK_DGRAM
+AF_INET6 = getattr(socket, 'AF_INET6', None)
+AF_UNIX = getattr(socket, 'AF_UNIX', None)
+
+conn_tmap = {
+    "all"  : ([AF_INET, AF_INET6, AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]),
+    "tcp"  : ([AF_INET, AF_INET6], [SOCK_STREAM]),
+    "tcp4" : ([AF_INET],           [SOCK_STREAM]),
+    "udp"  : ([AF_INET, AF_INET6], [SOCK_DGRAM]),
+    "udp4" : ([AF_INET],           [SOCK_DGRAM]),
+    "inet" : ([AF_INET, AF_INET6], [SOCK_STREAM, SOCK_DGRAM]),
+    "inet4": ([AF_INET],           [SOCK_STREAM, SOCK_DGRAM]),
+    "inet6": ([AF_INET6],          [SOCK_STREAM, SOCK_DGRAM]),
+}
+
+if AF_INET6 is not None:
+    conn_tmap.update({
+        "tcp6" : ([AF_INET6],          [SOCK_STREAM]),
+        "udp6" : ([AF_INET6],          [SOCK_DGRAM]),
+    })
+
+if AF_UNIX is not None:
+    conn_tmap.update({
+        "unix" : ([AF_UNIX],           [SOCK_STREAM, SOCK_DGRAM]),
+    })
+
+
+del AF_INET, AF_INET6, AF_UNIX, SOCK_STREAM, SOCK_DGRAM, socket
+
+# --- namedtuples
+
+# system
+nt_sysmeminfo = namedtuple('usage', 'total used free percent')
+# XXX - would 'available' be better than 'free' as for virtual_memory() nt?
+nt_swapmeminfo = namedtuple('swap', 'total used free percent sin sout')
+nt_diskinfo = namedtuple('usage', 'total used free percent')
+nt_partition = namedtuple('partition',  'device mountpoint fstype opts')
+nt_net_iostat = namedtuple('iostat',
+    'bytes_sent bytes_recv packets_sent packets_recv errin errout dropin dropout')
+nt_disk_iostat = namedtuple('iostat', 'read_count write_count read_bytes write_bytes read_time write_time')
+nt_user = namedtuple('user', 'name terminal host started')
+
+# processes
+nt_meminfo = namedtuple('meminfo', 'rss vms')
+nt_cputimes = namedtuple('cputimes', 'user system')
+nt_openfile = namedtuple('openfile', 'path fd')
+nt_thread = namedtuple('thread', 'id user_time system_time')
+nt_uids = namedtuple('user', 'real effective saved')
+nt_gids = namedtuple('group', 'real effective saved')
+nt_io = namedtuple('io', 'read_count write_count read_bytes write_bytes')
+nt_ionice = namedtuple('ionice', 'ioclass value')
+nt_ctxsw = namedtuple('amount', 'voluntary involuntary')
+
+class nt_connection(namedtuple('connection',
+                               'fd family type laddr raddr status')):
+        __slots__ = ()
+
+        @property
+        def local_address(self):
+            warnings.warn("'local_address' field is deprecated; use 'laddr'" \
+                          "instead", category=DeprecationWarning, stacklevel=2)
+            return self.laddr
+
+        @property
+        def remote_address(self):
+            warnings.warn("'remote_address' field is deprecated; use 'raddr'" \
+                          "instead", category=DeprecationWarning, stacklevel=2)
+            return self.raddr

build/psutil/build/lib.linux-x86_64-2.7/psutil/_compat.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Module which provides compatibility with older Python versions."""
+
+__all__ = ["PY3", "int", "long", "xrange", "exec_", "callable",
+           "namedtuple", "property", "defaultdict"]
+
+import sys
+
+
+# --- python 2/3 compatibility layer
+
+PY3 = sys.version_info >= (3,)
+
+try:
+    import __builtin__
+except ImportError:
+    import builtins as __builtin__  # py3
+
+if PY3:
+    int = int
+    long = int
+    xrange = range
+    unicode = str
+    exec_ = getattr(__builtin__, "exec")
+    print_ = getattr(__builtin__, "print")
+
+    def u(s):
+        return s
+else:
+    int = int
+    long = long
+    xrange = xrange
+    unicode = unicode
+
+    def u(s):
+        return unicode(s, "unicode_escape")
+
+    def exec_(code, globs=None, locs=None):
+        if globs is None:
+            frame = _sys._getframe(1)
+            globs = frame.f_globals
+            if locs is None:
+                locs = frame.f_locals
+            del frame
+        elif locs is None:
+            locs = globs
+        exec("""exec code in globs, locs""")
+
+    def print_(s):
+        sys.stdout.write(s + '\n')
+        sys.stdout.flush()
+
+
+# removed in 3.0, reintroduced in 3.2
+try:
+    callable = callable
+except Exception:
+    def callable(obj):
+        for klass in type(obj).__mro__:
+            if "__call__" in klass.__dict__:
+                return True
+        return False
+
+
+# --- stdlib additions
+
+try:
+    from collections import namedtuple
+except ImportError:
+    from operator import itemgetter as _itemgetter
+    from keyword import iskeyword as _iskeyword
+    import sys as _sys
+
+    def namedtuple(typename, field_names, verbose=False, rename=False):
+        """A collections.namedtuple implementation written in Python
+        to support Python versions < 2.6.
+
+        Taken from: http://code.activestate.com/recipes/500261/
+        """
+        # Parse and validate the field names.  Validation serves two
+        # purposes, generating informative error messages and preventing
+        # template injection attacks.
+        if isinstance(field_names, basestring):
+             # names separated by whitespace and/or commas
+            field_names = field_names.replace(',', ' ').split()
+        field_names = tuple(map(str, field_names))
+        if rename:
+            names = list(field_names)
+            seen = set()
+            for i, name in enumerate(names):
+                if (not min(c.isalnum() or c=='_' for c in name) or _iskeyword(name)
+                    or not name or name[0].isdigit() or name.startswith('_')
+                    or name in seen):
+                        names[i] = '_%d' % i
+                seen.add(name)
+            field_names = tuple(names)
+        for name in (typename,) + field_names:
+            if not min(c.isalnum() or c=='_' for c in name):
+                raise ValueError('Type names and field names can only contain ' \
+                                 'alphanumeric characters and underscores: %r'
+                                 % name)
+            if _iskeyword(name):
+                raise ValueError('Type names and field names cannot be a keyword: %r' \
+                                 % name)
+            if name[0].isdigit():
+                raise ValueError('Type names and field names cannot start with a ' \
+                                 'number: %r' % name)
+        seen_names = set()
+        for name in field_names:
+            if name.startswith('_') and not rename:
+                raise ValueError('Field names cannot start with an underscore: %r'
+                                 % name)
+            if name in seen_names:
+                raise ValueError('Encountered duplicate field name: %r' % name)
+            seen_names.add(name)
+
+        # Create and fill-in the class template
+        numfields = len(field_names)
+        # tuple repr without parens or quotes
+        argtxt = repr(field_names).replace("'", "")[1:-1]
+        reprtxt = ', '.join('%s=%%r' % name for name in field_names)
+        template = '''class %(typename)s(tuple):
+        '%(typename)s(%(argtxt)s)' \n
+        __slots__ = () \n
+        _fields = %(field_names)r \n
+        def __new__(_cls, %(argtxt)s):
+            return _tuple.__new__(_cls, (%(argtxt)s)) \n
+        @classmethod
+        def _make(cls, iterable, new=tuple.__new__, len=len):
+            'Make a new %(typename)s object from a sequence or iterable'
+            result = new(cls, iterable)
+            if len(result) != %(numfields)d:
+                raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result))
+            return result \n
+        def __repr__(self):
+            return '%(typename)s(%(reprtxt)s)' %% self \n
+        def _asdict(self):
+            'Return a new dict which maps field names to their values'
+            return dict(zip(self._fields, self)) \n
+        def _replace(_self, **kwds):
+            'Return a new %(typename)s object replacing specified fields with new values'
+            result = _self._make(map(kwds.pop, %(field_names)r, _self))
+            if kwds:
+                raise ValueError('Got unexpected field names: %%r' %% kwds.keys())
+            return result \n
+        def __getnewargs__(self):
+            return tuple(self) \n\n''' % locals()
+        for i, name in enumerate(field_names):
+            template += '        %s = _property(_itemgetter(%d))\n' % (name, i)
+        if verbose:
+            sys.stdout.write(template + '\n')
+            sys.stdout.flush()
+
+        # Execute the template string in a temporary namespace
+        namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename,
+                         _property=property, _tuple=tuple)
+        try:
+            exec_(template, namespace)
+        except SyntaxError:
+            e = sys.exc_info()[1]
+            raise SyntaxError(e.message + ':\n' + template)
+        result = namespace[typename]
+
+        # For pickling to work, the __module__ variable needs to be set
+        # to the frame where the named tuple is created.  Bypass this
+        # step in enviroments where sys._getframe is not defined (Jython
+        # for example) or sys._getframe is not defined for arguments
+        # greater than 0 (IronPython).
+        try:
+            result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__')
+        except (AttributeError, ValueError):
+            pass
+
+        return result
+
+
+# hack to support property.setter/deleter on python < 2.6
+# http://docs.python.org/library/functions.html?highlight=property#property
+if hasattr(property, 'setter'):
+    property = property
+else:
+    class property(__builtin__.property):
+        __metaclass__ = type
+
+        def __init__(self, fget, *args, **kwargs):
+            super(property, self).__init__(fget, *args, **kwargs)
+            self.__doc__ = fget.__doc__
+
+        def getter(self, method):
+            return property(method, self.fset, self.fdel)
+
+        def setter(self, method):
+            return property(self.fget, method, self.fdel)
+
+        def deleter(self, method):
+            return property(self.fget, self.fset, method)
+
+
+# py 2.5 collections.defauldict
+# Taken from:
+# http://code.activestate.com/recipes/523034-emulate-collectionsdefaultdict/
+# credits: Jason Kirtland
+try:
+    from collections import defaultdict
+except ImportError:
+    class defaultdict(dict):
+
+        def __init__(self, default_factory=None, *a, **kw):
+            if (default_factory is not None and
+                not hasattr(default_factory, '__call__')):
+                raise TypeError('first argument must be callable')
+            dict.__init__(self, *a, **kw)
+            self.default_factory = default_factory
+
+        def __getitem__(self, key):
+            try:
+                return dict.__getitem__(self, key)
+            except KeyError:
+                return self.__missing__(key)
+
+        def __missing__(self, key):
+            if self.default_factory is None:
+                raise KeyError(key)
+            self[key] = value = self.default_factory()
+            return value
+
+        def __reduce__(self):
+            if self.default_factory is None:
+                args = tuple()
+            else:
+                args = self.default_factory,
+            return type(self), args, None, None, self.items()
+
+        def copy(self):
+            return self.__copy__()
+
+        def __copy__(self):
+            return type(self)(self.default_factory, self)
+
+        def __deepcopy__(self, memo):
+            import copy
+            return type(self)(self.default_factory,
+                              copy.deepcopy(self.items()))
+
+        def __repr__(self):
+            return 'defaultdict(%s, %s)' % (self.default_factory,
+                                            dict.__repr__(self))
+
+
+# py 2.5 functools.wraps
+try:
+    from functools import wraps
+except ImportError:
+    def wraps(original):
+        def inner(fn):
+            # see functools.WRAPPER_ASSIGNMENTS
+            for attribute in ['__module__',
+                              '__name__',
+                              '__doc__'
+                              ]:
+                setattr(fn, attribute, getattr(original, attribute))
+            # see functools.WRAPPER_UPDATES
+            for attribute in ['__dict__',
+                              ]:
+                if hasattr(fn, attribute):
+                    getattr(fn, attribute).update(getattr(original, attribute))
+                else:
+                    setattr(fn, attribute,
+                            getattr(original, attribute).copy())
+            return fn
+        return inner

build/psutil/build/lib.linux-x86_64-2.7/psutil/_error.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""psutil exception classes.
+Not supposed to be used / imported directly.
+Instead use psutil.NoSuchProcess, etc.
+"""
+
+
+class Error(Exception):
+    """Base exception class. All other psutil exceptions inherit
+    from this one.
+    """
+
+class NoSuchProcess(Error):
+    """Exception raised when a process with a certain PID doesn't
+    or no longer exists (zombie).
+    """
+
+    def __init__(self, pid, name=None, msg=None):
+        self.pid = pid
+        self.name = name
+        self.msg = msg
+        if msg is None:
+            if name:
+                details = "(pid=%s, name=%s)" % (self.pid, repr(self.name))
+            else:
+                details = "(pid=%s)" % self.pid
+            self.msg = "process no longer exists " + details
+
+    def __str__(self):
+        return self.msg
+
+
+class AccessDenied(Error):
+    """Exception raised when permission to perform an action is denied."""
+
+    def __init__(self, pid=None, name=None, msg=None):
+        self.pid = pid
+        self.name = name
+        self.msg = msg
+        if msg is None:
+            if (pid is not None) and (name is not None):
+                self.msg = "(pid=%s, name=%s)" % (pid, repr(name))
+            elif (pid is not None):
+                self.msg = "(pid=%s)" % self.pid
+            else:
+                self.msg = ""
+
+    def __str__(self):
+        return self.msg
+
+
+class TimeoutExpired(Error):
+    """Raised on Process.wait(timeout) if timeout expires and process
+    is still alive.
+    """
+
+    def __init__(self, pid=None, name=None):
+        self.pid = pid
+        self.name = name
+        if (pid is not None) and (name is not None):
+            self.msg = "(pid=%s, name=%s)" % (pid, repr(name))
+        elif (pid is not None):
+            self.msg = "(pid=%s)" % self.pid
+        else:
+            self.msg = ""
+
+    def __str__(self):
+        return self.msg

build/psutil/build/lib.linux-x86_64-2.7/psutil/_psposix.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Routines common to all posix systems."""
+
+import os
+import errno
+import psutil
+import sys
+import time
+import glob
+
+from psutil._compat import PY3, unicode
+from psutil._error import TimeoutExpired
+from psutil._common import nt_diskinfo, usage_percent, memoize
+
+
+def pid_exists(pid):
+    """Check whether pid exists in the current process table."""
+    if pid < 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        e = sys.exc_info()[1]
+        return e.errno == errno.EPERM
+    else:
+        return True
+
+def wait_pid(pid, timeout=None):
+    """Wait for process with pid 'pid' to terminate and return its
+    exit status code as an integer.
+
+    If pid is not a children of os.getpid() (current process) just
+    waits until the process disappears and return None.
+
+    If pid does not exist at all return None immediately.
+
+    Raise TimeoutExpired on timeout expired.
+    """
+    def check_timeout(delay):
+        if timeout is not None:
+            if timer() >= stop_at:
+                raise TimeoutExpired(pid)
+        time.sleep(delay)
+        return min(delay * 2, 0.04)
+
+    timer = getattr(time, 'monotonic', time.time)
+    if timeout is not None:
+        waitcall = lambda: os.waitpid(pid, os.WNOHANG)
+        stop_at = timer() + timeout
+    else:
+        waitcall = lambda: os.waitpid(pid, 0)
+
+    delay = 0.0001
+    while 1:
+        try:
+            retpid, status = waitcall()
+        except OSError:
+            err = sys.exc_info()[1]
+            if err.errno == errno.EINTR:
+                delay = check_timeout(delay)
+                continue
+            elif err.errno == errno.ECHILD:
+                # This has two meanings:
+                # - pid is not a child of os.getpid() in which case
+                #   we keep polling until it's gone
+                # - pid never existed in the first place
+                # In both cases we'll eventually return None as we
+                # can't determine its exit status code.
+                while 1:
+                    if pid_exists(pid):
+                        delay = check_timeout(delay)
+                    else:
+                        return
+            else:
+                raise
+        else:
+            if retpid == 0:
+                # WNOHANG was used, pid is still running
+                delay = check_timeout(delay)
+                continue
+            # process exited due to a signal; return the integer of
+            # that signal
+            if os.WIFSIGNALED(status):
+                return os.WTERMSIG(status)
+            # process exited using exit(2) system call; return the
+            # integer exit(2) system call has been called with
+            elif os.WIFEXITED(status):
+                return os.WEXITSTATUS(status)
+            else:
+                # should never happen
+                raise RuntimeError("unknown process exit status")
+
+def get_disk_usage(path):
+    """Return disk usage associated with path."""
+    try:
+        st = os.statvfs(path)
+    except UnicodeEncodeError:
+        if not PY3 and isinstance(path, unicode):
+            # this is a bug with os.statvfs() and unicode on
+            # Python 2, see:
+            # - https://code.google.com/p/psutil/issues/detail?id=416
+            # - http://bugs.python.org/issue18695
+            try:
+                path = path.encode(sys.getfilesystemencoding())
+            except UnicodeEncodeError:
+                pass
+            st = os.statvfs(path)
+        else:
+            raise
+    free = (st.f_bavail * st.f_frsize)
+    total = (st.f_blocks * st.f_frsize)
+    used = (st.f_blocks - st.f_bfree) * st.f_frsize
+    percent = usage_percent(used, total, _round=1)
+    # NB: the percentage is -5% than what shown by df due to
+    # reserved blocks that we are currently not considering:
+    # http://goo.gl/sWGbH
+    return nt_diskinfo(total, used, free, percent)
+
+@memoize
+def _get_terminal_map():
+    ret = {}
+    ls = glob.glob('/dev/tty*') + glob.glob('/dev/pts/*')
+    for name in ls:
+        assert name not in ret
+        try:
+            ret[os.stat(name).st_rdev] = name
+        except OSError:
+            err = sys.exc_info()[1]
+            if err.errno != errno.ENOENT:
+                raise
+    return ret

build/psutil/build/lib.linux-x86_64-2.7/psutil/error.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""This module is deprecated as exceptions are defined in _error.py
+and are supposed to be accessed from 'psutil' namespace as in:
+- psutil.NoSuchProcess
+- psutil.AccessDenied
+- psutil.TimeoutExpired
+"""
+
+import warnings
+from psutil._error import *
+
+warnings.warn("psutil.error module is deprecated and scheduled for removal; " \
+              "use psutil namespace instead", category=DeprecationWarning,
+               stacklevel=2)

build/psutil/examples/disk_usage.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+List all mounted disk partitions a-la "df -h" command.
+"""
+
+import sys
+import os
+import psutil
+from psutil._compat import print_
+
+def bytes2human(n):
+    # http://code.activestate.com/recipes/578019
+    # >>> bytes2human(10000)
+    # '9.8K'
+    # >>> bytes2human(100001221)
+    # '95.4M'
+    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
+    prefix = {}
+    for i, s in enumerate(symbols):
+        prefix[s] = 1 << (i+1)*10
+    for s in reversed(symbols):
+        if n >= prefix[s]:
+            value = float(n) / prefix[s]
+            return '%.1f%s' % (value, s)
+    return "%sB" % n
+
+
+def main():
+    templ = "%-17s %8s %8s %8s %5s%% %9s  %s"
+    print_(templ % ("Device", "Total", "Used", "Free", "Use ", "Type", "Mount"))
+    for part in psutil.disk_partitions(all=False):
+        if os.name == 'nt':
+            if 'cdrom' in part.opts or part.fstype == '':
+                # skip cd-rom drives with no disk in it; they may raise
+                # ENOENT, pop-up a Windows GUI error for a non-ready
+                # partition or just hang.
+                continue
+        usage = psutil.disk_usage(part.mountpoint)
+        print_(templ % (part.device,
+                        bytes2human(usage.total),
+                        bytes2human(usage.used),
+                        bytes2human(usage.free),
+                        int(usage.percent),
+                        part.fstype,
+                        part.mountpoint))
+
+if __name__ == '__main__':
+    sys.exit(main())

build/psutil/examples/free.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+A clone of 'free' cmdline utility.
+"""
+
+import psutil
+from psutil._compat import print_
+
+def main():
+    virt = psutil.virtual_memory()
+    swap = psutil.swap_memory()
+    templ = "%-7s %10s %10s %10s %10s %10s %10s"
+    print_(templ % ('', 'total', 'used', 'free', 'shared', 'buffers', 'cache'))
+    print_(templ % ('Mem:', int(virt.total / 1024),
+                            int(virt.used / 1024),
+                            int(virt.free / 1024),
+                            int(getattr(virt, 'shared', 0) / 1024),
+                            int(getattr(virt, 'buffers', 0) / 1024),
+                            int(getattr(virt, 'cached', 0) / 1024)))
+    print_(templ % ('Swap:', int(swap.total / 1024),
+                             int(swap.used / 1024),
+                             int(swap.free / 1024),
+                             '', '', ''))
+
+if __name__ == '__main__':
+    main()

build/psutil/examples/iotop.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+A clone of iotop (http://guichaz.free.fr/iotop/) showing real time
+disk I/O statistics.
+
+It works on Linux only (FreeBSD and OSX are missing support for IO
+counters).
+It doesn't work on Windows as curses module is required.
+
+Author: Giampaolo Rodola' <g.rodola@gmail.com>
+"""
+
+import os
+import sys
+import psutil
+if not hasattr(psutil.Process, 'get_io_counters') or os.name != 'posix':
+    sys.exit('platform not supported')
+import time
+import curses
+import atexit
+
+
+# --- curses stuff
+def tear_down():
+    win.keypad(0)
+    curses.nocbreak()
+    curses.echo()
+    curses.endwin()
+
+win = curses.initscr()
+atexit.register(tear_down)
+curses.endwin()
+lineno = 0
+
+def print_line(line, highlight=False):
+    """A thin wrapper around curses's addstr()."""
+    global lineno
+    try:
+        if highlight:
+            line += " " * (win.getmaxyx()[1] - len(line))
+            win.addstr(lineno, 0, line, curses.A_REVERSE)
+        else:
+            win.addstr(lineno, 0, line, 0)
+    except curses.error:
+        lineno = 0
+        win.refresh()
+        raise
+    else:
+        lineno += 1
+# --- /curses stuff
+
+
+def bytes2human(n):
+    """
+    >>> bytes2human(10000)
+    '9.8 K/s'
+    >>> bytes2human(100001221)
+    '95.4 M/s'
+    """
+    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
+    prefix = {}
+    for i, s in enumerate(symbols):
+        prefix[s] = 1 << (i+1)*10
+    for s in reversed(symbols):
+        if n >= prefix[s]:
+            value = float(n) / prefix[s]
+            return '%.2f %s/s' % (value, s)
+    return '%.2f B/s' % (n)
+
+def poll(interval):
+    """Calculate IO usage by comparing IO statics before and
+    after the interval.
+    Return a tuple including all currently running processes
+    sorted by IO activity and total disks I/O activity.
+    """
+    # first get a list of all processes and disk io counters
+    procs = [p for p in psutil.process_iter()]
+    for p in procs[:]:
+        try:
+            p._before = p.get_io_counters()
+        except psutil.Error:
+            procs.remove(p)
+            continue
+    disks_before = psutil.disk_io_counters()
+
+    # sleep some time
+    time.sleep(interval)
+
+    # then retrieve the same info again
+    for p in procs[:]:
+        try:
+            p._after = p.get_io_counters()
+            p._cmdline = ' '.join(p.cmdline)
+            if not p._cmdline:
+                p._cmdline = p.name
+            p._username = p.username
+        except psutil.NoSuchProcess:
+            procs.remove(p)
+    disks_after = psutil.disk_io_counters()
+
+    # finally calculate results by comparing data before and
+    # after the interval
+    for p in procs:
+        p._read_per_sec = p._after.read_bytes - p._before.read_bytes
+        p._write_per_sec = p._after.write_bytes - p._before.write_bytes
+        p._total = p._read_per_sec + p._write_per_sec
+
+    disks_read_per_sec = disks_after.read_bytes - disks_before.read_bytes
+    disks_write_per_sec = disks_after.write_bytes - disks_before.write_bytes
+
+    # sort processes by total disk IO so that the more intensive
+    # ones get listed first
+    processes = sorted(procs, key=lambda p: p._total, reverse=True)
+
+    return (processes, disks_read_per_sec, disks_write_per_sec)
+
+
+def refresh_window(procs, disks_read, disks_write):
+    """Print results on screen by using curses."""
+    curses.endwin()
+    templ = "%-5s %-7s %11s %11s  %s"
+    win.erase()
+
+    disks_tot = "Total DISK READ: %s | Total DISK WRITE: %s" \
+                % (bytes2human(disks_read), bytes2human(disks_write))
+    print_line(disks_tot)
+
+    header = templ % ("PID", "USER", "DISK READ", "DISK WRITE", "COMMAND")
+    print_line(header, highlight=True)
+
+    for p in procs:
+        line = templ % (p.pid,
+                        p._username[:7],
+                        bytes2human(p._read_per_sec),
+                        bytes2human(p._write_per_sec),
+                        p._cmdline)
+        try:
+            print_line(line)
+        except curses.error:
+            break
+    win.refresh()
+
+def main():
+    try:
+        interval = 0
+        while 1:
+            args = poll(interval)
+            refresh_window(*args)
+            interval = 1
+    except (KeyboardInterrupt, SystemExit):
+        pass
+
+if __name__ == '__main__':
+    main()

build/psutil/examples/killall.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+Kill a process by name.
+"""
+
+import os
+import sys
+import psutil
+
+def main():
+    if len(sys.argv) != 2:
+        sys.exit('usage: %s name' % __file__)
+    else:
+        NAME = sys.argv[1]
+
+    killed = []
+    for proc in psutil.process_iter():
+        if proc.name == NAME and proc.pid != os.getpid():
+            proc.kill()
+            killed.append(proc.pid)
+    if not killed:
+        sys.exit('%s: no process found' % NAME)
+    else:
+        sys.exit(0)
+
+sys.exit(main())

build/psutil/examples/meminfo.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+Print system memory information.
+"""
+
+import psutil
+from psutil._compat import print_
+
+def to_meg(n):
+    return str(int(n / 1024 / 1024)) + "M"
+
+def pprint_ntuple(nt):
+    for name in nt._fields:
+        value = getattr(nt, name)
+        if name != 'percent':
+            value = to_meg(value)
+        print_('%-10s : %7s' % (name.capitalize(), value))
+
+def main():
+    print_('MEMORY\n------')
+    pprint_ntuple(psutil.virtual_memory())
+    print_('\nSWAP\n----')
+    pprint_ntuple(psutil.swap_memory())
+
+if __name__ == '__main__':
+    main()

build/psutil/examples/netstat.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+A clone of 'netstat'.
+"""
+
+import socket
+from socket import AF_INET, SOCK_STREAM, SOCK_DGRAM
+
+import psutil
+from psutil._compat import print_
+
+
+AD = "-"
+AF_INET6 = getattr(socket, 'AF_INET6', object())
+proto_map = {(AF_INET, SOCK_STREAM)  : 'tcp',
+             (AF_INET6, SOCK_STREAM) : 'tcp6',
+             (AF_INET, SOCK_DGRAM)   : 'udp',
+             (AF_INET6, SOCK_DGRAM)  : 'udp6'}
+
+def main():
+    templ = "%-5s %-22s %-22s %-13s %-6s %s"
+    print_(templ % ("Proto", "Local addr", "Remote addr", "Status", "PID",
+                    "Program name"))
+    for p in psutil.process_iter():
+        name = '?'
+        try:
+            name = p.name
+            cons = p.get_connections(kind='inet')
+        except psutil.AccessDenied:
+            print_(templ % (AD, AD, AD, AD, p.pid, name))
+        except psutil.NoSuchProcess:
+            continue
+        else:
+            for c in cons:
+                raddr = ""
+                laddr = "%s:%s" % (c.laddr)
+                if c.raddr:
+                    raddr = "%s:%s" % (c.raddr)
+                print_(templ % (proto_map[(c.family, c.type)],
+                                laddr,
+                                raddr,
+                                c.status,
+                                p.pid,
+                                name[:15]))
+
+if __name__ == '__main__':
+    main()

build/psutil/examples/nettop.py

+#!/usr/bin/env python
+#
+# $Id: iotop.py 1160 2011-10-14 18:50:36Z g.rodola@gmail.com $
+#
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+Shows real-time network statistics.
+
+Author: Giampaolo Rodola' <g.rodola@gmail.com>
+"""
+
+import sys
+import os
+if os.name != 'posix':
+    sys.exit('platform not supported')
+import curses
+import atexit
+import time
+
+import psutil
+
+
+# --- curses stuff
+def tear_down():
+    win.keypad(0)
+    curses.nocbreak()
+    curses.echo()
+    curses.endwin()
+
+win = curses.initscr()
+atexit.register(tear_down)
+curses.endwin()
+lineno = 0
+
+def print_line(line, highlight=False):
+    """A thin wrapper around curses's addstr()."""
+    global lineno
+    try:
+        if highlight:
+            line += " " * (win.getmaxyx()[1] - len(line))
+            win.addstr(lineno, 0, line, curses.A_REVERSE)
+        else:
+            win.addstr(lineno, 0, line, 0)
+    except curses.error:
+        lineno = 0
+        win.refresh()
+        raise
+    else:
+        lineno += 1
+# --- curses stuff
+
+
+def bytes2human(n):
+    """
+    >>> bytes2human(10000)
+    '9.8 K'
+    >>> bytes2human(100001221)
+    '95.4 M'
+    """
+    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
+    prefix = {}
+    for i, s in enumerate(symbols):
+        prefix[s] = 1 << (i+1)*10
+    for s in reversed(symbols):
+        if n >= prefix[s]:
+            value = float(n) / prefix[s]
+            return '%.2f %s' % (value, s)
+    return '%.2f B' % (n)
+
+def poll(interval):
+    """Retrieve raw stats within an interval window."""
+    tot_before = psutil.net_io_counters()
+    pnic_before = psutil.net_io_counters(pernic=True)
+    # sleep some time
+    time.sleep(interval)
+    tot_after = psutil.net_io_counters()
+    pnic_after = psutil.net_io_counters(pernic=True)
+    return (tot_before, tot_after, pnic_before, pnic_after)
+
+
+def refresh_window(tot_before, tot_after, pnic_before, pnic_after):
+    """Print stats on screen."""
+    global lineno
+
+    # totals
+    print_line("total bytes:           sent: %-10s   received: %s" \
+          % (bytes2human(tot_after.bytes_sent),
+             bytes2human(tot_after.bytes_recv))
+    )
+    print_line("total packets:         sent: %-10s   received: %s" \
+          % (tot_after.packets_sent, tot_after.packets_recv)
+    )
+
+
+    # per-network interface details: let's sort network interfaces so
+    # that the ones which generated more traffic are shown first
+    print_line("")
+    nic_names = list(pnic_after.keys())
+    nic_names.sort(key=lambda x: sum(pnic_after[x]), reverse=True)
+    for name in nic_names:
+        stats_before = pnic_before[name]
+        stats_after = pnic_after[name]
+        templ = "%-15s %15s %15s"
+        print_line(templ % (name, "TOTAL", "PER-SEC"), highlight=True)
+        print_line(templ % (
+            "bytes-sent",
+            bytes2human(stats_after.bytes_sent),
+            bytes2human(stats_after.bytes_sent - stats_before.bytes_sent) + '/s',
+        ))
+        print_line(templ % (
+            "bytes-recv",
+            bytes2human(stats_after.bytes_recv),
+            bytes2human(stats_after.bytes_recv - stats_before.bytes_recv) + '/s',
+        ))
+        print_line(templ % (
+            "pkts-sent",
+            stats_after.packets_sent,
+            stats_after.packets_sent - stats_before.packets_sent,
+        ))
+        print_line(templ % (
+            "pkts-recv",
+            stats_after.packets_recv,
+            stats_after.packets_recv - stats_before.packets_recv,
+        ))
+        print_line("")
+    win.refresh()
+    lineno = 0
+
+
+def main():
+    try:
+        interval = 0
+        while 1:
+            args = poll(interval)
+            refresh_window(*args)
+            interval = 1
+    except (KeyboardInterrupt, SystemExit):
+        pass
+
+if __name__ == '__main__':
+    main()

build/psutil/examples/pmap.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+A clone of 'pmap' utility on Linux, 'vmmap' on OSX and 'procstat -v' on BSD.
+Report memory map of a process.
+"""
+
+import sys
+
+import psutil
+from psutil._compat import print_
+
+def main():
+    if len(sys.argv) != 2:
+        sys.exit('usage: pmap pid')
+    p = psutil.Process(int(sys.argv[1]))
+    print_("pid=%s, name=%s" % (p.pid, p.name))
+    templ = "%-16s %10s  %-7s %s"
+    print_(templ % ("Address", "RSS", "Mode", "Mapping"))
+    total_rss = 0
+    for m in p.get_memory_maps(grouped=False):
+        total_rss += m.rss
+        print_(templ % (m.addr.split('-')[0].zfill(16),
+                        str(m.rss / 1024) + 'K' ,
+                        m.perms,
+                        m.path))
+    print_("-" * 33)
+    print_(templ % ("Total", str(total_rss / 1024) + 'K', '', ''))
+
+if __name__ == '__main__':
+    main()

build/psutil/examples/process_detail.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+Print detailed information about a process.
+
+Author: Giampaolo Rodola' <g.rodola@gmail.com>
+"""
+
+import os
+import datetime
+import socket
+import sys
+
+import psutil
+
+
+def convert_bytes(n):
+    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
+    prefix = {}
+    for i, s in enumerate(symbols):
+        prefix[s] = 1 << (i+1)*10
+    for s in reversed(symbols):
+        if n >= prefix[s]:
+            value = float(n) / prefix[s]
+            return '%.1f%s' % (value, s)
+    return "%sB" % n
+
+def print_(a, b):
+    if sys.stdout.isatty() and os.name == 'posix':
+        fmt = '\x1b[1;32m%-17s\x1b[0m %s' %(a, b)
+    else:
+        fmt = '%-15s %s' %(a, b)
+    # python 2/3 compatibility layer
+    sys.stdout.write(fmt + '\n')
+    sys.stdout.flush()
+
+def run(pid):
+    ACCESS_DENIED = ''
+    try:
+        p = psutil.Process(pid)
+        pinfo = p.as_dict(ad_value=ACCESS_DENIED)
+    except psutil.NoSuchProcess:
+        sys.exit(str(sys.exc_info()[1]))
+
+    try:
+        if p.parent:
+            parent = '(%s)' % p.parent.name
+        else:
+            parent = ''
+    except psutil.Error:
+        parent = ''
+    started = datetime.datetime.fromtimestamp(pinfo['create_time']
+                                                ).strftime('%Y-%M-%d %H:%M')
+    io = pinfo.get('io_counters', ACCESS_DENIED)
+    mem = '%s%% (resident=%s, virtual=%s) ' % (
+                                      round(pinfo['memory_percent'], 1),
+                                      convert_bytes(pinfo['memory_info'].rss),
+                                      convert_bytes(pinfo['memory_info'].vms))
+    children = p.get_children()
+
+    print_('pid', pinfo['pid'])
+    print_('name', pinfo['name'])
+    print_('exe', pinfo['exe'])
+    print_('parent', '%s %s' % (pinfo['ppid'], parent))
+    print_('cmdline', ' '.join(pinfo['cmdline']))
+    print_('started', started)
+    print_('user', pinfo['username'])
+    if os.name == 'posix' and pinfo['uids'] and pinfo['gids']:
+        print_('uids', 'real=%s, effective=%s, saved=%s' % pinfo['uids'])
+    if os.name == 'posix' and pinfo['gids']:
+        print_('gids', 'real=%s, effective=%s, saved=%s' % pinfo['gids'])
+    if os.name == 'posix':
+        print_('terminal', pinfo['terminal'] or '')
+    if hasattr(p, 'getcwd'):
+        print_('cwd', pinfo['cwd'])
+    print_('memory', mem)
+    print_('cpu', '%s%% (user=%s, system=%s)' % (pinfo['cpu_percent'],
+                                    getattr(pinfo['cpu_times'], 'user', '?'),
+                                    getattr(pinfo['cpu_times'], 'system', '?')))
+    print_('status', pinfo['status'])
+    print_('niceness', pinfo['nice'])
+    print_('num threads', pinfo['num_threads'])
+    if io != ACCESS_DENIED:
+        print_('I/O', 'bytes-read=%s, bytes-written=%s' % \
+                                               (convert_bytes(io.read_bytes),
+                                                convert_bytes(io.write_bytes)))
+    if children:
+        print_('children', '')
+        for child in children:
+            print_('', 'pid=%s name=%s' % (child.pid, child.name))
+
+    if pinfo['open_files'] != ACCESS_DENIED:
+        print_('open files', '')
+        for file in pinfo['open_files']:
+            print_('',  'fd=%s %s ' % (file.fd, file.path))
+
+    if pinfo['threads']:
+        print_('running threads', '')
+        for thread in pinfo['threads']:
+            print_('',  'id=%s, user-time=%s, sys-time=%s' \
+                         % (thread.id, thread.user_time, thread.system_time))
+    if pinfo['connections'] != ACCESS_DENIED:
+        print_('open connections', '')
+        for conn in pinfo['connections']:
+            if conn.type == socket.SOCK_STREAM:
+                type = 'TCP'
+            elif conn.type == socket.SOCK_DGRAM:
+                type = 'UDP'
+            else:
+                type = 'UNIX'
+            lip, lport = conn.laddr
+            if not conn.raddr:
+                rip, rport = '*', '*'
+            else:
+                rip, rport = conn.raddr
+            print_('',  '%s:%s -> %s:%s type=%s status=%s' \
+                         % (lip, lport, rip, rport, type, conn.status))
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+    if len(argv) == 1:
+        sys.exit(run(os.getpid()))
+    elif len(argv) == 2:
+        sys.exit(run(int(argv[1])))
+    else:
+        sys.exit('usage: %s [pid]' % __file__)
+
+if __name__ == '__main__':
+    sys.exit(main())

build/psutil/examples/top.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+A clone of top / htop.
+
+Author: Giampaolo Rodola' <g.rodola@gmail.com>
+"""
+
+import os
+import sys
+if os.name != 'posix':
+    sys.exit('platform not supported')
+import time
+import curses
+import atexit
+from datetime import datetime, timedelta
+
+import psutil
+
+
+# --- curses stuff
+def tear_down():
+    win.keypad(0)
+    curses.nocbreak()
+    curses.echo()
+    curses.endwin()
+
+win = curses.initscr()
+atexit.register(tear_down)
+curses.endwin()
+lineno = 0
+
+def print_line(line, highlight=False):
+    """A thin wrapper around curses's addstr()."""
+    global lineno
+    try:
+        if highlight:
+            line += " " * (win.getmaxyx()[1] - len(line))
+            win.addstr(lineno, 0, line, curses.A_REVERSE)
+        else:
+            win.addstr(lineno, 0, line, 0)
+    except curses.error:
+        lineno = 0
+        win.refresh()
+        raise
+    else:
+        lineno += 1
+# --- /curses stuff
+
+
+def bytes2human(n):
+    """
+    >>> bytes2human(10000)
+    '9K'
+    >>> bytes2human(100001221)
+    '95M'
+    """
+    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
+    prefix = {}
+    for i, s in enumerate(symbols):
+        prefix[s] = 1 << (i+1)*10
+    for s in reversed(symbols):
+        if n >= prefix[s]:
+            value = int(float(n) / prefix[s])
+            return '%s%s' % (value, s)
+    return "%sB" % n
+
+def poll(interval):
+    # sleep some time
+    time.sleep(interval)
+    procs = []
+    procs_status = {}
+    for p in psutil.process_iter():
+        try:
+            p.dict = p.as_dict(['username', 'get_nice', 'get_memory_info',
+                                'get_memory_percent', 'get_cpu_percent',
+                                'get_cpu_times', 'name', 'status'])
+            try:
+                procs_status[p.dict['status']] += 1
+            except KeyError:
+                procs_status[p.dict['status']] = 1
+        except psutil.NoSuchProcess:
+            pass
+        else:
+            procs.append(p)
+
+    # return processes sorted by CPU percent usage
+    processes = sorted(procs, key=lambda p: p.dict['cpu_percent'], reverse=True)
+    return (processes, procs_status)
+
+def print_header(procs_status, num_procs):
+    """Print system-related info, above the process list."""
+
+    def get_dashes(perc):
+        dashes =  "|" * int((float(perc) / 10 * 4))
+        empty_dashes = " " * (40 - len(dashes))
+        return dashes, empty_dashes
+
+    # cpu usage
+    for cpu_num, perc in enumerate(psutil.cpu_percent(interval=0, percpu=True)):
+        dashes, empty_dashes = get_dashes(perc)
+        print_line(" CPU%-2s [%s%s] %5s%%" % (cpu_num, dashes, empty_dashes,
+                                              perc))
+    mem = psutil.virtual_memory()
+    dashes, empty_dashes = get_dashes(mem.percent)
+    used = mem.total - mem.available
+    line = " Mem   [%s%s] %5s%% %6s/%s" % (
+        dashes, empty_dashes,
+        mem.percent,
+        str(int(used / 1024 / 1024)) + "M",
+        str(int(mem.total / 1024 / 1024)) + "M"
+    )
+    print_line(line)
+
+    # swap usage
+    swap = psutil.swap_memory()
+    dashes, empty_dashes = get_dashes(swap.percent)
+    line = " Swap  [%s%s] %5s%% %6s/%s" % (
+        dashes, empty_dashes,
+        swap.percent,
+        str(int(swap.used / 1024 / 1024)) + "M",
+        str(int(swap.total / 1024 / 1024)) + "M"
+    )
+    print_line(line)
+
+    # processes number and status
+    st = []
+    for x, y in procs_status.items():
+        if y:
+            st.append("%s=%s" % (x, y))
+    st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1)
+    print_line(" Processes: %s (%s)" % (num_procs, ' '.join(st)))
+    # load average, uptime
+    uptime = datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME)
+    av1, av2, av3 = os.getloadavg()
+    line = " Load average: %.2f %.2f %.2f  Uptime: %s" \
+            % (av1, av2, av3, str(uptime).split('.')[0])
+    print_line(line)
+
+def refresh_window(procs, procs_status):
+    """Print results on screen by using curses."""
+    curses.endwin()
+    templ = "%-6s %-8s %4s %5s %5s %6s %4s %9s  %2s"
+    win.erase()
+    header = templ % ("PID", "USER", "NI", "VIRT", "RES", "CPU%", "MEM%",
+                      "TIME+", "NAME")
+    print_header(procs_status, len(procs))
+    print_line("")
+    print_line(header, highlight=True)
+    for p in procs:
+        # TIME+ column shows process CPU cumulative time and it
+        # is expressed as: "mm:ss.ms"
+        if p.dict['cpu_times'] != None:
+            ctime = timedelta(seconds=sum(p.dict['cpu_times']))
+            ctime = "%s:%s.%s" % (ctime.seconds // 60 % 60,
+                                  str((ctime.seconds % 60)).zfill(2),
+                                  str(ctime.microseconds)[:2])
+        else:
+            ctime = ''
+        if p.dict['memory_percent'] is not None:
+            p.dict['memory_percent'] = round(p.dict['memory_percent'], 1)
+        else:
+            p.dict['memory_percent'] = ''
+        if p.dict['cpu_percent'] is None:
+            p.dict['cpu_percent'] = ''
+        if p.dict['username']:
+            username = p.dict['username'][:8]
+        else:
+            username = ""
+        line = templ % (p.pid,
+                        username,
+                        p.dict['nice'],
+                        bytes2human(getattr(p.dict['memory_info'], 'vms', 0)),
+                        bytes2human(getattr(p.dict['memory_info'], 'rss', 0)),
+                        p.dict['cpu_percent'],
+                        p.dict['memory_percent'],
+                        ctime,
+                        p.dict['name'] or '',
+                        )
+        try:
+            print_line(line)
+        except curses.error:
+            break
+        win.refresh()
+
+
+def main():
+    try:
+        interval = 0
+        while 1:
+            args = poll(interval)
+            refresh_window(*args)
+            interval = 1
+    except (KeyboardInterrupt, SystemExit):
+        pass
+
+if __name__ == '__main__':
+    main()

build/psutil/examples/who.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+A clone of 'who' command; print information about users who are
+currently logged in.
+"""
+
+import sys
+from datetime import datetime
+
+import psutil
+from psutil._compat import print_
+
+
+def main():
+    users = psutil.get_users()
+    for user in users:
+        print_("%-15s %-15s %s  (%s)" % \
+            (user.name,
+             user.terminal or '-',
+             datetime.fromtimestamp(user.started).strftime("%Y-%m-%d %H:%M"),
+             user.host)
+        )
+
+if __name__ == '__main__':
+    main()

build/psutil/pip-egg-info/psutil.egg-info/SOURCES.txt

+CREDITS
+HISTORY
+LICENSE
+MANIFEST.in
+README
+TODO
+setup.cfg
+setup.py
+examples/disk_usage.py
+examples/free.py
+examples/iotop.py
+examples/killall.py
+examples/meminfo.py
+examples/netstat.py
+examples/nettop.py
+examples/pmap.py
+examples/process_detail.py
+examples/top.py
+examples/who.py
+pip-egg-info/psutil.egg-info/PKG-INFO
+pip-egg-info/psutil.egg-info/SOURCES.txt
+pip-egg-info/psutil.egg-info/dependency_links.txt
+pip-egg-info/psutil.egg-info/top_level.txt
+psutil/__init__.py
+psutil/_common.py
+psutil/_compat.py
+psutil/_error.py
+psutil/_psbsd.py
+psutil/_pslinux.py
+psutil/_psmswindows.py
+psutil/_psosx.py
+psutil/_psposix.py
+psutil/_pssunos.py
+psutil/_psutil_bsd.c
+psutil/_psutil_bsd.h
+psutil/_psutil_common.c
+psutil/_psutil_common.h
+psutil/_psutil_linux.c
+psutil/_psutil_linux.h
+psutil/_psutil_mswindows.c
+psutil/_psutil_mswindows.h
+psutil/_psutil_osx.c
+psutil/_psutil_osx.h
+psutil/_psutil_posix.c
+psutil/_psutil_posix.h
+psutil/_psutil_sunos.c
+psutil/_psutil_sunos.h
+psutil/error.py
+psutil/arch/bsd/process_info.c
+psutil/arch/bsd/process_info.h
+psutil/arch/mswindows/ntextapi.h
+psutil/arch/mswindows/process_handles.c
+psutil/arch/mswindows/process_handles.h
+psutil/arch/mswindows/process_info.c
+psutil/arch/mswindows/process_info.h
+psutil/arch/mswindows/security.c
+psutil/arch/mswindows/security.h
+psutil/arch/osx/process_info.c
+psutil/arch/osx/process_info.h
+test/__init__.py
+test/_bsd.py
+test/_linux.py
+test/_osx.py
+test/_posix.py
+test/_sunos.py
+test/_windows.py
+test/test_memory_leaks.py
+test/test_psutil.py
\ No newline at end of file

build/psutil/pip-egg-info/psutil.egg-info/dependency_links.txt

+

build/psutil/pip-egg-info/psutil.egg-info/top_level.txt

+psutil
+_psutil_linux
+_psutil_posix

build/psutil/psutil.egg-info/SOURCES.txt

+CREDITS
+HISTORY
+LICENSE
+MANIFEST.in
+README
+TODO
+setup.py
+examples/disk_usage.py
+examples/free.py
+examples/iotop.py
+examples/killall.py
+examples/meminfo.py
+examples/netstat.py
+examples/nettop.py
+examples/pmap.py
+examples/process_detail.py
+examples/top.py
+examples/who.py
+psutil/__init__.py
+psutil/_common.py
+psutil/_compat.py
+psutil/_error.py
+psutil/_psbsd.py
+psutil/_pslinux.py
+psutil/_psmswindows.py
+psutil/_psosx.py
+psutil/_psposix.py
+psutil/_pssunos.py
+psutil/_psutil_bsd.c
+psutil/_psutil_bsd.h
+psutil/_psutil_common.c
+psutil/_psutil_common.h
+psutil/_psutil_linux.c
+psutil/_psutil_linux.h
+psutil/_psutil_mswindows.c
+psutil/_psutil_mswindows.h
+psutil/_psutil_osx.c
+psutil/_psutil_osx.h
+psutil/_psutil_posix.c
+psutil/_psutil_posix.h
+psutil/_psutil_sunos.c
+psutil/_psutil_sunos.h
+psutil/error.py
+psutil.egg-info/PKG-INFO
+psutil.egg-info/SOURCES.txt
+psutil.egg-info/dependency_links.txt
+psutil.egg-info/top_level.txt
+psutil/arch/bsd/process_info.c
+psutil/arch/bsd/process_info.h
+psutil/arch/mswindows/ntextapi.h
+psutil/arch/mswindows/process_handles.c
+psutil/arch/mswindows/process_handles.h
+psutil/arch/mswindows/process_info.c
+psutil/arch/mswindows/process_info.h
+psutil/arch/mswindows/security.c
+psutil/arch/mswindows/security.h
+psutil/arch/osx/process_info.c
+psutil/arch/osx/process_info.h
+test/__init__.py
+test/_bsd.py
+test/_linux.py
+test/_osx.py
+test/_posix.py
+test/_sunos.py
+test/_windows.py
+test/test_memory_leaks.py
+test/test_psutil.py
\ No newline at end of file

build/psutil/psutil.egg-info/dependency_links.txt

+

build/psutil/psutil.egg-info/top_level.txt

+psutil
+_psutil_linux
+_psutil_posix

build/psutil/psutil/_common.py

+#/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Common objects shared by all _ps* modules."""
+
+from __future__ import division
+import sys
+import os
+import stat
+import errno
+import warnings
+
+from psutil._compat import namedtuple, long, wraps
+
+# --- functions
+
+def usage_percent(used, total, _round=None):
+    """Calculate percentage usage of 'used' against 'total'."""
+    try:
+        ret = (used / total) * 100
+    except ZeroDivisionError:
+        ret = 0
+    if _round is not None:
+        return round(ret, _round)
+    else:
+        return ret
+
+def memoize(f):
+    """A simple memoize decorator for functions."""
+    cache= {}
+    def memf(*x):
+        if x not in cache:
+            cache[x] = f(*x)
+        return cache[x]
+    return memf
+
+class cached_property(object):
+    """A memoize decorator for class properties."""
+    enabled = True
+
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, type):
+        ret = self.func(instance)
+        if self.enabled:
+            instance.__dict__[self.func.__name__] = ret
+        return ret
+
+# http://goo.gl/jYLvf
+def deprecated(replacement=None):
+    """A decorator which can be used to mark functions as deprecated."""
+    def outer(fun):
+        msg = "psutil.%s is deprecated" % fun.__name__
+        if replacement is not None:
+            msg += "; use %s instead" % replacement
+        if fun.__doc__ is None:
+            fun.__doc__ = msg
+
+        @wraps(fun)
+        def inner(*args, **kwargs):
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            return fun(*args, **kwargs)
+
+        return inner
+    return outer
+
+
+def isfile_strict(path):
+    """Same as os.path.isfile() but does not swallow EACCES / EPERM
+    exceptions, see:
+    http://mail.python.org/pipermail/python-dev/2012-June/120787.html
+    """
+    try:
+        st = os.stat(path)
+    except OSError:
+        err = sys.exc_info()[1]
+        if err.errno in (errno.EPERM, errno.EACCES):
+            raise
+        return False
+    else:
+        return stat.S_ISREG(st.st_mode)
+
+
+# --- constants
+
+STATUS_RUNNING = "running"
+STATUS_SLEEPING = "sleeping"
+STATUS_DISK_SLEEP = "disk-sleep"
+STATUS_STOPPED = "stopped"
+STATUS_TRACING_STOP = "tracing-stop"
+STATUS_ZOMBIE = "zombie"
+STATUS_DEAD = "dead"
+STATUS_WAKE_KILL = "wake-kill"
+STATUS_WAKING = "waking"
+STATUS_IDLE = "idle"  # BSD
+STATUS_LOCKED = "locked"  # BSD
+STATUS_WAITING = "waiting"  # BSD
+
+CONN_ESTABLISHED = "ESTABLISHED"
+CONN_SYN_SENT = "SYN_SENT"
+CONN_SYN_RECV = "SYN_RECV"
+CONN_FIN_WAIT1 = "FIN_WAIT1"
+CONN_FIN_WAIT2 = "FIN_WAIT2"
+CONN_TIME_WAIT = "TIME_WAIT"
+CONN_CLOSE = "CLOSE"
+CONN_CLOSE_WAIT = "CLOSE_WAIT"
+CONN_LAST_ACK = "LAST_ACK"
+CONN_LISTEN = "LISTEN"
+CONN_CLOSING = "CLOSING"
+CONN_NONE = "NONE"
+
+# --- Process.get_connections() 'kind' parameter mapping
+
+import socket
+from socket import AF_INET, SOCK_STREAM, SOCK_DGRAM
+AF_INET6 = getattr(socket, 'AF_INET6', None)
+AF_UNIX = getattr(socket, 'AF_UNIX', None)
+
+conn_tmap = {
+    "all"  : ([AF_INET, AF_INET6, AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]),
+    "tcp"  : ([AF_INET, AF_INET6], [SOCK_STREAM]),
+    "tcp4" : ([AF_INET],           [SOCK_STREAM]),
+    "udp"  : ([AF_INET, AF_INET6], [SOCK_DGRAM]),
+    "udp4" : ([AF_INET],           [SOCK_DGRAM]),
+    "inet" : ([AF_INET, AF_INET6], [SOCK_STREAM, SOCK_DGRAM]),
+    "inet4": ([AF_INET],           [SOCK_STREAM, SOCK_DGRAM]),
+    "inet6": ([AF_INET6],          [SOCK_STREAM, SOCK_DGRAM]),
+}
+
+if AF_INET6 is not None:
+    conn_tmap.update({
+        "tcp6" : ([AF_INET6],          [SOCK_STREAM]),
+        "udp6" : ([AF_INET6],          [SOCK_DGRAM]),
+    })
+
+if AF_UNIX is not None:
+    conn_tmap.update({
+        "unix" : ([AF_UNIX],           [SOCK_STREAM, SOCK_DGRAM]),
+    })
+
+
+del AF_INET, AF_INET6, AF_UNIX, SOCK_STREAM, SOCK_DGRAM, socket
+
+# --- namedtuples
+
+# system
+nt_sysmeminfo = namedtuple('usage', 'total used free percent')
+# XXX - would 'available' be better than 'free' as for virtual_memory() nt?
+nt_swapmeminfo = namedtuple('swap', 'total used free percent sin sout')
+nt_diskinfo = namedtuple('usage', 'total used free percent')
+nt_partition = namedtuple('partition',  'device mountpoint fstype opts')
+nt_net_iostat = namedtuple('iostat',
+    'bytes_sent bytes_recv packets_sent packets_recv errin errout dropin dropout')
+nt_disk_iostat = namedtuple('iostat', 'read_count write_count read_bytes write_bytes read_time write_time')
+nt_user = namedtuple('user', 'name terminal host started')
+
+# processes
+nt_meminfo = namedtuple('meminfo', 'rss vms')
+nt_cputimes = namedtuple('cputimes', 'user system')
+nt_openfile = namedtuple('openfile', 'path fd')
+nt_thread = namedtuple('thread', 'id user_time system_time')
+nt_uids = namedtuple('user', 'real effective saved')
+nt_gids = namedtuple('group', 'real effective saved')
+nt_io = namedtuple('io', 'read_count write_count read_bytes write_bytes')
+nt_ionice = namedtuple('ionice', 'ioclass value')
+nt_ctxsw = namedtuple('amount', 'voluntary involuntary')
+
+class nt_connection(namedtuple('connection',
+                               'fd family type laddr raddr status')):
+        __slots__ = ()
+
+        @property
+        def local_address(self):
+            warnings.warn("'local_address' field is deprecated; use 'laddr'" \
+                          "instead", category=DeprecationWarning, stacklevel=2)
+            return self.laddr
+
+        @property
+        def remote_address(self):
+            warnings.warn("'remote_address' field is deprecated; use 'raddr'" \
+                          "instead", category=DeprecationWarning, stacklevel=2)
+            return self.raddr

build/psutil/psutil/_compat.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Module which provides compatibility with older Python versions."""
+
+__all__ = ["PY3", "int", "long", "xrange", "exec_", "callable",
+           "namedtuple", "property", "defaultdict"]
+
+import sys
+
+
+# --- python 2/3 compatibility layer
+
+PY3 = sys.version_info >= (3,)
+
+try:
+    import __builtin__
+except ImportError:
+    import builtins as __builtin__  # py3
+
+if PY3:
+    int = int
+    long = int
+    xrange = range
+    unicode = str
+    exec_ = getattr(__builtin__, "exec")
+    print_ = getattr(__builtin__, "print")
+
+    def u(s):
+        return s
+else:
+    int = int
+    long = long
+    xrange = xrange
+    unicode = unicode
+
+    def u(s):
+        return unicode(s, "unicode_escape")
+
+    def exec_(code, globs=None, locs=None):
+        if globs is None:
+            frame = _sys._getframe(1)
+            globs = frame.f_globals
+            if locs is None:
+                locs = frame.f_locals
+            del frame
+        elif locs is None:
+            locs = globs
+        exec("""exec code in globs, locs""")
+
+    def print_(s):
+        sys.stdout.write(s + '\n')
+        sys.stdout.flush()
+
+
+# removed in 3.0, reintroduced in 3.2
+try:
+    callable = callable
+except Exception:
+    def callable(obj):
+        for klass in type(obj).__mro__:
+            if "__call__" in klass.__dict__:
+                return True
+        return False
+
+
+# --- stdlib additions
+
+try:
+    from collections import namedtuple
+except ImportError:
+    from operator import itemgetter as _itemgetter
+    from keyword import iskeyword as _iskeyword
+    import sys as _sys
+
+    def namedtuple(typename, field_names, verbose=False, rename=False):
+        """A collections.namedtuple implementation written in Python
+        to support Python versions < 2.6.
+
+        Taken from: http://code.activestate.com/recipes/500261/
+        """
+        # Parse and validate the field names.  Validation serves two
+        # purposes, generating informative error messages and preventing
+        # template injection attacks.
+        if isinstance(field_names, basestring):
+             # names separated by whitespace and/or commas
+            field_names = field_names.replace(',', ' ').split()
+        field_names = tuple(map(str, field_names))
+        if rename:
+            names = list(field_names)
+            seen = set()
+            for i, name in enumerate(names):
+                if (not min(c.isalnum() or c=='_' for c in name) or _iskeyword(name)
+                    or not name or name[0].isdigit() or name.startswith('_')
+                    or name in seen):
+                        names[i] = '_%d' % i
+                seen.add(name)
+            field_names = tuple(names)
+        for name in (typename,) + field_names:
+            if not min(c.isalnum() or c=='_' for c in name):
+                raise ValueError('Type names and field names can only contain ' \
+                                 'alphanumeric characters and underscores: %r'
+                                 % name)
+            if _iskeyword(name):
+                raise ValueError('Type names and field names cannot be a keyword: %r' \
+                                 % name)
+            if name[0].isdigit():
+                raise ValueError('Type names and field names cannot start with a ' \
+                                 'number: %r' % name)
+        seen_names = set()
+        for name in field_names:
+            if name.startswith('_') and not rename:
+                raise ValueError('Field names cannot start with an underscore: %r'
+                                 % name)
+            if name in seen_names:
+                raise ValueError('Encountered duplicate field name: %r' % name)
+            seen_names.add(name)
+
+        # Create and fill-in the class template
+        numfields = len(field_names)
+        # tuple repr without parens or quotes
+        argtxt = repr(field_names).replace("'", "")[1:-1]
+        reprtxt = ', '.join('%s=%%r' % name for name in field_names)
+        template = '''class %(typename)s(tuple):
+        '%(typename)s(%(argtxt)s)' \n
+        __slots__ = () \n
+        _fields = %(field_names)r \n
+        def __new__(_cls, %(argtxt)s):
+            return _tuple.__new__(_cls, (%(argtxt)s)) \n
+        @classmethod
+        def _make(cls, iterable, new=tuple.__new__, len=len):
+            'Make a new %(typename)s object from a sequence or iterable'
+            result = new(cls, iterable)
+            if len(result) != %(numfields)d:
+                raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result))
+            return result \n
+        def __repr__(self):
+            return '%(typename)s(%(reprtxt)s)' %% self \n
+        def _asdict(self):
+            'Return a new dict which maps field names to their values'
+            return dict(zip(self._fields, self)) \n
+        def _replace(_self, **kwds):
+            'Return a new %(typename)s object replacing specified fields with new values'
+            result = _self._make(map(kwds.pop, %(field_names)r, _self))
+            if kwds:
+                raise ValueError('Got unexpected field names: %%r' %% kwds.keys())
+            return result \n
+        def __getnewargs__(self):
+            return tuple(self) \n\n''' % locals()
+        for i, name in enumerate(field_names):
+            template += '        %s = _property(_itemgetter(%d))\n' % (name, i)
+        if verbose:
+            sys.stdout.write(template + '\n')
+            sys.stdout.flush()
+
+        # Execute the template string in a temporary namespace
+        namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename,
+                         _property=property, _tuple=tuple)
+        try:
+            exec_(template, namespace)
+        except SyntaxError:
+            e = sys.exc_info()[1]
+            raise SyntaxError(e.message + ':\n' + template)
+        result = namespace[typename]
+
+        # For pickling to work, the __module__ variable needs to be set
+        # to the frame where the named tuple is created.  Bypass this
+        # step in enviroments where sys._getframe is not defined (Jython
+        # for example) or sys._getframe is not defined for arguments
+        # greater than 0 (IronPython).
+        try:
+            result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__')
+        except (AttributeError, ValueError):
+            pass
+
+        return result
+
+
+# hack to support property.setter/deleter on python < 2.6
+# http://docs.python.org/library/functions.html?highlight=property#property
+if hasattr(property, 'setter'):
+    property = property
+else:
+    class property(__builtin__.property):
+        __metaclass__ = type
+
+        def __init__(self, fget, *args, **kwargs):
+            super(property, self).__init__(fget, *args, **kwargs)
+            self.__doc__ = fget.__doc__
+
+        def getter(self, method):
+            return property(method, self.fset, self.fdel)
+
+        def setter(self, method):
+            return property(self.fget, method, self.fdel)
+
+        def deleter(self, method):
+            return property(self.fget, self.fset, method)
+
+
+# py 2.5 collections.defauldict
+# Taken from:
+# http://code.activestate.com/recipes/523034-emulate-collectionsdefaultdict/
+# credits: Jason Kirtland
+try:
+    from collections import defaultdict
+except ImportError:
+    class defaultdict(dict):
+
+        def __init__(self, default_factory=None, *a, **kw):
+            if (default_factory is not None and
+                not hasattr(default_factory, '__call__')):
+                raise TypeError('first argument must be callable')
+            dict.__init__(self, *a, **kw)
+            self.default_factory = default_factory
+
+        def __getitem__(self, key):
+            try:
+                return dict.__getitem__(self, key)
+            except KeyError:
+                return self.__missing__(key)
+
+        def __missing__(self, key):
+            if self.default_factory is None:
+                raise KeyError(key)
+            self[key] = value = self.default_factory()
+            return value
+
+        def __reduce__(self):
+            if self.default_factory is None:
+                args = tuple()
+            else:
+                args = self.default_factory,
+            return type(self), args, None, None, self.items()
+
+        def copy(self):
+            return self.__copy__()
+
+        def __copy__(self):
+            return type(self)(self.default_factory, self)
+
+        def __deepcopy__(self, memo):
+            import copy
+            return type(self)(self.default_factory,
+                              copy.deepcopy(self.items()))
+
+        def __repr__(self):
+            return 'defaultdict(%s, %s)' % (self.default_factory,
+                                            dict.__repr__(self))
+
+
+# py 2.5 functools.wraps
+try:
+    from functools import wraps
+except ImportError:
+    def wraps(original):
+        def inner(fn):
+            # see functools.WRAPPER_ASSIGNMENTS
+            for attribute in ['__module__',
+                              '__name__',
+                              '__doc__'
+                              ]:
+                setattr(fn, attribute, getattr(original, attribute))
+            # see functools.WRAPPER_UPDATES
+            for attribute in ['__dict__',
+                              ]:
+                if hasattr(fn, attribute):
+                    getattr(fn, attribute).update(getattr(original, attribute))
+                else:
+                    setattr(fn, attribute,
+                            getattr(original, attribute).copy())
+            return fn
+        return inner

build/psutil/psutil/_error.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""psutil exception classes.
+Not supposed to be used / imported directly.
+Instead use psutil.NoSuchProcess, etc.
+"""
+
+
+class Error(Exception):
+    """Base exception class. All other psutil exceptions inherit
+    from this one.
+    """
+
+class NoSuchProcess(Error):
+    """Exception raised when a process with a certain PID doesn't
+    or no longer exists (zombie).
+    """
+
+    def __init__(self, pid, name=None, msg=None):
+        self.pid = pid
+        self.name = name
+        self.msg = msg
+        if msg is None:
+            if name:
+                details = "(pid=%s, name=%s)" % (self.pid, repr(self.name))
+            else:
+                details = "(pid=%s)" % self.pid
+            self.msg = "process no longer exists " + details
+
+    def __str__(self):
+        return self.msg
+
+
+class AccessDenied(Error):
+    """Exception raised when permission to perform an action is denied."""
+
+    def __init__(self, pid=None, name=None, msg=None):
+        self.pid = pid
+        self.name = name
+        self.msg = msg
+        if msg is None:
+            if (pid is not None) and (name is not None):
+                self.msg = "(pid=%s, name=%s)" % (pid, repr(name))
+            elif (pid is not None):
+                self.msg = "(pid=%s)" % self.pid
+            else:
+                self.msg = ""
+
+    def __str__(self):
+        return self.msg
+
+
+class TimeoutExpired(Error):
+    """Raised on Process.wait(timeout) if timeout expires and process
+    is still alive.
+    """
+
+    def __init__(self, pid=None, name=None):
+        self.pid = pid
+        self.name = name
+        if (pid is not None) and (name is not None):
+            self.msg = "(pid=%s, name=%s)" % (pid, repr(name))
+        elif (pid is not None):
+            self.msg = "(pid=%s)" % self.pid
+        else:
+            self.msg = ""
+
+    def __str__(self):
+        return self.msg

build/psutil/psutil/_psposix.py

+#!/usr/bin/env python
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Routines common to all posix systems."""
+
+import os
+import errno
+import psutil
+import sys
+import time
+import glob
+
+from psutil._compat import PY3, unicode
+from psutil._error import TimeoutExpired
+from psutil._common import nt_diskinfo, usage_percent, memoize
+
+
+def pid_exists(pid):
+    """Check whether pid exists in the current process table."""
+    if pid < 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        e = sys.exc_info()[1]
+        return e.errno == errno.EPERM
+    else:
+        return True
+
+def wait_pid(pid, timeout=None):
+    """Wait for process with pid 'pid' to terminate and return its
+    exit status code as an integer.
+
+    If pid is not a children of os.getpid() (current process) just
+    waits until the process disappears and return None.
+
+    If pid does not exist at all return None immediately.
+
+    Raise TimeoutExpired on timeout expired.
+    """
+    def check_timeout(delay):
+        if timeout is not None:
+            if timer() >= stop_at:
+                raise TimeoutExpired(pid)
+        time.sleep(delay)
+        return min(delay * 2, 0.04)
+
+    timer = getattr(time, 'monotonic', time.time)
+    if timeout is not None:
+        waitcall = lambda: os.waitpid(pid, os.WNOHANG)
+        stop_at = timer() + timeout
+    else:
+        waitcall = lambda: os.waitpid(pid, 0)
+
+    delay = 0.0001
+    while 1:
+        try:
+            retpid, status = waitcall()
+        except OSError:
+            err = sys.exc_info()[1]
+            if err.errno == errno.EINTR:
+                delay = check_timeout(delay)
+                continue
+            elif err.errno == errno.ECHILD:
+                # This has two meanings:
+                # - pid is not a child of os.getpid() in which case
+                #   we keep polling until it's gone
+                # - pid never existed in the first place
+                # In both cases we'll eventually return None as we
+                # can't determine its exit status code.
+                while 1:
+                    if pid_exists(pid):
+                        delay = check_timeout(delay)
+                    else:
+                        return
+            else:
+                raise
+        else:
+            if retpid == 0:
+                # WNOHANG was used, pid is still running
+                delay = check_timeout(delay)
+                continue
+            # process exited due to a signal; return the integer of
+            # that signal
+            if os.WIFSIGNALED(status):
+                return os.WTERMSIG(status)
+            # process exited using exit(2) system call; return the
+            # integer exit(2) system call has been called with
+            elif os.WIFEXITED(status):
+                return os.WEXITSTATUS(status)
+            else:
+                # should never happen
+                raise RuntimeError("unknown process exit status")
+
+def get_disk_usage(path):
+    """Return disk usage associated with path."""
+    try:
+        st = os.statvfs(path)
+    except UnicodeEncodeError:
+        if not PY3 and isinstance(path, unicode):
+            # this is a bug with os.statvfs() and unicode on
+            # Python 2, see:
+            # - https://code.google.com/p/psutil/issues/detail?id=416
+            # - http://bugs.python.org/issue18695
+            try:
+                path = path.encode(sys.getfilesystemencoding())
+            except UnicodeEncodeError:
+                pass
+            st = os.statvfs(path)
+        else:
+            raise
+    free = (st.f_bavail * st.f_frsize)
+    total = (st.f_blocks * st.f_frsize)
+    used = (st.f_blocks - st.f_bfree) * st.f_frsize
+    percent = usage_percent(used, total, _round=1)
+    # NB: the percentage is -5% than what shown by df due to
+    # reserved blocks that we are currently not considering:
+    # http://goo.gl/sWGbH
+    return nt_diskinfo(total, used, free, percent)
+
+@memoize
+def _get_terminal_map():
+    ret = {}
+    ls = glob.glob('/dev/tty*') + glob.glob('/dev/pts/*')
+    for name in ls:
+        assert name not in ret
+        try:
+            ret[os.stat(name).st_rdev] = name
+        except OSError:
+            err = sys.exc_info()[1]
+            if err.errno != errno.ENOENT:
+                raise
+    return ret

build/psutil/psutil/_psutil_bsd.h

+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * BSD platform-specific module methods for _psutil_bsd
+ */
+
+#include <Python.h>
+
+// --- per-process functions
+
+static PyObject* get_process_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_process_name(PyObject* self, PyObject* args);
+static PyObject* get_process_exe(PyObject* self, PyObject* args);
+static PyObject* get_process_cmdline(PyObject* self, PyObject* args);
+static PyObject* get_process_ppid(PyObject* self, PyObject* args);
+static PyObject* get_process_uids(PyObject* self, PyObject* args);
+static PyObject* get_process_gids(PyObject* self, PyObject* args);
+static PyObject* get_process_connections(PyObject* self, PyObject* args);
+static PyObject* get_process_create_time(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_info(PyObject* self, PyObject* args);
+static PyObject* get_process_num_threads(PyObject* self, PyObject* args);
+static PyObject* get_process_num_fds(PyObject* self, PyObject* args);
+static PyObject* get_process_threads(PyObject* self, PyObject* args);
+static PyObject* get_process_status(PyObject* self, PyObject* args);
+static PyObject* get_process_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_process_tty_nr(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_maps(PyObject* self, PyObject* args);
+static PyObject* get_process_num_ctx_switches(PyObject* self, PyObject* args);
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 800000
+static PyObject* get_process_open_files(PyObject* self, PyObject* args);
+static PyObject* get_process_cwd(PyObject* self, PyObject* args);
+#endif
+
+// --- system-related functions
+
+static PyObject* get_pid_list(PyObject* self, PyObject* args);
+static PyObject* get_num_cpus(PyObject* self, PyObject* args);
+static PyObject* get_virtual_mem(PyObject* self, PyObject* args);
+static PyObject* get_swap_mem(PyObject* self, PyObject* args);
+static PyObject* get_system_cpu_times(PyObject* self, PyObject* args);
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 800000
+static PyObject* get_system_per_cpu_times(PyObject* self, PyObject* args);
+#endif
+static PyObject* get_system_boot_time(PyObject* self, PyObject* args);
+static PyObject* get_disk_partitions(PyObject* self, PyObject* args);
+static PyObject* get_net_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_disk_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_system_users(PyObject* self, PyObject* args);

build/psutil/psutil/_psutil_common.c

+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Routines common to all platforms.
+ */
+
+#include <Python.h>
+
+
+/*
+ * Set OSError(errno=ESRCH, strerror="No such process") Python exception.
+ */
+PyObject *
+NoSuchProcess(void) {
+    PyObject *exc;
+    char *msg = strerror(ESRCH);
+    exc = PyObject_CallFunction(PyExc_OSError, "(is)", ESRCH, msg);
+    PyErr_SetObject(PyExc_OSError, exc);
+    Py_XDECREF(exc);
+    return NULL;
+}
+
+/*
+ * Set OSError(errno=EACCES, strerror="Permission denied") Python exception.
+ */
+PyObject *
+AccessDenied(void) {
+    PyObject *exc;
+    char *msg = strerror(EACCES);
+    exc = PyObject_CallFunction(PyExc_OSError, "(is)", EACCES, msg);
+    PyErr_SetObject(PyExc_OSError, exc);
+    Py_XDECREF(exc);
+    return NULL;
+}

build/psutil/psutil/_psutil_common.h

+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+PyObject* NoSuchProcess(void);
+PyObject* AccessDenied(void);
+

build/psutil/psutil/_psutil_linux.h

+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * LINUX specific module methods for _psutil_linux
+ */
+
+#include <Python.h>
+
+static PyObject* linux_ioprio_get(PyObject* self, PyObject* args);
+static PyObject* linux_ioprio_set(PyObject* self, PyObject* args);
+static PyObject* get_disk_partitions(PyObject* self, PyObject* args);
+static PyObject* get_sysinfo(PyObject* self, PyObject* args);
+static PyObject* get_process_cpu_affinity(PyObject* self, PyObject* args);
+static PyObject* set_process_cpu_affinity(PyObject* self, PyObject* args);
+static PyObject* get_system_users(PyObject* self, PyObject* args);

build/psutil/psutil/_psutil_mswindows.h

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Windows platform-specific module methods for _psutil_mswindows
+ */
+
+#include <Python.h>
+#include <windows.h>
+
+// --- per-process functions
+
+static PyObject* get_process_cmdline(PyObject* self, PyObject* args);
+static PyObject* get_process_exe(PyObject* self, PyObject* args);
+static PyObject* get_process_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_process_create_time(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_info(PyObject* self, PyObject* args);
+static PyObject* get_process_cwd(PyObject* self, PyObject* args);
+static PyObject* get_process_open_files(PyObject* self, PyObject* args);
+static PyObject* get_process_username(PyObject* self, PyObject* args);
+static PyObject* get_process_connections(PyObject* self, PyObject* args);
+static PyObject* get_process_num_threads(PyObject* self, PyObject* args);
+static PyObject* get_process_threads(PyObject* self, PyObject* args);
+static PyObject* get_process_priority(PyObject* self, PyObject* args);
+static PyObject* set_process_priority(PyObject* self, PyObject* args);
+#if (_WIN32_WINNT >= 0x0600)  // Windows Vista
+static PyObject* get_process_io_priority(PyObject* self, PyObject* args);
+static PyObject* set_process_io_priority(PyObject* self, PyObject* args);
+#endif
+static PyObject* get_process_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_process_cpu_affinity(PyObject* self, PyObject* args);
+static PyObject* set_process_cpu_affinity(PyObject* self, PyObject* args);
+static PyObject* get_process_num_handles(PyObject* self, PyObject* args);
+static PyObject* get_process_num_ctx_switches(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_maps(PyObject* self, PyObject* args);
+static PyObject* get_ppid_map(PyObject* self, PyObject* args);
+
+static PyObject* get_process_cpu_times_2(PyObject* self, PyObject* args);
+static PyObject* get_process_create_time_2(PyObject* self, PyObject* args);
+static PyObject* get_process_num_handles_2(PyObject* self, PyObject* args);
+static PyObject* get_process_io_counters_2(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_info_2(PyObject* self, PyObject* args);
+
+static PyObject* suspend_process(PyObject* self, PyObject* args);
+static PyObject* resume_process(PyObject* self, PyObject* args);
+static PyObject* is_process_suspended(PyObject* self, PyObject* args);
+static PyObject* process_wait(PyObject* self, PyObject* args);
+static PyObject* kill_process(PyObject* self, PyObject* args);
+
+// --- system-related functions
+
+static PyObject* get_pid_list(PyObject* self, PyObject* args);
+static PyObject* get_num_cpus(PyObject* self, PyObject* args);
+static PyObject* get_system_boot_time(PyObject* self, PyObject* args);
+static PyObject* get_virtual_mem(PyObject* self, PyObject* args);
+static PyObject* get_system_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_system_per_cpu_times(PyObject* self, PyObject* args);
+static PyObject* pid_exists(PyObject* self, PyObject* args);
+static PyObject* get_disk_usage(PyObject* self, PyObject* args);
+static PyObject* get_disk_partitions(PyObject* self, PyObject* args);
+static PyObject* get_net_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_disk_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_system_users(PyObject* self, PyObject* args);
+
+// --- windows API bindings
+
+static PyObject* win32_QueryDosDevice(PyObject* self, PyObject* args);
+
+// --- internal
+int suspend_resume_process(DWORD pid, int suspend);

build/psutil/psutil/_psutil_osx.h

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * OS X platform-specific module methods for _psutil_osx
+ */
+
+#include <Python.h>
+
+// --- per-process functions
+static PyObject* get_process_name(PyObject* self, PyObject* args);
+static PyObject* get_process_cmdline(PyObject* self, PyObject* args);
+static PyObject* get_process_cwd(PyObject* self, PyObject* args);
+static PyObject* get_process_exe(PyObject* self, PyObject* args);
+static PyObject* get_process_ppid(PyObject* self, PyObject* args);
+static PyObject* get_process_uids(PyObject* self, PyObject* args);
+static PyObject* get_process_gids(PyObject* self, PyObject* args);
+static PyObject* get_process_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_process_create_time(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_info(PyObject* self, PyObject* args);
+static PyObject* get_process_num_threads(PyObject* self, PyObject* args);
+static PyObject* get_process_status(PyObject* self, PyObject* args);
+static PyObject* get_process_threads(PyObject* self, PyObject* args);
+static PyObject* get_process_open_files(PyObject* self, PyObject* args);
+static PyObject* get_process_connections(PyObject* self, PyObject* args);
+static PyObject* get_process_num_fds(PyObject* self, PyObject* args);
+static PyObject* get_process_tty_nr(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_maps(PyObject* self, PyObject* args);
+
+// --- system-related functions
+static PyObject* get_pid_list(PyObject* self, PyObject* args);
+static PyObject* get_num_cpus(PyObject* self, PyObject* args);
+static PyObject* get_virtual_mem(PyObject* self, PyObject* args);
+static PyObject* get_swap_mem(PyObject* self, PyObject* args);
+static PyObject* get_system_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_system_per_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_system_boot_time(PyObject* self, PyObject* args);
+static PyObject* get_disk_partitions(PyObject* self, PyObject* args);
+static PyObject* get_net_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_disk_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_system_users(PyObject* self, PyObject* args);

build/psutil/psutil/_psutil_posix.c

+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Functions specific to all POSIX compliant platforms.
+ */
+
+#include <Python.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+
+#include "_psutil_posix.h"
+
+
+/*
+ * Given a PID return process priority as a Python integer.
+ */
+static PyObject*
+posix_getpriority(PyObject* self, PyObject* args)
+{
+    long pid;
+    int priority;
+    errno = 0;
+    if (! PyArg_ParseTuple(args, "l", &pid)) {
+        return NULL;
+    }
+    priority = getpriority(PRIO_PROCESS, pid);
+    if (errno != 0) {
+        return PyErr_SetFromErrno(PyExc_OSError);
+    }
+    return Py_BuildValue("i", priority);
+}
+
+/*
+ * Given a PID and a value change process priority.
+ */
+static PyObject*
+posix_setpriority(PyObject* self, PyObject* args)
+{
+    long pid;
+    int priority;
+    int retval;
+    if (! PyArg_ParseTuple(args, "li", &pid, &priority)) {
+        return NULL;
+    }
+    retval = setpriority(PRIO_PROCESS, pid, priority);
+    if (retval == -1) {
+        return PyErr_SetFromErrno(PyExc_OSError);
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+/*
+ * define the psutil C module methods and initialize the module.
+ */
+static PyMethodDef
+PsutilMethods[] =
+{
+     {"getpriority", posix_getpriority, METH_VARARGS,
+        "Return process priority"},
+     {"setpriority", posix_setpriority, METH_VARARGS,
+        "Set process priority"},
+     {NULL, NULL, 0, NULL}
+};
+
+struct module_state {
+    PyObject *error;
+};
+
+#if PY_MAJOR_VERSION >= 3
+#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
+#else
+#define GETSTATE(m) (&_state)
+#endif
+
+#if PY_MAJOR_VERSION >= 3
+
+static int
+psutil_posix_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int
+psutil_posix_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+static struct PyModuleDef
+moduledef = {
+        PyModuleDef_HEAD_INIT,
+        "psutil_posix",
+        NULL,
+        sizeof(struct module_state),
+        PsutilMethods,
+        NULL,
+        psutil_posix_traverse,
+        psutil_posix_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyObject *
+PyInit__psutil_posix(void)
+
+#else
+#define INITERROR return
+
+void init_psutil_posix(void)
+#endif
+{
+#if PY_MAJOR_VERSION >= 3
+    PyObject *module = PyModule_Create(&moduledef);
+#else
+    PyObject *module = Py_InitModule("_psutil_posix", PsutilMethods);
+#endif
+    if (module == NULL) {
+        INITERROR;
+    }
+#if PY_MAJOR_VERSION >= 3
+    return module;
+#endif
+}

build/psutil/psutil/_psutil_posix.h

+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * POSIX specific module methods for _psutil_posix
+ */
+
+#include <Python.h>
+
+static PyObject* posix_getpriority(PyObject* self, PyObject* args);
+static PyObject* posix_setpriority(PyObject* self, PyObject* args);

build/psutil/psutil/_psutil_sunos.h

+/*
+ * $Id$
+ *
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Sun OS specific module functions for _psutil_sunos extension
+ */
+
+#include <Python.h>
+
+// processes
+static PyObject* query_process_thread(PyObject* self, PyObject* args);
+static PyObject* get_process_basic_info(PyObject* self, PyObject* args);
+static PyObject* get_process_name_and_args(PyObject* self, PyObject* args);
+static PyObject* get_process_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_process_cred(PyObject* self, PyObject* args);
+static PyObject* get_process_memory_maps(PyObject* self, PyObject* args);
+static PyObject* get_process_num_ctx_switches(PyObject* self, PyObject* args);
+static PyObject* get_process_connections(PyObject* self, PyObject* args);
+
+// system
+static PyObject* get_swap_mem(PyObject* self, PyObject* args);
+static PyObject* get_system_users(PyObject* self, PyObject* args);
+static PyObject* get_disk_partitions(PyObject* self, PyObject* args);
+static PyObject* get_system_per_cpu_times(PyObject* self, PyObject* args);
+static PyObject* get_disk_io_counters(PyObject* self, PyObject* args);
+static PyObject* get_net_io_counters(PyObject* self, PyObject* args);

build/psutil/psutil/arch/bsd/process_info.c

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Helper functions related to fetching process information. Used by _psutil_bsd
+ * module methods.
+ */
+
+#include <Python.h>
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/param.h>
+#include <sys/user.h>
+#include <sys/proc.h>
+#include <signal.h>
+
+#include "process_info.h"
+
+
+/*
+ * Returns a list of all BSD processes on the system.  This routine
+ * allocates the list and puts it in *procList and a count of the
+ * number of entries in *procCount.  You are responsible for freeing
+ * this list (use "free" from System framework).
+ * On success, the function returns 0.
+ * On error, the function returns a BSD errno value.
+ */
+int
+psutil_get_proc_list(struct kinfo_proc **procList, size_t *procCount)
+{
+    int err;
+    struct kinfo_proc * result;
+    int done;
+    static const int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_PROC, 0 };
+    // Declaring name as const requires us to cast it when passing it to
+    // sysctl because the prototype doesn't include the const modifier.
+    size_t              length;
+
+    assert( procList != NULL);
+    assert(*procList == NULL);
+    assert(procCount != NULL);
+
+    *procCount = 0;
+
+    /*
+     * We start by calling sysctl with result == NULL and length == 0.
+     * That will succeed, and set length to the appropriate length.
+     * We then allocate a buffer of that size and call sysctl again
+     * with that buffer.  If that succeeds, we're done.  If that fails
+     * with ENOMEM, we have to throw away our buffer and loop.  Note
+     * that the loop causes use to call sysctl with NULL again; this
+     * is necessary because the ENOMEM failure case sets length to
+     * the amount of data returned, not the amount of data that
+     * could have been returned.
+     */
+    result = NULL;
+    done = 0;
+    do {
+        assert(result == NULL);
+        // Call sysctl with a NULL buffer.
+        length = 0;
+        err = sysctl((int *)name, (sizeof(name) / sizeof(*name)) - 1,
+                     NULL, &length, NULL, 0);
+        if (err == -1)
+            err = errno;
+
+        // Allocate an appropriately sized buffer based on the results
+        // from the previous call.
+        if (err == 0) {
+            result = malloc(length);
+            if (result == NULL)
+                err = ENOMEM;
+        }
+
+        // Call sysctl again with the new buffer.  If we get an ENOMEM
+        // error, toss away our buffer and start again.
+        if (err == 0) {
+            err = sysctl((int *) name, (sizeof(name) / sizeof(*name)) - 1,
+                          result, &length, NULL, 0);
+            if (err == -1)
+                err = errno;
+            if (err == 0) {
+                done = 1;
+            }
+            else if (err == ENOMEM) {
+                assert(result != NULL);
+                free(result);
+                result = NULL;
+                err = 0;
+            }
+        }
+    } while (err == 0 && ! done);
+
+    // Clean up and establish post conditions.
+    if (err != 0 && result != NULL) {
+        free(result);
+        result = NULL;
+    }
+
+    *procList = result;
+    *procCount = length / sizeof(struct kinfo_proc);
+
+    assert((err == 0) == (*procList != NULL));
+    return err;
+}
+
+
+char
+*psutil_get_cmd_path(long pid, size_t *pathsize)
+{
+    int  mib[4];
+    char *path;
+    size_t size = 0;
+
+    /*
+     * Make a sysctl() call to get the raw argument space of the process.
+     */
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PATHNAME;
+    mib[3] = pid;
+
+    // call with a null buffer first to determine if we need a buffer
+    if (sysctl(mib, 4, NULL, &size, NULL, 0) == -1) {
+        return NULL;
+    }
+
+    path = malloc(size);
+    if (path == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    *pathsize = size;
+    if (sysctl(mib, 4, path, &size, NULL, 0) == -1) {
+        free(path);
+        return NULL;       /* Insufficient privileges */
+    }
+
+    return path;
+}
+
+
+/*
+ * XXX no longer used; it probably makese sense to remove it.
+ * Borrowed from psi Python System Information project
+ *
+ * Get command arguments and environment variables.
+ *
+ * Based on code from ps.
+ *
+ * Returns:
+ *      0 for success;
+ *      -1 for failure (Exception raised);
+ *      1 for insufficient privileges.
+ */
+char
+*psutil_get_cmd_args(long pid, size_t *argsize)
+{
+    int mib[4], argmax;
+    size_t size = sizeof(argmax);
+    char *procargs = NULL;
+
+    /* Get the maximum process arguments size. */
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_ARGMAX;
+
+    size = sizeof(argmax);
+    if (sysctl(mib, 2, &argmax, &size, NULL, 0) == -1)
+        return NULL;
+
+    /* Allocate space for the arguments. */
+    procargs = (char *)malloc(argmax);
+    if (procargs == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    /*
+     * Make a sysctl() call to get the raw argument space of the process.
+     */
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_ARGS;
+    mib[3] = pid;
+
+    size = argmax;
+    if (sysctl(mib, 4, procargs, &size, NULL, 0) == -1) {
+        free(procargs);
+        return NULL;       /* Insufficient privileges */
+    }
+
+    // return string and set the length of arguments
+    *argsize = size;
+    return procargs;
+}
+
+
+/* returns the command line as a python list object */
+PyObject*
+psutil_get_arg_list(long pid)
+{
+    char *argstr = NULL;
+    int pos = 0;
+    size_t argsize = 0;
+    PyObject *retlist = Py_BuildValue("[]");
+    PyObject *item = NULL;
+
+    if (pid < 0) {
+        return retlist;
+    }
+
+    argstr = psutil_get_cmd_args(pid, &argsize);
+    if (argstr == NULL) {
+        goto error;
+    }
+
+    // args are returned as a flattened string with \0 separators between
+    // arguments add each string to the list then step forward to the next
+    // separator
+    if (argsize > 0) {
+        while(pos < argsize) {
+            item = Py_BuildValue("s", &argstr[pos]);
+            if (!item)
+                goto error;
+            if (PyList_Append(retlist, item))
+                goto error;
+            Py_DECREF(item);
+            pos = pos + strlen(&argstr[pos]) + 1;
+        }
+    }
+
+    free(argstr);
+    return retlist;
+
+error:
+    Py_XDECREF(item);
+    Py_DECREF(retlist);
+    if (argstr != NULL)
+        free(argstr);
+    return NULL;
+}
+
+
+/*
+ * Return 1 if PID exists in the current process list, else 0.
+ */
+int
+psutil_pid_exists(long pid)
+{
+    int kill_ret;
+    if (pid < 0) {
+        return 0;
+    }
+
+    // if kill returns success of permission denied we know it's a valid PID
+    kill_ret = kill(pid , 0);
+    if ((0 == kill_ret) || (EPERM == errno)) {
+        return 1;
+    }
+
+    // otherwise return 0 for PID not found
+    return 0;
+}
+
+
+/*
+ * Set exception to AccessDenied if pid exists else NoSuchProcess.
+ */
+int
+psutil_raise_ad_or_nsp(pid) {
+    if (psutil_pid_exists(pid) == 0) {
+        NoSuchProcess();
+    }
+    else {
+        AccessDenied();
+    }
+}

build/psutil/psutil/arch/bsd/process_info.h

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Helper functions related to fetching process information. Used by _psutil_bsd
+ * module methods.
+ */
+
+#include <Python.h>
+
+typedef struct kinfo_proc kinfo_proc;
+
+int  psutil_get_proc_list(struct kinfo_proc **procList, size_t *procCount);
+char *psutil_get_cmd_args(long pid, size_t *argsize);
+char *psutil_get_cmd_path(long pid, size_t *pathsize);
+int  psutil_pid_exists(long pid);
+PyObject* psutil_get_arg_list(long pid);

build/psutil/psutil/arch/mswindows/ntextapi.h

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ */
+
+typedef enum _KTHREAD_STATE
+{
+    Initialized,
+    Ready,
+    Running,
+    Standby,
+    Terminated,
+    Waiting,
+    Transition,
+    DeferredReady,
+    GateWait,
+    MaximumThreadState
+} KTHREAD_STATE, *PKTHREAD_STATE;
+
+typedef enum _KWAIT_REASON
+{
+    Executive = 0,
+    FreePage = 1,
+    PageIn = 2,
+    PoolAllocation = 3,
+    DelayExecution = 4,
+    Suspended = 5,
+    UserRequest = 6,
+    WrExecutive = 7,
+    WrFreePage = 8,
+    WrPageIn = 9,
+    WrPoolAllocation = 10,
+    WrDelayExecution = 11,
+    WrSuspended = 12,
+    WrUserRequest = 13,
+    WrEventPair = 14,
+    WrQueue = 15,
+    WrLpcReceive = 16,
+    WrLpcReply = 17,
+    WrVirtualMemory = 18,
+    WrPageOut = 19,
+    WrRendezvous = 20,
+    Spare2 = 21,
+    Spare3 = 22,
+    Spare4 = 23,
+    Spare5 = 24,
+    WrCalloutStack = 25,
+    WrKernel = 26,
+    WrResource = 27,
+    WrPushLock = 28,
+    WrMutex = 29,
+    WrQuantumEnd = 30,
+    WrDispatchInt = 31,
+    WrPreempted = 32,
+    WrYieldExecution = 33,
+    WrFastMutex = 34,
+    WrGuardedMutex = 35,
+    WrRundown = 36,
+    MaximumWaitReason = 37
+} KWAIT_REASON, *PKWAIT_REASON;
+
+
+typedef struct _CLIENT_ID
+{
+    HANDLE UniqueProcess;
+    HANDLE UniqueThread;
+} CLIENT_ID, *PCLIENT_ID;
+
+
+typedef struct _UNICODE_STRING {
+    USHORT Length;
+    USHORT MaximumLength;
+    PWSTR Buffer;
+} UNICODE_STRING, *PUNICODE_STRING;
+
+
+typedef struct _SYSTEM_TIMEOFDAY_INFORMATION
+{
+    LARGE_INTEGER BootTime;
+    LARGE_INTEGER CurrentTime;
+    LARGE_INTEGER TimeZoneBias;
+    ULONG TimeZoneId;
+    ULONG Reserved;
+    ULONGLONG BootTimeBias;
+    ULONGLONG SleepTimeBias;
+} SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION;
+
+typedef struct _SYSTEM_THREAD_INFORMATION
+{
+    LARGE_INTEGER KernelTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER CreateTime;
+    ULONG WaitTime;
+    PVOID StartAddress;
+    CLIENT_ID ClientId;
+    LONG Priority;
+    LONG BasePriority;
+    ULONG ContextSwitches;
+    ULONG ThreadState;
+    KWAIT_REASON WaitReason;
+} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
+
+typedef struct _TEB *PTEB;
+
+// private
+typedef struct _SYSTEM_EXTENDED_THREAD_INFORMATION
+{
+    SYSTEM_THREAD_INFORMATION ThreadInfo;
+    PVOID StackBase;
+    PVOID StackLimit;
+    PVOID Win32StartAddress;
+    PTEB TebBase;
+    ULONG_PTR Reserved2;
+    ULONG_PTR Reserved3;
+    ULONG_PTR Reserved4;
+} SYSTEM_EXTENDED_THREAD_INFORMATION, *PSYSTEM_EXTENDED_THREAD_INFORMATION;
+
+typedef struct _SYSTEM_PROCESS_INFORMATION
+{
+    ULONG NextEntryOffset;
+    ULONG NumberOfThreads;
+    LARGE_INTEGER SpareLi1;
+    LARGE_INTEGER SpareLi2;
+    LARGE_INTEGER SpareLi3;
+    LARGE_INTEGER CreateTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER KernelTime;
+    UNICODE_STRING ImageName;
+    LONG BasePriority;
+    HANDLE UniqueProcessId;
+    HANDLE InheritedFromUniqueProcessId;
+    ULONG HandleCount;
+    ULONG SessionId;
+    ULONG_PTR PageDirectoryBase;
+    SIZE_T PeakVirtualSize;
+    SIZE_T VirtualSize;
+    DWORD PageFaultCount;
+    SIZE_T PeakWorkingSetSize;
+    SIZE_T WorkingSetSize;
+    SIZE_T QuotaPeakPagedPoolUsage;
+    SIZE_T QuotaPagedPoolUsage;
+    SIZE_T QuotaPeakNonPagedPoolUsage;
+    SIZE_T QuotaNonPagedPoolUsage;
+    SIZE_T PagefileUsage;
+    SIZE_T PeakPagefileUsage;
+    SIZE_T PrivatePageCount;
+    LARGE_INTEGER ReadOperationCount;
+    LARGE_INTEGER WriteOperationCount;
+    LARGE_INTEGER OtherOperationCount;
+    LARGE_INTEGER ReadTransferCount;
+    LARGE_INTEGER WriteTransferCount;
+    LARGE_INTEGER OtherTransferCount;
+    SYSTEM_THREAD_INFORMATION Threads[1];
+} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
+
+
+// structures and enums from winternl.h (not available under mingw)
+typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
+    LARGE_INTEGER IdleTime;
+    LARGE_INTEGER KernelTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER Reserved1[2];
+    ULONG Reserved2;
+} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
+
+
+typedef enum _SYSTEM_INFORMATION_CLASS {
+    SystemBasicInformation = 0,
+    SystemPerformanceInformation = 2,
+    SystemTimeOfDayInformation = 3,
+    SystemProcessInformation = 5,
+    SystemProcessorPerformanceInformation = 8,
+    SystemInterruptInformation = 23,
+    SystemExceptionInformation = 33,
+    SystemRegistryQuotaInformation = 37,
+    SystemLookasideInformation = 45
+} SYSTEM_INFORMATION_CLASS;
+
+
+// ================================================
+// get_system_users support ()
+// ================================================
+
+typedef struct _WINSTATION_INFO {
+    BYTE Reserved1[72];
+    ULONG SessionId;
+    BYTE Reserved2[4];
+    FILETIME ConnectTime;
+    FILETIME DisconnectTime;
+    FILETIME LastInputTime;
+    FILETIME LoginTime;
+    BYTE Reserved3[1096];
+    FILETIME CurrentTime;
+} WINSTATION_INFO, *PWINSTATION_INFO;
+
+typedef enum _WINSTATIONINFOCLASS {
+     WinStationInformation = 8
+} WINSTATIONINFOCLASS;
+
+typedef BOOLEAN (WINAPI * PWINSTATIONQUERYINFORMATIONW)
+                 (HANDLE,ULONG,WINSTATIONINFOCLASS,PVOID,ULONG,PULONG);
+
+typedef struct _WINSTATIONINFORMATIONW {
+    BYTE Reserved2[70];
+    ULONG LogonId;
+    BYTE Reserved3[1140];
+} WINSTATIONINFORMATIONW, *PWINSTATIONINFORMATIONW;
+
+// start mingw support:
+// http://www.koders.com/c/fid7C02CAE627C526914CDEB427405B51DF393A5EFA.aspx
+#ifndef _INC_WTSAPI
+typedef struct _WTS_CLIENT_ADDRESS {
+    DWORD AddressFamily;  // AF_INET, AF_IPX, AF_NETBIOS, AF_UNSPEC
+    BYTE  Address[20];    // client network address
+} WTS_CLIENT_ADDRESS, * PWTS_CLIENT_ADDRESS;
+
+HANDLE
+WINAPI
+WTSOpenServerA(
+    IN LPSTR pServerName
+    );
+
+VOID
+WINAPI
+WTSCloseServer(
+    IN HANDLE hServer
+    );
+#endif
+// end mingw support:
+
+/*
+ * NtQueryInformationProcess code taken from
+ * http://wj32.wordpress.com/2009/01/24/howto-get-the-command-line-of-processes/
+ * typedefs needed to compile against ntdll functions not exposted in the API
+ */
+typedef LONG NTSTATUS;
+
+typedef NTSTATUS (NTAPI *_NtQueryInformationProcess)(
+    HANDLE ProcessHandle,
+    DWORD ProcessInformationClass,
+    PVOID ProcessInformation,
+    DWORD ProcessInformationLength,
+    PDWORD ReturnLength
+    );
+
+typedef NTSTATUS (NTAPI *_NtSetInformationProcess)(
+    HANDLE ProcessHandle,
+    DWORD ProcessInformationClass,
+    PVOID ProcessInformation,
+    DWORD ProcessInformationLength
+);
+
+typedef struct _PROCESS_BASIC_INFORMATION
+{
+    PVOID Reserved1;
+    PVOID PebBaseAddress;
+    PVOID Reserved2[2];
+    ULONG_PTR UniqueProcessId;
+    PVOID Reserved3;
+} PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
+
+
+typedef enum _PROCESSINFOCLASS {
+    ProcessBasicInformation,
+    ProcessQuotaLimits,
+    ProcessIoCounters,
+    ProcessVmCounters,
+    ProcessTimes,
+    ProcessBasePriority,
+    ProcessRaisePriority,
+    ProcessDebugPort,
+    ProcessExceptionPort,
+    ProcessAccessToken,
+    ProcessLdtInformation,
+    ProcessLdtSize,
+    ProcessDefaultHardErrorMode,
+    ProcessIoPortHandlers,
+    ProcessPooledUsageAndLimits,
+    ProcessWorkingSetWatch,
+    ProcessUserModeIOPL,
+    ProcessEnableAlignmentFaultFixup,
+    ProcessPriorityClass,
+    ProcessWx86Information,
+    ProcessHandleCount,
+    ProcessAffinityMask,
+    ProcessPriorityBoost,
+    ProcessDeviceMap,
+    ProcessSessionInformation,
+    ProcessForegroundInformation,
+    ProcessWow64Information,
+    /* added after XP+ */
+    ProcessImageFileName,
+    ProcessLUIDDeviceMapsEnabled,
+    ProcessBreakOnTermination,
+    ProcessDebugObjectHandle,
+    ProcessDebugFlags,
+    ProcessHandleTracing,
+    ProcessIoPriority,
+    ProcessExecuteFlags,
+    ProcessResourceManagement,
+    ProcessCookie,
+    ProcessImageInformation,
+    MaxProcessInfoClass
+} PROCESSINFOCLASS;

build/psutil/psutil/arch/mswindows/process_handles.c

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ */
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+#include <Python.h>
+#include <windows.h>
+#include <stdio.h>
+#include "process_handles.h"
+
+#ifndef NT_SUCCESS
+    #define NT_SUCCESS(x) ((x) >= 0)
+#endif
+#define STATUS_INFO_LENGTH_MISMATCH 0xc0000004
+
+#define SystemHandleInformation 16
+#define ObjectBasicInformation 0
+#define ObjectNameInformation 1
+#define ObjectTypeInformation 2
+
+
+typedef LONG NTSTATUS;
+
+typedef struct _UNICODE_STRING {
+  USHORT  Length;
+  USHORT  MaximumLength;
+  PWSTR  Buffer;
+} UNICODE_STRING, *PUNICODE_STRING;
+
+typedef NTSTATUS (NTAPI *_NtQuerySystemInformation)(
+    ULONG SystemInformationClass,
+    PVOID SystemInformation,
+    ULONG SystemInformationLength,
+    PULONG ReturnLength
+    );
+
+typedef NTSTATUS (NTAPI *_NtDuplicateObject)(
+    HANDLE SourceProcessHandle,
+    HANDLE SourceHandle,
+    HANDLE TargetProcessHandle,
+    PHANDLE TargetHandle,
+    ACCESS_MASK DesiredAccess,
+    ULONG Attributes,
+    ULONG Options
+    );
+
+typedef NTSTATUS (NTAPI *_NtQueryObject)(
+    HANDLE ObjectHandle,
+    ULONG ObjectInformationClass,
+    PVOID ObjectInformation,
+    ULONG ObjectInformationLength,
+    PULONG ReturnLength
+    );
+
+typedef struct _SYSTEM_HANDLE
+{
+    ULONG ProcessId;
+    BYTE ObjectTypeNumber;
+    BYTE Flags;
+    USHORT Handle;
+    PVOID Object;
+    ACCESS_MASK GrantedAccess;
+} SYSTEM_HANDLE, *PSYSTEM_HANDLE;
+
+typedef struct _SYSTEM_HANDLE_INFORMATION
+{
+    ULONG HandleCount;
+    SYSTEM_HANDLE Handles[1];
+} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
+
+typedef enum _POOL_TYPE
+{
+    NonPagedPool,
+    PagedPool,
+    NonPagedPoolMustSucceed,
+    DontUseThisType,
+    NonPagedPoolCacheAligned,
+    PagedPoolCacheAligned,
+    NonPagedPoolCacheAlignedMustS
+} POOL_TYPE, *PPOOL_TYPE;
+
+typedef struct _OBJECT_TYPE_INFORMATION
+{
+    UNICODE_STRING Name;
+    ULONG TotalNumberOfObjects;
+    ULONG TotalNumberOfHandles;
+    ULONG TotalPagedPoolUsage;
+    ULONG TotalNonPagedPoolUsage;
+    ULONG TotalNamePoolUsage;
+    ULONG TotalHandleTableUsage;
+    ULONG HighWaterNumberOfObjects;
+    ULONG HighWaterNumberOfHandles;
+    ULONG HighWaterPagedPoolUsage;
+    ULONG HighWaterNonPagedPoolUsage;
+    ULONG HighWaterNamePoolUsage;
+    ULONG HighWaterHandleTableUsage;
+    ULONG InvalidAttributes;
+    GENERIC_MAPPING GenericMapping;
+    ULONG ValidAccess;
+    BOOLEAN SecurityRequired;
+    BOOLEAN MaintainHandleCount;
+    USHORT MaintainTypeList;
+    POOL_TYPE PoolType;
+    ULONG PagedPoolUsage;
+    ULONG NonPagedPoolUsage;
+} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
+
+PVOID GetLibraryProcAddress(PSTR LibraryName, PSTR ProcName)
+{
+    return GetProcAddress(GetModuleHandleA(LibraryName), ProcName);
+}
+
+
+PyObject*
+psutil_get_open_files(long pid, HANDLE processHandle)
+{
+    _NtQuerySystemInformation NtQuerySystemInformation =
+        GetLibraryProcAddress("ntdll.dll", "NtQuerySystemInformation");
+    _NtDuplicateObject NtDuplicateObject =
+        GetLibraryProcAddress("ntdll.dll", "NtDuplicateObject");
+    _NtQueryObject NtQueryObject =
+        GetLibraryProcAddress("ntdll.dll", "NtQueryObject");
+
+    NTSTATUS                    status;
+    PSYSTEM_HANDLE_INFORMATION  handleInfo;
+    ULONG                       handleInfoSize = 0x10000;
+
+    ULONG                       i;
+    ULONG                       fileNameLength;
+    PyObject                    *filesList = Py_BuildValue("[]");
+    PyObject                    *arg = NULL;
+    PyObject                    *fileFromWchar = NULL;
+
+    if (filesList == NULL)
+        return NULL;
+
+    handleInfo = (PSYSTEM_HANDLE_INFORMATION)malloc(handleInfoSize);
+    if (handleInfo == NULL) {
+        Py_DECREF(filesList);
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    /* NtQuerySystemInformation won't give us the correct buffer size,
+       so we guess by doubling the buffer size. */
+    while ((status = NtQuerySystemInformation(
+        SystemHandleInformation,
+        handleInfo,
+        handleInfoSize,
+        NULL
+        )) == STATUS_INFO_LENGTH_MISMATCH)
+    {
+        handleInfo = (PSYSTEM_HANDLE_INFORMATION)realloc(handleInfo, handleInfoSize *= 2);
+    }
+
+    /* NtQuerySystemInformation stopped giving us STATUS_INFO_LENGTH_MISMATCH. */
+    if (!NT_SUCCESS(status)) {
+        //printf("NtQuerySystemInformation failed!\n");
+        Py_DECREF(filesList);
+        free(handleInfo);
+        return NULL;
+    }
+
+    for (i = 0; i < handleInfo->HandleCount; i++)
+    {
+        SYSTEM_HANDLE            handle = handleInfo->Handles[i];
+        HANDLE                   dupHandle = NULL;
+        POBJECT_TYPE_INFORMATION objectTypeInfo = NULL;
+        PVOID                    objectNameInfo;
+        UNICODE_STRING           objectName;
+        ULONG                    returnLength;
+        fileFromWchar = NULL;
+        arg = NULL;
+
+        /* Check if this handle belongs to the PID the user specified. */
+        if (handle.ProcessId != pid)
+            continue;
+
+        /* Skip handles with the following access codes as the next call
+           to NtDuplicateObject() or NtQueryObject() might hang forever. */
+        if((handle.GrantedAccess == 0x0012019f)
+        || (handle.GrantedAccess == 0x001a019f)
+        || (handle.GrantedAccess == 0x00120189)
+        || (handle.GrantedAccess == 0x00100000)) {
+            continue;
+        }
+
+        /* Duplicate the handle so we can query it. */
+        if (!NT_SUCCESS(NtDuplicateObject(
+            processHandle,
+            handle.Handle,
+            GetCurrentProcess(),
+            &dupHandle,
+            0,
+            0,
+            0
+            )))
+        {
+            //printf("[%#x] Error!\n", handle.Handle);
+            continue;
+        }
+
+        /* Query the object type. */
+        objectTypeInfo = (POBJECT_TYPE_INFORMATION)malloc(0x1000);
+        if (!NT_SUCCESS(NtQueryObject(
+            dupHandle,
+            ObjectTypeInformation,
+            objectTypeInfo,
+            0x1000,
+            NULL
+            )))
+        {
+            //printf("[%#x] Error!\n", handle.Handle);
+            free(objectTypeInfo);
+            CloseHandle(dupHandle);
+            continue;
+        }
+
+        objectNameInfo = malloc(0x1000);
+        if (!NT_SUCCESS(NtQueryObject(
+            dupHandle,
+            ObjectNameInformation,
+            objectNameInfo,
+            0x1000,
+            &returnLength
+            )))
+        {
+            /* Reallocate the buffer and try again. */
+            objectNameInfo = realloc(objectNameInfo, returnLength);
+            if (!NT_SUCCESS(NtQueryObject(
+                dupHandle,
+                ObjectNameInformation,
+                objectNameInfo,
+                returnLength,
+                NULL
+                )))
+            {
+                /* We have the type name, so just display that.*/
+                /*
+                printf(
+                    "[%#x] %.*S: (could not get name)\n",
+                    handle.Handle,
+                    objectTypeInfo->Name.Length / 2,
+                    objectTypeInfo->Name.Buffer
+                    );
+                */
+                free(objectTypeInfo);
+                free(objectNameInfo);
+                CloseHandle(dupHandle);
+                continue;
+
+            }
+        }
+
+        /* Cast our buffer into an UNICODE_STRING. */
+        objectName = *(PUNICODE_STRING)objectNameInfo;
+
+        /* Print the information! */
+        if (objectName.Length)
+        {
+            /* The object has a name.  Make sure it is a file otherwise
+               ignore it */
+            fileNameLength = objectName.Length / 2;
+            if (wcscmp(objectTypeInfo->Name.Buffer, L"File") == 0) {
+                //printf("%.*S\n", objectName.Length / 2, objectName.Buffer);
+                fileFromWchar = PyUnicode_FromWideChar(objectName.Buffer,
+                                                       fileNameLength);
+                if (fileFromWchar == NULL)
+                    goto error_py_fun;
+                #if PY_MAJOR_VERSION >= 3
+                    arg = Py_BuildValue("N", PyUnicode_AsUTF8String(fileFromWchar));
+                #else
+                    arg = Py_BuildValue("N", PyUnicode_FromObject(fileFromWchar));
+                #endif
+                if (!arg)
+                    goto error_py_fun;
+                Py_XDECREF(fileFromWchar);
+                fileFromWchar = NULL;
+                if (PyList_Append(filesList, arg))
+                    goto error_py_fun;
+                Py_XDECREF(arg);
+            }
+            /*
+            printf(
+                "[%#x] %.*S: %.*S\n",
+                handle.Handle,
+                objectTypeInfo->Name.Length / 2,
+                objectTypeInfo->Name.Buffer,
+                objectName.Length / 2,
+                objectName.Buffer
+                );
+            */
+        }
+        else
+        {
+            /* Print something else. */
+            /*
+            printf(
+                "[%#x] %.*S: (unnamed)\n",
+                handle.Handle,
+                objectTypeInfo->Name.Length / 2,
+                objectTypeInfo->Name.Buffer
+                );
+            */
+            ;;
+        }
+        free(objectTypeInfo);
+        free(objectNameInfo);
+        CloseHandle(dupHandle);
+    }
+    free(handleInfo);
+    CloseHandle(processHandle);
+    return filesList;
+
+error_py_fun:
+    Py_XDECREF(arg);
+    Py_XDECREF(fileFromWchar);
+    Py_DECREF(filesList);
+    return NULL;
+}

build/psutil/psutil/arch/mswindows/process_handles.h

+/*
+ * $Id: process_info.h 1060 2011-07-02 18:05:26Z g.rodola $
+ *
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+
+PyObject* psutil_get_open_files(long pid, HANDLE processHandle);

build/psutil/psutil/arch/mswindows/process_info.h

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Helper functions related to fetching process information. Used by _psutil_mswindows
+ * module methods.
+ */
+
+#include <Python.h>
+#include <windows.h>
+
+HANDLE psutil_handle_from_pid_waccess(DWORD pid, DWORD dwDesiredAccess);
+HANDLE psutil_handle_from_pid(DWORD pid);
+PVOID psutil_get_peb_address(HANDLE ProcessHandle);
+HANDLE psutil_handle_from_pid(DWORD pid);
+int psutil_pid_in_proclist(DWORD pid);
+int psutil_pid_is_running(DWORD pid);
+int psutil_handlep_is_running(HANDLE hProcess);
+PyObject* psutil_get_arg_list(long pid);
+DWORD* psutil_get_pids(DWORD *numberOfReturnedPIDs);

build/psutil/psutil/arch/mswindows/security.c

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Security related functions for Windows platform (Set privileges such as
+ * SeDebug), as well as security helper functions.
+ */
+
+#include <windows.h>
+#include <Python.h>
+
+/*
+ * Convert a process handle to a process token handle.
+ */
+HANDLE
+token_from_handle(HANDLE hProcess) {
+    HANDLE hToken = NULL;
+
+    if (! OpenProcessToken(hProcess, TOKEN_QUERY, &hToken) ) {
+        return PyErr_SetFromWindowsErr(0);
+    }
+
+    return hToken;
+}
+
+
+/*
+ * http://www.ddj.com/windows/184405986
+ *
+ * There's a way to determine whether we're running under the Local System
+ * account. However (you guessed it), we have to call more Win32 functions to
+ * determine this. Backing up through the code listing, we need to make another
+ * call to GetTokenInformation, but instead of passing through the TOKEN_USER
+ * constant, we pass through the TOKEN_PRIVILEGES constant. This value returns
+ * an array of privileges that the account has in the environment. Iterating
+ * through the array, we call the function LookupPrivilegeName looking for the
+ * string SeTcbPrivilege. If the function returns this string, then this
+ * account has Local System privileges
+ */
+int HasSystemPrivilege(HANDLE hProcess) {
+    DWORD i;
+    DWORD dwSize = 0;
+    DWORD dwRetval = 0;
+    TCHAR privName[256];
+    DWORD dwNameSize = 256;
+    //PTOKEN_PRIVILEGES tp = NULL;
+    BYTE *pBuffer = NULL;
+    TOKEN_PRIVILEGES* tp = NULL;
+    HANDLE hToken = token_from_handle(hProcess);
+
+    if (NULL == hToken) {
+        return -1;
+    }
+
+    // call GetTokenInformation first to get the buffer size
+    if (! GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize)) {
+        dwRetval = GetLastError();
+        // if it failed for a reason other than the buffer, bail out
+        if (dwRetval != ERROR_INSUFFICIENT_BUFFER ) {
+            PyErr_SetFromWindowsErr(dwRetval);
+            return 0;
+        }
+    }
+
+    // allocate buffer and call GetTokenInformation again
+    //tp = (PTOKEN_PRIVILEGES) GlobalAlloc(GPTR, dwSize);
+    pBuffer = (BYTE *) malloc(dwSize);
+    if (pBuffer == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    if (! GetTokenInformation(hToken, TokenPrivileges, pBuffer, dwSize, &dwSize) ) {
+        PyErr_SetFromWindowsErr(0);
+        free(pBuffer);
+        return -1;
+    }
+
+    // convert the BYTE buffer to a TOKEN_PRIVILEGES struct pointer
+    tp = (TOKEN_PRIVILEGES*)pBuffer;
+
+    // check all the privileges looking for SeTcbPrivilege
+    for(i=0; i < tp->PrivilegeCount; i++) {
+        // reset the buffer contents and the buffer size
+        strcpy(privName, "");
+        dwNameSize = sizeof(privName) / sizeof(TCHAR);
+        if (! LookupPrivilegeName(NULL,
+                &tp->Privileges[i].Luid,
+                (LPTSTR)privName,
+                &dwNameSize)) {
+
+            PyErr_SetFromWindowsErr(0);
+            free(pBuffer);
+            return -1;
+        }
+
+        // if we find the SeTcbPrivilege then it's a LocalSystem process
+        if (! lstrcmpi(privName, TEXT("SeTcbPrivilege"))) {
+            free(pBuffer);
+            return 1;
+        }
+
+    } //for
+
+    free(pBuffer);
+    return 0;
+}
+
+
+BOOL SetPrivilege(HANDLE hToken, LPCTSTR Privilege, BOOL bEnablePrivilege)
+{
+    TOKEN_PRIVILEGES tp;
+    LUID luid;
+    TOKEN_PRIVILEGES tpPrevious;
+    DWORD cbPrevious=sizeof(TOKEN_PRIVILEGES);
+
+    if(!LookupPrivilegeValue( NULL, Privilege, &luid )) return FALSE;
+
+    // first pass.  get current privilege setting
+    tp.PrivilegeCount = 1;
+    tp.Privileges[0].Luid = luid;
+    tp.Privileges[0].Attributes = 0;
+
+    AdjustTokenPrivileges(
+        hToken,
+        FALSE,
+        &tp,
+        sizeof(TOKEN_PRIVILEGES),
+        &tpPrevious,
+        &cbPrevious
+    );
+
+    if (GetLastError() != ERROR_SUCCESS) return FALSE;
+
+    // second pass. set privilege based on previous setting
+    tpPrevious.PrivilegeCount = 1;
+    tpPrevious.Privileges[0].Luid = luid;
+
+    if(bEnablePrivilege) {
+        tpPrevious.Privileges[0].Attributes |= (SE_PRIVILEGE_ENABLED);
+    }
+
+    else {
+        tpPrevious.Privileges[0].Attributes ^= (SE_PRIVILEGE_ENABLED &
+                tpPrevious.Privileges[0].Attributes);
+    }
+
+    AdjustTokenPrivileges(
+        hToken,
+        FALSE,
+        &tpPrevious,
+        cbPrevious,
+        NULL,
+        NULL
+    );
+
+    if (GetLastError() != ERROR_SUCCESS) return FALSE;
+
+    return TRUE;
+}
+
+
+int SetSeDebug()
+{
+    HANDLE hToken;
+    if(! OpenThreadToken(GetCurrentThread(),
+                         TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                         FALSE,
+                         &hToken)
+                         ){
+        if (GetLastError() == ERROR_NO_TOKEN){
+            if (!ImpersonateSelf(SecurityImpersonation)){
+                CloseHandle(hToken);
+                return 0;
+            }
+            if (!OpenThreadToken(GetCurrentThread(),
+                                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                                 FALSE,
+                                 &hToken)
+                                 ){
+                RevertToSelf();
+                CloseHandle(hToken);
+                return 0;
+            }
+        }
+    }
+
+    // enable SeDebugPrivilege (open any process)
+    if (! SetPrivilege(hToken, SE_DEBUG_NAME, TRUE)){
+        RevertToSelf();
+        CloseHandle(hToken);
+        return 0;
+    }
+
+    RevertToSelf();
+    CloseHandle(hToken);
+    return 1;
+}
+
+
+int UnsetSeDebug()
+{
+    HANDLE hToken;
+    if(! OpenThreadToken(GetCurrentThread(),
+                        TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                        FALSE,
+                        &hToken)
+                        ){
+        if(GetLastError() == ERROR_NO_TOKEN){
+            if(! ImpersonateSelf(SecurityImpersonation)){
+                //Log2File("Error setting impersonation! [UnsetSeDebug()]", L_DEBUG);
+                return 0;
+            }
+
+            if(!OpenThreadToken(GetCurrentThread(),
+                                TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                                FALSE,
+                                &hToken)
+                                ){
+                //Log2File("Error Opening Thread Token! [UnsetSeDebug()]", L_DEBUG);
+                return 0;
+            }
+        }
+    }
+
+    //now disable SeDebug
+    if(!SetPrivilege(hToken, SE_DEBUG_NAME, FALSE)){
+        //Log2File("Error unsetting SeDebug Privilege [SetPrivilege()]", L_WARN);
+        return 0;
+    }
+
+    CloseHandle(hToken);
+    return 1;
+}

build/psutil/psutil/arch/mswindows/security.h

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Security related functions for Windows platform (Set privileges such as
+ * SeDebug), as well as security helper functions.
+ */
+
+#include <windows.h>
+
+
+BOOL SetPrivilege(HANDLE hToken, LPCTSTR Privilege, BOOL bEnablePrivilege);
+int SetSeDebug();
+int UnsetSeDebug();
+HANDLE token_from_handle(HANDLE hProcess);
+int HasSystemPrivilege(HANDLE hProcess);
+

build/psutil/psutil/arch/osx/process_info.c

+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Helper functions related to fetching process information. Used by _psutil_osx
+ * module methods.
+ */
+
+#include <Python.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>  /* for INT_MAX */
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/sysctl.h>
+#include <libproc.h>
+
+#include "process_info.h"
+#include "../../_psutil_common.h"
+
+
+/*
+ * Return 1 if PID exists in the current process list, else 0.
+ */
+int
+psutil_pid_exists(long pid)
+{
+    int kill_ret;
+
+    // save some time if it's an invalid PID
+    if (pid < 0) {
+        return 0;
+    }
+
+    // if kill returns success of permission denied we know it's a valid PID
+    kill_ret = kill(pid , 0);
+    if ( (0 == kill_ret) || (EPERM == errno) ) {
+        return 1;
+    }
+
+    // otherwise return 0 for PID not found
+    return 0;
+}
+
+
+
+/*
+ * Returns a list of all BSD processes on the system.  This routine
+ * allocates the list and puts it in *procList and a count of the
+ * number of entries in *procCount.  You are responsible for freeing
+ * this list (use "free" from System framework).
+ * On success, the function returns 0.
+ * On error, the function returns a BSD errno value.
+ */
+int
+psutil_get_proc_list(kinfo_proc **procList, size_t *procCount)
+{
+    /* Declaring mib as const requires use of a cast since the
+     * sysctl prototype doesn't include the const modifier. */
+    static const int mib3[3] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL };
+    size_t           size, size2;
+    void            *ptr;
+    int              err, lim = 8;  /* some limit */
+
+    assert( procList != NULL);
+    assert(*procList == NULL);
+    assert(procCount != NULL);
+
+    *procCount = 0;
+
+    /* We start by calling sysctl with ptr == NULL and size == 0.
+     * That will succeed, and set size to the appropriate length.
+     * We then allocate a buffer of at least that size and call
+     * sysctl with that buffer.  If that succeeds, we're done.
+     * If that call fails with ENOMEM, we throw the buffer away
+     * and try again.
+     * Note that the loop calls sysctl with NULL again.  This is
+     * is necessary because the ENOMEM failure case sets size to
+     * the amount of data returned, not the amount of data that
+     * could have been returned.
+     */
+    while (lim-- > 0) {
+        size = 0;
+        if (sysctl((int *)mib3, 3, NULL, &size, NULL, 0) == -1) {
+            return errno;
+        }
+
+        size2 = size + (size >> 3);  /* add some */
+        if (size2 > size) {
+            ptr = malloc(size2);
+            if (ptr == NULL) {
+                ptr = malloc(size);
+            } else {
+                size = size2;
+            }
+        }
+        else {
+            ptr = malloc(size);
+        }
+        if (ptr == NULL) {
+            return ENOMEM;
+        }
+
+        if (sysctl((int *)mib3, 3, ptr, &size, NULL, 0) == -1) {
+            err = errno;
+            free(ptr);
+            if (err != ENOMEM) {
+                return err;
+            }
+
+        } else {
+            *procList = (kinfo_proc *)ptr;
+            *procCount = size / sizeof(kinfo_proc);
+            return 0;
+        }
+    }
+    return ENOMEM;
+}
+
+
+/* Read the maximum argument size for processes */
+int
+psutil_get_argmax()
+{
+    int argmax;
+    int mib[] = { CTL_KERN, KERN_ARGMAX };
+    size_t size = sizeof(argmax);
+
+    if (sysctl(mib, 2, &argmax, &size, NULL, 0) == 0) {
+        return argmax;
+    }
+    return 0;
+}
+
+
+/* return process args as a python list */
+PyObject*
+psutil_get_arg_list(long pid)
+{
+    int mib[3];
+    int nargs;
+    int len;
+    char *procargs = NULL;
+    char *arg_ptr;
+    char *arg_end;
+    char *curr_arg;
+    size_t argmax;
+    PyObject *arg = NULL;
+    PyObject *arglist = NULL;
+
+    //special case for PID 0 (kernel_task) where cmdline cannot be fetched
+    if (pid == 0) {
+        return Py_BuildValue("[]");
+    }
+
+    /* read argmax and allocate memory for argument space. */
+    argmax = psutil_get_argmax();
+    if (! argmax) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        goto error;
+    }
+
+    procargs = (char *)malloc(argmax);
+    if (NULL == procargs) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        goto error;
+    }
+
+    /* read argument space */
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROCARGS2;
+    mib[2] = pid;
+    if (sysctl(mib, 3, procargs, &argmax, NULL, 0) < 0) {
+        if (EINVAL == errno) { // invalid == access denied OR nonexistent PID
+            if ( psutil_pid_exists(pid) ) {
+                AccessDenied();
+            } else {
+                NoSuchProcess();
+            }
+        }
+        goto error;
+    }
+
+    arg_end = &procargs[argmax];
+    /* copy the number of arguments to nargs */
+    memcpy(&nargs, procargs, sizeof(nargs));
+
+    arg_ptr = procargs + sizeof(nargs);
+    len = strlen(arg_ptr);
+    arg_ptr += len + 1;
+
+    if (arg_ptr == arg_end) {
+        free(procargs);
+        return Py_BuildValue("[]");
+    }
+
+    // skip ahead to the first argument
+    for (; arg_ptr < arg_end; arg_ptr++) {
+        if (*arg_ptr != '\0') {
+            break;
+        }
+    }
+
+    /* iterate through arguments */
+    curr_arg = arg_ptr;
+    arglist = Py_BuildValue("[]");
+    if (!arglist)
+        goto error;
+    while (arg_ptr < arg_end && nargs > 0) {
+        if (*arg_ptr++ == '\0') {
+            arg = Py_BuildValue("s", curr_arg);
+            if (!arg)
+                goto error;
+            if (PyList_Append(arglist, arg))
+                goto error;
+            Py_DECREF(arg);
+            // iterate to next arg and decrement # of args
+            curr_arg = arg_ptr;
+            nargs--;
+        }
+    }
+
+    free(procargs);
+    return arglist;
+
+error:
+    Py_XDECREF(arg);
+    Py_XDECREF(arglist);
+    if (procargs != NULL)
+        free(procargs);
+    return NULL;
+}
+
+
+int
+psutil_get_kinfo_proc(pid_t pid, struct kinfo_proc *kp)
+{
+    int mib[4];
+    size_t len;
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PID;
+    mib[3] = pid;
+
+    // fetch the info with sysctl()
+    len = sizeof(struct kinfo_proc);
+
+    // now read the data from sysctl
+    if (sysctl(mib, 4, kp, &len, NULL, 0) == -1) {
+        // raise an exception and throw errno as the error
+        PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+
+    /*
+     * sysctl succeeds but len is zero, happens when process has gone away
+     */
+    if (len == 0) {
+        NoSuchProcess();
+        return -1;
+    }
+    return 0;
+}
+
+
+/*
+ * A thin wrapper around proc_pidinfo()
+ */
+int
+psutil_proc_pidinfo(long pid, int flavor, void *pti, int size)
+{
+    int ret = proc_pidinfo((int)pid, flavor, 0, pti, size);
+    if (ret == 0) {
+        if (! psutil_pid_exists(pid)) {
+            NoSuchProcess();
+            return 0;
+        }
+        else {
+            AccessDenied();
+            return 0;
+        }
+    }
+    else if (ret != size) {
+        AccessDenied();
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}