mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-02 08:41:34 +00:00
532 lines
14 KiB
C
532 lines
14 KiB
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 <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <ifaddrs.h>
|
|
|
|
#ifdef __linux
|
|
#include <netdb.h>
|
|
#include <linux/if_packet.h>
|
|
#endif // end linux
|
|
|
|
#if defined(__FreeBSD__) || defined(__APPLE__)
|
|
#include <netdb.h>
|
|
#include <netinet/in.h>
|
|
#include <net/if_dl.h>
|
|
#endif
|
|
|
|
#if defined(__sun)
|
|
#include <netdb.h>
|
|
#endif
|
|
|
|
#include "_psutil_posix.h"
|
|
|
|
|
|
/*
|
|
* Given a PID return process priority as a Python integer.
|
|
*/
|
|
static PyObject *
|
|
psutil_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 *
|
|
psutil_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_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*
|
|
* Translate a sockaddr struct into a Python string.
|
|
* Return None if address family is not AF_INET* or AF_PACKET.
|
|
*/
|
|
static PyObject *
|
|
psutil_convert_ipaddr(struct sockaddr *addr, int family)
|
|
{
|
|
char buf[NI_MAXHOST];
|
|
int err;
|
|
int addrlen;
|
|
int n;
|
|
size_t len;
|
|
const char *data;
|
|
char *ptr;
|
|
|
|
if (addr == NULL) {
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
else if (family == AF_INET || family == AF_INET6) {
|
|
if (family == AF_INET)
|
|
addrlen = sizeof(struct sockaddr_in);
|
|
else
|
|
addrlen = sizeof(struct sockaddr_in6);
|
|
err = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
|
|
NI_NUMERICHOST);
|
|
if (err != 0) {
|
|
// XXX we get here on FreeBSD when processing 'lo' / AF_INET6
|
|
// broadcast. Not sure what to do other than returning None.
|
|
// ifconfig does not show anything BTW.
|
|
//PyErr_Format(PyExc_RuntimeError, gai_strerror(err));
|
|
//return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
else {
|
|
return Py_BuildValue("s", buf);
|
|
}
|
|
}
|
|
#ifdef __linux
|
|
else if (family == AF_PACKET) {
|
|
struct sockaddr_ll *lladdr = (struct sockaddr_ll *)addr;
|
|
len = lladdr->sll_halen;
|
|
data = (const char *)lladdr->sll_addr;
|
|
}
|
|
#endif
|
|
#if defined(__FreeBSD__) || defined(__APPLE__)
|
|
else if (addr->sa_family == AF_LINK) {
|
|
// Note: prior to Python 3.4 socket module does not expose
|
|
// AF_LINK so we'll do.
|
|
struct sockaddr_dl *dladdr = (struct sockaddr_dl *)addr;
|
|
len = dladdr->sdl_alen;
|
|
data = LLADDR(dladdr);
|
|
}
|
|
#endif
|
|
else {
|
|
// unknown family
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
// AF_PACKET or AF_LINK
|
|
if (len > 0) {
|
|
ptr = buf;
|
|
for (n = 0; n < len; ++n) {
|
|
sprintf(ptr, "%02x:", data[n] & 0xff);
|
|
ptr += 3;
|
|
}
|
|
*--ptr = '\0';
|
|
return Py_BuildValue("s", buf);
|
|
}
|
|
else {
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Return NICs information a-la ifconfig as a list of tuples.
|
|
* TODO: on Solaris we won't get any MAC address.
|
|
*/
|
|
static PyObject*
|
|
psutil_net_if_addrs(PyObject* self, PyObject* args)
|
|
{
|
|
struct ifaddrs *ifaddr, *ifa;
|
|
int family;
|
|
|
|
PyObject *py_retlist = PyList_New(0);
|
|
PyObject *py_tuple = NULL;
|
|
PyObject *py_address = NULL;
|
|
PyObject *py_netmask = NULL;
|
|
PyObject *py_broadcast = NULL;
|
|
|
|
if (py_retlist == NULL)
|
|
return NULL;
|
|
if (getifaddrs(&ifaddr) == -1) {
|
|
PyErr_SetFromErrno(PyExc_OSError);
|
|
goto error;
|
|
}
|
|
|
|
for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
|
|
if (!ifa->ifa_addr)
|
|
continue;
|
|
family = ifa->ifa_addr->sa_family;
|
|
py_address = psutil_convert_ipaddr(ifa->ifa_addr, family);
|
|
// If the primary address can't be determined just skip it.
|
|
// I've never seen this happen on Linux but I did on FreeBSD.
|
|
if (py_address == Py_None)
|
|
continue;
|
|
if (py_address == NULL)
|
|
goto error;
|
|
py_netmask = psutil_convert_ipaddr(ifa->ifa_netmask, family);
|
|
if (py_netmask == NULL)
|
|
goto error;
|
|
#ifdef __linux
|
|
py_broadcast = psutil_convert_ipaddr(ifa->ifa_ifu.ifu_broadaddr, family);
|
|
#else
|
|
py_broadcast = psutil_convert_ipaddr(ifa->ifa_broadaddr, family);
|
|
#endif
|
|
if (py_broadcast == NULL)
|
|
goto error;
|
|
py_tuple = Py_BuildValue(
|
|
"(siOOO)",
|
|
ifa->ifa_name,
|
|
family,
|
|
py_address,
|
|
py_netmask,
|
|
py_broadcast
|
|
);
|
|
|
|
if (! py_tuple)
|
|
goto error;
|
|
if (PyList_Append(py_retlist, py_tuple))
|
|
goto error;
|
|
Py_DECREF(py_tuple);
|
|
Py_DECREF(py_address);
|
|
Py_DECREF(py_netmask);
|
|
Py_DECREF(py_broadcast);
|
|
}
|
|
|
|
freeifaddrs(ifaddr);
|
|
return py_retlist;
|
|
|
|
error:
|
|
if (ifaddr != NULL)
|
|
freeifaddrs(ifaddr);
|
|
Py_DECREF(py_retlist);
|
|
Py_XDECREF(py_tuple);
|
|
Py_XDECREF(py_address);
|
|
Py_XDECREF(py_netmask);
|
|
Py_XDECREF(py_broadcast);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
* net_if_stats() implementation. This is here because it is common
|
|
* to both OSX and FreeBSD and I didn't know where else to put it.
|
|
*/
|
|
#if defined(__FreeBSD__) || defined(__APPLE__)
|
|
|
|
#include <sys/sockio.h>
|
|
#include <net/if_media.h>
|
|
#include <net/if.h>
|
|
|
|
int psutil_get_nic_speed(int ifm_active) {
|
|
// Determine NIC speed. Taken from:
|
|
// http://www.i-scream.org/libstatgrab/
|
|
// Assuming only ETHER devices
|
|
switch(IFM_TYPE(ifm_active)) {
|
|
case IFM_ETHER:
|
|
switch(IFM_SUBTYPE(ifm_active)) {
|
|
#if defined(IFM_HPNA_1) && ((!defined(IFM_10G_LR)) \
|
|
|| (IFM_10G_LR != IFM_HPNA_1))
|
|
// HomePNA 1.0 (1Mb/s)
|
|
case(IFM_HPNA_1):
|
|
return 1;
|
|
#endif
|
|
// 10 Mbit
|
|
case(IFM_10_T): // 10BaseT - RJ45
|
|
case(IFM_10_2): // 10Base2 - Thinnet
|
|
case(IFM_10_5): // 10Base5 - AUI
|
|
case(IFM_10_STP): // 10BaseT over shielded TP
|
|
case(IFM_10_FL): // 10baseFL - Fiber
|
|
return 10;
|
|
// 100 Mbit
|
|
case(IFM_100_TX): // 100BaseTX - RJ45
|
|
case(IFM_100_FX): // 100BaseFX - Fiber
|
|
case(IFM_100_T4): // 100BaseT4 - 4 pair cat 3
|
|
case(IFM_100_VG): // 100VG-AnyLAN
|
|
case(IFM_100_T2): // 100BaseT2
|
|
return 100;
|
|
// 1000 Mbit
|
|
case(IFM_1000_SX): // 1000BaseSX - multi-mode fiber
|
|
case(IFM_1000_LX): // 1000baseLX - single-mode fiber
|
|
case(IFM_1000_CX): // 1000baseCX - 150ohm STP
|
|
#if defined(IFM_1000_TX) && !defined(OPENBSD)
|
|
// FreeBSD 4 and others (but NOT OpenBSD)?
|
|
case(IFM_1000_TX):
|
|
#endif
|
|
#ifdef IFM_1000_FX
|
|
case(IFM_1000_FX):
|
|
#endif
|
|
#ifdef IFM_1000_T
|
|
case(IFM_1000_T):
|
|
#endif
|
|
return 1000;
|
|
#if defined(IFM_10G_SR) || defined(IFM_10G_LR) || defined(IFM_10G_CX4) \
|
|
|| defined(IFM_10G_T)
|
|
#ifdef IFM_10G_SR
|
|
case(IFM_10G_SR):
|
|
#endif
|
|
#ifdef IFM_10G_LR
|
|
case(IFM_10G_LR):
|
|
#endif
|
|
#ifdef IFM_10G_CX4
|
|
case(IFM_10G_CX4):
|
|
#endif
|
|
#ifdef IFM_10G_TWINAX
|
|
case(IFM_10G_TWINAX):
|
|
#endif
|
|
#ifdef IFM_10G_TWINAX_LONG
|
|
case(IFM_10G_TWINAX_LONG):
|
|
#endif
|
|
#ifdef IFM_10G_T
|
|
case(IFM_10G_T):
|
|
#endif
|
|
return 10000;
|
|
#endif
|
|
#if defined(IFM_2500_SX)
|
|
#ifdef IFM_2500_SX
|
|
case(IFM_2500_SX):
|
|
#endif
|
|
return 2500;
|
|
#endif // any 2.5GBit stuff...
|
|
// We don't know what it is
|
|
default:
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
#ifdef IFM_TOKEN
|
|
case IFM_TOKEN:
|
|
switch(IFM_SUBTYPE(ifm_active)) {
|
|
case IFM_TOK_STP4: // Shielded twisted pair 4m - DB9
|
|
case IFM_TOK_UTP4: // Unshielded twisted pair 4m - RJ45
|
|
return 4;
|
|
case IFM_TOK_STP16: // Shielded twisted pair 16m - DB9
|
|
case IFM_TOK_UTP16: // Unshielded twisted pair 16m - RJ45
|
|
return 16;
|
|
#if defined(IFM_TOK_STP100) || defined(IFM_TOK_UTP100)
|
|
#ifdef IFM_TOK_STP100
|
|
case IFM_TOK_STP100: // Shielded twisted pair 100m - DB9
|
|
#endif
|
|
#ifdef IFM_TOK_UTP100
|
|
case IFM_TOK_UTP100: // Unshielded twisted pair 100m - RJ45
|
|
#endif
|
|
return 100;
|
|
#endif
|
|
// We don't know what it is
|
|
default:
|
|
return 0;
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#ifdef IFM_FDDI
|
|
case IFM_FDDI:
|
|
switch(IFM_SUBTYPE(ifm_active)) {
|
|
// We don't know what it is
|
|
default:
|
|
return 0;
|
|
}
|
|
break;
|
|
#endif
|
|
case IFM_IEEE80211:
|
|
switch(IFM_SUBTYPE(ifm_active)) {
|
|
case IFM_IEEE80211_FH1: // Frequency Hopping 1Mbps
|
|
case IFM_IEEE80211_DS1: // Direct Sequence 1Mbps
|
|
return 1;
|
|
case IFM_IEEE80211_FH2: // Frequency Hopping 2Mbps
|
|
case IFM_IEEE80211_DS2: // Direct Sequence 2Mbps
|
|
return 2;
|
|
case IFM_IEEE80211_DS5: // Direct Sequence 5Mbps
|
|
return 5;
|
|
case IFM_IEEE80211_DS11: // Direct Sequence 11Mbps
|
|
return 11;
|
|
case IFM_IEEE80211_DS22: // Direct Sequence 22Mbps
|
|
return 22;
|
|
// We don't know what it is
|
|
default:
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Return stats about a particular network interface.
|
|
* References:
|
|
* http://www.i-scream.org/libstatgrab/
|
|
*/
|
|
static PyObject *
|
|
psutil_net_if_stats(PyObject *self, PyObject *args)
|
|
{
|
|
char *nic_name;
|
|
int sock = 0;
|
|
int ret;
|
|
int duplex;
|
|
int speed;
|
|
int mtu;
|
|
struct ifreq ifr;
|
|
struct ifmediareq ifmed;
|
|
|
|
PyObject *py_is_up = NULL;
|
|
|
|
if (! PyArg_ParseTuple(args, "s", &nic_name))
|
|
return NULL;
|
|
|
|
sock = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (sock == -1)
|
|
goto error;
|
|
strncpy(ifr.ifr_name, nic_name, sizeof(ifr.ifr_name));
|
|
|
|
// is up?
|
|
ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
|
|
if (ret == -1)
|
|
goto error;
|
|
if ((ifr.ifr_flags & IFF_UP) != 0)
|
|
py_is_up = Py_True;
|
|
else
|
|
py_is_up = Py_False;
|
|
Py_INCREF(py_is_up);
|
|
|
|
// MTU
|
|
ret = ioctl(sock, SIOCGIFMTU, &ifr);
|
|
if (ret == -1)
|
|
goto error;
|
|
mtu = ifr.ifr_mtu;
|
|
|
|
// speed / duplex
|
|
memset(&ifmed, 0, sizeof(struct ifmediareq));
|
|
strlcpy(ifmed.ifm_name, nic_name, sizeof(ifmed.ifm_name));
|
|
ret = ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmed);
|
|
if (ret == -1) {
|
|
speed = 0;
|
|
duplex = 0;
|
|
}
|
|
else {
|
|
speed = psutil_get_nic_speed(ifmed.ifm_active);
|
|
if ((ifmed.ifm_active | IFM_FDX) == ifmed.ifm_active)
|
|
duplex = 2;
|
|
else if ((ifmed.ifm_active | IFM_HDX) == ifmed.ifm_active)
|
|
duplex = 1;
|
|
else
|
|
duplex = 0;
|
|
}
|
|
|
|
close(sock);
|
|
Py_DECREF(py_is_up);
|
|
|
|
return Py_BuildValue("[Oiii]", py_is_up, duplex, speed, mtu);
|
|
|
|
error:
|
|
Py_XDECREF(py_is_up);
|
|
if (sock != 0)
|
|
close(sock);
|
|
PyErr_SetFromErrno(PyExc_OSError);
|
|
return NULL;
|
|
}
|
|
#endif // net_if_stats() implementation
|
|
|
|
|
|
/*
|
|
* define the psutil C module methods and initialize the module.
|
|
*/
|
|
static PyMethodDef
|
|
PsutilMethods[] =
|
|
{
|
|
{"getpriority", psutil_posix_getpriority, METH_VARARGS,
|
|
"Return process priority"},
|
|
{"setpriority", psutil_posix_setpriority, METH_VARARGS,
|
|
"Set process priority"},
|
|
{"net_if_addrs", psutil_net_if_addrs, METH_VARARGS,
|
|
"Retrieve NICs information"},
|
|
#if defined(__FreeBSD__) || defined(__APPLE__)
|
|
{"net_if_stats", psutil_net_if_stats, METH_VARARGS,
|
|
"Return NIC stats."},
|
|
#endif
|
|
{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
|
|
|
|
PyMODINIT_FUNC 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 defined(__FreeBSD__) || defined(__APPLE__) || defined(__sun)
|
|
PyModule_AddIntConstant(module, "AF_LINK", AF_LINK);
|
|
#endif
|
|
|
|
if (module == NULL)
|
|
INITERROR;
|
|
#if PY_MAJOR_VERSION >= 3
|
|
return module;
|
|
#endif
|
|
}
|