1 diff --git Python-2.6.4/Modules/ucred.c Python-2.6.4/Modules/ucred.c

     2 new file mode 100644

     3 --- /dev/null

     4 +++ Python-2.6.4/Modules/ucred.c

     5 @@ -0,0 +1,391 @@

     6 +/*

     7 + * Permission is hereby granted, free of charge, to any person obtaining a copy

     8 + * of this software and associated documentation files (the "Software"), to

     9 + * deal in the Software without restriction, including without limitation the

    10 + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

    11 + * sell copies of the Software, and to permit persons to whom the Software is

    12 + * furnished to do so, subject to the following conditions:

    13 + *

    14 + * The above copyright notice and this permission notice shall be included in

    15 + * all copies or substantial portions of the Software.

    16 + *

    17 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    18 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    19 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    20 + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    21 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

    22 + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

    23 + * DEALINGS IN THE SOFTWARE.

    24 + *

    25 + * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.

    26 + * Use is subject to license terms.

    27 + */

    28 +

    29 +#include <Python.h>

    30 +

    31 +#include <stdio.h>

    32 +#include <priv.h>

    33 +#include <ucred.h>

    34 +#include <ctype.h>

    35 +#include <tsol/label.h>

    36 +

    37 +typedef struct {

    38 +	PyObject_HEAD

    39 +	ucred_t *ucred;

    40 +} pyucred_t;

    41 +

    42 +#define pyucred_getlongid(name, type)				\

    43 +	static PyObject *					\

    44 +	pyucred_get##name(pyucred_t *uc)			\

    45 +	{ 							\

    46 +		type val;					\

    47 +								\

    48 +		if (uc->ucred == NULL) {			\

    49 +			errno = EINVAL;				\

    50 +			PyErr_SetFromErrno(PyExc_OSError);	\

    51 +			return (NULL);				\

    52 +		}						\

    53 +								\

    54 +		if ((val = ucred_get##name(uc->ucred)) == -1) {	\

    55 +			PyErr_SetFromErrno(PyExc_OSError);	\

    56 +			return (NULL);				\

    57 +		}						\

    58 +								\

    59 +		return (Py_BuildValue("l", (long)val));		\

    60 +	}

    61 +

    62 +pyucred_getlongid(euid, uid_t)

    63 +pyucred_getlongid(ruid, uid_t)

    64 +pyucred_getlongid(suid, uid_t)

    65 +pyucred_getlongid(egid, gid_t)

    66 +pyucred_getlongid(rgid, gid_t)

    67 +pyucred_getlongid(sgid, gid_t)

    68 +pyucred_getlongid(pid, pid_t)

    69 +pyucred_getlongid(projid, projid_t)

    70 +pyucred_getlongid(zoneid, zoneid_t)

    71 +

    72 +static PyObject *

    73 +pyucred_getgroups(pyucred_t *uc)

    74 +{

    75 +	const gid_t *groups;

    76 +	PyObject *list;

    77 +	int len;

    78 +	int i;

    79 +

    80 +	if (uc->ucred == NULL) {

    81 +		errno = EINVAL;

    82 +		PyErr_SetFromErrno(PyExc_OSError);

    83 +		return (NULL);

    84 +	}

    85 +

    86 +	if ((len = ucred_getgroups(uc->ucred, &groups)) == -1) {

    87 +		PyErr_SetFromErrno(PyExc_OSError);

    88 +		return (NULL);

    89 +	}

    90 +

    91 +	if ((list = PyList_New(len)) == NULL)

    92 +		return (NULL);

    93 +

    94 +	for (i = 0; i < len; i++) {

    95 +		PyObject *gid = Py_BuildValue("l", (long)groups[i]);

    96 +		if (PyList_SetItem(list, i, gid) == -1)

    97 +			return (NULL);

    98 +	}

    99 +

   100 +	return (list);

   101 +}

   102 +

   103 +static PyObject *

   104 +pyucred_getlabel(pyucred_t *uc)

   105 +{

   106 +	m_label_t *label;

   107 +	PyObject *ret;

   108 +	char *str;

   109 +

   110 +	if (uc->ucred == NULL) {

   111 +		errno = EINVAL;

   112 +		PyErr_SetFromErrno(PyExc_OSError);

   113 +		return (NULL);

   114 +	}

   115 +

   116 +	label = ucred_getlabel(uc->ucred);

   117 +	if (label == NULL)

   118 +		return (Py_BuildValue("s", ""));

   119 +

   120 +	if (label_to_str(label, &str, M_LABEL, DEF_NAMES) == -1) {

   121 +		PyErr_SetFromErrno(PyExc_OSError);

   122 +		return (NULL);

   123 +	}

   124 +

   125 +	ret = Py_BuildValue("s", str);

   126 +	free(str);

   127 +	return (ret);

   128 +}

   129 +

   130 +static PyObject *

   131 +pyucred_getpflags(pyucred_t *uc, PyObject *args, PyObject *kwargs)

   132 +{

   133 +	static char *kwlist[] = { "flags", NULL };

   134 +	uint_t flags;

   135 +

   136 +	if (uc->ucred == NULL) {

   137 +		errno = EINVAL;

   138 +		PyErr_SetFromErrno(PyExc_OSError);

   139 +		return (NULL);

   140 +	}

   141 +

   142 +	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist,

   143 +	    &flags))

   144 +		return (NULL);

   145 +

   146 +	if ((flags = ucred_getpflags(uc->ucred, flags)) == (uint_t)-1) {

   147 +		PyErr_SetFromErrno(PyExc_OSError);

   148 +		return (NULL);

   149 +	}

   150 +

   151 +	return (Py_BuildValue("i", flags));

   152 +}

   153 +

   154 +static PyObject *

   155 +pyucred_has_priv(pyucred_t *uc, PyObject *args, PyObject *kwargs)

   156 +{

   157 +	static char *kwlist[] = { "set", "priv", NULL };

   158 +	const priv_set_t *privs;

   159 +	const char *set;

   160 +	const char *priv;

   161 +

   162 +	if (uc->ucred == NULL) {

   163 +		errno = EINVAL;

   164 +		PyErr_SetFromErrno(PyExc_OSError);

   165 +		return (NULL);

   166 +	}

   167 +

   168 +	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ss", kwlist,

   169 +	    &set, &priv))

   170 +		return (NULL);

   171 +

   172 +	if ((privs = ucred_getprivset(uc->ucred, set)) == NULL) {

   173 +		PyErr_SetFromErrno(PyExc_OSError);

   174 +		return (NULL);

   175 +	}

   176 +

   177 +	if (priv_ismember(privs, priv)) {

   178 +		Py_INCREF(Py_True);

   179 +		return Py_True;

   180 +	}

   181 +

   182 +	Py_INCREF(Py_False);

   183 +	return Py_False;

   184 +}

   185 +

   186 +PyDoc_STRVAR(pyucred_getlabel_doc,

   187 +    "getlabel() -> string\n"

   188 +    "\n"

   189 +    "Return the Trusted Extensions label string, or an "

   190 +    "empty string if not available. The label string is "

   191 +    "converted using the default name and M_LABEL (human-readable). "

   192 +    "Raises OSError. See label_to_str(3TSOL).");

   193 +PyDoc_STRVAR(pyucred_getpflags_doc,

   194 +    "getpflags(flags) -> int\n"

   195 +    "\n"

   196 +    "Return the values of the specified privilege flags.");

   197 +PyDoc_STRVAR(pyucred_has_priv_doc,

   198 +    "has_priv(set, priv) -> bool\n"

   199 +    "\n"

   200 +    "Return true if the given privilege is set in the "

   201 +    "specified set. Raises OSError if the set or privilege is "

   202 +    "invalid, or a problem occurs.\n"

   203 +    "\n"

   204 +    "Currently, the following privilege sets are defined, as "

   205 +    "described in privileges(5):\n"

   206 +    "\n"

   207 +    "Effective\n"

   208 +    "Permitted\n"

   209 +    "Inheritable\n"

   210 +    "Limit\n");

   211 +

   212 +static PyMethodDef pyucred_methods[] = {

   213 +	{ "geteuid", (PyCFunction)pyucred_geteuid, METH_NOARGS,

   214 +	    "Return the effective user ID." },

   215 +	{ "getruid", (PyCFunction)pyucred_getruid, METH_NOARGS,

   216 +	    "Return the real user ID." },

   217 +	{ "getsuid", (PyCFunction)pyucred_getsuid, METH_NOARGS,

   218 +	    "Return the saved user ID." },

   219 +	{ "getegid", (PyCFunction)pyucred_getegid, METH_NOARGS,

   220 +	    "Return the effective group ID." },

   221 +	{ "getrgid", (PyCFunction)pyucred_getrgid, METH_NOARGS,

   222 +	    "Return the real group ID." },

   223 +	{ "getsgid", (PyCFunction)pyucred_getsgid, METH_NOARGS,

   224 +	    "Return the saved group ID." },

   225 +	{ "getpid", (PyCFunction)pyucred_getpid, METH_NOARGS,

   226 +	    "Return the effective user ID." },

   227 +	{ "getprojid", (PyCFunction)pyucred_getprojid, METH_NOARGS,

   228 +	    "Return the project ID." },

   229 +	{ "getzoneid", (PyCFunction)pyucred_getzoneid, METH_NOARGS,

   230 +	    "Return the zone ID." },

   231 +	{ "getgroups", (PyCFunction)pyucred_getgroups, METH_NOARGS,

   232 +	    "Return a list of group IDs." },

   233 +	{ "getlabel", (PyCFunction)pyucred_getlabel, METH_NOARGS,

   234 +	    pyucred_getlabel_doc },

   235 +	{ "getpflags", (PyCFunction)pyucred_getpflags,

   236 +	    METH_VARARGS|METH_KEYWORDS, pyucred_getpflags_doc },

   237 +	{ "has_priv", (PyCFunction)pyucred_has_priv,

   238 +	    METH_VARARGS|METH_KEYWORDS, pyucred_has_priv_doc },

   239 +	{ NULL }

   240 +};

   241 +

   242 +static int

   243 +pyucred_init(PyObject *self, PyObject *args, PyObject *kwargs)

   244 +{

   245 +	pyucred_t *uc = (pyucred_t *)self;

   246 +	uc->ucred = NULL;

   247 +	return (0);

   248 +}

   249 +

   250 +static void

   251 +pyucred_dealloc(PyObject *self)

   252 +{

   253 +	pyucred_t *uc = (pyucred_t *)self;

   254 +	if (uc->ucred != NULL)

   255 +		ucred_free(uc->ucred);

   256 +	self->ob_type->tp_free(self);

   257 +}

   258 +

   259 +static PyTypeObject pyucred_type = {

   260 +	PyObject_HEAD_INIT(NULL)

   261 +	0,                         /*ob_size*/

   262 +	"ucred.ucred",             /*tp_name*/

   263 +	sizeof (pyucred_t),        /*tp_basicsize*/

   264 +	0,                         /*tp_itemsize*/

   265 +	pyucred_dealloc,           /*tp_dealloc*/

   266 +	0,                         /*tp_print*/

   267 +	0,                         /*tp_getattr*/

   268 +	0,                         /*tp_setattr*/

   269 +	0,                         /*tp_compare*/

   270 +	0,                         /*tp_repr*/

   271 +	0,                         /*tp_as_number*/

   272 +	0,                         /*tp_as_sequence*/

   273 +	0,                         /*tp_as_mapping*/

   274 +	0,                         /*tp_hash */

   275 +	0,                         /*tp_call*/

   276 +	0,                         /*tp_str*/

   277 +	0,                         /*tp_getattro*/

   278 +	0,                         /*tp_setattro*/

   279 +	0,                         /*tp_as_buffer*/

   280 +	Py_TPFLAGS_DEFAULT,        /*tp_flags*/

   281 +	"user credentials",        /*tp_doc */

   282 +	0,		           /* tp_traverse */

   283 +	0,		           /* tp_clear */

   284 +	0,		           /* tp_richcompare */

   285 +	0,		           /* tp_weaklistoffset */

   286 +	0,		           /* tp_iter */

   287 +	0,		           /* tp_iternext */

   288 +	pyucred_methods,           /* tp_methods */

   289 +	0,                         /* tp_members */

   290 +	0,                         /* tp_getset */

   291 +	0,                         /* tp_base */

   292 +	0,                         /* tp_dict */

   293 +	0,                         /* tp_descr_get */

   294 +	0,                         /* tp_descr_set */

   295 +	0,                         /* tp_dictoffset */

   296 +	(initproc)pyucred_init,    /* tp_init */

   297 +	0,                         /* tp_alloc */

   298 +	0,                         /* tp_new */

   299 +};

   300 +

   301 +static PyObject *

   302 +pyucred_new(const ucred_t *uc)

   303 +{

   304 +	pyucred_t *self;

   305 +

   306 +	self = (pyucred_t *)PyObject_CallObject((PyObject *)&pyucred_type, NULL);

   307 +

   308 +	if (self == NULL)

   309 +		return (NULL);

   310 +

   311 +	self->ucred = (ucred_t *)uc;

   312 +

   313 +	return ((PyObject *)self);

   314 +}

   315 +

   316 +static PyObject *

   317 +pyucred_get(PyObject *o, PyObject *args, PyObject *kwargs)

   318 +{

   319 +	static char *kwlist[] = { "pid", NULL };

   320 +	ucred_t *ucred = NULL;

   321 +	int pid;

   322 +

   323 +	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist,

   324 +	    &pid))

   325 +		return (NULL);

   326 +

   327 +	ucred = ucred_get(pid);

   328 +

   329 +	if (ucred == NULL) {

   330 +		PyErr_SetFromErrno(PyExc_OSError);

   331 +		return (NULL);

   332 +	}

   333 +

   334 +	return (pyucred_new(ucred));

   335 +}

   336 +

   337 +static PyObject *

   338 +pyucred_getpeer(PyObject *o, PyObject *args, PyObject *kwargs)

   339 +{

   340 +	static char *kwlist[] = { "fd", NULL };

   341 +	ucred_t *ucred = NULL;

   342 +	int fd;

   343 +

   344 +	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist,

   345 +	    &fd))

   346 +		return (NULL);

   347 +

   348 +	if (getpeerucred(fd, &ucred) == -1) {

   349 +		PyErr_SetFromErrno(PyExc_OSError);

   350 +		return (NULL);

   351 +	}

   352 +

   353 +	return (pyucred_new(ucred));

   354 +}

   355 +

   356 +PyDoc_STRVAR(pyucred_get_doc,

   357 +    "get(pid) -> ucred\n"

   358 +    "\n"

   359 +    "Return the credentials of the specified process ID. "

   360 +    "Raises OSError. See ucred_get(3C).");

   361 +PyDoc_STRVAR(pyucred_getpeer_doc,

   362 +    "getpeer(fd) -> ucred\n"

   363 +    "\n"

   364 +    "Return the credentials of the peer endpoint of a "

   365 +    "connection-oriented socket (SOCK_STREAM) or STREAM fd "

   366 +    "at the time the endpoint was created or the connection "

   367 +    "was established. Raises OSError. See getpeerucred(3C).");

   368 +

   369 +static struct PyMethodDef pyucred_module_methods[] = {

   370 +	{ "get", (PyCFunction) pyucred_get,

   371 +	  METH_VARARGS|METH_KEYWORDS, pyucred_get_doc },

   372 +	{ "getpeer", (PyCFunction) pyucred_getpeer,

   373 +	  METH_VARARGS|METH_KEYWORDS, pyucred_getpeer_doc },

   374 +	{ NULL, NULL, 0, NULL }

   375 +};

   376 +

   377 +PyDoc_STRVAR(pyucred_module_doc,

   378 +    "This module provides an interface to the user credential access "

   379 +    "methods, obtainable either by process ID or file descriptor.");

   380 +   

   381 +PyMODINIT_FUNC

   382 +initucred(void)

   383 +{

   384 +	PyObject *m;

   385 +

   386 +	m = Py_InitModule3("ucred", pyucred_module_methods,

   387 +	    pyucred_module_doc);

   388 +

   389 +	pyucred_type.tp_new = PyType_GenericNew;

   390 +	if (PyType_Ready(&pyucred_type) < 0)

   391 +		return;

   392 +

   393 +	Py_INCREF(&pyucred_type);

   394 +

   395 +	PyModule_AddObject(m, "ucred", (PyObject *)&pyucred_type);

   396 +}

   397 diff --git Python-2.6.4/setup.py Python-2.6.4/setup.py

   398 --- Python-2.6.4/setup.py

   399 +++ Python-2.6.4/setup.py

   400 @@ -1277,6 +1277,13 @@

   401          else:

   402              missing.append('dl')

   403  

   404 +        # ucred module (Solaris)

   405 +        ucred_inc = find_file('ucred.h', [], inc_dirs)

   406 +        tsol_inc = find_file('tsol/label.h', [], inc_dirs)

   407 +        if ucred_inc is not None and tsol_inc is not None:

   408 +            exts.append( Extension('ucred', ['ucred.c'],

   409 +                                   libraries = ['tsol']) )

   410 +

   411          # Thomas Heller's _ctypes module

   412          self.detect_ctypes(inc_dirs, lib_dirs)

   413  

   414 diff --git Python-2.6.4/setup.py.orig Python-2.6.4/setup.py.orig

   415 new file mode 100644

   416 --- /dev/null

   417 +++ Python-2.6.4/setup.py.orig

   418 @@ -0,0 +1,1958 @@

   419 +# Autodetecting setup.py script for building the Python extensions

   420 +#

   421 +

   422 +__version__ = "$Revision: 75282 $"

   423 +

   424 +import sys, os, imp, re, optparse

   425 +from glob import glob

   426 +from platform import machine as platform_machine

   427 +

   428 +from distutils import log

   429 +from distutils import sysconfig

   430 +from distutils import text_file

   431 +from distutils.errors import *

   432 +from distutils.core import Extension, setup

   433 +from distutils.command.build_ext import build_ext

   434 +from distutils.command.install import install

   435 +from distutils.command.install_lib import install_lib

   436 +

   437 +# This global variable is used to hold the list of modules to be disabled.

   438 +disabled_module_list = []

   439 +

   440 +def add_dir_to_list(dirlist, dir):

   441 +    """Add the directory 'dir' to the list 'dirlist' (at the front) if

   442 +    1) 'dir' is not already in 'dirlist'

   443 +    2) 'dir' actually exists, and is a directory."""

   444 +    if dir is not None and os.path.isdir(dir) and dir not in dirlist:

   445 +        dirlist.insert(0, dir)

   446 +

   447 +def find_file(filename, std_dirs, paths):

   448 +    """Searches for the directory where a given file is located,

   449 +    and returns a possibly-empty list of additional directories, or None

   450 +    if the file couldn't be found at all.

   451 +

   452 +    'filename' is the name of a file, such as readline.h or libcrypto.a.

   453 +    'std_dirs' is the list of standard system directories; if the

   454 +        file is found in one of them, no additional directives are needed.

   455 +    'paths' is a list of additional locations to check; if the file is

   456 +        found in one of them, the resulting list will contain the directory.

   457 +    """

   458 +

   459 +    # Check the standard locations

   460 +    for dir in std_dirs:

   461 +        f = os.path.join(dir, filename)

   462 +        if os.path.exists(f): return []

   463 +

   464 +    # Check the additional directories

   465 +    for dir in paths:

   466 +        f = os.path.join(dir, filename)

   467 +        if os.path.exists(f):

   468 +            return [dir]

   469 +

   470 +    # Not found anywhere

   471 +    return None

   472 +

   473 +def find_library_file(compiler, libname, std_dirs, paths):

   474 +    result = compiler.find_library_file(std_dirs + paths, libname)

   475 +    if result is None:

   476 +        return None

   477 +

   478 +    # Check whether the found file is in one of the standard directories

   479 +    dirname = os.path.dirname(result)

   480 +    for p in std_dirs:

   481 +        # Ensure path doesn't end with path separator

   482 +        p = p.rstrip(os.sep)

   483 +        if p == dirname:

   484 +            return [ ]

   485 +

   486 +    # Otherwise, it must have been in one of the additional directories,

   487 +    # so we have to figure out which one.

   488 +    for p in paths:

   489 +        # Ensure path doesn't end with path separator

   490 +        p = p.rstrip(os.sep)

   491 +        if p == dirname:

   492 +            return [p]

   493 +    else:

   494 +        assert False, "Internal error: Path not found in std_dirs or paths"

   495 +

   496 +def module_enabled(extlist, modname):

   497 +    """Returns whether the module 'modname' is present in the list

   498 +    of extensions 'extlist'."""

   499 +    extlist = [ext for ext in extlist if ext.name == modname]

   500 +    return len(extlist)

   501 +

   502 +def find_module_file(module, dirlist):

   503 +    """Find a module in a set of possible folders. If it is not found

   504 +    return the unadorned filename"""

   505 +    list = find_file(module, [], dirlist)

   506 +    if not list:

   507 +        return module

   508 +    if len(list) > 1:

   509 +        log.info("WARNING: multiple copies of %s found"%module)

   510 +    return os.path.join(list[0], module)

   511 +

   512 +class PyBuildExt(build_ext):

   513 +

   514 +    def __init__(self, dist):

   515 +        build_ext.__init__(self, dist)

   516 +        self.failed = []

   517 +

   518 +    def build_extensions(self):

   519 +

   520 +        # Detect which modules should be compiled

   521 +        missing = self.detect_modules()

   522 +

   523 +        # Remove modules that are present on the disabled list

   524 +        extensions = [ext for ext in self.extensions

   525 +                      if ext.name not in disabled_module_list]

   526 +        # move ctypes to the end, it depends on other modules

   527 +        ext_map = dict((ext.name, i) for i, ext in enumerate(extensions))

   528 +        if "_ctypes" in ext_map:

   529 +            ctypes = extensions.pop(ext_map["_ctypes"])

   530 +            extensions.append(ctypes)

   531 +        self.extensions = extensions

   532 +

   533 +        # Fix up the autodetected modules, prefixing all the source files

   534 +        # with Modules/ and adding Python's include directory to the path.

   535 +        (srcdir,) = sysconfig.get_config_vars('srcdir')

   536 +        if not srcdir:

   537 +            # Maybe running on Windows but not using CYGWIN?

   538 +            raise ValueError("No source directory; cannot proceed.")

   539 +

   540 +        # Figure out the location of the source code for extension modules

   541 +        # (This logic is copied in distutils.test.test_sysconfig,

   542 +        # so building in a separate directory does not break test_distutils.)

   543 +        moddir = os.path.join(os.getcwd(), srcdir, 'Modules')

   544 +        moddir = os.path.normpath(moddir)

   545 +        srcdir, tail = os.path.split(moddir)

   546 +        srcdir = os.path.normpath(srcdir)

   547 +        moddir = os.path.normpath(moddir)

   548 +

   549 +        moddirlist = [moddir]

   550 +        incdirlist = ['./Include']

   551 +

   552 +        # Platform-dependent module source and include directories

   553 +        platform = self.get_platform()

   554 +        if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in

   555 +            sysconfig.get_config_var("CONFIG_ARGS")):

   556 +            # Mac OS X also includes some mac-specific modules

   557 +            macmoddir = os.path.join(os.getcwd(), srcdir, 'Mac/Modules')

   558 +            moddirlist.append(macmoddir)

   559 +            incdirlist.append('./Mac/Include')

   560 +

   561 +        alldirlist = moddirlist + incdirlist

   562 +

   563 +        # Fix up the paths for scripts, too

   564 +        self.distribution.scripts = [os.path.join(srcdir, filename)

   565 +                                     for filename in self.distribution.scripts]

   566 +

   567 +        # Python header files

   568 +        headers = glob("Include/*.h") + ["pyconfig.h"]

   569 +

   570 +        for ext in self.extensions[:]:

   571 +            ext.sources = [ find_module_file(filename, moddirlist)

   572 +                            for filename in ext.sources ]

   573 +            if ext.depends is not None:

   574 +                ext.depends = [find_module_file(filename, alldirlist)

   575 +                               for filename in ext.depends]

   576 +            else:

   577 +                ext.depends = []

   578 +            # re-compile extensions if a header file has been changed

   579 +            ext.depends.extend(headers)

   580 +

   581 +            ext.include_dirs.append( '.' ) # to get config.h

   582 +            for incdir in incdirlist:

   583 +                ext.include_dirs.append( os.path.join(srcdir, incdir) )

   584 +

   585 +            # If a module has already been built statically,

   586 +            # don't build it here

   587 +            if ext.name in sys.builtin_module_names:

   588 +                self.extensions.remove(ext)

   589 +

   590 +        if platform != 'mac':

   591 +            # Parse Modules/Setup and Modules/Setup.local to figure out which

   592 +            # modules are turned on in the file.

   593 +            remove_modules = []

   594 +            for filename in ('Modules/Setup', 'Modules/Setup.local'):

   595 +                input = text_file.TextFile(filename, join_lines=1)

   596 +                while 1:

   597 +                    line = input.readline()

   598 +                    if not line: break

   599 +                    line = line.split()

   600 +                    remove_modules.append(line[0])

   601 +                input.close()

   602 +

   603 +            for ext in self.extensions[:]:

   604 +                if ext.name in remove_modules:

   605 +                    self.extensions.remove(ext)

   606 +

   607 +        # When you run "make CC=altcc" or something similar, you really want

   608 +        # those environment variables passed into the setup.py phase.  Here's

   609 +        # a small set of useful ones.

   610 +        compiler = os.environ.get('CC')

   611 +        args = {}

   612 +        # unfortunately, distutils doesn't let us provide separate C and C++

   613 +        # compilers

   614 +        if compiler is not None:

   615 +            (ccshared,cflags) = sysconfig.get_config_vars('CCSHARED','CFLAGS')

   616 +            args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cflags

   617 +        self.compiler.set_executables(**args)

   618 +

   619 +        build_ext.build_extensions(self)

   620 +

   621 +        longest = max([len(e.name) for e in self.extensions])

   622 +        if self.failed:

   623 +            longest = max(longest, max([len(name) for name in self.failed]))

   624 +

   625 +        def print_three_column(lst):

   626 +            lst.sort(key=str.lower)

   627 +            # guarantee zip() doesn't drop anything

   628 +            while len(lst) % 3:

   629 +                lst.append("")

   630 +            for e, f, g in zip(lst[::3], lst[1::3], lst[2::3]):

   631 +                print "%-*s   %-*s   %-*s" % (longest, e, longest, f,

   632 +                                              longest, g)

   633 +

   634 +        if missing:

   635 +            print

   636 +            print "Failed to find the necessary bits to build these modules:"

   637 +            print_three_column(missing)

   638 +            print ("To find the necessary bits, look in setup.py in"

   639 +                   " detect_modules() for the module's name.")

   640 +            print

   641 +

   642 +        if self.failed:

   643 +            failed = self.failed[:]

   644 +            print

   645 +            print "Failed to build these modules:"

   646 +            print_three_column(failed)

   647 +            print

   648 +

   649 +    def build_extension(self, ext):

   650 +

   651 +        if ext.name == '_ctypes':

   652 +            if not self.configure_ctypes(ext):

   653 +                return

   654 +

   655 +        try:

   656 +            build_ext.build_extension(self, ext)

   657 +        except (CCompilerError, DistutilsError), why:

   658 +            self.announce('WARNING: building of extension "%s" failed: %s' %

   659 +                          (ext.name, sys.exc_info()[1]))

   660 +            self.failed.append(ext.name)

   661 +            return

   662 +        # Workaround for Mac OS X: The Carbon-based modules cannot be

   663 +        # reliably imported into a command-line Python

   664 +        if 'Carbon' in ext.extra_link_args:

   665 +            self.announce(

   666 +                'WARNING: skipping import check for Carbon-based "%s"' %

   667 +                ext.name)

   668 +            return

   669 +

   670 +        if self.get_platform() == 'darwin' and (

   671 +                sys.maxint > 2**32 and '-arch' in ext.extra_link_args):

   672 +            # Don't bother doing an import check when an extension was

   673 +            # build with an explicit '-arch' flag on OSX. That's currently

   674 +            # only used to build 32-bit only extensions in a 4-way

   675 +            # universal build and loading 32-bit code into a 64-bit

   676 +            # process will fail.

   677 +            self.announce(

   678 +                'WARNING: skipping import check for "%s"' %

   679 +                ext.name)

   680 +            return

   681 +

   682 +        # Workaround for Cygwin: Cygwin currently has fork issues when many

   683 +        # modules have been imported

   684 +        if self.get_platform() == 'cygwin':

   685 +            self.announce('WARNING: skipping import check for Cygwin-based "%s"'

   686 +                % ext.name)

   687 +            return

   688 +        ext_filename = os.path.join(

   689 +            self.build_lib,

   690 +            self.get_ext_filename(self.get_ext_fullname(ext.name)))

   691 +        try:

   692 +            imp.load_dynamic(ext.name, ext_filename)

   693 +        except ImportError, why:

   694 +            self.failed.append(ext.name)

   695 +            self.announce('*** WARNING: renaming "%s" since importing it'

   696 +                          ' failed: %s' % (ext.name, why), level=3)

   697 +            assert not self.inplace

   698 +            basename, tail = os.path.splitext(ext_filename)

   699 +            newname = basename + "_failed" + tail

   700 +            if os.path.exists(newname):

   701 +                os.remove(newname)

   702 +            os.rename(ext_filename, newname)

   703 +

   704 +            # XXX -- This relies on a Vile HACK in

   705 +            # distutils.command.build_ext.build_extension().  The

   706 +            # _built_objects attribute is stored there strictly for

   707 +            # use here.

   708 +            # If there is a failure, _built_objects may not be there,

   709 +            # so catch the AttributeError and move on.

   710 +            try:

   711 +                for filename in self._built_objects:

   712 +                    os.remove(filename)

   713 +            except AttributeError:

   714 +                self.announce('unable to remove files (ignored)')

   715 +        except:

   716 +            exc_type, why, tb = sys.exc_info()

   717 +            self.announce('*** WARNING: importing extension "%s" '

   718 +                          'failed with %s: %s' % (ext.name, exc_type, why),

   719 +                          level=3)

   720 +            self.failed.append(ext.name)

   721 +

   722 +    def get_platform(self):

   723 +        # Get value of sys.platform

   724 +        for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:

   725 +            if sys.platform.startswith(platform):

   726 +                return platform

   727 +        return sys.platform

   728 +

   729 +    def detect_modules(self):

   730 +        if sys.platform != 'sunos5':

   731 +            # Ensure that /usr/local is always used

   732 +            add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')

   733 +            add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')

   734 +        # Add paths specified in the environment variables LDFLAGS and

   735 +        # CPPFLAGS for header and library files.

   736 +        # We must get the values from the Makefile and not the environment

   737 +        # directly since an inconsistently reproducible issue comes up where

   738 +        # the environment variable is not set even though the value were passed

   739 +        # into configure and stored in the Makefile (issue found on OS X 10.3).

   740 +        for env_var, arg_name, dir_list in (

   741 +                ('LDFLAGS', '-R', self.compiler.runtime_library_dirs),

   742 +                ('LDFLAGS', '-L', self.compiler.library_dirs),

   743 +                ('CPPFLAGS', '-I', self.compiler.include_dirs)):

   744 +            env_val = sysconfig.get_config_var(env_var)

   745 +            if env_val:

   746 +                # To prevent optparse from raising an exception about any

   747 +                # options in env_val that it doesn't know about we strip out

   748 +                # all double dashes and any dashes followed by a character

   749 +                # that is not for the option we are dealing with.

   750 +                #

   751 +                # Please note that order of the regex is important!  We must

   752 +                # strip out double-dashes first so that we don't end up with

   753 +                # substituting "--Long" to "-Long" and thus lead to "ong" being

   754 +                # used for a library directory.

   755 +                env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1],

   756 +                                 ' ', env_val)

   757 +                parser = optparse.OptionParser()

   758 +                # Make sure that allowing args interspersed with options is

   759 +                # allowed

   760 +                parser.allow_interspersed_args = True

   761 +                parser.error = lambda msg: None

   762 +                parser.add_option(arg_name, dest="dirs", action="append")

   763 +                options = parser.parse_args(env_val.split())[0]

   764 +                if options.dirs:

   765 +                    for directory in reversed(options.dirs):

   766 +                        add_dir_to_list(dir_list, directory)

   767 +

   768 +        if os.path.normpath(sys.prefix) != '/usr':

   769 +            add_dir_to_list(self.compiler.library_dirs,

   770 +                            sysconfig.get_config_var("LIBDIR"))

   771 +            add_dir_to_list(self.compiler.include_dirs,

   772 +                            sysconfig.get_config_var("INCLUDEDIR"))

   773 +

   774 +        try:

   775 +            have_unicode = unicode

   776 +        except NameError:

   777 +            have_unicode = 0

   778 +

   779 +        # lib_dirs and inc_dirs are used to search for files;

   780 +        # if a file is found in one of those directories, it can

   781 +        # be assumed that no additional -I,-L directives are needed.

   782 +        lib_dirs = self.compiler.library_dirs + [

   783 +            '/lib64', '/usr/lib64',

   784 +            '/lib', '/usr/lib',

   785 +            ]

   786 +        inc_dirs = self.compiler.include_dirs + ['/usr/include']

   787 +        exts = []

   788 +        missing = []

   789 +

   790 +        config_h = sysconfig.get_config_h_filename()

   791 +        config_h_vars = sysconfig.parse_config_h(open(config_h))

   792 +

   793 +        platform = self.get_platform()

   794 +        (srcdir,) = sysconfig.get_config_vars('srcdir')

   795 +

   796 +        # Check for AtheOS which has libraries in non-standard locations

   797 +        if platform == 'atheos':

   798 +            lib_dirs += ['/system/libs', '/atheos/autolnk/lib']

   799 +            lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)

   800 +            inc_dirs += ['/system/include', '/atheos/autolnk/include']

   801 +            inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)

   802 +

   803 +        # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)

   804 +        if platform in ['osf1', 'unixware7', 'openunix8']:

   805 +            lib_dirs += ['/usr/ccs/lib']

   806 +

   807 +        if platform == 'darwin':

   808 +            # This should work on any unixy platform ;-)

   809 +            # If the user has bothered specifying additional -I and -L flags

   810 +            # in OPT and LDFLAGS we might as well use them here.

   811 +            #   NOTE: using shlex.split would technically be more correct, but

   812 +            # also gives a bootstrap problem. Let's hope nobody uses directories

   813 +            # with whitespace in the name to store libraries.

   814 +            cflags, ldflags = sysconfig.get_config_vars(

   815 +                    'CFLAGS', 'LDFLAGS')

   816 +            for item in cflags.split():

   817 +                if item.startswith('-I'):

   818 +                    inc_dirs.append(item[2:])

   819 +

   820 +            for item in ldflags.split():

   821 +                if item.startswith('-L'):

   822 +                    lib_dirs.append(item[2:])

   823 +

   824 +        # Check for MacOS X, which doesn't need libm.a at all

   825 +        math_libs = ['m']

   826 +        if platform in ['darwin', 'beos', 'mac']:

   827 +            math_libs = []

   828 +

   829 +        # XXX Omitted modules: gl, pure, dl, SGI-specific modules

   830 +

   831 +        #

   832 +        # The following modules are all pretty straightforward, and compile

   833 +        # on pretty much any POSIXish platform.

   834 +        #

   835 +

   836 +        # Some modules that are normally always on:

   837 +        exts.append( Extension('_weakref', ['_weakref.c']) )

   838 +

   839 +        # array objects

   840 +        exts.append( Extension('array', ['arraymodule.c']) )

   841 +        # complex math library functions

   842 +        exts.append( Extension('cmath', ['cmathmodule.c'],

   843 +                               libraries=math_libs) )

   844 +

   845 +        # math library functions, e.g. sin()

   846 +        exts.append( Extension('math',  ['mathmodule.c'],

   847 +                               libraries=math_libs) )

   848 +        # fast string operations implemented in C

   849 +        exts.append( Extension('strop', ['stropmodule.c']) )

   850 +        # time operations and variables

   851 +        exts.append( Extension('time', ['timemodule.c'],

   852 +                               libraries=math_libs) )

   853 +        exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],

   854 +                               libraries=math_libs) )

   855 +        # fast iterator tools implemented in C

   856 +        exts.append( Extension("itertools", ["itertoolsmodule.c"]) )

   857 +        # code that will be builtins in the future, but conflict with the

   858 +        #  current builtins

   859 +        exts.append( Extension('future_builtins', ['future_builtins.c']) )

   860 +        # random number generator implemented in C

   861 +        exts.append( Extension("_random", ["_randommodule.c"]) )

   862 +        # high-performance collections

   863 +        exts.append( Extension("_collections", ["_collectionsmodule.c"]) )

   864 +        # bisect

   865 +        exts.append( Extension("_bisect", ["_bisectmodule.c"]) )

   866 +        # heapq

   867 +        exts.append( Extension("_heapq", ["_heapqmodule.c"]) )

   868 +        # operator.add() and similar goodies

   869 +        exts.append( Extension('operator', ['operator.c']) )

   870 +        # Python 3.0 _fileio module

   871 +        exts.append( Extension("_fileio", ["_fileio.c"]) )

   872 +        # Python 3.0 _bytesio module

   873 +        exts.append( Extension("_bytesio", ["_bytesio.c"]) )

   874 +        # _functools

   875 +        exts.append( Extension("_functools", ["_functoolsmodule.c"]) )

   876 +        # _json speedups

   877 +        exts.append( Extension("_json", ["_json.c"]) )

   878 +        # Python C API test module

   879 +        exts.append( Extension('_testcapi', ['_testcapimodule.c'],

   880 +                               depends=['testcapi_long.h']) )

   881 +        # profilers (_lsprof is for cProfile.py)

   882 +        exts.append( Extension('_hotshot', ['_hotshot.c']) )

   883 +        exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )

   884 +        # static Unicode character database

   885 +        if have_unicode:

   886 +            exts.append( Extension('unicodedata', ['unicodedata.c']) )

   887 +        else:

   888 +            missing.append('unicodedata')

   889 +        # access to ISO C locale support

   890 +        data = open('pyconfig.h').read()

   891 +        m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)

   892 +        if m is not None:

   893 +            locale_libs = ['intl']

   894 +        else:

   895 +            locale_libs = []

   896 +        if platform == 'darwin':

   897 +            locale_extra_link_args = ['-framework', 'CoreFoundation']

   898 +        else:

   899 +            locale_extra_link_args = []

   900 +

   901 +

   902 +        exts.append( Extension('_locale', ['_localemodule.c'],

   903 +                               libraries=locale_libs,

   904 +                               extra_link_args=locale_extra_link_args) )

   905 +

   906 +        # Modules with some UNIX dependencies -- on by default:

   907 +        # (If you have a really backward UNIX, select and socket may not be

   908 +        # supported...)

   909 +

   910 +        # fcntl(2) and ioctl(2)

   911 +        exts.append( Extension('fcntl', ['fcntlmodule.c']) )

   912 +        if platform not in ['mac']:

   913 +            # pwd(3)

   914 +            exts.append( Extension('pwd', ['pwdmodule.c']) )

   915 +            # grp(3)

   916 +            exts.append( Extension('grp', ['grpmodule.c']) )

   917 +            # spwd, shadow passwords

   918 +            if (config_h_vars.get('HAVE_GETSPNAM', False) or

   919 +                    config_h_vars.get('HAVE_GETSPENT', False)):

   920 +                exts.append( Extension('spwd', ['spwdmodule.c']) )

   921 +            else:

   922 +                missing.append('spwd')

   923 +        else:

   924 +            missing.extend(['pwd', 'grp', 'spwd'])

   925 +

   926 +        # select(2); not on ancient System V

   927 +        exts.append( Extension('select', ['selectmodule.c']) )

   928 +

   929 +        # Fred Drake's interface to the Python parser

   930 +        exts.append( Extension('parser', ['parsermodule.c']) )

   931 +

   932 +        # cStringIO and cPickle

   933 +        exts.append( Extension('cStringIO', ['cStringIO.c']) )

   934 +        exts.append( Extension('cPickle', ['cPickle.c']) )

   935 +

   936 +        # Memory-mapped files (also works on Win32).

   937 +        if platform not in ['atheos', 'mac']:

   938 +            exts.append( Extension('mmap', ['mmapmodule.c']) )

   939 +        else:

   940 +            missing.append('mmap')

   941 +

   942 +        # Lance Ellinghaus's syslog module

   943 +        if platform not in ['mac']:

   944 +            # syslog daemon interface

   945 +            exts.append( Extension('syslog', ['syslogmodule.c']) )

   946 +        else:

   947 +            missing.append('syslog')

   948 +

   949 +        # George Neville-Neil's timing module:

   950 +        # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html

   951 +        # http://mail.python.org/pipermail/python-dev/2006-January/060023.html

   952 +        #exts.append( Extension('timing', ['timingmodule.c']) )

   953 +

   954 +        #

   955 +        # Here ends the simple stuff.  From here on, modules need certain

   956 +        # libraries, are platform-specific, or present other surprises.

   957 +        #

   958 +

   959 +        # Multimedia modules

   960 +        # These don't work for 64-bit platforms!!!

   961 +        # These represent audio samples or images as strings:

   962 +

   963 +        # Operations on audio samples

   964 +        # According to #993173, this one should actually work fine on

   965 +        # 64-bit platforms.

   966 +        exts.append( Extension('audioop', ['audioop.c']) )

   967 +

   968 +        # Disabled on 64-bit platforms

   969 +        if sys.maxint != 9223372036854775807L:

   970 +            # Operations on images

   971 +            exts.append( Extension('imageop', ['imageop.c']) )

   972 +        else:

   973 +            missing.extend(['imageop'])

   974 +

   975 +        # readline

   976 +        do_readline = self.compiler.find_library_file(lib_dirs, 'readline')

   977 +        if platform == 'darwin': # and os.uname()[2] < '9.':

   978 +            # MacOSX 10.4 has a broken readline. Don't try to build

   979 +            # the readline module unless the user has installed a fixed

   980 +            # readline package

   981 +            # FIXME: The readline emulation on 10.5 is better, but the

   982 +            # readline module doesn't compile out of the box.

   983 +            if find_file('readline/rlconf.h', inc_dirs, []) is None:

   984 +                do_readline = False

   985 +        if do_readline:

   986 +            if sys.platform == 'darwin':

   987 +                # In every directory on the search path search for a dynamic

   988 +                # library and then a static library, instead of first looking

   989 +                # for dynamic libraries on the entiry path.

   990 +                # This way a staticly linked custom readline gets picked up

   991 +                # before the (broken) dynamic library in /usr/lib.

   992 +                readline_extra_link_args = ('-Wl,-search_paths_first',)

   993 +            else:

   994 +                readline_extra_link_args = ()

   995 +

   996 +            readline_libs = ['readline']

   997 +            if self.compiler.find_library_file(lib_dirs,

   998 +                                                 'ncursesw'):

   999 +                readline_libs.append('ncursesw')

  1000 +            elif self.compiler.find_library_file(lib_dirs,

  1001 +                                                 'ncurses'):

  1002 +                readline_libs.append('ncurses')

  1003 +            elif self.compiler.find_library_file(lib_dirs, 'curses'):

  1004 +                readline_libs.append('curses')

  1005 +            elif self.compiler.find_library_file(lib_dirs +

  1006 +                                               ['/usr/lib/termcap'],

  1007 +                                               'termcap'):

  1008 +                readline_libs.append('termcap')

  1009 +            exts.append( Extension('readline', ['readline.c'],

  1010 +                                   library_dirs=['/usr/lib/termcap'],

  1011 +                                   extra_link_args=readline_extra_link_args,

  1012 +                                   libraries=readline_libs) )

  1013 +        else:

  1014 +            missing.append('readline')

  1015 +

  1016 +        if platform not in ['mac']:

  1017 +            # crypt module.

  1018 +

  1019 +            if self.compiler.find_library_file(lib_dirs, 'crypt'):

  1020 +                libs = ['crypt']

  1021 +            else:

  1022 +                libs = []

  1023 +            exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )

  1024 +        else:

  1025 +            missing.append('crypt')

  1026 +

  1027 +        # CSV files

  1028 +        exts.append( Extension('_csv', ['_csv.c']) )

  1029 +

  1030 +        # socket(2)

  1031 +        socket_libs = []

  1032 +        if self.compiler.find_library_file(lib_dirs,

  1033 +                                           'socket'):

  1034 +            socket_libs.append('socket')

  1035 +        if self.compiler.find_library_file(lib_dirs,

  1036 +                                           'nsl'):

  1037 +            socket_libs.append('nsl')

  1038 +        if self.compiler.find_library_file(lib_dirs,

  1039 +                                           'resolv'):

  1040 +            socket_libs.append('resolv')

  1041 +        exts.append( Extension('_socket', ['socketmodule.c'],

  1042 +                               depends = ['socketmodule.h'],

  1043 +                               libraries = socket_libs) )

  1044 +        # Detect SSL support for the socket module (via _ssl)

  1045 +        search_for_ssl_incs_in = [

  1046 +                              '/usr/sfw/include',

  1047 +                              '/usr/contrib/ssl/include/'

  1048 +                             ]

  1049 +        ssl_incs = find_file('openssl/ssl.h', inc_dirs,

  1050 +                             search_for_ssl_incs_in

  1051 +                             )

  1052 +        if ssl_incs is not None:

  1053 +            krb5_h = find_file('krb5.h', inc_dirs,

  1054 +                               ['/usr/kerberos/include'])

  1055 +            if krb5_h:

  1056 +                ssl_incs += krb5_h

  1057 +        if sys.maxint == 2147483647L:

  1058 +            sfw_libdir = '/usr/sfw/lib';

  1059 +        else:

  1060 +            sfw_libdir = '/usr/sfw/lib/64';

  1061 +        ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,

  1062 +                                     [sfw_libdir,

  1063 +                                      '/usr/contrib/ssl/lib/'

  1064 +                                     ] )

  1065 +

  1066 +        if (ssl_incs is not None and

  1067 +            ssl_libs is not None):

  1068 +            exts.append( Extension('_ssl', ['_ssl.c'],

  1069 +                                   include_dirs = ssl_incs,

  1070 +                                   library_dirs = ssl_libs,

  1071 +				   runtime_library_dirs = ssl_libs,

  1072 +                                   libraries = ['ssl', 'crypto'],

  1073 +                                   depends = ['socketmodule.h']), )

  1074 +        else:

  1075 +            missing.append('_ssl')

  1076 +

  1077 +        # find out which version of OpenSSL we have

  1078 +        openssl_ver = 0

  1079 +        openssl_ver_re = re.compile(

  1080 +            '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )

  1081 +        for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:

  1082 +            name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')

  1083 +            if os.path.isfile(name):

  1084 +                try:

  1085 +                    incfile = open(name, 'r')

  1086 +                    for line in incfile:

  1087 +                        m = openssl_ver_re.match(line)

  1088 +                        if m:

  1089 +                            openssl_ver = eval(m.group(1))

  1090 +                            break

  1091 +                except IOError:

  1092 +                    pass

  1093 +

  1094 +            # first version found is what we'll use (as the compiler should)

  1095 +            if openssl_ver:

  1096 +                break

  1097 +

  1098 +        #print 'openssl_ver = 0x%08x' % openssl_ver

  1099 +

  1100 +        if (ssl_incs is not None and

  1101 +            ssl_libs is not None and

  1102 +            openssl_ver >= 0x00907000):

  1103 +            # The _hashlib module wraps optimized implementations

  1104 +            # of hash functions from the OpenSSL library.

  1105 +            exts.append( Extension('_hashlib', ['_hashopenssl.c'],

  1106 +                                   include_dirs = ssl_incs,

  1107 +                                   library_dirs = ssl_libs,

  1108 +                                   libraries = ['ssl', 'crypto']) )

  1109 +            # these aren't strictly missing since they are unneeded.

  1110 +            #missing.extend(['_sha', '_md5'])

  1111 +        else:

  1112 +            # The _sha module implements the SHA1 hash algorithm.

  1113 +            exts.append( Extension('_sha', ['shamodule.c']) )

  1114 +            # The _md5 module implements the RSA Data Security, Inc. MD5

  1115 +            # Message-Digest Algorithm, described in RFC 1321.  The

  1116 +            # necessary files md5.c and md5.h are included here.

  1117 +            exts.append( Extension('_md5',

  1118 +                            sources = ['md5module.c', 'md5.c'],

  1119 +                            depends = ['md5.h']) )

  1120 +            missing.append('_hashlib')

  1121 +

  1122 +        if (openssl_ver < 0x00908000):

  1123 +            # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash

  1124 +            exts.append( Extension('_sha256', ['sha256module.c']) )

  1125 +            exts.append( Extension('_sha512', ['sha512module.c']) )

  1126 +

  1127 +        # Modules that provide persistent dictionary-like semantics.  You will

  1128 +        # probably want to arrange for at least one of them to be available on

  1129 +        # your machine, though none are defined by default because of library

  1130 +        # dependencies.  The Python module anydbm.py provides an

  1131 +        # implementation independent wrapper for these; dumbdbm.py provides

  1132 +        # similar functionality (but slower of course) implemented in Python.

  1133 +

  1134 +        # Sleepycat^WOracle Berkeley DB interface.

  1135 +        #  http://www.oracle.com/database/berkeley-db/db/index.html