Add Python 3.4 from userland-gate
22 files added
1 files modified
New file |
| | |
| | | # |
| | | # CDDL HEADER START |
| | | # |
| | | # The contents of this file are subject to the terms of the |
| | | # Common Development and Distribution License (the "License"). |
| | | # You may not use this file except in compliance with the License. |
| | | # |
| | | # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | # or http://www.opensolaris.org/os/licensing. |
| | | # See the License for the specific language governing permissions |
| | | # and limitations under the License. |
| | | # |
| | | # When distributing Covered Code, include this CDDL HEADER in each |
| | | # file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | # If applicable, add the following below this CDDL HEADER, with the |
| | | # fields enclosed by brackets "[]" replaced with your own identifying |
| | | # information: Portions Copyright [yyyy] [name of copyright owner] |
| | | # |
| | | # CDDL HEADER END |
| | | # |
| | | |
| | | # |
| | | # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved. |
| | | # |
| | | |
| | | include ../../../make-rules/shared-macros.mk |
| | | |
| | | COMPONENT_NAME= Python |
| | | COMPONENT_VERSION= 3.4.0 |
| | | COMPONENT_PROJECT_URL= http://python.org/ |
| | | COMPONENT_SRC= $(COMPONENT_NAME)-$(COMPONENT_VERSION) |
| | | COMPONENT_ARCHIVE= $(COMPONENT_SRC).tar.xz |
| | | COMPONENT_ARCHIVE_HASH= \ |
| | | sha256:f13686c0a2d45e7146759e9d5d1cbd8097a0606483c0cf7730e1e13f58b14cbe |
| | | COMPONENT_ARCHIVE_URL= $(COMPONENT_PROJECT_URL)ftp/python/$(COMPONENT_VERSION)/$(COMPONENT_ARCHIVE) |
| | | COMPONENT_BUGDB= utility/python |
| | | |
| | | include $(WS_TOP)/make-rules/prep.mk |
| | | include $(WS_TOP)/make-rules/configure.mk |
| | | include $(WS_TOP)/make-rules/ips.mk |
| | | include $(WS_TOP)/make-rules/lint-libraries.mk |
| | | |
| | | # Need to preserve timestamp for Grammar files. If the pickle files are older, |
| | | # Python will try to rebuild them. |
| | | PKGSEND_PUBLISH_OPTIONS += -T \*Grammar\*.txt |
| | | PKGSEND_PUBLISH_OPTIONS += -T \*Grammar\*.pickle |
| | | |
| | | # We patch auto* files, so regenerate headers and configure |
| | | COMPONENT_PREP_ACTION = \ |
| | | (cd $(@D) ; autoheader ; autoconf) |
| | | |
| | | # The DTrace patch needs this file to be mode 0755. |
| | | COMPONENT_PRE_BUILD_ACTION=($(CHMOD) +x \ |
| | | $(SOURCE_DIR)/Include/pydtrace_offsets.sh) |
| | | |
| | | # we don't want to leak $(CC_BITS) into BASECFLAGS as it causes problems with |
| | | # python-config |
| | | CC += $(CFLAGS) |
| | | |
| | | C99MODE= |
| | | CPPFLAGS += -IPython |
| | | |
| | | # to find the ncurses headers |
| | | CPPFLAGS += -I/usr/include/ncurses |
| | | # enable large files how they did in JDS |
| | | CPPFLAGS += -D_LARGEFILE64_SOURCE |
| | | |
| | | # libffi for _ctypes |
| | | CPPFLAGS += $(shell pkg-config --cflags-only-I libffi) |
| | | |
| | | # because python links with $(CC) ... $(LDFLAGS) ... |
| | | LDFLAGS = $(CC_BITS) $(CC_PIC) |
| | | |
| | | # build pic |
| | | CFLAGS += $(CC_PIC) |
| | | |
| | | # The python build is profile-guided for studio; to see the benefits of that, |
| | | # Python must be compiled with -xO5 and a different build target must be used. |
| | | # Use of xprofile requires that the same options be used during compilation and |
| | | # linking. The targets chosen are based on Solaris 11 minimum supported system |
| | | # requirements. |
| | | COMPONENT_BUILD_TARGETS = profile-opt |
| | | XPROFILE_DIR = $(BUILD_DIR_$(BITS))/.profile |
| | | PYFLAGS.i386 = -xtarget=opteron -xarch=sse2 -xcache=generic |
| | | PYFLAGS.sparc = |
| | | CFLAGS += -xO5 $(PYFLAGS.$(MACH)) |
| | | LDFLAGS += -xO5 $(PYFLAGS.$(MACH)) |
| | | |
| | | # add /usr/gnu/lib to the library search/run path |
| | | LDFLAGS.64 = -R/usr/gnu/lib/$(MACH64) -L/usr/gnu/lib/$(MACH64) |
| | | LDFLAGS += $(LDFLAGS.$(BITS)) |
| | | |
| | | # Python puts its header files in a special place. |
| | | LINT_FLAGS += -I$(SOURCE_DIR)/Include |
| | | |
| | | CONFIGURE_OPTIONS += --infodir=$(CONFIGURE_INFODIR) |
| | | CONFIGURE_OPTIONS += --enable-shared |
| | | CONFIGURE_OPTIONS += --with-dtrace |
| | | CONFIGURE_OPTIONS += --with-system-expat |
| | | CONFIGURE_OPTIONS += --with-system-ffi |
| | | CONFIGURE_OPTIONS += --without-gcc |
| | | # Building with pymalloc is the default, but that causes core dumps; |
| | | # see http://bugs.python.org/issue21412 for details. |
| | | CONFIGURE_OPTIONS += --without-pymalloc |
| | | CONFIGURE_OPTIONS += --without-ensurepip |
| | | CONFIGURE_OPTIONS += --enable-ipv6 |
| | | CONFIGURE_OPTIONS += CPPFLAGS="$(CPPFLAGS)" |
| | | CONFIGURE_OPTIONS += LDFLAGS="$(LDFLAGS)" |
| | | CONFIGURE_OPTIONS += CFLAGS="$(CFLAGS)" |
| | | CONFIGURE_OPTIONS += DFLAGS="-$(BITS)" |
| | | CONFIGURE_OPTIONS += XPROFILE_DIR="$(XPROFILE_DIR)" |
| | | |
| | | COMPONENT_BUILD_ENV += DFLAGS="-$(BITS)" |
| | | COMPONENT_BUILD_ENV += XPROFILE_DIR="$(XPROFILE_DIR)" |
| | | |
| | | # Some tests have non-ASCII characters encoded for international domain names; |
| | | # the publish step will fail in 'pkgdepend generate' without this: |
| | | COMPONENT_PUBLISH_ENV += LC_ALL=en_US.UTF-8 |
| | | |
| | | # 64 bit shared objects need to go in a 64-bit directory |
| | | COMPONENT_INSTALL_ARGS.64 += DESTSHARED=$(CONFIGURE_PREFIX)/lib/python3.4/lib-dynload |
| | | |
| | | ASLR_MODE = $(ASLR_ENABLE) |
| | | |
| | | # common targets |
| | | build: $(BUILD_64) |
| | | install: $(INSTALL_64) |
| | | |
| | | # Using "-uall,-network" ensures all tests are run except the network tests. |
| | | # The network tests contain many expected failures when run behind a firewall. |
| | | # The "-v" ensures verbose mode. You can set TESTOPTS_PYTHON_TEST to a |
| | | # particular test if you want to run just one test. For example, |
| | | # $ TESTOPTS_PYTHON_TEST=test_sys gmake -k test |
| | | # Note that when a test succeeds, the builds/*/.tested file gets created. You |
| | | # may need to remove these files, or run "gmake clobber" or "gmake clean" |
| | | # between tests. |
| | | # |
| | | COMPONENT_TEST_ENV = EXTRATESTOPTS="-v -uall,-network $(TESTOPTS_PYTHON_TEST)" |
| | | # Prevent the tests from getting stuck waiting for input. |
| | | COMPONENT_TEST_TARGETS = test < /dev/null |
| | | |
| | | test: $(TEST_64) |
| | | |
| | | BUILD_PKG_DEPENDENCIES = $(BUILD_TOOLS) |
| | | |
| | | include $(WS_TOP)/make-rules/depend.mk |
New file |
| | |
| | | This patch comes from upstream: |
| | | http://www.jcea.es/artic/python_dtrace-3_4_0_0de6441eedb7.txt |
| | | http://www.jcea.es/artic/python_dtrace.htm |
| | | Follow http://bugs.python.org/issue13405 for plans to get it |
| | | integrated into the main tree. |
| | | |
| | | --- Python-3.4.0/Doc/library/debug.rst |
| | | +++ Python-3.4.0/Doc/library/debug.rst |
| | | @@ -15,4 +15,5 @@ |
| | | profile.rst |
| | | timeit.rst |
| | | trace.rst |
| | | + dtrace.rst |
| | | tracemalloc.rst |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Doc/library/dtrace.rst |
| | | @@ -0,0 +1,183 @@ |
| | | +:mod:`dtrace` --- DTrace probes for Python |
| | | +=============================================== |
| | | + |
| | | +.. module:: dtrace |
| | | + :synopsis: DTrace probes for Python. |
| | | + |
| | | +**Source code:** :source:`Lib/dtrace.py` |
| | | + |
| | | +-------------- |
| | | + |
| | | +The :mod:`dtrace` module indicates if the CPython executable currently |
| | | +running has been compiled with DTrace probes support. |
| | | + |
| | | +.. impl-detail:: |
| | | + |
| | | + DTrace probes are implementation details of the CPython interpreter! |
| | | + No garantees are made about probe compatibility between versions of |
| | | + CPython. DTrace scripts can stop working or work incorrectly without |
| | | + warning when changing CPython versions. |
| | | + |
| | | +The :mod:`dtrace` module defines the following variable: |
| | | + |
| | | + |
| | | +.. data:: available |
| | | + |
| | | + The variable will be ``True`` if the current CPython interpreter was |
| | | + compiled with DTrace probe support. ``False`` if not. |
| | | + |
| | | + |
| | | +DTrace probes |
| | | +------------- |
| | | + |
| | | +DTrace scripts are run externally to CPython. DTrace probes export |
| | | +selected events inside CPython interpreter in order to make them |
| | | +accessible to external scripts. |
| | | + |
| | | +The probes are exported through the "python" provider. The available |
| | | +probes are defined in the file :file:`Include/pydtrace.d`. |
| | | + |
| | | +To learn how to use DTrace, read `DTrace User Guide |
| | | +<http://docs.oracle.com/cd/E19253-01/819-5488/>`_. |
| | | + |
| | | +.. opcode:: function-entry (arg0, arg1, arg2) |
| | | + |
| | | + Fires when python code enters a new function. *arg0* is sourcecode |
| | | + file path, *arg1* is the name of the funcion called, and *arg2* is |
| | | + line number. |
| | | + |
| | | + The probe is not fired if Python code calls C functions. |
| | | + |
| | | +.. opcode:: function-return (arg0, arg1, arg2) |
| | | + |
| | | + Fires when Python code finishes execution of a function. Parameters |
| | | + are the same as in ``function-entry``. |
| | | + |
| | | + The probe is not fired if the finishing function is written in C. |
| | | + |
| | | +.. opcode:: line (arg0, arg1, arg2) |
| | | + |
| | | + Fires when Python code changes the execution line. Parameters are the |
| | | + same as in ``function-entry``. |
| | | + |
| | | + The probe is not fired in C functions. |
| | | + |
| | | +.. opcode:: gc-start (arg0) |
| | | + |
| | | + Fires when the Python interpreter starts a garbage collection cycle. |
| | | + *arg0* is the generation to scan, like :func:`gc.collect()`. |
| | | + |
| | | +.. opcode:: gc-done (arg0) |
| | | + |
| | | + Fires when the Python interpreter finishes a garbage collection |
| | | + cycle. *arg0* is the number of collected objects. |
| | | + |
| | | +.. opcode:: instance-new-start (arg0, arg1) |
| | | + |
| | | + Fires when an object instanciation starts. *arg0* is the class name, |
| | | + *arg1* is the filename where the class is defined. |
| | | + |
| | | + The probe is not fired for most C code object creations. |
| | | + |
| | | +.. opcode:: instance-new-done (arg0, arg1) |
| | | + |
| | | + Fires when an object instanciation finishes. Parameters are the same |
| | | + as in ``instance-new-done``. |
| | | + |
| | | + The probe is not fired for most C code object creations. |
| | | + |
| | | +.. opcode:: instance-delete-start (arg0, arg1) |
| | | + |
| | | + Fires when an object instance is going to be destroyed. Parameters |
| | | + are the same as in ``instance-new-done``. |
| | | + |
| | | + The probe is not fired for most C code object destructions. |
| | | + |
| | | +.. opcode:: instance-delete-done (arg0, arg1) |
| | | + |
| | | + Fires when an object instance has been destroyed. parameters are the |
| | | + same as in ``instance-new-done``. |
| | | + |
| | | + Between an ``instance-delete-start`` and corresponding |
| | | + ``instance-delete-done`` others probes can fire if, for instance, |
| | | + deletion of an instance creates a deletion cascade. |
| | | + |
| | | + The probe is not fired for most C code object destructions. |
| | | + |
| | | + |
| | | +Python stack |
| | | +------------ |
| | | + |
| | | +When a DTrace probe is fired, the DTrace script can examine the stack. |
| | | +Since CPython is a Python interpreter coded in C, the stack will show C |
| | | +functions, with no direct relation to the Python code currently being |
| | | +executed. |
| | | + |
| | | +Using the special "jstack()" DTrace function, the user will be given |
| | | +hints about the python program stack, if possible. In particular, the |
| | | +augmented stack will show python function calls, filename, name |
| | | +of the function or method, and the line number. |
| | | + |
| | | +DTrace scripts examples |
| | | +----------------------- |
| | | + |
| | | +DTrace python provider is suffixed by the pid of the process to monitor. |
| | | +In the examples, the pid will be 9876. |
| | | + |
| | | +Show the time spent doing garbage collection (in nanoseconds):: |
| | | + |
| | | + python9876:::gc-start |
| | | + { |
| | | + self->t = timestamp; |
| | | + } |
| | | + |
| | | + python9876:::gc-done |
| | | + /self->t/ |
| | | + { |
| | | + printf("%d", timestamp-self->t); |
| | | + self->t = 0; |
| | | + } |
| | | + |
| | | +Count how many instances are created of each class:: |
| | | + |
| | | + python9876:::instance-new-start |
| | | + { |
| | | + @v[copyinstr(arg1), copyinstr(arg0)] = count(); |
| | | + } |
| | | + |
| | | +Observe time spent in object destruction, useful if datastructures are |
| | | +complicated and deletion of an object can create a cascade effect:: |
| | | + |
| | | + python9876:::instance-delete-start |
| | | + /self->t==0/ |
| | | + { |
| | | + self->t = timestamp; |
| | | + self->level = 0; |
| | | + } |
| | | + |
| | | + python9876:::instance-delete-start |
| | | + /self->t/ |
| | | + { |
| | | + self->level += 1; |
| | | + } |
| | | + |
| | | + python9876:::instance-delete-done |
| | | + /(self->level) && (self->t)/ |
| | | + { |
| | | + self->level -= 1; |
| | | + } |
| | | + |
| | | + python9876:::instance-delete-done |
| | | + /(self->level==0) && (self->t)/ |
| | | + { |
| | | + @time = quantize(timestamp-self->t); |
| | | + self->t = 0; |
| | | + } |
| | | + |
| | | +To know which python source code lines create new TCP/IP connections:: |
| | | + |
| | | + pid9876::sock_connect:entry |
| | | + { |
| | | + @conn[jstack()] = count(); |
| | | + } |
| | | + |
| | | --- Python-3.4.0/Include/code.h |
| | | +++ Python-3.4.0/Include/code.h |
| | | @@ -7,6 +7,8 @@ |
| | | extern "C" { |
| | | #endif |
| | | |
| | | +#include "pyconfig.h" |
| | | + |
| | | /* Bytecode object */ |
| | | typedef struct { |
| | | PyObject_HEAD |
| | | @@ -28,6 +30,9 @@ |
| | | int co_firstlineno; /* first source line number */ |
| | | PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) See |
| | | Objects/lnotab_notes.txt for details. */ |
| | | +#ifdef WITH_DTRACE |
| | | + unsigned short *co_linenos; /* dtrace stack helper */ |
| | | +#endif |
| | | void *co_zombieframe; /* for optimization only (see frameobject.c) */ |
| | | PyObject *co_weakreflist; /* to support weakrefs to code objects */ |
| | | } PyCodeObject; |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Include/pydtrace.d |
| | | @@ -0,0 +1,177 @@ |
| | | +provider python { |
| | | + probe function__entry(const char *, const char *, int); |
| | | + probe function__return(const char *, const char *, int); |
| | | + probe instance__new__start(const char *, const char *); |
| | | + probe instance__new__done(const char *, const char *); |
| | | + probe instance__delete__start(const char *, const char *); |
| | | + probe instance__delete__done(const char *, const char *); |
| | | + probe line(const char *, const char *, int); |
| | | + probe gc__start(int); |
| | | + probe gc__done(long); |
| | | +}; |
| | | + |
| | | +#pragma D attributes Evolving/Evolving/Common provider python provider |
| | | +#pragma D attributes Private/Private/Common provider python module |
| | | +#pragma D attributes Private/Private/Common provider python function |
| | | +#pragma D attributes Evolving/Evolving/Common provider python name |
| | | +#pragma D attributes Evolving/Evolving/Common provider python args |
| | | + |
| | | + |
| | | + |
| | | +#ifdef PYDTRACE_STACK_HELPER |
| | | +/* |
| | | + * Python ustack helper. This relies on the first argument (PyFrame *) being |
| | | + * on the stack; see Python/ceval.c for the contortions we go through to ensure |
| | | + * this is the case. |
| | | + * |
| | | + * On x86, the PyFrame * is two slots up from the frame pointer; on SPARC, it's |
| | | + * eight. |
| | | + * |
| | | + * Some details about this in "Python and DTrace in build 65": |
| | | + * http://blogs.oracle.com/levon/entry/python_and_dtrace_in_build |
| | | + */ |
| | | + |
| | | +/* |
| | | + * Yes, this is as gross as it looks. DTrace cannot handle static functions, |
| | | + * and our stat_impl.h has them in ILP32. |
| | | + */ |
| | | +#define _SYS_STAT_H |
| | | + |
| | | +/* |
| | | +** When compiling in 32 bits: |
| | | +** - Early inclusion to avoid problems with |
| | | +** _FILE_OFFSET_BITS redefined. |
| | | +** - Also, we must "undef" _POSIX_PTHREAD_SEMANTICS |
| | | +** to avoid error compiling this source. |
| | | +*/ |
| | | +#include "pyconfig.h" |
| | | +#undef _POSIX_PTHREAD_SEMANTICS |
| | | + |
| | | +#include <stdio.h> |
| | | +#include <sys/types.h> |
| | | + |
| | | +#include "pyport.h" |
| | | +#include "pyatomic.h" |
| | | +/* "string" type is used in dtrace */ |
| | | +#define string stringDTRACE |
| | | +#include "object.h" |
| | | +#include "pystate.h" |
| | | +#include "pyarena.h" |
| | | +#include "pythonrun.h" |
| | | +#include "compile.h" |
| | | +#include "frameobject.h" |
| | | +/* Avoid a compile error because a symbol (equivalent) redefinition */ |
| | | +#undef __STDC__ |
| | | +/* "self" has an special meaning for dtrace */ |
| | | +#define self selfDTRACE |
| | | +#include "unicodeobject.h" |
| | | +#undef string |
| | | +#undef self |
| | | + |
| | | +#include "pydtrace_offsets.h" |
| | | + |
| | | +#if defined(__i386) |
| | | +#define startframe PyEval_EvalFrameEx |
| | | +#define endframe AFTER_PyEval_EvalFrameEx |
| | | +#elif defined(__amd64) |
| | | +#define startframe PyEval_EvalFrameExReal |
| | | +#define endframe AFTER_PyEval_EvalFrameExReal |
| | | +#elif defined(__sparc) |
| | | +#define startframe PyEval_EvalFrameExReal |
| | | +#define endframe AFTER_PyEval_EvalFrameExReal |
| | | +#endif |
| | | + |
| | | +#ifdef __sparcv9 |
| | | +#define STACK_BIAS (2048-1) |
| | | +#else |
| | | +#define STACK_BIAS 0 |
| | | +#endif |
| | | + |
| | | +#define at_evalframe(addr) \ |
| | | + ((uintptr_t)addr >= ((uintptr_t)&``startframe) && \ |
| | | + (uintptr_t)addr < ((uintptr_t)&``endframe)) |
| | | +#define probe dtrace:helper:ustack: |
| | | +#define print_result(r) (r) |
| | | + |
| | | +#if defined(__i386) || defined(__amd64) |
| | | +#define frame_ptr_addr ((uintptr_t)arg1 + sizeof(uintptr_t) * 2) |
| | | +#elif defined(__sparc) |
| | | +#define frame_ptr_addr ((uintptr_t)arg1 + STACK_BIAS + sizeof(uintptr_t) * 8) |
| | | +#else |
| | | +#error unknown architecture |
| | | +#endif |
| | | + |
| | | +/* startframe and endframe are macro-expansions */ |
| | | +extern uintptr_t startframe; |
| | | +extern uintptr_t endframe; |
| | | + |
| | | + |
| | | +#define copyin_obj(addr, obj) ((obj *)copyin((uintptr_t)(addr), sizeof(obj))) |
| | | + |
| | | +/* |
| | | +** Check if the string is ASCII. Don't use bitfields, because the |
| | | +** packing in GCC and D are different. BEWARE!!!. |
| | | +** The size of the structures are also different!. That is the reason for |
| | | +** the negative offset. BEWARE!!! |
| | | +*/ |
| | | +#define pystr_len(addr) ((*(((char *)addr)+PYDTRACE_ASCII_OFFSET)) & PYDTRACE_ASCII_MASK ? \ |
| | | + (addr)->_base.length : \ |
| | | + *(Py_ssize_t *)(((char *)(addr)) + PYDTRACE_UTF8_LENGTH_OFFSET)) |
| | | +#define pystr_addr(addr, addr2) ((*(((char *)addr)+PYDTRACE_ASCII_OFFSET)) & PYDTRACE_ASCII_MASK ? \ |
| | | + (char *)(((char *)(addr2)) + PYDTRACE_PyASCIIObject_SIZE) : \ |
| | | + (char *)*(uintptr_t *)(((char *)(addr)) + PYDTRACE_UTF8_OFFSET)) |
| | | + |
| | | +#define add_digit(nr, div) (((nr) / div) ? \ |
| | | + (this->result[this->pos++] = '0' + (((nr) / div) % 10)) : \ |
| | | + (this->result[this->pos] = '\0')) |
| | | +#define add_char(c) (this->result[this->pos++] = c) |
| | | + |
| | | +probe /at_evalframe(arg0)/ |
| | | +{ |
| | | + this->framep = *(uintptr_t *)copyin(frame_ptr_addr, sizeof(uintptr_t)); |
| | | + this->frameo = copyin_obj(this->framep, PyFrameObject); |
| | | + this->codep = this->frameo->f_code; |
| | | + this->codeo = copyin_obj(this->codep, PyCodeObject); |
| | | + /* If we just enter a function, show the definition line */ |
| | | + this->lineno = this->codeo->co_firstlineno + |
| | | + (this->frameo->f_lasti == -1 ? 0 : |
| | | + *copyin_obj(this->codeo->co_linenos + this->frameo->f_lasti, |
| | | + unsigned short)); |
| | | + this->filenameo = copyin_obj(this->codeo->co_filename, PyCompactUnicodeObject); |
| | | + this->len_filename = pystr_len(this->filenameo); |
| | | + this->nameo = copyin_obj(this->codeo->co_name, PyCompactUnicodeObject); |
| | | + this->len_name = pystr_len(this->nameo); |
| | | + this->len = 1 + (this->len_filename) + 1 + 5 + 2 + |
| | | + (this->len_name) + 1 + 1; |
| | | + |
| | | + this->result = (char *)alloca(this->len); |
| | | + this->pos = 0; |
| | | + add_char('@'); |
| | | + |
| | | + copyinto((uintptr_t)pystr_addr(this->filenameo, this->codeo->co_filename), this->len_filename, this->result+this->pos); |
| | | + this->pos += this->len_filename; |
| | | + |
| | | + add_char(':'); |
| | | + add_digit(this->lineno, 10000); |
| | | + add_digit(this->lineno, 1000); |
| | | + add_digit(this->lineno, 100); |
| | | + add_digit(this->lineno, 10); |
| | | + add_digit(this->lineno, 1); |
| | | + add_char(' '); |
| | | + add_char('('); |
| | | + |
| | | + copyinto((uintptr_t)pystr_addr(this->nameo, this->codeo->co_name), this->len_name, this->result+this->pos); |
| | | + this->pos += this->len_name; |
| | | + |
| | | + add_char(')'); |
| | | + this->result[this->pos] = '\0'; |
| | | + print_result(stringof(this->result)); |
| | | +} |
| | | + |
| | | +probe /!at_evalframe(arg0)/ |
| | | +{ |
| | | + NULL; |
| | | +} |
| | | + |
| | | +#endif /* PYDTRACE_STACK_HELPER */ |
| | | + |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Include/pydtrace_offsets.c |
| | | @@ -0,0 +1,40 @@ |
| | | +#include "Python.h" |
| | | +#include "unicodeobject.h" |
| | | +#include <stdlib.h> |
| | | +#include <stdio.h> |
| | | + |
| | | +int main(int argc, const char* argv[]) { |
| | | + PyCompactUnicodeObject o; |
| | | + unsigned char *p = (unsigned char *)(&o); |
| | | + |
| | | + if (argc != 3) { |
| | | + printf("Parameter number incorrect\n"); |
| | | + exit(1); |
| | | + } |
| | | + |
| | | + memset(&o, 0, sizeof(o)); |
| | | + o._base.state.ascii = 1; |
| | | + while (!*p) p++; |
| | | + |
| | | + printf("/* File autogenerated. DO NOT MODIFY MANUALLY */\n"); |
| | | + printf("\n"); |
| | | + printf("#ifndef PYDTRACE_OFFSETS_H\n"); |
| | | + printf("#define PYDTRACE_OFFSETS_H\n"); |
| | | + printf("\n"); |
| | | + printf("#define PYDTRACE_ASCII_OFFSET %d\n", |
| | | + p-(unsigned char *)(&o)); |
| | | + printf("#define PYDTRACE_ASCII_MASK %d\n", *p); |
| | | + printf("#define PYDTRACE_PyASCIIObject_SIZE %d\n", |
| | | + sizeof(PyASCIIObject)); |
| | | + printf("#define PYDTRACE_UTF8_LENGTH_OFFSET %d\n", |
| | | + offsetof(PyCompactUnicodeObject, utf8_length)); |
| | | + printf("#define PYDTRACE_UTF8_OFFSET %d\n", |
| | | + offsetof(PyCompactUnicodeObject, utf8)); |
| | | + printf("\n"); |
| | | + printf("#define AFTER_PyEval_EvalFrameEx %s\n", argv[1]); |
| | | + printf("#define AFTER_PyEval_EvalFrameExReal %s\n", argv[2]); |
| | | + printf("\n"); |
| | | + printf("#endif\n"); |
| | | + return 0; |
| | | +} |
| | | + |
| | | new file mode 100755 |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Include/pydtrace_offsets.sh |
| | | @@ -0,0 +1,32 @@ |
| | | +#!/bin/sh |
| | | + |
| | | +DTRACE_NM=$1 |
| | | +CEVAL_O=$2 |
| | | +PYDTRACE_OFFSETS=$3 |
| | | +if test "$DTRACE_NM" = "OTHER" ; then |
| | | + $PYDTRACE_OFFSETS \ |
| | | + "`nm -n $CEVAL_O | grep \" T \" | \ |
| | | + sed -n \"/ T PyEval_EvalFrameEx$/{n;p;}\" | \ |
| | | + sed \"s/.* T \(.*\)$/\1/\"`" \ |
| | | + "`nm -n $CEVAL_O | grep \" T \" | \ |
| | | + sed -n \"/ T PyEval_EvalFrameExReal$/{n;p;}\" | \ |
| | | + sed \"s/.* T \(.*\)$/\1/\"`" |
| | | +fi |
| | | +if test "$DTRACE_NM" = "SOLARIS" ; then |
| | | + $PYDTRACE_OFFSETS \ |
| | | + "`/usr/ccs/bin/nm -n $CEVAL_O | \ |
| | | + /usr/bin/grep \"\\|FUNC \\|\" | \ |
| | | + /usr/bin/grep -v \"\\|IGNORE \\|\" | \ |
| | | + /usr/bin/grep -v \"\\|UNDEF \\|\" | \ |
| | | + /usr/bin/tr -d \"\\[\\]\\|\" | sort -n | \ |
| | | + sed -n \"/ PyEval_EvalFrameEx$/{n;p;}\" | \ |
| | | + sed \"s/.* \([a-zA-Z0-9_]*\)$/\1/\"`" \ |
| | | + "`/usr/ccs/bin/nm -n $CEVAL_O | \ |
| | | + /usr/bin/grep \"\\|FUNC \\|\" | \ |
| | | + /usr/bin/grep -v \"\\|UNDEF \\|\" | \ |
| | | + /usr/bin/grep -v \"\\|IGNORE \\|\" | \ |
| | | + /usr/bin/tr -d \"\\[\\]\\|\" | sort -n | \ |
| | | + sed -n \"/ PyEval_EvalFrameExReal$/{n;p;}\" | \ |
| | | + sed \"s/.* \([a-zA-Z0-9_]*\)$/\1/\"`" |
| | | +fi |
| | | + |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Lib/test/dtrace_sample.py |
| | | @@ -0,0 +1,80 @@ |
| | | +# Sample script for use by test_dtrace.py |
| | | +# DO NOT MODIFY THIS FILE IN ANY WAY WITHOUT UPDATING test_dtrace.py!!!!! |
| | | + |
| | | +import gc |
| | | + |
| | | +def function_1() : |
| | | + pass |
| | | + |
| | | +# Check stacktrace |
| | | +def function_2() : |
| | | + function_1() |
| | | + |
| | | +# CALL_FUNCTION_VAR |
| | | +def function_3(dummy, dummy2) : |
| | | + pass |
| | | + |
| | | +# CALL_FUNCTION_KW |
| | | +def function_4(**dummy) : |
| | | + pass |
| | | + |
| | | +# CALL_FUNCTION_VAR_KW |
| | | +def function_5(dummy, dummy2, **dummy3) : |
| | | + pass |
| | | + |
| | | +def test_entry_return_and_stack() : |
| | | + function_1() |
| | | + function_2() |
| | | + function_3(*(1,2)) |
| | | + function_4(**{"test":42}) |
| | | + function_5(*(1,2), **{"test":42}) |
| | | + |
| | | +def test_line() : |
| | | + a = 1 # Preamble |
| | | + for i in range(2) : |
| | | + a = i |
| | | + b = i+2 |
| | | + c = i+3 |
| | | + d = a + b +c |
| | | + a = 1 # Epilogue |
| | | + |
| | | +def test_unicode_entry_return_and_stack() : |
| | | + def únÃcódé() : |
| | | + pass |
| | | + únÃcódé() |
| | | + |
| | | +def test_instance_creation_destruction() : |
| | | + class old_style_class() : |
| | | + pass |
| | | + class new_style_class(object) : |
| | | + pass |
| | | + |
| | | + a = old_style_class() |
| | | + del a |
| | | + gc.collect() |
| | | + b = new_style_class() |
| | | + del b |
| | | + gc.collect() |
| | | + |
| | | + a = old_style_class() |
| | | + del old_style_class |
| | | + gc.collect() |
| | | + b = new_style_class() |
| | | + del new_style_class |
| | | + gc.collect() |
| | | + del a |
| | | + gc.collect() |
| | | + del b |
| | | + gc.collect() |
| | | + |
| | | +def test_garbage_collection() : |
| | | + gc.collect() |
| | | + |
| | | + |
| | | +if __name__ == "__main__": |
| | | + test_entry_return_and_stack() |
| | | + test_line() |
| | | + test_unicode_entry_return_and_stack() |
| | | + test_instance_creation_destruction() |
| | | + test_garbage_collection() |
| | | + |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Lib/test/test_dtrace.py |
| | | @@ -0,0 +1,447 @@ |
| | | +import sys, unittest, subprocess, os.path, dis, types, re |
| | | +import dtrace |
| | | +from test.support import TESTFN, run_unittest, findfile |
| | | + |
| | | +sample = os.path.abspath(findfile("dtrace_sample.py")) |
| | | +if not dtrace.available : |
| | | + raise unittest.SkipTest("dtrace support not compiled in") |
| | | + |
| | | +def normalize(data) : |
| | | + # DTRACE keeps a per-CPU buffer, and when showing the fired probes, |
| | | + # buffers are concatenated. So if the operating system moves our |
| | | + # thread around, the straight result can be "non causal". |
| | | + # So we add timestamps to the probe firing, and sort by that field. |
| | | + |
| | | + result = data if isinstance(data, str) else data.decode("ascii") |
| | | + # When compiling with '--with-pydebug' |
| | | + result = "".join(re.split("\[[0-9]+ refs\]", result)) |
| | | + |
| | | + try : |
| | | + result = [i.split("\t") \ |
| | | + for i in result.replace("\r", "").split("\n") if len(i)] |
| | | + result.sort(key = lambda i: int(i[0])) |
| | | + result = "".join((i[1] for i in result)) |
| | | + result = result.replace(" ", "") |
| | | + except : |
| | | + # If something goes wrong, rebuild the value so we can see the |
| | | + # real result when the assert fails. |
| | | + result = data if isinstance(data, str) else data.decode("ascii") |
| | | + result = result.replace("\r", "").replace("\n", "") |
| | | + return result |
| | | + |
| | | +dscript = """ |
| | | +pid$target::PyEval_EvalCode:entry |
| | | +""" |
| | | +dscript = dscript.replace("\r", "").replace("\n", "") |
| | | +result, _ = subprocess.Popen(["dtrace", "-q", "-l", "-n", dscript, |
| | | + "-c", "%s %s" %(sys.executable, sample)], stdout=subprocess.PIPE, |
| | | + stderr=subprocess.STDOUT).communicate() |
| | | +if result.decode("ascii").split("\n")[1].split()[-2:] != \ |
| | | + ["PyEval_EvalCode", "entry"] : |
| | | + result2 = repr(result) |
| | | + raise unittest.SkipTest("dtrace seems not to be working. " + \ |
| | | + "Please, check your privileges. " + |
| | | + "Result: " +result2) |
| | | + |
| | | +class DTraceTestsNormal(unittest.TestCase) : |
| | | + def setUp(self) : |
| | | + self.optimize = False |
| | | + |
| | | + def test_function_entry_return(self) : |
| | | + dscript = """ |
| | | +python$target:::function-entry |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 1; |
| | | +} |
| | | +python$target:::function-entry,python$target:::function-return |
| | | +/(copyinstr(arg0)=="%(path)s") && (self->trace)/ |
| | | +{ |
| | | + printf("%%d\t**%%s*%%s*%%s*%%d\\n", timestamp, |
| | | + probename, copyinstr(arg0), |
| | | + copyinstr(arg1), arg2); |
| | | +} |
| | | +python$target:::function-return |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 0; |
| | | +} |
| | | +""" %{"path":sample} |
| | | + |
| | | + dscript = dscript.replace("\r", "").replace("\n", "") |
| | | + expected_result = """ |
| | | + **function-entry*%(path)s*test_entry_return_and_stack*25 |
| | | + **function-entry*%(path)s*function_1*6 |
| | | + **function-return*%(path)s*function_1*7 |
| | | + **function-entry*%(path)s*function_2*10 |
| | | + **function-entry*%(path)s*function_1*6 |
| | | + **function-return*%(path)s*function_1*7 |
| | | + **function-return*%(path)s*function_2*11 |
| | | + **function-entry*%(path)s*function_3*14 |
| | | + **function-return*%(path)s*function_3*15 |
| | | + **function-entry*%(path)s*function_4*18 |
| | | + **function-return*%(path)s*function_4*19 |
| | | + **function-entry*%(path)s*function_5*22 |
| | | + **function-return*%(path)s*function_5*23 |
| | | + **function-return*%(path)s*test_entry_return_and_stack*30 |
| | | + """ %{"path":sample} |
| | | + |
| | | + command = "%s %s" %(sys.executable, sample) |
| | | + if self.optimize : |
| | | + command = "%s -OO %s" %(sys.executable, sample) |
| | | + actual_result, _ = subprocess.Popen(["dtrace", "-q", "-n", |
| | | + dscript, |
| | | + "-c", command], |
| | | + stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate() |
| | | + |
| | | + actual_result = normalize(actual_result) |
| | | + expected_result = expected_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + self.assertEqual(actual_result, expected_result) |
| | | + |
| | | + @unittest.skipIf(sys.platform == 'darwin', |
| | | + "MacOS X doesn't support jstack()") |
| | | + def test_stack(self) : |
| | | + dscript = """ |
| | | +python$target:::function-entry |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 1; |
| | | +} |
| | | +python$target:::function-entry |
| | | +/(copyinstr(arg0)=="%(path)s") && (self->trace)/ |
| | | +{ |
| | | + printf("[x]"); |
| | | + jstack(); |
| | | +} |
| | | +python$target:::function-return |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 0; |
| | | +} |
| | | +""" %{"path":sample} |
| | | + |
| | | + dscript = dscript.replace("\r", "").replace("\n", "") |
| | | + expected_result = """ |
| | | + [x] |
| | | + [%(path)s:25(test_entry_return_and_stack)] |
| | | + [x] |
| | | + [%(path)s:6(function_1)] |
| | | + [%(path)s:26(test_entry_return_and_stack)] |
| | | + [x] |
| | | + [%(path)s:10(function_2)] |
| | | + [%(path)s:27(test_entry_return_and_stack)] |
| | | + [x] |
| | | + [%(path)s:6(function_1)] |
| | | + [%(path)s:11(function_2)] |
| | | + [%(path)s:27(test_entry_return_and_stack)] |
| | | + [x] |
| | | + [%(path)s:14(function_3)] |
| | | + [%(path)s:28(test_entry_return_and_stack)] |
| | | + [x] |
| | | + [%(path)s:18(function_4)] |
| | | + [%(path)s:29(test_entry_return_and_stack)] |
| | | + [x] |
| | | + [%(path)s:22(function_5)] |
| | | + [%(path)s:30(test_entry_return_and_stack)] |
| | | + """ %{"path":sample} |
| | | + |
| | | + command = "%s %s" %(sys.executable, sample) |
| | | + if self.optimize : |
| | | + command = "%s -OO %s" %(sys.executable, sample) |
| | | + actual_result, _ = subprocess.Popen(["dtrace", "-q", "-n", |
| | | + dscript, |
| | | + "-c", command], |
| | | + stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate() |
| | | + |
| | | + actual_result = actual_result.decode("ascii") |
| | | + # When compiling with '--with-pydebug' |
| | | + actual_result = "".join(re.split("\[[0-9]+ refs\]", actual_result)) |
| | | + |
| | | + actual_result = [i for i in actual_result.split("\n") \ |
| | | + if (("[" in i) and not i.endswith(" (<module>) ]"))] |
| | | + actual_result = "".join(actual_result) |
| | | + actual_result = actual_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + expected_result = expected_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + self.assertEqual(actual_result, expected_result) |
| | | + |
| | | + def test_garbage_collection(self) : |
| | | + dscript = """ |
| | | +python$target:::gc-start,python$target:::gc-done |
| | | +{ |
| | | + printf("%d\t**%s(%ld)\\n", timestamp, probename, arg0); |
| | | +} |
| | | +""" |
| | | + |
| | | + dscript = dscript.replace("\r", "").replace("\n", "") |
| | | + command = "%s %s" %(sys.executable, sample) |
| | | + if self.optimize : |
| | | + command = "%s -OO %s" %(sys.executable, sample) |
| | | + actual_result, _ = subprocess.Popen(["dtrace", "-q", "-n", |
| | | + dscript, |
| | | + "-c", command], |
| | | + stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate() |
| | | + |
| | | + actual_result = normalize(actual_result) |
| | | + for i in range(10) : |
| | | + actual_result = actual_result.replace(str(i), "") |
| | | + expected_result = "**gc-start()**gc-done()" * \ |
| | | + actual_result.count("**gc-start()**") |
| | | + |
| | | + self.assertEqual(actual_result, expected_result) |
| | | + |
| | | + def test_verify_opcodes(self) : |
| | | + # Verify that we are checking: |
| | | + opcodes = set(["CALL_FUNCTION", "CALL_FUNCTION_VAR", |
| | | + "CALL_FUNCTION_KW", "CALL_FUNCTION_VAR_KW"]) |
| | | + with open(sample, encoding="utf-8") as f : |
| | | + obj = compile(f.read(), "sample", "exec") |
| | | + class dump() : |
| | | + def __init__(self) : |
| | | + self.buf = [] |
| | | + def write(self, v) : |
| | | + self.buf.append(v) |
| | | + |
| | | + dump = dump() |
| | | + stdout = sys.stdout |
| | | + sys.stdout = dump |
| | | + for i in obj.co_consts : |
| | | + if isinstance(i, types.CodeType) and \ |
| | | + (i.co_name == 'test_entry_return_and_stack') : |
| | | + dis.dis(i) |
| | | + sys.stdout = stdout |
| | | + dump = "\n".join(dump.buf) |
| | | + dump = dump.replace("\r", "").replace("\n", "").split() |
| | | + for i in dump : |
| | | + opcodes.discard(i) |
| | | + # Are we verifying all the relevant opcodes? |
| | | + self.assertEqual(set(), opcodes) # Are we verifying all opcodes? |
| | | + |
| | | + def test_line(self) : |
| | | + dscript = """ |
| | | +python$target:::line |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_line")/ |
| | | +{ |
| | | + printf("%%d\t**%%s*%%s*%%s*%%d\\n", timestamp, |
| | | + probename, copyinstr(arg0), |
| | | + copyinstr(arg1), arg2); |
| | | +} |
| | | +""" %{"path":sample} |
| | | + |
| | | + dscript = dscript.replace("\r", "").replace("\n", "") |
| | | + expected_result = """ |
| | | + **line*%(path)s*test_line*33 |
| | | + **line*%(path)s*test_line*34 |
| | | + **line*%(path)s*test_line*35 |
| | | + **line*%(path)s*test_line*36 |
| | | + **line*%(path)s*test_line*37 |
| | | + **line*%(path)s*test_line*38 |
| | | + **line*%(path)s*test_line*34 |
| | | + **line*%(path)s*test_line*35 |
| | | + **line*%(path)s*test_line*36 |
| | | + **line*%(path)s*test_line*37 |
| | | + **line*%(path)s*test_line*38 |
| | | + **line*%(path)s*test_line*34 |
| | | + **line*%(path)s*test_line*39 |
| | | + """ %{"path":sample} |
| | | + |
| | | + command = "%s %s" %(sys.executable, sample) |
| | | + if self.optimize : |
| | | + command = "%s -OO %s" %(sys.executable, sample) |
| | | + actual_result, _ = subprocess.Popen(["dtrace", "-q", "-n", |
| | | + dscript, |
| | | + "-c", command], |
| | | + stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate() |
| | | + |
| | | + actual_result = normalize(actual_result) |
| | | + expected_result = expected_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + self.assertEqual(actual_result, expected_result) |
| | | + |
| | | + def test_instance_creation_destruction(self) : |
| | | + dscript = """ |
| | | +python$target:::function-entry |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_instance_creation_destruction")/ |
| | | +{ |
| | | + self->trace = 1; |
| | | +} |
| | | + |
| | | +python$target:::instance-new-start, |
| | | +python$target:::instance-new-done, |
| | | +python$target:::instance-delete-start, |
| | | +python$target:::instance-delete-done |
| | | +/self->trace/ |
| | | +{ |
| | | + printf("%%d\t**%%s* (%%s.%%s)\\n", timestamp, |
| | | + probename, copyinstr(arg1), copyinstr(arg0)); |
| | | +} |
| | | + |
| | | +python$target:::function-return |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_instance_creation_destruction")/ |
| | | +{ |
| | | + self->trace = 0; |
| | | +} |
| | | +""" %{"path":sample} |
| | | + |
| | | + dscript = dscript.replace("\r", "").replace("\n", "") |
| | | + expected_result = """ |
| | | + **instance-new-start*(__main__.old_style_class) |
| | | + **instance-new-done*(__main__.old_style_class) |
| | | + **instance-delete-start*(__main__.old_style_class) |
| | | + **instance-delete-done*(__main__.old_style_class) |
| | | + **instance-new-start*(__main__.new_style_class) |
| | | + **instance-new-done*(__main__.new_style_class) |
| | | + **instance-delete-start*(__main__.new_style_class) |
| | | + **instance-delete-done*(__main__.new_style_class) |
| | | + **instance-new-start*(__main__.old_style_class) |
| | | + **instance-new-done*(__main__.old_style_class) |
| | | + **instance-new-start*(__main__.new_style_class) |
| | | + **instance-new-done*(__main__.new_style_class) |
| | | + **instance-delete-start*(__main__.old_style_class) |
| | | + **instance-delete-done*(__main__.old_style_class) |
| | | + **instance-delete-start*(__main__.new_style_class) |
| | | + **instance-delete-done*(__main__.new_style_class) |
| | | + """ |
| | | + |
| | | + command = "%s %s" %(sys.executable, sample) |
| | | + if self.optimize : |
| | | + command = "%s -OO %s" %(sys.executable, sample) |
| | | + actual_result, _ = subprocess.Popen(["dtrace", "-q", "-n", |
| | | + dscript, |
| | | + "-c", command], |
| | | + stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate() |
| | | + |
| | | + actual_result = normalize(actual_result) |
| | | + expected_result = expected_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + self.assertEqual(actual_result, expected_result) |
| | | + |
| | | + def test_unicode_function_entry_return(self) : |
| | | + dscript = """ |
| | | +python$target:::function-entry |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_unicode_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 1; |
| | | +} |
| | | +python$target:::function-entry,python$target:::function-return |
| | | +/(copyinstr(arg0)=="%(path)s") && (self->trace)/ |
| | | +{ |
| | | + printf("%%d\t**%%s*%%s*%%s*%%d\\n", timestamp, |
| | | + probename, copyinstr(arg0), |
| | | + copyinstr(arg1), arg2); |
| | | +} |
| | | +python$target:::function-return |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_unicode_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 0; |
| | | +} |
| | | +""" %{"path":sample} |
| | | + |
| | | + dscript = dscript.replace("\r", "").replace("\n", "") |
| | | + expected_result = """ |
| | | + **function-entry*%(path)s*test_unicode_entry_return_and_stack*41 |
| | | + **function-entry*%(path)s*únÃcódé*42 |
| | | + **function-return*%(path)s*únÃcódé*43 |
| | | + **function-return*%(path)s*test_unicode_entry_return_and_stack*44 |
| | | + """ %{"path":sample} |
| | | + |
| | | + command = "%s %s" %(sys.executable, sample) |
| | | + if self.optimize : |
| | | + command = "%s -OO %s" %(sys.executable, sample) |
| | | + actual_result, _ = subprocess.Popen(["dtrace", "-q", "-n", |
| | | + dscript, |
| | | + "-c", command], |
| | | + stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate() |
| | | + |
| | | + actual_result = actual_result.decode("utf8") |
| | | + actual_result = normalize(actual_result) |
| | | + expected_result = expected_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + self.assertEqual(actual_result, expected_result) |
| | | + |
| | | + @unittest.skipIf(sys.platform == 'darwin', |
| | | + "MacOS X doesn't support jstack()") |
| | | + def test_unicode_stack(self) : |
| | | + dscript = """ |
| | | +python$target:::function-entry |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_unicode_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 1; |
| | | +} |
| | | +python$target:::function-entry |
| | | +/(copyinstr(arg0)=="%(path)s") && (self->trace)/ |
| | | +{ |
| | | + printf("[x]"); |
| | | + jstack(); |
| | | +} |
| | | +python$target:::function-return |
| | | +/(copyinstr(arg0)=="%(path)s") && |
| | | +(copyinstr(arg1)=="test_unicode_entry_return_and_stack")/ |
| | | +{ |
| | | + self->trace = 0; |
| | | +} |
| | | +""" %{"path":sample} |
| | | + |
| | | + dscript = dscript.replace("\r", "").replace("\n", "") |
| | | + expected_result = """ |
| | | + [x] |
| | | + [%(path)s:41(test_unicode_entry_return_and_stack)] |
| | | + [x] |
| | | + [%(path)s:42(únÃcódé)] |
| | | + [%(path)s:44(test_unicode_entry_return_and_stack)] |
| | | + """ %{"path":sample} |
| | | + |
| | | + command = "%s %s" %(sys.executable, sample) |
| | | + if self.optimize : |
| | | + command = "%s -OO %s" %(sys.executable, sample) |
| | | + actual_result, _ = subprocess.Popen(["dtrace", "-q", "-n", |
| | | + dscript, |
| | | + "-c", command], |
| | | + stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate() |
| | | + |
| | | + actual_result = actual_result.decode("utf8") |
| | | + # When compiling with '--with-pydebug' |
| | | + actual_result = "".join(re.split("\[[0-9]+ refs\]", actual_result)) |
| | | + |
| | | + actual_result = [i for i in actual_result.split("\n") \ |
| | | + if (("[" in i) and not i.endswith(" (<module>) ]"))] |
| | | + actual_result = "".join(actual_result) |
| | | + actual_result = actual_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + expected_result = expected_result.replace("\r", "").replace("\n", |
| | | + "").replace(" ", "") |
| | | + self.assertEqual(actual_result, expected_result) |
| | | + |
| | | + |
| | | + |
| | | +# This class try to verify that dtrace probes |
| | | +# are still working with optimizations enabled in the bytecode. |
| | | +# |
| | | +# Some tests will not actually verify it. For instance, |
| | | +# source code compilation follows optimization status of |
| | | +# current working Python. So, you should run the test |
| | | +# both with an optimizing and a non optimizing Python. |
| | | +class DTraceTestsOptimize(DTraceTestsNormal) : |
| | | + def setUp(self) : |
| | | + self.optimize = True |
| | | + |
| | | + |
| | | +def test_main(): |
| | | + run_unittest(DTraceTestsNormal) |
| | | + run_unittest(DTraceTestsOptimize) |
| | | + |
| | | +if __name__ == '__main__': |
| | | + test_main() |
| | | + |
| | | --- Python-3.4.0/Lib/test/test_sys.py |
| | | +++ Python-3.4.0/Lib/test/test_sys.py |
| | | @@ -729,6 +729,7 @@ |
| | | self.assertEqual(sys.getsizeof(True, -1), size('') + self.longdigit) |
| | | |
| | | def test_objecttypes(self): |
| | | + import dtrace |
| | | # check all types defined in Objects/ |
| | | size = test.support.calcobjsize |
| | | vsize = test.support.calcvobjsize |
| | | @@ -754,13 +755,17 @@ |
| | | return inner |
| | | check(get_cell().__closure__[0], size('P')) |
| | | # code |
| | | - check(get_cell().__code__, size('5i9Pi3P')) |
| | | - check(get_cell.__code__, size('5i9Pi3P')) |
| | | + if dtrace.available : |
| | | + code = '5i9PiPH2P' |
| | | + else : |
| | | + code = '5i9Pi3P' |
| | | + check(get_cell().__code__, size(code)) |
| | | + check(get_cell.__code__, size(code)) |
| | | def get_cell2(x): |
| | | def inner(): |
| | | return x |
| | | return inner |
| | | - check(get_cell2.__code__, size('5i9Pi3P') + 1) |
| | | + check(get_cell2.__code__, size(code) + 1) |
| | | # complex |
| | | check(complex(0,1), size('2d')) |
| | | # method_descriptor (descriptor object) |
| | | --- Python-3.4.0/Makefile.pre.in |
| | | +++ Python-3.4.0/Makefile.pre.in |
| | | @@ -52,6 +52,13 @@ |
| | | # Use this to make a link between python$(VERSION) and python in $(BINDIR) |
| | | LN= @LN@ |
| | | |
| | | +DTRACE= @DTRACE@ |
| | | +DFLAGS= @DFLAGS@ |
| | | +DTRACEOBJS= @DTRACEOBJS@ |
| | | +DTRACE_NM= @DTRACE_NM@ |
| | | +DTRACE_LINKER= @DTRACE_LINKER@ |
| | | + |
| | | + |
| | | # Portable install script (configure doesn't always guess right) |
| | | INSTALL= @INSTALL@ |
| | | INSTALL_PROGRAM=@INSTALL_PROGRAM@ |
| | | @@ -569,7 +576,7 @@ |
| | | $(AR) $(ARFLAGS) $@ $(MODOBJS) |
| | | $(RANLIB) $@ |
| | | |
| | | -libpython$(LDVERSION).so: $(LIBRARY_OBJS) |
| | | +libpython$(LDVERSION).so: $(LIBRARY_OBJS) $(DTRACEOBJS) |
| | | if test $(INSTSONAME) != $(LDLIBRARY); then \ |
| | | $(BLDSHARED) -Wl,-h$(INSTSONAME) -o $(INSTSONAME) $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \ |
| | | $(LN) -f $(INSTSONAME) $@; \ |
| | | @@ -580,9 +587,8 @@ |
| | | libpython3.so: libpython$(LDVERSION).so |
| | | $(BLDSHARED) $(NO_AS_NEEDED) -o $@ -Wl,-h$@ $^ |
| | | |
| | | -libpython$(LDVERSION).dylib: $(LIBRARY_OBJS) |
| | | - $(CC) -dynamiclib -Wl,-single_module $(PY_LDFLAGS) -undefined dynamic_lookup -Wl,-install_name,$(prefix)/lib/libpython$(LDVERSION).dylib -Wl,-compatibility_version,$(VERSION) -Wl,-current_version,$(VERSION) -o $@ $(LIBRARY_OBJS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \ |
| | | - |
| | | +libpython$(LDVERSION).dylib: $(LIBRARY_OBJS) $(DTRACEOBJS) |
| | | + $(CC) -dynamiclib -Wl,-single_module $(PY_LDFLAGS) -undefined dynamic_lookup -Wl,-install_name,$(prefix)/lib/libpython$(LDVERSION).dylib -Wl,-compatibility_version,$(VERSION) -Wl,-current_version,$(VERSION) -o $@ $(LIBRARY_OBJS) $(DTRACEOBJS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST) |
| | | |
| | | libpython$(VERSION).sl: $(LIBRARY_OBJS) |
| | | $(LDSHARED) -o $@ $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST) |
| | | @@ -682,12 +688,18 @@ |
| | | $(MODULE_OBJS) \ |
| | | $(SIGNAL_OBJS) \ |
| | | $(MODOBJS) \ |
| | | + $(DTRACEOBJS) \ |
| | | $(srcdir)/Modules/getbuildinfo.c |
| | | $(CC) -c $(PY_CORE_CFLAGS) \ |
| | | -DHGVERSION="\"`LC_ALL=C $(HGVERSION)`\"" \ |
| | | -DHGTAG="\"`LC_ALL=C $(HGTAG)`\"" \ |
| | | -DHGBRANCH="\"`LC_ALL=C $(HGBRANCH)`\"" \ |
| | | -o $@ $(srcdir)/Modules/getbuildinfo.c |
| | | + if test "$(DTRACEOBJS)" != "" ; then \ |
| | | + $(DTRACE_LINKER) --relocatable \ |
| | | + $@ $(DTRACEOBJS) -o $@.DTRACE ; \ |
| | | + mv $@.DTRACE $@ ; \ |
| | | + fi; |
| | | |
| | | Modules/getpath.o: $(srcdir)/Modules/getpath.c Makefile |
| | | $(CC) -c $(PY_CORE_CFLAGS) -DPYTHONPATH='"$(PYTHONPATH)"' \ |
| | | @@ -820,6 +832,46 @@ |
| | | Objects/typeslots.inc: $(srcdir)/Include/typeslots.h $(srcdir)/Objects/typeslots.py |
| | | $(PYTHON) $(srcdir)/Objects/typeslots.py < $(srcdir)/Include/typeslots.h > Objects/typeslots.inc |
| | | |
| | | +$(srcdir)/Include/pydtrace.h: $(srcdir)/Include/pydtrace.d |
| | | + if test "$(DTRACE)" != "" ; then \ |
| | | + $(DTRACE) -o $@ $(DFLAGS) \ |
| | | + -C -h -s $(srcdir)/Include/pydtrace.d ; \ |
| | | + else touch $@ ; \ |
| | | + fi; |
| | | + |
| | | +$(srcdir)/Include/pydtrace_offsets.h: $(srcdir)/Include/pydtrace_offsets.c Python/ceval.o |
| | | + $(CC) $(PY_CORE_CFLAGS) -o $(srcdir)/Include/pydtrace_offsets \ |
| | | + $(srcdir)/Include/pydtrace_offsets.c |
| | | + $(srcdir)/Include/pydtrace_offsets.sh $(DTRACE_NM) \ |
| | | + Python/ceval.o $(srcdir)/Include/pydtrace_offsets > \ |
| | | + $(srcdir)/Include/pydtrace_offsets.h |
| | | + |
| | | +Python/ceval.o: Include/pydtrace.h |
| | | +Modules/gcmodule.o: Include/pydtrace.h |
| | | +Objects/typeobject.o: Include/pydtrace.h |
| | | + |
| | | +Python/pydtrace.o: $(srcdir)/Include/pydtrace.d $(srcdir)/Include/pydtrace_offsets.h \ |
| | | + Python/ceval.o Modules/gcmodule.o Objects/typeobject.o |
| | | + # We do the "touch" game to break a circular dependency between |
| | | + # "Python/ceval.o" and "Include/pydtrace_offsets.h". |
| | | + if test "$(DTRACE)" != "" ; then \ |
| | | + touch -r Python/ceval.o Python/ceval.o.ts_dtrace ; \ |
| | | + touch -r Modules/gcmodule.o Modules/gcmodule.o.ts_dtrace ; \ |
| | | + touch -r Objects/typeobject.o Objects/typeobject.o.ts_dtrace ; \ |
| | | + $(DTRACE) -o $@ -DPYDTRACE_STACK_HELPER \ |
| | | + $(DFLAGS) $(PY_CPPFLAGS) \ |
| | | + -C -G -s $(srcdir)/Include/pydtrace.d \ |
| | | + Python/ceval.o Modules/gcmodule.o \ |
| | | + Objects/typeobject.o; \ |
| | | + touch -r Python/ceval.o.ts_dtrace Python/ceval.o ; \ |
| | | + touch -r Modules/gcmodule.o.ts_dtrace Modules/gcmodule.o ; \ |
| | | + touch -r Objects/typeobject.o.ts_dtrace Objects/typeobject.o ; \ |
| | | + rm Python/ceval.o.ts_dtrace ; \ |
| | | + rm Modules/gcmodule.o.ts_dtrace ; \ |
| | | + rm Objects/typeobject.o.ts_dtrace ; \ |
| | | + else touch $@ ; \ |
| | | + fi; |
| | | + |
| | | ############################################################################ |
| | | # Header files |
| | | |
| | | @@ -1515,6 +1567,11 @@ |
| | | find build -name '*.py[co]' -exec rm -f {} ';' || true |
| | | -rm -f pybuilddir.txt |
| | | -rm -f Lib/lib2to3/*Grammar*.pickle |
| | | + rm -f Include/pydtrace.h |
| | | + rm -f Include/pydtrace_offsets Include/pydtrace_offsets.h |
| | | + rm -f Python/ceval.o.ts_dtrace |
| | | + rm -f Modules/gcmodule.o.ts_dtrace |
| | | + rm -f Objects/typeobject.o.ts_dtrace |
| | | -rm -f Modules/_testembed Modules/_freeze_importlib |
| | | |
| | | profile-removal: |
| | | @@ -1546,6 +1603,11 @@ |
| | | -o -name '*.orig' -o -name '*.rej' \ |
| | | -o -name '*.bak' ')' \ |
| | | -exec rm -f {} ';' |
| | | + rm -f Include/pydtrace.h |
| | | + rm -f Include/pydtrace_offsets Include/pydtrace_offsets.h |
| | | + rm -f Python/ceval.o.ts_dtrace |
| | | + rm -f Modules/gcmodule.o.ts_dtrace |
| | | + rm -f Objects/typeobject.o.ts_dtrace |
| | | |
| | | # Check for smelly exported symbols (not starting with Py/_Py) |
| | | smelly: all |
| | | --- Python-3.4.0/Modules/Setup.dist |
| | | +++ Python-3.4.0/Modules/Setup.dist |
| | | @@ -390,3 +390,5 @@ |
| | | |
| | | # Another example -- the 'xxsubtype' module shows C-level subtyping in action |
| | | xxsubtype xxsubtype.c |
| | | + |
| | | +dtrace dtracemodule.c |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Modules/dtracemodule.c |
| | | @@ -0,0 +1,39 @@ |
| | | +#include "Python.h" |
| | | + |
| | | +static PyMethodDef dtrace_methods[] = { |
| | | + {NULL, NULL} /* sentinel */ |
| | | +}; |
| | | + |
| | | + |
| | | +static struct PyModuleDef dtracemodule = { |
| | | + PyModuleDef_HEAD_INIT, |
| | | + "dtrace", |
| | | + NULL, |
| | | + -1, |
| | | + dtrace_methods, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL |
| | | +}; |
| | | + |
| | | +PyMODINIT_FUNC |
| | | +PyInit_dtrace(void) |
| | | +{ |
| | | + PyObject *m, *v; |
| | | + |
| | | + m = PyModule_Create(&dtracemodule); |
| | | + if (m) { |
| | | +#ifdef WITH_DTRACE |
| | | + v = Py_True; |
| | | +#else |
| | | + v = Py_False; |
| | | +#endif |
| | | + Py_INCREF(v); |
| | | + if (PyModule_AddObject(m, "available", v) < 0) { |
| | | + Py_DECREF(m); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + return m; |
| | | +} |
| | | --- Python-3.4.0/Modules/gcmodule.c |
| | | +++ Python-3.4.0/Modules/gcmodule.c |
| | | @@ -26,6 +26,10 @@ |
| | | #include "Python.h" |
| | | #include "frameobject.h" /* for PyFrame_ClearFreeList */ |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +#include "pydtrace.h" |
| | | +#endif |
| | | + |
| | | /* Get an object's GC head */ |
| | | #define AS_GC(o) ((PyGC_Head *)(o)-1) |
| | | |
| | | @@ -905,7 +909,12 @@ |
| | | /* This is the main function. Read this to understand how the |
| | | * collection process works. */ |
| | | static Py_ssize_t |
| | | -collect(int generation, Py_ssize_t *n_collected, Py_ssize_t *n_uncollectable, |
| | | +#ifdef WITH_DTRACE |
| | | +collect2 |
| | | +#else |
| | | +collect |
| | | +#endif |
| | | +(int generation, Py_ssize_t *n_collected, Py_ssize_t *n_uncollectable, |
| | | int nofail) |
| | | { |
| | | int i; |
| | | @@ -1080,6 +1089,50 @@ |
| | | return n+m; |
| | | } |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +static void |
| | | +dtrace_gc_start(int collection) |
| | | +{ |
| | | + PYTHON_GC_START(collection); |
| | | + |
| | | + /* |
| | | + * Currently a USDT tail-call will not receive the correct arguments. |
| | | + * Disable the tail call here. |
| | | + */ |
| | | +#if defined(__sparc) |
| | | + asm("nop"); |
| | | +#endif |
| | | +} |
| | | + |
| | | +static void |
| | | +dtrace_gc_done(Py_ssize_t value) |
| | | +{ |
| | | + PYTHON_GC_DONE((long) value); |
| | | + |
| | | + /* |
| | | + * Currently a USDT tail-call will not receive the correct arguments. |
| | | + * Disable the tail call here. |
| | | + */ |
| | | +#if defined(__sparc) |
| | | + asm("nop"); |
| | | +#endif |
| | | +} |
| | | + |
| | | +static Py_ssize_t |
| | | +collect(int collection, Py_ssize_t *n_collected, Py_ssize_t *n_uncollectable, |
| | | + int nofail) |
| | | +{ |
| | | + Py_ssize_t value; |
| | | + |
| | | + if (PYTHON_GC_START_ENABLED()) |
| | | + dtrace_gc_start(collection); |
| | | + value = collect2(collection, n_collected, n_uncollectable, nofail); |
| | | + if (PYTHON_GC_DONE_ENABLED()) |
| | | + dtrace_gc_done(value); |
| | | + return value; |
| | | +} |
| | | +#endif /* WITH_DTRACE */ |
| | | + |
| | | /* Invoke progress callbacks to notify clients that garbage collection |
| | | * is starting or stopping |
| | | */ |
| | | --- Python-3.4.0/Objects/codeobject.c |
| | | +++ Python-3.4.0/Objects/codeobject.c |
| | | @@ -152,6 +152,37 @@ |
| | | co->co_lnotab = lnotab; |
| | | co->co_zombieframe = NULL; |
| | | co->co_weakreflist = NULL; |
| | | + |
| | | +#ifdef WITH_DTRACE |
| | | + /* |
| | | + ** Cache UTF8 internally, available |
| | | + ** for the pythonframe stack walker. |
| | | + */ |
| | | + PyUnicode_AsUTF8(filename); |
| | | + PyUnicode_AsUTF8(name); |
| | | + |
| | | + i = PyBytes_Size(co->co_code); |
| | | + co->co_linenos = PyMem_Malloc(sizeof(unsigned short) * i); |
| | | + if (co->co_linenos) { |
| | | + unsigned short *p = (unsigned short *)(co->co_linenos); |
| | | + unsigned char *p2 = (unsigned char*)PyBytes_AsString(co->co_lnotab); |
| | | + int size = PyBytes_Size(co->co_lnotab) / 2; |
| | | + int i2; |
| | | + unsigned short offset = 0; |
| | | + |
| | | + while (size) { |
| | | + size -= 1; |
| | | + i2 = *p2++; |
| | | + i-=i2; |
| | | + while (i2--) |
| | | + *p++ = offset; |
| | | + offset += *p2++; |
| | | + } |
| | | + while(i--) |
| | | + *p++ = offset; |
| | | + } |
| | | +#endif |
| | | + |
| | | return co; |
| | | } |
| | | |
| | | --- Python-3.4.0/Objects/frameobject.c |
| | | +++ Python-3.4.0/Objects/frameobject.c |
| | | @@ -733,6 +733,15 @@ |
| | | f->f_executing = 0; |
| | | f->f_gen = NULL; |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | + /* |
| | | + ** Cache UTF8 internally, available |
| | | + ** for the pythonframe stack walker. |
| | | + */ |
| | | + PyUnicode_AsUTF8(f->f_code->co_filename); |
| | | + PyUnicode_AsUTF8(f->f_code->co_name); |
| | | +#endif |
| | | + |
| | | _PyObject_GC_TRACK(f); |
| | | return f; |
| | | } |
| | | --- Python-3.4.0/Objects/typeobject.c |
| | | +++ Python-3.4.0/Objects/typeobject.c |
| | | @@ -4,6 +4,10 @@ |
| | | #include "frameobject.h" |
| | | #include "structmember.h" |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +#include "pydtrace.h" |
| | | +#endif |
| | | + |
| | | #include <ctype.h> |
| | | |
| | | |
| | | @@ -880,8 +884,29 @@ |
| | | PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) |
| | | { |
| | | PyObject *obj; |
| | | - const size_t size = _PyObject_VAR_SIZE(type, nitems+1); |
| | | + size_t size; |
| | | + |
| | | +#ifdef WITH_DTRACE |
| | | + PyObject *mod; |
| | | + char *mod_name; |
| | | + |
| | | + if (PYTHON_INSTANCE_NEW_START_ENABLED()) { |
| | | + if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) { |
| | | + mod = PyDict_GetItemString(type->tp_dict, "__module__"); |
| | | + if (mod == NULL || !PyUnicode_Check(mod)) { |
| | | + mod_name = "?"; |
| | | + } else { |
| | | + mod_name = PyUnicode_AsUTF8(mod); |
| | | + if (!mod_name) |
| | | + mod_name = "?"; |
| | | + } |
| | | + PYTHON_INSTANCE_NEW_START((char *)(type->tp_name), mod_name); |
| | | + } |
| | | + } |
| | | +#endif |
| | | + |
| | | /* note that we need to add one, for the sentinel */ |
| | | + size = _PyObject_VAR_SIZE(type, nitems+1); |
| | | |
| | | if (PyType_IS_GC(type)) |
| | | obj = _PyObject_GC_Malloc(size); |
| | | @@ -903,6 +928,23 @@ |
| | | |
| | | if (PyType_IS_GC(type)) |
| | | _PyObject_GC_TRACK(obj); |
| | | + |
| | | +#ifdef WITH_DTRACE |
| | | + if (PYTHON_INSTANCE_NEW_DONE_ENABLED()) { |
| | | + if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) { |
| | | + mod = PyDict_GetItemString(type->tp_dict, "__module__"); |
| | | + if (mod == NULL || !PyUnicode_Check(mod)) { |
| | | + mod_name = "?"; |
| | | + } else { |
| | | + mod_name = PyUnicode_AsUTF8(mod); |
| | | + if (!mod_name) |
| | | + mod_name = "?"; |
| | | + } |
| | | + PYTHON_INSTANCE_NEW_DONE((char *)(type->tp_name), mod_name); |
| | | + } |
| | | + } |
| | | +#endif |
| | | + |
| | | return obj; |
| | | } |
| | | |
| | | @@ -1023,9 +1065,56 @@ |
| | | return 0; |
| | | } |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +static void subtype_dealloc2(PyObject *); /* Forward declaration */ |
| | | + |
| | | static void |
| | | subtype_dealloc(PyObject *self) |
| | | { |
| | | + PyObject *mod; |
| | | + char *mod_name; |
| | | + PyTypeObject *type; |
| | | + |
| | | + type = Py_TYPE(self); |
| | | + Py_INCREF(type); |
| | | + |
| | | + if (PYTHON_INSTANCE_DELETE_START_ENABLED()) { |
| | | + mod = PyDict_GetItemString(type->tp_dict, "__module__"); |
| | | + if (mod == NULL || !PyUnicode_Check(mod)) { |
| | | + mod_name = "?"; |
| | | + } else { |
| | | + mod_name = PyUnicode_AsUTF8(mod); |
| | | + if (!mod_name) |
| | | + mod_name = "?"; |
| | | + } |
| | | + PYTHON_INSTANCE_DELETE_START((char *)(type->tp_name), mod_name); |
| | | + } |
| | | + |
| | | + subtype_dealloc2(self); |
| | | + |
| | | + if (PYTHON_INSTANCE_DELETE_DONE_ENABLED()) { |
| | | + mod = PyDict_GetItemString(type->tp_dict, "__module__"); |
| | | + if (mod == NULL || !PyUnicode_Check(mod)) { |
| | | + mod_name = "?"; |
| | | + } else { |
| | | + mod_name = PyUnicode_AsUTF8(mod); |
| | | + if (!mod_name) |
| | | + mod_name = "?"; |
| | | + } |
| | | + PYTHON_INSTANCE_DELETE_DONE((char *)(type->tp_name), mod_name); |
| | | + } |
| | | + Py_DECREF(type); |
| | | +} |
| | | +#endif |
| | | + |
| | | +static void |
| | | +#ifdef WITH_DTRACE |
| | | +subtype_dealloc2 |
| | | +#else |
| | | +subtype_dealloc |
| | | +#endif |
| | | +(PyObject *self) |
| | | +{ |
| | | PyTypeObject *type, *base; |
| | | destructor basedealloc; |
| | | PyThreadState *tstate = PyThreadState_GET(); |
| | | --- Python-3.4.0/Python/ceval.c |
| | | +++ Python-3.4.0/Python/ceval.c |
| | | @@ -18,6 +18,13 @@ |
| | | |
| | | #include <ctype.h> |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +#include "pydtrace.h" |
| | | +#else |
| | | +/* We can not have conditional compilation inside macros */ |
| | | +#define PYTHON_LINE_ENABLED() (0) |
| | | +#endif |
| | | + |
| | | #ifndef WITH_TSC |
| | | |
| | | #define READ_TIMESTAMP(var) |
| | | @@ -119,6 +126,12 @@ |
| | | #define CALL_FLAG_VAR 1 |
| | | #define CALL_FLAG_KW 2 |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +static void maybe_dtrace_line(PyFrameObject *frame, |
| | | + int *instr_lb, int *instr_ub, |
| | | + int *instr_prev); |
| | | +#endif |
| | | + |
| | | #ifdef LLTRACE |
| | | static int lltrace; |
| | | static int prtrace(PyObject *, char *); |
| | | @@ -778,6 +791,49 @@ |
| | | NULL, NULL); |
| | | } |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +static void |
| | | +dtrace_entry(PyFrameObject *f) |
| | | +{ |
| | | + char *filename; |
| | | + char *name; |
| | | + int lineno; |
| | | + |
| | | + filename = PyUnicode_AsUTF8(f->f_code->co_filename); |
| | | + name = PyUnicode_AsUTF8(f->f_code->co_name); |
| | | + lineno = PyCode_Addr2Line(f->f_code, f->f_lasti); |
| | | + PYTHON_FUNCTION_ENTRY(filename, name, lineno); |
| | | + |
| | | + /* |
| | | + * Currently a USDT tail-call will not receive the correct arguments. |
| | | + * Disable the tail call here. |
| | | + */ |
| | | +#if defined(__sparc) |
| | | + asm("nop"); |
| | | +#endif |
| | | +} |
| | | + |
| | | +static void |
| | | +dtrace_return(PyFrameObject *f) |
| | | +{ |
| | | + char *filename; |
| | | + char *name; |
| | | + int lineno; |
| | | + |
| | | + filename = PyUnicode_AsUTF8(f->f_code->co_filename); |
| | | + name = PyUnicode_AsUTF8(f->f_code->co_name); |
| | | + lineno = PyCode_Addr2Line(f->f_code, f->f_lasti); |
| | | + PYTHON_FUNCTION_RETURN(filename, name, lineno); |
| | | + |
| | | + /* |
| | | + * Currently a USDT tail-call will not receive the correct arguments. |
| | | + * Disable the tail call here. |
| | | + */ |
| | | +#if defined(__sparc) |
| | | + asm("nop"); |
| | | +#endif |
| | | +} |
| | | +#endif |
| | | |
| | | /* Interpreter main loop */ |
| | | |
| | | @@ -789,8 +845,16 @@ |
| | | return PyEval_EvalFrameEx(f, 0); |
| | | } |
| | | |
| | | + |
| | | PyObject * |
| | | +#if defined(WITH_DTRACE) && defined(__amd64) |
| | | +PyEval_EvalFrameExReal(long a1, long a2, long a3, long a4, long a5, long a6, |
| | | + PyFrameObject *f, int throwflag) |
| | | +#elif defined(WITH_DTRACE) && defined(__sparc) |
| | | +PyEval_EvalFrameExReal(PyFrameObject *f, int throwflag) |
| | | +#else |
| | | PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) |
| | | +#endif |
| | | { |
| | | #ifdef DXPAIRS |
| | | int lastopcode = 0; |
| | | @@ -911,7 +975,7 @@ |
| | | #ifdef LLTRACE |
| | | #define FAST_DISPATCH() \ |
| | | { \ |
| | | - if (!lltrace && !_Py_TracingPossible) { \ |
| | | + if (!lltrace && !_Py_TracingPossible && !PYTHON_LINE_ENABLED()) { \ |
| | | f->f_lasti = INSTR_OFFSET(); \ |
| | | goto *opcode_targets[*next_instr++]; \ |
| | | } \ |
| | | @@ -920,7 +984,7 @@ |
| | | #else |
| | | #define FAST_DISPATCH() \ |
| | | { \ |
| | | - if (!_Py_TracingPossible) { \ |
| | | + if (!_Py_TracingPossible && !PYTHON_LINE_ENABLED()) { \ |
| | | f->f_lasti = INSTR_OFFSET(); \ |
| | | goto *opcode_targets[*next_instr++]; \ |
| | | } \ |
| | | @@ -1156,6 +1220,11 @@ |
| | | } |
| | | } |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | + if (PYTHON_FUNCTION_ENTRY_ENABLED()) |
| | | + dtrace_entry(f); |
| | | +#endif |
| | | + |
| | | co = f->f_code; |
| | | names = co->co_names; |
| | | consts = co->co_consts; |
| | | @@ -1343,6 +1412,12 @@ |
| | | /* Main switch on opcode */ |
| | | READ_TIMESTAMP(inst0); |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | + if (PYTHON_LINE_ENABLED()) { |
| | | + maybe_dtrace_line(f, &instr_lb, &instr_ub, &instr_prev); |
| | | + } |
| | | +#endif |
| | | + |
| | | switch (opcode) { |
| | | |
| | | /* BEWARE! |
| | | @@ -3216,6 +3291,10 @@ |
| | | |
| | | /* pop frame */ |
| | | exit_eval_frame: |
| | | +#ifdef WITH_DTRACE |
| | | + if (PYTHON_FUNCTION_RETURN_ENABLED()) |
| | | + dtrace_return(f); |
| | | +#endif |
| | | Py_LeaveRecursiveCall(); |
| | | f->f_executing = 0; |
| | | tstate->frame = f->f_back; |
| | | @@ -3915,6 +3994,57 @@ |
| | | return result; |
| | | } |
| | | |
| | | +/* |
| | | + * These shenanigans look like utter madness, but what we're actually doing is |
| | | + * making sure that the ustack helper will see the PyFrameObject pointer on the |
| | | + * stack. We have two tricky cases: |
| | | + * |
| | | + * amd64 |
| | | + * |
| | | + * We use up the six registers for passing arguments, meaning the call can't |
| | | + * use a register for passing 'f', and has to push it onto the stack in a known |
| | | + * location. |
| | | + * |
| | | + * And how does "throwflag" figure in to this? -PN |
| | | + * |
| | | + * SPARC |
| | | + * |
| | | + * Here the problem is that (on 32-bit) the compiler is re-using %i0 before |
| | | + * some calls inside PyEval_EvalFrameReal(), which means that when it's saved, |
| | | + * it's just some junk value rather than the real first argument. So, instead, |
| | | + * we trace our proxy PyEval_EvalFrame(), where we 'know' the compiler won't |
| | | + * decide to re-use %i0. We also need to defeat optimization of our proxy. |
| | | + */ |
| | | + |
| | | +#if defined(WITH_DTRACE) |
| | | + |
| | | +#if defined(__amd64) |
| | | + |
| | | +PyObject * |
| | | +PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) |
| | | +{ |
| | | + volatile PyObject *f2; |
| | | + f2 = PyEval_EvalFrameExReal(0, 0, 0, 0, 0, 0, f, throwflag); |
| | | + return (PyObject *)f2; |
| | | +} |
| | | + |
| | | +#elif defined(__sparc) |
| | | + |
| | | +volatile int dummy; |
| | | + |
| | | +PyObject * |
| | | +PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) |
| | | +{ |
| | | + volatile PyObject *f2; |
| | | + f2 = PyEval_EvalFrameExReal(f, throwflag); |
| | | + dummy = f->ob_base.ob_base.ob_refcnt; |
| | | + return (PyObject *)f2; |
| | | +} |
| | | + |
| | | +#endif |
| | | +#endif |
| | | + |
| | | + |
| | | PyObject * |
| | | _PyEval_CallTracing(PyObject *func, PyObject *args) |
| | | { |
| | | @@ -3932,6 +4062,51 @@ |
| | | return result; |
| | | } |
| | | |
| | | +#ifdef WITH_DTRACE |
| | | +/* See Objects/lnotab_notes.txt for a description of how tracing works. */ |
| | | +/* Practically a ripoff of "maybe_call_line_trace" function. */ |
| | | +static void |
| | | +maybe_dtrace_line(PyFrameObject *frame, |
| | | + int *instr_lb, int *instr_ub, int *instr_prev) |
| | | +{ |
| | | + int line = frame->f_lineno; |
| | | + char *co_filename, *co_name; |
| | | + |
| | | + /* If the last instruction executed isn't in the current |
| | | + instruction window, reset the window. |
| | | + */ |
| | | + if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) { |
| | | + PyAddrPair bounds; |
| | | + line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti, |
| | | + &bounds); |
| | | + *instr_lb = bounds.ap_lower; |
| | | + *instr_ub = bounds.ap_upper; |
| | | + } |
| | | + /* If the last instruction falls at the start of a line or if |
| | | + it represents a jump backwards, update the frame's line |
| | | + number and call the trace function. */ |
| | | + if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) { |
| | | + frame->f_lineno = line; |
| | | + co_filename = PyUnicode_AsUTF8(frame->f_code->co_filename); |
| | | + if (!co_filename) |
| | | + co_filename = "?"; |
| | | + co_name = PyUnicode_AsUTF8(frame->f_code->co_name); |
| | | + if (!co_name) |
| | | + co_name = "?"; |
| | | + PYTHON_LINE(co_filename, co_name, line); |
| | | + } |
| | | + *instr_prev = frame->f_lasti; |
| | | + |
| | | + /* |
| | | + * Currently a USDT tail-call will not receive the correct arguments. |
| | | + * Disable the tail call here. |
| | | + */ |
| | | +#if defined(__sparc) |
| | | + asm("nop"); |
| | | +#endif |
| | | +} |
| | | +#endif |
| | | + |
| | | /* See Objects/lnotab_notes.txt for a description of how tracing works. */ |
| | | static int |
| | | maybe_call_line_trace(Py_tracefunc func, PyObject *obj, |
| | | --- Python-3.4.0/configure |
| | | +++ Python-3.4.0/configure |
| | | @@ -642,6 +642,11 @@ |
| | | MACHDEP_OBJS |
| | | DYNLOADFILE |
| | | DLINCLDIR |
| | | +DTRACEOBJS |
| | | +DTRACE_LINKER |
| | | +DTRACE_NM |
| | | +DFLAGS |
| | | +DTRACE |
| | | THREADOBJ |
| | | LDLAST |
| | | USE_THREAD_MODULE |
| | | @@ -811,6 +816,7 @@ |
| | | with_tsc |
| | | with_pymalloc |
| | | with_valgrind |
| | | +with_dtrace |
| | | with_fpectl |
| | | with_libm |
| | | with_libc |
| | | @@ -1494,6 +1500,7 @@ |
| | | --with(out)-tsc enable/disable timestamp counter profile |
| | | --with(out)-pymalloc disable/enable specialized mallocs |
| | | --with-valgrind Enable Valgrind support |
| | | + --with(out)-dtrace disable/enable dtrace support |
| | | --with-fpectl enable SIGFPE catching |
| | | --with-libm=STRING math library |
| | | --with-libc=STRING C library |
| | | @@ -10391,6 +10398,174 @@ |
| | | OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT" |
| | | fi |
| | | |
| | | +# Check for dtrace support |
| | | +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --with-dtrace" >&5 |
| | | +$as_echo_n "checking for --with-dtrace... " >&6; } |
| | | + |
| | | +# Check whether --with-dtrace was given. |
| | | +if test "${with_dtrace+set}" = set; then : |
| | | + withval=$with_dtrace; |
| | | +else |
| | | + with_dtrace=no |
| | | +fi |
| | | + |
| | | +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_dtrace" >&5 |
| | | +$as_echo "$with_dtrace" >&6; } |
| | | + |
| | | + |
| | | + |
| | | + |
| | | + |
| | | +DTRACE= |
| | | +DFLAGS= |
| | | +if test "$with_dtrace" = "yes" |
| | | +then |
| | | + DTRACE_NM=OTHER |
| | | + DTRACE_LINKER=ld |
| | | + DTRACEOBJS="Python/pydtrace.o" |
| | | + # Extract the first word of "dtrace", so it can be a program name with args. |
| | | +set dummy dtrace; ac_word=$2 |
| | | +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | | +$as_echo_n "checking for $ac_word... " >&6; } |
| | | +if ${ac_cv_path_DTRACE+:} false; then : |
| | | + $as_echo_n "(cached) " >&6 |
| | | +else |
| | | + case $DTRACE in |
| | | + [\\/]* | ?:[\\/]*) |
| | | + ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path. |
| | | + ;; |
| | | + *) |
| | | + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | | +for as_dir in $PATH$PATH_SEPARATOR/usr/sbin |
| | | +do |
| | | + IFS=$as_save_IFS |
| | | + test -z "$as_dir" && as_dir=. |
| | | + for ac_exec_ext in '' $ac_executable_extensions; do |
| | | + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then |
| | | + ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext" |
| | | + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | | + break 2 |
| | | + fi |
| | | +done |
| | | + done |
| | | +IFS=$as_save_IFS |
| | | + |
| | | + test -z "$ac_cv_path_DTRACE" && ac_cv_path_DTRACE="dtrace" |
| | | + ;; |
| | | +esac |
| | | +fi |
| | | +DTRACE=$ac_cv_path_DTRACE |
| | | +if test -n "$DTRACE"; then |
| | | + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5 |
| | | +$as_echo "$DTRACE" >&6; } |
| | | +else |
| | | + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | | +$as_echo "no" >&6; } |
| | | +fi |
| | | + |
| | | + |
| | | + # The cast to long int works around a bug in the HP C Compiler |
| | | +# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects |
| | | +# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. |
| | | +# This bug is HP SR number 8606223364. |
| | | +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5 |
| | | +$as_echo_n "checking size of long... " >&6; } |
| | | +if ${ac_cv_sizeof_long+:} false; then : |
| | | + $as_echo_n "(cached) " >&6 |
| | | +else |
| | | + if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long" "$ac_includes_default"; then : |
| | | + |
| | | +else |
| | | + if test "$ac_cv_type_long" = yes; then |
| | | + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 |
| | | +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} |
| | | +as_fn_error 77 "cannot compute sizeof (long) |
| | | +See \`config.log' for more details" "$LINENO" 5; } |
| | | + else |
| | | + ac_cv_sizeof_long=0 |
| | | + fi |
| | | +fi |
| | | + |
| | | +fi |
| | | +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5 |
| | | +$as_echo "$ac_cv_sizeof_long" >&6; } |
| | | + |
| | | + |
| | | + |
| | | +cat >>confdefs.h <<_ACEOF |
| | | +#define SIZEOF_LONG $ac_cv_sizeof_long |
| | | +_ACEOF |
| | | + |
| | | + |
| | | + if test "$ac_cv_sizeof_long" -eq 8 |
| | | + then |
| | | + DFLAGS="-64" |
| | | + else |
| | | + DFLAGS="-32" |
| | | + fi |
| | | + sys_release="$ac_sys_release" |
| | | + case $ac_sys_system/$sys_release in |
| | | + SunOS/5.10) |
| | | + DTRACE_NM=SOLARIS |
| | | + DTRACE_LINKER=/usr/ccs/bin/ld |
| | | + ;; |
| | | + SunOS/5.11 | SunOS/5.12) |
| | | + DTRACE_NM=SOLARIS |
| | | + DTRACE_LINKER=/usr/bin/ld |
| | | + ;; |
| | | + SunOS/*) |
| | | + DTRACE_LINKER=/usr/ccs/bin/ld |
| | | + ;; |
| | | + Darwin/*) |
| | | + DTRACEOBJS="" # Not needed in Mac |
| | | + # The cast to long int works around a bug in the HP C Compiler |
| | | +# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects |
| | | +# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. |
| | | +# This bug is HP SR number 8606223364. |
| | | +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5 |
| | | +$as_echo_n "checking size of long... " >&6; } |
| | | +if ${ac_cv_sizeof_long+:} false; then : |
| | | + $as_echo_n "(cached) " >&6 |
| | | +else |
| | | + if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long" "$ac_includes_default"; then : |
| | | + |
| | | +else |
| | | + if test "$ac_cv_type_long" = yes; then |
| | | + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 |
| | | +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} |
| | | +as_fn_error 77 "cannot compute sizeof (long) |
| | | +See \`config.log' for more details" "$LINENO" 5; } |
| | | + else |
| | | + ac_cv_sizeof_long=0 |
| | | + fi |
| | | +fi |
| | | + |
| | | +fi |
| | | +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5 |
| | | +$as_echo "$ac_cv_sizeof_long" >&6; } |
| | | + |
| | | + |
| | | + |
| | | +cat >>confdefs.h <<_ACEOF |
| | | +#define SIZEOF_LONG $ac_cv_sizeof_long |
| | | +_ACEOF |
| | | + |
| | | + |
| | | + if test "$ac_cv_sizeof_long" -eq 8 |
| | | + then |
| | | + DFLAGS="-arch i386" |
| | | + else |
| | | + DFLAGS="-arch x86_64" |
| | | + fi |
| | | + ;; |
| | | + esac |
| | | + |
| | | +$as_echo "#define WITH_DTRACE 1" >>confdefs.h |
| | | + |
| | | +fi |
| | | + |
| | | + |
| | | + |
| | | # -I${DLINCLDIR} is added to the compile rule for importdl.o |
| | | |
| | | DLINCLDIR=. |
| | | --- Python-3.4.0/configure.ac |
| | | +++ Python-3.4.0/configure.ac |
| | | @@ -2868,6 +2868,62 @@ |
| | | OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT" |
| | | fi |
| | | |
| | | +# Check for dtrace support |
| | | +AC_MSG_CHECKING(for --with-dtrace) |
| | | +AC_ARG_WITH(dtrace, |
| | | + AC_HELP_STRING(--with(out)-dtrace, disable/enable dtrace support),, |
| | | + with_dtrace=no) |
| | | +AC_MSG_RESULT($with_dtrace) |
| | | + |
| | | +AC_SUBST(DTRACE) |
| | | +AC_SUBST(DFLAGS) |
| | | +AC_SUBST(DTRACE_NM) |
| | | +AC_SUBST(DTRACE_LINKER) |
| | | +DTRACE= |
| | | +DFLAGS= |
| | | +if test "$with_dtrace" = "yes" |
| | | +then |
| | | + DTRACE_NM=OTHER |
| | | + DTRACE_LINKER=ld |
| | | + DTRACEOBJS="Python/pydtrace.o" |
| | | + AC_PATH_PROG(DTRACE, [dtrace], [dtrace], [$PATH$PATH_SEPARATOR/usr/sbin]) |
| | | + AC_CHECK_SIZEOF([long]) |
| | | + if [test "$ac_cv_sizeof_long" -eq 8] |
| | | + then |
| | | + DFLAGS="-64" |
| | | + else |
| | | + DFLAGS="-32" |
| | | + fi |
| | | + sys_release="$ac_sys_release" |
| | | + case $ac_sys_system/$sys_release in |
| | | + SunOS/5.10) |
| | | + DTRACE_NM=SOLARIS |
| | | + DTRACE_LINKER=/usr/ccs/bin/ld |
| | | + ;; |
| | | + SunOS/5.11 | SunOS/5.12) |
| | | + DTRACE_NM=SOLARIS |
| | | + DTRACE_LINKER=/usr/bin/ld |
| | | + ;; |
| | | + SunOS/*) |
| | | + DTRACE_LINKER=/usr/ccs/bin/ld |
| | | + ;; |
| | | + Darwin/*) |
| | | + DTRACEOBJS="" # Not needed in Mac |
| | | + AC_CHECK_SIZEOF([long]) |
| | | + if [test "$ac_cv_sizeof_long" -eq 8] |
| | | + then |
| | | + DFLAGS="-arch i386" |
| | | + else |
| | | + DFLAGS="-arch x86_64" |
| | | + fi |
| | | + ;; |
| | | + esac |
| | | + AC_DEFINE(WITH_DTRACE, 1, |
| | | + [Define if you want to compile in Dtrace support]) |
| | | +fi |
| | | + |
| | | +AC_SUBST(DTRACEOBJS) |
| | | + |
| | | # -I${DLINCLDIR} is added to the compile rule for importdl.o |
| | | AC_SUBST(DLINCLDIR) |
| | | DLINCLDIR=. |
| | | --- Python-3.4.0/pyconfig.h.in |
| | | +++ Python-3.4.0/pyconfig.h.in |
| | | @@ -1328,6 +1328,9 @@ |
| | | /* Define if you want documentation strings in extension modules */ |
| | | #undef WITH_DOC_STRINGS |
| | | |
| | | +/* Define if you want to compile in Dtrace support */ |
| | | +#undef WITH_DTRACE |
| | | + |
| | | /* Define if you want to use the new-style (Openstep, Rhapsody, MacOS) dynamic |
| | | linker (dyld) instead of the old-style (NextStep) dynamic linker (rld). |
| | | Dyld is necessary to support frameworks. */ |
| | | --- Python-3.4.0/setup.py |
| | | +++ Python-3.4.0/setup.py |
| | | @@ -637,6 +637,9 @@ |
| | | # syslog daemon interface |
| | | exts.append( Extension('syslog', ['syslogmodule.c']) ) |
| | | |
| | | + # jcea DTRACE probes |
| | | + exts.append( Extension('dtrace', ['dtracemodule.c']) ) |
| | | + |
| | | # |
| | | # Here ends the simple stuff. From here on, modules need certain |
| | | # libraries, are platform-specific, or present other surprises. |
New file |
| | |
| | | # |
| | | # This patch addresses problems with the configure script. |
| | | # As it is Solaris-specific, it is not suitable for upstream. |
| | | # |
| | | --- Python-3.4.0/configure.ac.~1~ 2014-03-16 19:31:31.000000000 -0700 |
| | | +++ Python-3.4.0/configure.ac 2014-03-17 11:11:22.990261823 -0700 |
| | | @@ -5,7 +5,7 @@ |
| | | # Set VERSION so we only need to edit in one place (i.e., here) |
| | | m4_define(PYTHON_VERSION, 3.4) |
| | | |
| | | -AC_PREREQ(2.65) |
| | | +AC_PREREQ(2.68) |
| | | |
| | | AC_INIT(python, PYTHON_VERSION, http://bugs.python.org/) |
| | | |
| | | @@ -2108,12 +2108,6 @@ |
| | | if test -z "$CCSHARED" |
| | | then |
| | | case $ac_sys_system/$ac_sys_release in |
| | | - SunOS*) if test "$GCC" = yes; |
| | | - then CCSHARED="-fPIC"; |
| | | - elif test `uname -p` = sparc; |
| | | - then CCSHARED="-xcode=pic32"; |
| | | - else CCSHARED="-Kpic"; |
| | | - fi;; |
| | | hp*|HP*) if test "$GCC" = yes; |
| | | then CCSHARED="-fPIC"; |
| | | else CCSHARED="+z"; |
New file |
| | |
| | | This patch provides extended file stdio support. |
| | | As it is Solaris-specific, it is not suitable for upstream. |
| | | Note that this patch is no longer needed, since is we build Python 3 64-bit |
| | | only, but we are keeping it around as a precaution in case we need to add |
| | | 32-bit support back in at some point. If a time comes when we are certain |
| | | we will never need 32-bit support, then the patch can be removed. |
| | | |
| | | --- Python-3.4.0/Modules/python.c.~1~ 2014-03-16 19:31:31.000000000 -0700 |
| | | +++ Python-3.4.0/Modules/python.c 2014-03-17 11:08:20.154195402 -0700 |
| | | @@ -15,6 +15,13 @@ |
| | | } |
| | | #else |
| | | |
| | | +#if defined(sun) && defined(__SVR4) && !defined(_LP64) |
| | | +#define USE_EXTENDED_FILE_STDIO 1 |
| | | +#include <stdio.h> |
| | | +#include <stdio_ext.h> |
| | | +#include <signal.h> |
| | | +#endif |
| | | + |
| | | int |
| | | main(int argc, char **argv) |
| | | { |
| | | @@ -44,6 +51,19 @@ |
| | | fpsetmask(m & ~FP_X_OFL); |
| | | #endif |
| | | |
| | | +#ifdef USE_EXTENDED_FILE_STDIO |
| | | + /* |
| | | + * enable extended FILE facility on Solaris so that Python |
| | | + * apps can keep more than 256 file descriptors open |
| | | + */ |
| | | + struct rlimit rlp; |
| | | + (void) getrlimit(RLIMIT_NOFILE, &rlp); |
| | | + rlp.rlim_cur = rlp.rlim_max; |
| | | + if (setrlimit(RLIMIT_NOFILE, &rlp) != -1) { |
| | | + enable_extended_FILE_stdio(-1, 0); |
| | | + } |
| | | +#endif |
| | | + |
| | | oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL)); |
| | | if (!oldloc) { |
| | | fprintf(stderr, "out of memory\n"); |
New file |
| | |
| | | This patch modifies the setup script to support Solaris. |
| | | As it is Solaris-specific, it is not suitable for upstream. |
| | | |
| | | --- Python-3.4.0/setup.py.~2~ 2014-03-19 10:36:25.778101571 -0700 |
| | | +++ Python-3.4.0/setup.py 2014-03-19 10:36:25.855568930 -0700 |
| | | @@ -728,6 +728,13 @@ |
| | | ['/usr/lib/termcap'], |
| | | 'termcap'): |
| | | readline_libs.append('termcap') |
| | | + |
| | | + if host_platform == 'sunos5': |
| | | + # insert '-zrecord' before the readline libraries that we |
| | | + # want to link with to avoid rl_insert() elimination |
| | | + readline_extra_link_args = ('-Wl,-zrecord','-lreadline','-lncurses') |
| | | + readline_libs = () |
| | | + |
| | | exts.append( Extension('readline', ['readline.c'], |
| | | library_dirs=['/usr/lib/termcap'], |
| | | extra_link_args=readline_extra_link_args, |
| | | @@ -1900,7 +1907,7 @@ |
| | | # this option. If you want to compile ctypes with the Sun |
| | | # compiler, please research a proper solution, instead of |
| | | # finding some -z option for the Sun compiler. |
| | | - extra_link_args.append('-mimpure-text') |
| | | + pass |
| | | |
| | | elif host_platform.startswith('hp-ux'): |
| | | extra_link_args.append('-fPIC') |
New file |
| | |
| | | This patch makes Python support the vendor-packages directory. |
| | | As it is Solaris-specific, it is not suitable for upstream. |
| | | |
| | | --- /dev/null Sat Feb 12 00:21:26 2011 |
| | | +++ Python-3.4.0/Lib/site-packages/vendor-packages.pth Sat Feb 12 00:47:05 2011 |
| | | @@ -0,0 +1,1 @@ |
| | | +import site; site.addsitedir('/usr/lib/python3.4/vendor-packages') |
| | | |
New file |
| | |
| | | This changes Python's standard profile-guided build target to work with |
| | | Studio instead of gcc. The unfortunate repetition of options seen below |
| | | is a workaround for build peculiarities and to meet Studio's requirement |
| | | that the profiling options be used at all steps of the build -- not just |
| | | compilation. As it is Solaris-specific, it is not suitable for upstream. |
| | | |
| | | --- Python-3.4.0/Makefile.pre.in.~2~ 2014-03-19 10:42:20.230354945 -0700 |
| | | +++ Python-3.4.0/Makefile.pre.in 2014-03-19 10:42:20.412767814 -0700 |
| | | @@ -472,30 +472,39 @@ |
| | | profile-opt: |
| | | @echo "Building with support for profile generation:" |
| | | $(MAKE) clean |
| | | + $(MAKE) profile-removal |
| | | $(MAKE) build_all_generate_profile |
| | | @echo "Running benchmark to generate profile data:" |
| | | - $(MAKE) profile-removal |
| | | $(MAKE) run_profile_task |
| | | @echo "Rebuilding with profile guided optimizations:" |
| | | $(MAKE) clean |
| | | $(MAKE) build_all_use_profile |
| | | |
| | | build_all_generate_profile: |
| | | - $(MAKE) all CFLAGS="$(CFLAGS) -fprofile-generate" LIBS="$(LIBS) -lgcov" |
| | | + $(MAKE) all CC="$(CC) -xprofile=collect:$(XPROFILE_DIR)" \ |
| | | + CFLAGS="$(CFLAGS) -xprofile=collect:$(XPROFILE_DIR)" \ |
| | | + LDFLAGS="$(LDFLAGS) -xprofile=collect:$(XPROFILE_DIR)" \ |
| | | + BLDSHARED="$(BLDSHARED) -xprofile=collect:$(XPROFILE_DIR)" |
| | | |
| | | run_profile_task: |
| | | : # FIXME: can't run for a cross build |
| | | - $(RUNSHARED) ./$(BUILDPYTHON) $(PROFILE_TASK) |
| | | + LD_LIBRARY_PATH=. $(RUNSHARED) ./$(BUILDPYTHON) $(PROFILE_TASK) |
| | | |
| | | build_all_use_profile: |
| | | - $(MAKE) all CFLAGS="$(CFLAGS) -fprofile-use -fprofile-correction" |
| | | + $(MAKE) all CC="$(CC) -xprofile=use:$(XPROFILE_DIR)" \ |
| | | + CFLAGS="$(CFLAGS) -xprofile=use:$(XPROFILE_DIR)" \ |
| | | + LDFLAGS="$(LDFLAGS) -xprofile=use:$(XPROFILE_DIR)" \ |
| | | + BLDSHARED="$(BLDSHARED) -xprofile=use:$(XPROFILE_DIR)" |
| | | |
| | | # Compile and run with gcov |
| | | .PHONY=coverage coverage-lcov coverage-report |
| | | coverage: |
| | | @echo "Building with support for coverage checking:" |
| | | $(MAKE) clean profile-removal |
| | | - $(MAKE) all CFLAGS="$(CFLAGS) -O0 -pg -fprofile-arcs -ftest-coverage" LIBS="$(LIBS) -lgcov" |
| | | + $(MAKE) all CC="$(CC) -xprofile=tcov" \ |
| | | + CFLAGS="$(CFLAGS) -xO1 -xprofile=tcov" \ |
| | | + LDFLAGS="$(LDFLAGS) -xprofile=tcov" \ |
| | | + BLDSHARED="$(BLDSHARED) -xprofile=tcov" |
| | | |
| | | coverage-lcov: |
| | | @echo "Creating Coverage HTML report with LCOV:" |
| | | @@ -556,13 +565,9 @@ |
| | | # -s, --silent or --quiet is always the first char. |
| | | # Under BSD make, MAKEFLAGS might be " -s -v x=y". |
| | | sharedmods: $(BUILDPYTHON) pybuilddir.txt |
| | | - @case "$$MAKEFLAGS" in \ |
| | | - *\ -s*|s*) quiet="-q";; \ |
| | | - *) quiet="";; \ |
| | | - esac; \ |
| | | $(RUNSHARED) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' \ |
| | | _TCLTK_INCLUDES='$(TCLTK_INCLUDES)' _TCLTK_LIBS='$(TCLTK_LIBS)' \ |
| | | - $(PYTHON_FOR_BUILD) $(srcdir)/setup.py $$quiet build |
| | | + $(PYTHON_FOR_BUILD) $(srcdir)/setup.py build |
| | | |
| | | # Build static library |
| | | # avoid long command lines, same as LIBRARY_OBJS |
| | | @@ -1575,7 +1580,7 @@ |
| | | -rm -f Modules/_testembed Modules/_freeze_importlib |
| | | |
| | | profile-removal: |
| | | - find . -name '*.gc??' -exec rm -f {} ';' |
| | | + find . -name '*profile' -exec rm -f {} ';' |
| | | rm -f $(COVERAGE_INFO) |
| | | rm -rf $(COVERAGE_REPORT) |
| | | |
New file |
| | |
| | | This patch ensures that 64-bit shared objects are in a subdirectory named |
| | | "64". Note that changes to the Lib/distutils/tests/test_build.py and |
| | | Lib/distutils/tests/test_install.py avoid running tests that fail due to |
| | | this patch. As this is Solaris-specific, it is not suitable for upstream. |
| | | |
| | | --- Python-3.4.0/Lib/distutils/command/build_ext.py.~1~ 2014-03-16 19:31:29.000000000 -0700 |
| | | +++ Python-3.4.0/Lib/distutils/command/build_ext.py 2014-03-17 13:18:10.057787061 -0700 |
| | | @@ -668,7 +668,12 @@ |
| | | ext_suffix = get_config_var('EXT_SUFFIX') |
| | | if os.name == 'nt' and self.debug: |
| | | return os.path.join(*ext_path) + '_d' + ext_suffix |
| | | - return os.path.join(*ext_path) + ext_suffix |
| | | + #return os.path.join(*ext_path) + ext_suffix |
| | | + path = os.path.join (ext_path) |
| | | + if sys.maxsize == 2147483647: |
| | | + return os.path.join(*ext_path) + ext_suffix |
| | | + (dirname, basename) = os.path.split(os.path.join(*ext_path)); |
| | | + return os.path.join(dirname, "64", basename + ext_suffix) |
| | | |
| | | def get_export_symbols(self, ext): |
| | | """Return the list of symbols that a shared extension has to |
| | | --- Python-3.4.0/Lib/distutils/tests/test_build_ext.py.~1~ 2014-03-16 19:31:29.000000000 -0700 |
| | | +++ Python-3.4.0/Lib/distutils/tests/test_build_ext.py 2014-03-17 13:18:10.098081226 -0700 |
| | | @@ -317,7 +317,7 @@ |
| | | ext_suffix = sysconfig.get_config_var('EXT_SUFFIX') |
| | | self.assertTrue(so_file.endswith(ext_suffix)) |
| | | so_dir = os.path.dirname(so_file) |
| | | - self.assertEqual(so_dir, other_tmp_dir) |
| | | + #self.assertEqual(so_dir, other_tmp_dir) |
| | | |
| | | cmd.inplace = 0 |
| | | cmd.compiler = None |
| | | @@ -364,7 +364,7 @@ |
| | | curdir = os.getcwd() |
| | | wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext) |
| | | path = cmd.get_ext_fullpath('lxml.etree') |
| | | - self.assertEqual(wanted, path) |
| | | + #self.assertEqual(wanted, path) |
| | | |
| | | # building lxml.etree not inplace |
| | | cmd.inplace = 0 |
| | | --- Python-3.4.0/Lib/sysconfig.py.~1~ 2014-03-16 19:31:30.000000000 -0700 |
| | | +++ Python-3.4.0/Lib/sysconfig.py 2014-03-17 13:18:10.099539252 -0700 |
| | | @@ -392,7 +392,11 @@ |
| | | if hasattr(sys, "gettotalrefcount"): |
| | | pybuilddir += '-pydebug' |
| | | os.makedirs(pybuilddir, exist_ok=True) |
| | | - destfile = os.path.join(pybuilddir, name + '.py') |
| | | + if sys.maxsize == 2147483647: |
| | | + destfile = os.path.join(pybuilddir, name + '.py') |
| | | + else: |
| | | + os.makedirs(pybuilddir + '/64', exist_ok=True) |
| | | + destfile = os.path.join(pybuilddir + '/64', name + '.py') |
| | | |
| | | with open(destfile, 'w', encoding='utf8') as f: |
| | | f.write('# system configuration generated and used by' |
| | | --- Python-3.4.0/Modules/getpath.c.~1~ 2014-03-16 19:31:31.000000000 -0700 |
| | | +++ Python-3.4.0/Modules/getpath.c 2014-04-25 15:02:02.837613851 -0700 |
| | | @@ -697,6 +697,10 @@ |
| | | wcsncpy(exec_prefix, _exec_prefix, MAXPATHLEN); |
| | | joinpath(exec_prefix, L"lib/lib-dynload"); |
| | | } |
| | | + if (sizeof(void *) == 8 && wcslen(exec_prefix) + 3 <= MAXPATHLEN) { |
| | | + wcscat(exec_prefix, L"/64"); |
| | | + } |
| | | + |
| | | /* If we found EXEC_PREFIX do *not* reduce it! (Yet.) */ |
| | | |
| | | if ((!pfound || !efound) && !Py_FrozenFlag) |
| | | @@ -710,8 +714,30 @@ |
| | | if (_rtpypath && _rtpypath[0] != '\0') { |
| | | size_t rtpypath_len; |
| | | rtpypath = _Py_char2wchar(_rtpypath, &rtpypath_len); |
| | | - if (rtpypath != NULL) |
| | | - bufsz += rtpypath_len + 1; |
| | | + if (rtpypath != NULL) { |
| | | + wchar_t *orig_rtpypath = rtpypath; |
| | | + |
| | | + /* |
| | | + * Split the path; for each component, add that component + "/64" |
| | | + * (if in 64-bit mode) and the component unadorned (regardless). |
| | | + */ |
| | | + while (1) { |
| | | + wchar_t *delim = wcschr(rtpypath, DELIM); |
| | | + if (delim) { |
| | | + /* once for usual, another for usual + "/64" */ |
| | | + bufsz += delim - rtpypath + 1; |
| | | + if (sizeof(void *) == 8) |
| | | + bufsz += delim - rtpypath + 1 + 3; |
| | | + } else { |
| | | + bufsz += wcslen(rtpypath) + 1; |
| | | + if (sizeof(void *) == 8) |
| | | + bufsz += wcslen(rtpypath) + 1 + 3; |
| | | + break; |
| | | + } |
| | | + rtpypath = delim + 1; |
| | | + } |
| | | + rtpypath = orig_rtpypath; |
| | | + } |
| | | } |
| | | |
| | | defpath = _pythonpath; |
| | | @@ -723,9 +749,19 @@ |
| | | /* Paths are relative to prefix */ |
| | | bufsz += prefixsz; |
| | | |
| | | - if (delim) |
| | | + if (delim) { |
| | | + if (sizeof(void *) == 8) { |
| | | + bufsz += delim - defpath + 1 + 3; |
| | | + if (defpath[0] != SEP) |
| | | + bufsz += prefixsz; |
| | | + } |
| | | bufsz += delim - defpath + 1; |
| | | - else { |
| | | + } else { |
| | | + if (sizeof(void *) == 8) { |
| | | + bufsz += wcslen(defpath) + 1 + 3; |
| | | + if (defpath[0] != SEP) |
| | | + bufsz += prefixsz; |
| | | + } |
| | | bufsz += wcslen(defpath) + 1; |
| | | break; |
| | | } |
| | | @@ -741,13 +777,38 @@ |
| | | "Not enough memory for dynamic PYTHONPATH"); |
| | | } |
| | | |
| | | + buf[0] = '\0'; |
| | | /* Run-time value of $PYTHONPATH goes first */ |
| | | if (rtpypath) { |
| | | - wcscpy(buf, rtpypath); |
| | | - wcscat(buf, delimiter); |
| | | + wchar_t *orig_rtpypath = rtpypath; |
| | | + |
| | | + while (1) { |
| | | + wchar_t *delim = wcschr(rtpypath, DELIM); |
| | | + |
| | | + if (delim) { |
| | | + *delim = '\0'; |
| | | + if (sizeof(void *) == 8) { |
| | | + wcscat(buf, rtpypath); |
| | | + wcscat(buf, L"/64"); |
| | | + wcscat(buf, delimiter); |
| | | + } |
| | | + wcscat(buf, rtpypath); |
| | | + wcscat(buf, delimiter); |
| | | + *delim = DELIM; |
| | | + } else { |
| | | + if (sizeof(void *) == 8) { |
| | | + wcscat(buf, rtpypath); |
| | | + wcscat(buf, L"/64"); |
| | | + wcscat(buf, delimiter); |
| | | + } |
| | | + wcscat(buf, rtpypath); |
| | | + wcscat(buf, delimiter); |
| | | + break; |
| | | + } |
| | | + rtpypath = delim + 1; |
| | | + } |
| | | + rtpypath = orig_rtpypath; |
| | | } |
| | | - else |
| | | - buf[0] = '\0'; |
| | | |
| | | /* Next is the default zip path */ |
| | | wcscat(buf, zip_path); |
| | | @@ -766,18 +827,35 @@ |
| | | } |
| | | |
| | | if (delim) { |
| | | - size_t len = delim - defpath + 1; |
| | | - size_t end = wcslen(buf) + len; |
| | | - wcsncat(buf, defpath, len); |
| | | - *(buf + end) = '\0'; |
| | | - } |
| | | - else { |
| | | + *delim = '\0'; |
| | | + if (sizeof(void *) == 8) { |
| | | + wcscat(buf, defpath); |
| | | + wcscat(buf, L"/64"); |
| | | + wcscat(buf, delimiter); |
| | | + if (defpath[0] != SEP) { |
| | | + wcscat(buf, prefix); |
| | | + wcscat(buf, separator); |
| | | + } |
| | | + } |
| | | wcscat(buf, defpath); |
| | | + wcscat(buf, delimiter); |
| | | + *delim = DELIM; |
| | | + } else { |
| | | + if (sizeof(void *) == 8) { |
| | | + wcscat(buf, defpath); |
| | | + wcscat(buf, L"/64"); |
| | | + wcscat(buf, delimiter); |
| | | + if (defpath[0] != SEP) { |
| | | + wcscat(buf, prefix); |
| | | + wcscat(buf, separator); |
| | | + } |
| | | + } |
| | | + wcscat(buf, defpath); |
| | | + wcscat(buf, delimiter); |
| | | break; |
| | | } |
| | | defpath = delim + 1; |
| | | } |
| | | - wcscat(buf, delimiter); |
| | | |
| | | /* Finally, on goes the directory for dynamic-load modules */ |
| | | wcscat(buf, exec_prefix); |
New file |
| | |
| | | This patch provides Python ucred support. It may be contributed upstream at |
| | | some point, but the suitability (or lack thereof) has not yet been determined. |
| | | |
| | | diff --git Python-2.6.4/Modules/ucred.c Python-2.6.4/Modules/ucred.c |
| | | new file mode 100644 |
| | | --- /dev/null |
| | | +++ Python-2.6.4/Modules/ucred.c |
| | | @@ -0,0 +1,404 @@ |
| | | +/* |
| | | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
| | | + * of this software and associated documentation files (the "Software"), to |
| | | + * deal in the Software without restriction, including without limitation the |
| | | + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| | | + * sell copies of the Software, and to permit persons to whom the Software is |
| | | + * furnished to do so, subject to the following conditions: |
| | | + * |
| | | + * The above copyright notice and this permission notice shall be included in |
| | | + * all copies or substantial portions of the Software. |
| | | + * |
| | | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| | | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| | | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| | | + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| | | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| | | + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| | | + * DEALINGS IN THE SOFTWARE. |
| | | + * |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +#include <Python.h> |
| | | + |
| | | +#include <stdio.h> |
| | | +#include <priv.h> |
| | | +#include <ucred.h> |
| | | +#include <ctype.h> |
| | | +#include <tsol/label.h> |
| | | + |
| | | +typedef struct { |
| | | + PyObject_HEAD |
| | | + ucred_t *ucred; |
| | | +} pyucred_t; |
| | | + |
| | | +#define pyucred_getlongid(name, type) \ |
| | | + static PyObject * \ |
| | | + pyucred_get##name(pyucred_t *uc) \ |
| | | + { \ |
| | | + type val; \ |
| | | + \ |
| | | + if (uc->ucred == NULL) { \ |
| | | + errno = EINVAL; \ |
| | | + PyErr_SetFromErrno(PyExc_OSError); \ |
| | | + return (NULL); \ |
| | | + } \ |
| | | + \ |
| | | + if ((val = ucred_get##name(uc->ucred)) == -1) { \ |
| | | + PyErr_SetFromErrno(PyExc_OSError); \ |
| | | + return (NULL); \ |
| | | + } \ |
| | | + \ |
| | | + return (Py_BuildValue("l", (long)val)); \ |
| | | + } |
| | | + |
| | | +pyucred_getlongid(euid, uid_t) |
| | | +pyucred_getlongid(ruid, uid_t) |
| | | +pyucred_getlongid(suid, uid_t) |
| | | +pyucred_getlongid(egid, gid_t) |
| | | +pyucred_getlongid(rgid, gid_t) |
| | | +pyucred_getlongid(sgid, gid_t) |
| | | +pyucred_getlongid(pid, pid_t) |
| | | +pyucred_getlongid(projid, projid_t) |
| | | +pyucred_getlongid(zoneid, zoneid_t) |
| | | + |
| | | +static PyObject * |
| | | +pyucred_getgroups(pyucred_t *uc) |
| | | +{ |
| | | + const gid_t *groups; |
| | | + PyObject *list; |
| | | + int len; |
| | | + int i; |
| | | + |
| | | + if (uc->ucred == NULL) { |
| | | + errno = EINVAL; |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((len = ucred_getgroups(uc->ucred, &groups)) == -1) { |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((list = PyList_New(len)) == NULL) |
| | | + return (NULL); |
| | | + |
| | | + for (i = 0; i < len; i++) { |
| | | + PyObject *gid = Py_BuildValue("l", (long)groups[i]); |
| | | + if (PyList_SetItem(list, i, gid) == -1) |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (list); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyucred_getlabel(pyucred_t *uc) |
| | | +{ |
| | | + m_label_t *label; |
| | | + PyObject *ret; |
| | | + char *str; |
| | | + |
| | | + if (uc->ucred == NULL) { |
| | | + errno = EINVAL; |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + label = ucred_getlabel(uc->ucred); |
| | | + if (label == NULL) |
| | | + return (Py_BuildValue("s", "")); |
| | | + |
| | | + if (label_to_str(label, &str, M_LABEL, DEF_NAMES) == -1) { |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + ret = Py_BuildValue("s", str); |
| | | + free(str); |
| | | + return (ret); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyucred_getpflags(pyucred_t *uc, PyObject *args, PyObject *kwargs) |
| | | +{ |
| | | + static char *kwlist[] = { "flags", NULL }; |
| | | + uint_t flags; |
| | | + |
| | | + if (uc->ucred == NULL) { |
| | | + errno = EINVAL; |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, |
| | | + &flags)) |
| | | + return (NULL); |
| | | + |
| | | + if ((flags = ucred_getpflags(uc->ucred, flags)) == (uint_t)-1) { |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("i", flags)); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyucred_has_priv(pyucred_t *uc, PyObject *args, PyObject *kwargs) |
| | | +{ |
| | | + static char *kwlist[] = { "set", "priv", NULL }; |
| | | + const priv_set_t *privs; |
| | | + const char *set; |
| | | + const char *priv; |
| | | + |
| | | + if (uc->ucred == NULL) { |
| | | + errno = EINVAL; |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ss", kwlist, |
| | | + &set, &priv)) |
| | | + return (NULL); |
| | | + |
| | | + if ((privs = ucred_getprivset(uc->ucred, set)) == NULL) { |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (priv_ismember(privs, priv)) { |
| | | + Py_INCREF(Py_True); |
| | | + return Py_True; |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_False); |
| | | + return Py_False; |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(pyucred_getlabel_doc, |
| | | + "getlabel() -> string\n" |
| | | + "\n" |
| | | + "Return the Trusted Extensions label string, or an " |
| | | + "empty string if not available. The label string is " |
| | | + "converted using the default name and M_LABEL (human-readable). " |
| | | + "Raises OSError. See label_to_str(3TSOL)."); |
| | | +PyDoc_STRVAR(pyucred_getpflags_doc, |
| | | + "getpflags(flags) -> int\n" |
| | | + "\n" |
| | | + "Return the values of the specified privilege flags."); |
| | | +PyDoc_STRVAR(pyucred_has_priv_doc, |
| | | + "has_priv(set, priv) -> bool\n" |
| | | + "\n" |
| | | + "Return true if the given privilege is set in the " |
| | | + "specified set. Raises OSError if the set or privilege is " |
| | | + "invalid, or a problem occurs.\n" |
| | | + "\n" |
| | | + "Currently, the following privilege sets are defined, as " |
| | | + "described in privileges(5):\n" |
| | | + "\n" |
| | | + "Effective\n" |
| | | + "Permitted\n" |
| | | + "Inheritable\n" |
| | | + "Limit\n"); |
| | | + |
| | | +static PyMethodDef pyucred_methods[] = { |
| | | + { "geteuid", (PyCFunction)pyucred_geteuid, METH_NOARGS, |
| | | + "Return the effective user ID." }, |
| | | + { "getruid", (PyCFunction)pyucred_getruid, METH_NOARGS, |
| | | + "Return the real user ID." }, |
| | | + { "getsuid", (PyCFunction)pyucred_getsuid, METH_NOARGS, |
| | | + "Return the saved user ID." }, |
| | | + { "getegid", (PyCFunction)pyucred_getegid, METH_NOARGS, |
| | | + "Return the effective group ID." }, |
| | | + { "getrgid", (PyCFunction)pyucred_getrgid, METH_NOARGS, |
| | | + "Return the real group ID." }, |
| | | + { "getsgid", (PyCFunction)pyucred_getsgid, METH_NOARGS, |
| | | + "Return the saved group ID." }, |
| | | + { "getpid", (PyCFunction)pyucred_getpid, METH_NOARGS, |
| | | + "Return the effective user ID." }, |
| | | + { "getprojid", (PyCFunction)pyucred_getprojid, METH_NOARGS, |
| | | + "Return the project ID." }, |
| | | + { "getzoneid", (PyCFunction)pyucred_getzoneid, METH_NOARGS, |
| | | + "Return the zone ID." }, |
| | | + { "getgroups", (PyCFunction)pyucred_getgroups, METH_NOARGS, |
| | | + "Return a list of group IDs." }, |
| | | + { "getlabel", (PyCFunction)pyucred_getlabel, METH_NOARGS, |
| | | + pyucred_getlabel_doc }, |
| | | + { "getpflags", (PyCFunction)pyucred_getpflags, |
| | | + METH_VARARGS|METH_KEYWORDS, pyucred_getpflags_doc }, |
| | | + { "has_priv", (PyCFunction)pyucred_has_priv, |
| | | + METH_VARARGS|METH_KEYWORDS, pyucred_has_priv_doc }, |
| | | + { NULL, NULL } |
| | | +}; |
| | | + |
| | | +static int |
| | | +pyucred_init(PyObject *self, PyObject *args, PyObject *kwargs) |
| | | +{ |
| | | + pyucred_t *uc = (pyucred_t *)self; |
| | | + uc->ucred = NULL; |
| | | + return (0); |
| | | +} |
| | | + |
| | | +static void |
| | | +pyucred_dealloc(PyObject *self) |
| | | +{ |
| | | + pyucred_t *uc = (pyucred_t *)self; |
| | | + if (uc->ucred != NULL) |
| | | + ucred_free(uc->ucred); |
| | | + Py_TYPE(self)->tp_free(self); |
| | | +} |
| | | + |
| | | +static PyTypeObject pyucred_type = { |
| | | + PyVarObject_HEAD_INIT(NULL, 0) |
| | | + "ucred.ucred", /*tp_name*/ |
| | | + sizeof (pyucred_t), /*tp_basicsize*/ |
| | | + 0, /*tp_itemsize*/ |
| | | + pyucred_dealloc, /*tp_dealloc*/ |
| | | + 0, /*tp_print*/ |
| | | + 0, /*tp_getattr*/ |
| | | + 0, /*tp_setattr*/ |
| | | + 0, /*tp_reserved*/ |
| | | + 0, /*tp_repr*/ |
| | | + 0, /*tp_as_number*/ |
| | | + 0, /*tp_as_sequence*/ |
| | | + 0, /*tp_as_mapping*/ |
| | | + 0, /*tp_hash */ |
| | | + 0, /*tp_call*/ |
| | | + 0, /*tp_str*/ |
| | | + 0, /*tp_getattro*/ |
| | | + 0, /*tp_setattro*/ |
| | | + 0, /*tp_as_buffer*/ |
| | | + Py_TPFLAGS_DEFAULT, /*tp_flags*/ |
| | | + "user credentials", /*tp_doc */ |
| | | + 0, /* tp_traverse */ |
| | | + 0, /* tp_clear */ |
| | | + 0, /* tp_richcompare */ |
| | | + 0, /* tp_weaklistoffset */ |
| | | + 0, /* tp_iter */ |
| | | + 0, /* tp_iternext */ |
| | | + pyucred_methods, /* tp_methods */ |
| | | + 0, /* tp_members */ |
| | | + 0, /* tp_getset */ |
| | | + 0, /* tp_base */ |
| | | + 0, /* tp_dict */ |
| | | + 0, /* tp_descr_get */ |
| | | + 0, /* tp_descr_set */ |
| | | + 0, /* tp_dictoffset */ |
| | | + (initproc)pyucred_init, /* tp_init */ |
| | | + 0, /* tp_alloc */ |
| | | + 0, /* tp_new */ |
| | | + 0, /* tp_free */ |
| | | + 0, /* tp_is_gc */ |
| | | +}; |
| | | + |
| | | +static PyObject * |
| | | +pyucred_new(const ucred_t *uc) |
| | | +{ |
| | | + pyucred_t *self; |
| | | + |
| | | + self = (pyucred_t *)PyObject_CallObject((PyObject *)&pyucred_type, NULL); |
| | | + |
| | | + if (self == NULL) |
| | | + return (NULL); |
| | | + |
| | | + self->ucred = (ucred_t *)uc; |
| | | + |
| | | + return ((PyObject *)self); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyucred_get(PyObject *o, PyObject *args, PyObject *kwargs) |
| | | +{ |
| | | + static char *kwlist[] = { "pid", NULL }; |
| | | + ucred_t *ucred = NULL; |
| | | + int pid; |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, |
| | | + &pid)) |
| | | + return (NULL); |
| | | + |
| | | + ucred = ucred_get(pid); |
| | | + |
| | | + if (ucred == NULL) { |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (pyucred_new(ucred)); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyucred_getpeer(PyObject *o, PyObject *args, PyObject *kwargs) |
| | | +{ |
| | | + static char *kwlist[] = { "fd", NULL }; |
| | | + ucred_t *ucred = NULL; |
| | | + int fd; |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, |
| | | + &fd)) |
| | | + return (NULL); |
| | | + |
| | | + if (getpeerucred(fd, &ucred) == -1) { |
| | | + PyErr_SetFromErrno(PyExc_OSError); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (pyucred_new(ucred)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(pyucred_get_doc, |
| | | + "get(pid) -> ucred\n" |
| | | + "\n" |
| | | + "Return the credentials of the specified process ID. " |
| | | + "Raises OSError. See ucred_get(3C)."); |
| | | +PyDoc_STRVAR(pyucred_getpeer_doc, |
| | | + "getpeer(fd) -> ucred\n" |
| | | + "\n" |
| | | + "Return the credentials of the peer endpoint of a " |
| | | + "connection-oriented socket (SOCK_STREAM) or STREAM fd " |
| | | + "at the time the endpoint was created or the connection " |
| | | + "was established. Raises OSError. See getpeerucred(3C)."); |
| | | + |
| | | +static struct PyMethodDef pyucred_module_methods[] = { |
| | | + { "get", (PyCFunction) pyucred_get, |
| | | + METH_VARARGS|METH_KEYWORDS, pyucred_get_doc }, |
| | | + { "getpeer", (PyCFunction) pyucred_getpeer, |
| | | + METH_VARARGS|METH_KEYWORDS, pyucred_getpeer_doc }, |
| | | + { NULL, NULL, 0, NULL } |
| | | +}; |
| | | + |
| | | +PyDoc_STRVAR(pyucred_module_doc, |
| | | + "This module provides an interface to the user credential access " |
| | | + "methods, obtainable either by process ID or file descriptor."); |
| | | + |
| | | +PyMODINIT_FUNC |
| | | +PyInit_ucred (void) |
| | | +{ |
| | | + PyObject *m; |
| | | + |
| | | + static struct PyModuleDef moduledef = { |
| | | + PyModuleDef_HEAD_INIT, |
| | | + "ucred", |
| | | + pyucred_module_doc, |
| | | + -1, |
| | | + pyucred_module_methods, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + }; |
| | | + |
| | | + m = PyModule_Create(&moduledef); |
| | | + |
| | | + pyucred_type.tp_new = PyType_GenericNew; |
| | | + if (PyType_Ready(&pyucred_type) < 0) |
| | | + return NULL; |
| | | + |
| | | + Py_INCREF(&pyucred_type); |
| | | + |
| | | + PyModule_AddObject(m, "ucred", (PyObject *)&pyucred_type); |
| | | + |
| | | + return m; |
| | | +} |
| | | --- Python-3.4.0/setup.py.~3~ 2014-03-19 10:44:16.508585670 -0700 |
| | | +++ Python-3.4.0/setup.py 2014-03-19 10:44:16.596735089 -0700 |
| | | @@ -1467,6 +1467,13 @@ |
| | | # Stefan Krah's _decimal module |
| | | exts.append(self._decimal_ext()) |
| | | |
| | | + # ucred module (Solaris) |
| | | + ucred_inc = find_file('ucred.h', [], inc_dirs) |
| | | + tsol_inc = find_file('tsol/label.h', [], inc_dirs) |
| | | + if ucred_inc is not None and tsol_inc is not None: |
| | | + exts.append( Extension('ucred', ['ucred.c'], |
| | | + libraries = ['tsol']) ) |
| | | + |
| | | # Thomas Heller's _ctypes module |
| | | self.detect_ctypes(inc_dirs, lib_dirs) |
| | | |
| | | --- /dev/null 2011-02-12 03:14:16.000000000 -0600 |
| | | +++ Python-2.6.4/Lib/test/ucredtest.py 2011-01-20 13:52:42.945657919 -0600 |
| | | @@ -0,0 +1,45 @@ |
| | | +#!/usr/bin/python3.4 |
| | | + |
| | | +import ucred |
| | | +import os |
| | | + |
| | | +uc = ucred.get(os.getpid()) |
| | | + |
| | | +print("pid = %d" % uc.getpid()) |
| | | +print("euid = %d" % uc.geteuid()) |
| | | +print("ruid = %d" % uc.getruid()) |
| | | +print("suid = %d" % uc.getsuid()) |
| | | +print("egid = %d" % uc.getegid()) |
| | | +print("rgid = %d" % uc.getrgid()) |
| | | +print("sgid = %d" % uc.getsgid()) |
| | | +print("zoneid = %d" % uc.getzoneid()) |
| | | +print("projid = %d" % uc.getprojid()) |
| | | +print("groups = %s" % uc.getgroups()) |
| | | +print("label = %s" % uc.getlabel()) |
| | | + |
| | | +print("getpflags(0x1) = %d" % uc.getpflags(0x1)) |
| | | +print("getpflags(0x2) = %d" % uc.getpflags(0x2)) |
| | | +print("has_priv(Effective, proc_fork) = %d" % uc.has_priv("Effective", "proc_fork")) |
| | | +print("has_priv(Permitted, proc_fork) = %d" % uc.has_priv("Permitted", "proc_fork")) |
| | | +print("has_priv(Inheritable, proc_fork) = %d" % uc.has_priv("Inheritable", "proc_fork")) |
| | | +print("has_priv(Limit, file_setid) = %d" % uc.has_priv("Limit", "file_setid")) |
| | | +print("has_priv(Effective, file_setid) = %d" % uc.has_priv("Effective", "file_setid")) |
| | | +try: |
| | | + uc.has_priv("Effective", "proc_bork") |
| | | +except OSError as e: |
| | | + print(e) |
| | | +try: |
| | | + uc.has_priv("Defective", "proc_fork") |
| | | +except OSError as e: |
| | | + print(e) |
| | | +try: |
| | | + uc.has_priv("Defective", "proc_bork") |
| | | +except OSError as e: |
| | | + print(e) |
| | | + |
| | | +del uc |
| | | +uc = ucred.ucred() |
| | | +try: |
| | | + uc.getpid() |
| | | +except OSError as e: |
| | | + print(e) |
New file |
| | |
| | | This patch provides Python dlpi support. It may be contributed upstream at |
| | | some point, but the suitability (or lack thereof) has not yet been determined. |
| | | |
| | | --- /dev/null |
| | | +++ Python-3.4.0/Modules/dlpimodule.c |
| | | @@ -0,0 +1,1219 @@ |
| | | +/* |
| | | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
| | | + * of this software and associated documentation files (the "Software"), to |
| | | + * deal in the Software without restriction, including without limitation the |
| | | + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| | | + * sell copies of the Software, and to permit persons to whom the Software is |
| | | + * furnished to do so, subject to the following conditions: |
| | | + * |
| | | + * The above copyright notice and this permission notice shall be included in |
| | | + * all copies or substantial portions of the Software. |
| | | + * |
| | | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| | | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| | | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| | | + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| | | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| | | + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| | | + * DEALINGS IN THE SOFTWARE. |
| | | + * |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +#include <Python.h> |
| | | +#include <stdio.h> |
| | | +#include <libdlpi.h> |
| | | + |
| | | +typedef struct { |
| | | + PyObject_HEAD |
| | | + dlpi_handle_t dlpihdl; |
| | | +} pylink_t; |
| | | + |
| | | +typedef struct { |
| | | + PyObject *pyfunc; |
| | | + PyObject *pyarg; |
| | | +} callback_data_t; |
| | | + |
| | | +/* |
| | | + * dlpi_err: the only exception raised for libdlpi related error. |
| | | + * The accompanying value is: |
| | | + * (dlpi_error_number, string), when it's a dlpi specific error, |
| | | + * or, (DL_SYSERR, errno, string), when it's coming from a system call. |
| | | + */ |
| | | +static PyObject *dlpi_err; |
| | | + |
| | | +static void |
| | | +dlpi_raise_exception(int err) |
| | | +{ |
| | | + PyObject *e = NULL; |
| | | + |
| | | + if (err == DL_SYSERR) { |
| | | + e = Py_BuildValue("(iis)", DL_SYSERR, errno, strerror(errno)); |
| | | + } else { |
| | | + e = Py_BuildValue("(is)", err, dlpi_strerror(err)); |
| | | + } |
| | | + if (e != NULL) { |
| | | + PyErr_SetObject(dlpi_err, e); |
| | | + Py_DECREF(e); |
| | | + } |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(link_doc, |
| | | + "link(linkname[, flags]) -> link object\n" |
| | | + "\n" |
| | | + "Open linkname with specified flags.\n" |
| | | + "Three flags are supported: PASSIVE, RAW, NATIVE.\n" |
| | | + "And these flags can be bitwise-OR'ed together(default flag is 0).\n" |
| | | + "You need sys_net_rawaccess privilege to open a link.\n" |
| | | + "See dlpi_open(3DLPI).\n" |
| | | +); |
| | | +static int |
| | | +link_init(PyObject *self, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + uint_t flags = 0; |
| | | + dlpi_handle_t dh; |
| | | + char *linkname; |
| | | + int rval; |
| | | + static char *keywords[] = {"linkname", "flags", NULL}; |
| | | + pylink_t *link = (pylink_t *)self; |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|I", keywords, |
| | | + &linkname, &flags)) |
| | | + return (-1); |
| | | + |
| | | + if ((rval = dlpi_open(linkname, &dh, flags)) != DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + link->dlpihdl = dh; |
| | | + |
| | | + return (0); |
| | | +} |
| | | + |
| | | +static void |
| | | +link_dealloc(pylink_t *link) |
| | | +{ |
| | | + if (link->dlpihdl != NULL) |
| | | + dlpi_close(link->dlpihdl); |
| | | + Py_TYPE(link)->tp_free((PyObject *)link); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(bind_doc, |
| | | + "bind(sap) -> unsigned int\n" |
| | | + "\n" |
| | | + "Attempts to bind the link to specified SAP, or ANY_SAP.\n" |
| | | + "Returns the SAP that the function actually bound to, which\n" |
| | | + "could be different from the SAP requested.\n" |
| | | + "See dlpi_bind(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_bind(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + uint_t sap = 0, boundsap = 0; |
| | | + static char *keywords[] = {"sap", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &sap)) |
| | | + return (NULL); |
| | | + |
| | | + if ((rval = dlpi_bind(link->dlpihdl, sap, &boundsap)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("I", boundsap)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(unbind_doc, |
| | | + "unbind() -> None\n" |
| | | + "\n" |
| | | + "Attempts to unbind the link from previously bound sap.\n" |
| | | + "See dlpi_unbind(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_unbind(pylink_t *link) |
| | | +{ |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_unbind(link->dlpihdl)) != DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(send_doc, |
| | | + "send(destaddr, message[, sap, minpri, maxpri]) -> None\n" |
| | | + "\n" |
| | | + "Attempts to send message over this link to sap on destaddr.\n" |
| | | + "If SAP is not specified, the bound SAP is used\n" |
| | | + "You can also specify priority range (minpri, maxpri).\n" |
| | | + "See dlpi_send(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_send(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + char *daddr = NULL, *msgbuf = NULL; |
| | | + size_t daddrlen = 0, msglen = 0; |
| | | + t_scalar_t minpri = DL_QOS_DONT_CARE, maxpri = DL_QOS_DONT_CARE; |
| | | + uint_t sap = DLPI_ANY_SAP; |
| | | + dlpi_sendinfo_t ds, *dsp = NULL; |
| | | + static char *keywords[] = |
| | | + {"destaddr", "message", "sap", "minpri", "maxpri", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#s#|Iii", keywords, |
| | | + &daddr, &daddrlen, &msgbuf, &msglen, &sap, &minpri, &maxpri)) |
| | | + return (NULL); |
| | | + |
| | | + if ((sap != DLPI_ANY_SAP) || (minpri != DL_QOS_DONT_CARE) || |
| | | + (maxpri != DL_QOS_DONT_CARE)) { |
| | | + ds.dsi_sap = sap; |
| | | + ds.dsi_prio.dl_min = minpri; |
| | | + ds.dsi_prio.dl_max = maxpri; |
| | | + dsp = &ds; |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_send(link->dlpihdl, daddr, daddrlen, |
| | | + msgbuf, msglen, dsp)) != DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(recv_doc, |
| | | + "recv(msglen[, timeout]) -> (string, string), or (None, None)\n" |
| | | + "\n" |
| | | + "Attempts to receive message over this link.\n" |
| | | + "You need to specify the message length for the received message.\n" |
| | | + "And you can specify timeout value in milliseconds.\n" |
| | | + "The default timeout value is -1 (wait forever).\n" |
| | | + "Returns (source address, message data), or (None, None) when error occurs.\n" |
| | | + "See dlpi_recv(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_recv(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + PyObject *obj; |
| | | + char *saddr = NULL, *msgbuf = NULL; |
| | | + size_t saddrlen = 0, msglen = 0, *saddrlenp = NULL, *msglenp = NULL; |
| | | + int msec = -1; /* block until receive data */ |
| | | + static char *keywords[] = {"msglen", "timeout", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "k|i", |
| | | + keywords, &msglen, &msec)) |
| | | + return (NULL); |
| | | + |
| | | + if (msglen > 0) { |
| | | + msgbuf = malloc(msglen); |
| | | + if (msgbuf == NULL) { |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + saddrlen = DLPI_PHYSADDR_MAX; |
| | | + saddr = malloc(saddrlen); |
| | | + if (saddr == NULL) { |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + free(msgbuf); |
| | | + return (NULL); |
| | | + } |
| | | + msglenp = &msglen; |
| | | + saddrlenp = &saddrlen; |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_recv(link->dlpihdl, saddr, saddrlenp, msgbuf, |
| | | + msglenp, msec, NULL)) != DLPI_SUCCESS) { |
| | | + if (msgbuf != NULL) |
| | | + free(msgbuf); |
| | | + if (saddr != NULL) |
| | | + free(saddr); |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + obj = Py_BuildValue("s#s#", saddr, saddrlen, msgbuf, msglen); |
| | | + if (msgbuf != NULL) |
| | | + free(msgbuf); |
| | | + if (saddr != NULL) |
| | | + free(saddr); |
| | | + return (obj); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(disabmulti_doc, |
| | | + "disabmulti(address) -> None\n" |
| | | + "\n" |
| | | + "Disable a specified multicast address on this link.\n" |
| | | + "See dlpi_disabmulti(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_disabmulti(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + char *addr = NULL; |
| | | + size_t addrlen = 0; |
| | | + static char *keywords[] = {"address", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords, |
| | | + &addr, &addrlen)) |
| | | + return (NULL); |
| | | + |
| | | + if ((addrlen == 0) || (addrlen > DLPI_PHYSADDR_MAX)) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_disabmulti(link->dlpihdl, addr, addrlen)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(enabmulti_doc, |
| | | + "enabmulti(address) -> None\n" |
| | | + "\n" |
| | | + "Enable a specified multicast address on this link.\n" |
| | | + "See dlpi_enabmulti(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_enabmulti(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + char *addr = NULL; |
| | | + size_t addrlen = 0; |
| | | + static char *keywords[] = {"address", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords, |
| | | + &addr, &addrlen)) |
| | | + return (NULL); |
| | | + |
| | | + if ((addrlen == 0) || (addrlen > DLPI_PHYSADDR_MAX)) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_enabmulti(link->dlpihdl, addr, addrlen)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +static void |
| | | +dlpi_callback(dlpi_handle_t hdl, dlpi_notifyinfo_t *ni, void *arg) |
| | | +{ |
| | | + callback_data_t *cd = (callback_data_t *)arg; |
| | | + PyObject *arglist, *result; |
| | | + |
| | | + switch (ni->dni_note) { |
| | | + case DL_NOTE_SPEED: |
| | | + arglist = Py_BuildValue("(OII)", |
| | | + cd->pyarg, ni->dni_note, ni->dni_speed); |
| | | + break; |
| | | + case DL_NOTE_SDU_SIZE: |
| | | + arglist = Py_BuildValue("(OII)", |
| | | + cd->pyarg, ni->dni_note, ni->dni_size); |
| | | + break; |
| | | + case DL_NOTE_PHYS_ADDR: |
| | | + arglist = Py_BuildValue("(OIs#)", |
| | | + cd->pyarg, ni->dni_note, ni->dni_physaddr, |
| | | + ni->dni_physaddrlen); |
| | | + break; |
| | | + default: |
| | | + arglist = Py_BuildValue("(OIO)", cd->pyarg, ni->dni_note, |
| | | + Py_None); |
| | | + } |
| | | + |
| | | + result = PyEval_CallObject(cd->pyfunc, arglist); |
| | | + Py_DECREF(arglist); |
| | | + if (result == NULL) { |
| | | + PyErr_Clear(); /* cannot raise error */ |
| | | + } |
| | | + Py_DECREF(result); |
| | | + Py_DECREF(cd->pyfunc); |
| | | + Py_XDECREF(cd->pyarg); |
| | | + free(cd); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(enabnotify_doc, |
| | | + "enabnotify(events, function[, arg]) -> unsigned long\n" |
| | | + "\n" |
| | | + "Enables a notification callback for the set of specified events,\n" |
| | | + "which must be one or more (by a logical OR) events listed as below:\n" |
| | | + "NOTE_LINK_DOWN Notify when link has gone down\n" |
| | | + "NOTE_LINK_UP Notify when link has come up\n" |
| | | + "NOTE_PHYS_ADDR Notify when address changes\n" |
| | | + "NOTE_SDU_SIZE Notify when MTU changes\n" |
| | | + "NOTE_SPEED Notify when speed changes\n" |
| | | + "NOTE_PROMISC_ON_PHYS Notify when PROMISC_PHYS is set\n" |
| | | + "NOTE_PROMISC_OFF_PHYS Notify when PROMISC_PHYS is cleared\n" |
| | | + "Returns a handle for this registration.\n" |
| | | + "See dlpi_enabnotify(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_enabnotify(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + PyObject *func = NULL, *arg = NULL; |
| | | + callback_data_t *cd; |
| | | + uint_t notes = 0; |
| | | + static char *keywords[] = {"events", "function", "arg", NULL}; |
| | | + dlpi_notifyid_t id; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "IO|O", |
| | | + keywords, ¬es, &func, &arg)) |
| | | + return (NULL); |
| | | + |
| | | + if (!PyCallable_Check(func)) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + cd = malloc(sizeof(callback_data_t)); |
| | | + if (cd == NULL) { |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + Py_INCREF(func); |
| | | + Py_XINCREF(arg); |
| | | + cd->pyfunc = func; |
| | | + cd->pyarg = arg; |
| | | + |
| | | + if ((rval = dlpi_enabnotify(link->dlpihdl, notes, dlpi_callback, |
| | | + cd, &id)) != DLPI_SUCCESS) { |
| | | + free(cd); |
| | | + Py_DECREF(func); |
| | | + Py_XDECREF(arg); |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("k", id)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(disabnotify_doc, |
| | | + "disabnotify(handle) -> argument object, or None\n" |
| | | + "\n" |
| | | + "Disables the notification registration associated with handle.\n" |
| | | + "You should get this handle by calling enabnotify().\n" |
| | | + "Returns the argument passed in when registering the callback, or None.\n" |
| | | + "See dlpi_disabnotify(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_disabnotify(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + dlpi_notifyid_t id; |
| | | + callback_data_t *arg; |
| | | + PyObject *pyargsaved; |
| | | + static char *keywords[] = {"handle", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "k", keywords, &id)) |
| | | + return (NULL); |
| | | + |
| | | + if ((rval = dlpi_disabnotify(link->dlpihdl, id, (void **)&arg)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + /* clean up */ |
| | | + pyargsaved = arg->pyarg; |
| | | + Py_XINCREF(pyargsaved); |
| | | + Py_XDECREF(arg->pyarg); |
| | | + Py_DECREF(arg->pyfunc); |
| | | + free(arg); |
| | | + |
| | | + if (pyargsaved != NULL) |
| | | + return (pyargsaved); |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_sap_doc, |
| | | + "get_sap() -> unsigned int\n" |
| | | + "\n" |
| | | + "Returns the sap bound to this link.\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_sap(pylink_t *link) |
| | | +{ |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("I", info.di_sap)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_fd_doc, |
| | | + "get_fd() -> int\n" |
| | | + "\n" |
| | | + "Returns the integer file descriptor that can be used to directly\n" |
| | | + "operate on the link.\n" |
| | | + "See dlpi_fd(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_fd(pylink_t *link) |
| | | +{ |
| | | + int fd; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((fd = dlpi_fd(link->dlpihdl)) == -1) { |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("i", fd)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_linkname_doc, |
| | | + "get_linkname() -> string\n" |
| | | + "\n" |
| | | + "Returns the name of the link.\n" |
| | | + "See dlpi_linkname(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_linkname(pylink_t *link) |
| | | +{ |
| | | + const char *name = NULL; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((name = dlpi_linkname(link->dlpihdl)) == NULL) { |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("s", name)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_bcastaddr_doc, |
| | | + "get_bcastaddr() -> string, or None\n" |
| | | + "\n" |
| | | + "Returns the broadcast address of the link.\n" |
| | | + "Returns None if the broadcast address is empty.\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_bcastaddr(pylink_t *link) |
| | | +{ |
| | | + char *addr[DLPI_PHYSADDR_MAX]; |
| | | + size_t addrlen = 0; |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (info.di_bcastaddrlen == 0) { |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("s#", info.di_bcastaddr, info.di_bcastaddrlen)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_physaddr_doc, |
| | | + "get_physaddr(addrtype) -> string, or None\n" |
| | | + "\n" |
| | | + "Addrtype can be any one of the value listed below:\n" |
| | | + "FACT_PHYS_ADDR Factory physical address\n" |
| | | + "CURR_PHYS_ADDR Current physical address\n" |
| | | + "Returns the corresponding physical address of the link.\n" |
| | | + "See dlpi_get_physaddr(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_physaddr(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + char *addr[DLPI_PHYSADDR_MAX]; |
| | | + size_t addrlen = DLPI_PHYSADDR_MAX; |
| | | + static char *keywords[] = {"addrtype", NULL}; |
| | | + uint_t type; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &type)) |
| | | + return (NULL); |
| | | + |
| | | + if ((rval = dlpi_get_physaddr(link->dlpihdl, type, addr, &addrlen)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("s#", addr, addrlen)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(set_physaddr_doc, |
| | | + "set_physaddr(address) -> None\n" |
| | | + "\n" |
| | | + "Sets the physical address of the link.\n" |
| | | + "See dlpi_set_physaddr(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_set_physaddr(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + char *addr = NULL; |
| | | + size_t addrlen = 0; |
| | | + static char *keywords[] = {"address", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords, |
| | | + &addr, &addrlen)) |
| | | + return (NULL); |
| | | + |
| | | + if ((rval = dlpi_set_physaddr(link->dlpihdl, DL_CURR_PHYS_ADDR, |
| | | + addr, addrlen)) != DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(promiscon_doc, |
| | | + "promiscon([level]) -> None\n" |
| | | + "\n" |
| | | + "Enables promiscuous mode for the link at levels:\n" |
| | | + "PROMISC_PHYS Promiscuous mode at the physical level(default)\n" |
| | | + "PROMISC_SAP Promiscuous mode at the SAP level\n" |
| | | + "PROMISC_MULTI Promiscuous mode for all multicast addresses\n" |
| | | + "See dlpi_promiscon(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_promiscon(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + uint_t level = DL_PROMISC_PHYS; |
| | | + static char *keywords[] = {"level", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|I", keywords, &level)) |
| | | + return (NULL); |
| | | + |
| | | + if ((rval = dlpi_promiscon(link->dlpihdl, level)) != DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(promiscoff_doc, |
| | | + "promiscoff([level]) -> None\n" |
| | | + "\n" |
| | | + "Disables promiscuous mode for the link at levels:\n" |
| | | + "PROMISC_PHYS Promiscuous mode at the physical level(default)\n" |
| | | + "PROMISC_SAP Promiscuous mode at the SAP level\n" |
| | | + "PROMISC_MULTI Promiscuous mode for all multicast addresses\n" |
| | | + "See dlpi_promiscoff(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_promiscoff(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + uint_t level = DL_PROMISC_PHYS; |
| | | + static char *keywords[] = {"level", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|I", keywords, &level)) |
| | | + return (NULL); |
| | | + |
| | | + if ((rval = dlpi_promiscoff(link->dlpihdl, level)) != DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_timeout_doc, |
| | | + "get_timeout() -> int\n" |
| | | + "\n" |
| | | + "Returns current time out value of the link.\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_timeout(pylink_t *link) |
| | | +{ |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("i", info.di_timeout)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_mactype_doc, |
| | | + "get_mactype() -> unsigned char\n" |
| | | + "\n" |
| | | + "Returns MAC type of the link.\n" |
| | | + "See <sys/dlpi.h> for the list of possible MAC types.\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_mactype(pylink_t *link) |
| | | +{ |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("B", info.di_mactype)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(set_timeout_doc, |
| | | + "set_timeout(timeout) -> None\n" |
| | | + "\n" |
| | | + "Sets time out value of the link (default value: DEF_TIMEOUT).\n" |
| | | + "See dlpi_set_timeout(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_set_timeout(pylink_t *link, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + int timeout = DLPI_DEF_TIMEOUT; |
| | | + static char *keywords[] = {"timeout", NULL}; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", keywords, &timeout)) |
| | | + return (NULL); |
| | | + |
| | | + if ((rval = dlpi_set_timeout(link->dlpihdl, timeout)) != DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + Py_INCREF(Py_None); |
| | | + return (Py_None); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_sdu_doc, |
| | | + "get_sdu() -> (unsigned int, unsigned int)\n" |
| | | + "\n" |
| | | + "Returns (min sdu, max sdu).\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_sdu(pylink_t *link) |
| | | +{ |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("II", info.di_min_sdu, info.di_max_sdu)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_state_doc, |
| | | + "get_state() -> unsigned int\n" |
| | | + "\n" |
| | | + "Returns current state of the link (either UNBOUND or IDLE).\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_state(pylink_t *link) |
| | | +{ |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("I", info.di_state)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_qos_select_doc, |
| | | + "get_qos_select() -> (unsigned int, int, int, int)\n" |
| | | + "\n" |
| | | + "Returns (qos type, trans delay, priority, residul err).\n" |
| | | + "Unsupported QOS parameters are set to UNKNOWN.\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_qos_select(pylink_t *link) |
| | | +{ |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("Iiiii", |
| | | + info.di_qos_sel.dl_qos_type, |
| | | + info.di_qos_sel.dl_trans_delay, |
| | | + info.di_qos_sel.dl_priority, |
| | | + info.di_qos_sel.dl_residual_error)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(get_qos_range_doc, |
| | | + "get_qos_range() -> \n" |
| | | + " (unsigned int, (int, int), (int, int), (int, int), int)\n" |
| | | + "\n" |
| | | + "Returns (qos type, (trans delay target, trans delay accept),\n" |
| | | + "(min priority, max priority), (min protection, max protection),\n" |
| | | + "residual err).\n" |
| | | + "Unsupported QOS range values are set to UNKNOWN.\n" |
| | | + "See dlpi_info(3DLPI).\n" |
| | | +); |
| | | +static PyObject * |
| | | +link_get_qos_range(pylink_t *link) |
| | | +{ |
| | | + dlpi_info_t info; |
| | | + int rval; |
| | | + |
| | | + if (link->dlpihdl == NULL) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) != |
| | | + DLPI_SUCCESS) { |
| | | + dlpi_raise_exception(rval); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("I(ii)(ii)(ii)i", |
| | | + info.di_qos_range.dl_qos_type, |
| | | + info.di_qos_range.dl_trans_delay.dl_target_value, |
| | | + info.di_qos_range.dl_trans_delay.dl_accept_value, |
| | | + info.di_qos_range.dl_priority.dl_min, |
| | | + info.di_qos_range.dl_priority.dl_max, |
| | | + info.di_qos_range.dl_protection.dl_min, |
| | | + info.di_qos_range.dl_protection.dl_max, |
| | | + info.di_qos_range.dl_residual_error)); |
| | | +} |
| | | + |
| | | +static PyMethodDef pylink_methods[] = { |
| | | + {"bind", (PyCFunction)link_bind, METH_VARARGS|METH_KEYWORDS, bind_doc}, |
| | | + {"unbind", (PyCFunction)link_unbind, METH_NOARGS, unbind_doc}, |
| | | + {"send", (PyCFunction)link_send, METH_VARARGS|METH_KEYWORDS, |
| | | + send_doc}, |
| | | + {"recv", (PyCFunction)link_recv, METH_VARARGS|METH_KEYWORDS, |
| | | + recv_doc}, |
| | | + {"disabmulti", (PyCFunction)link_disabmulti, METH_VARARGS|METH_KEYWORDS, |
| | | + disabmulti_doc}, |
| | | + {"enabmulti", (PyCFunction)link_enabmulti, METH_VARARGS|METH_KEYWORDS, |
| | | + enabmulti_doc}, |
| | | + {"enabnotify", (PyCFunction)link_enabnotify, |
| | | + METH_VARARGS|METH_KEYWORDS, enabnotify_doc}, |
| | | + {"disabnotify", (PyCFunction)link_disabnotify, |
| | | + METH_VARARGS|METH_KEYWORDS, disabnotify_doc}, |
| | | + {"get_fd", (PyCFunction)link_get_fd, METH_NOARGS, get_fd_doc}, |
| | | + {"get_sap", (PyCFunction)link_get_sap, METH_NOARGS, get_sap_doc}, |
| | | + {"get_mactype", (PyCFunction)link_get_mactype, METH_NOARGS, |
| | | + get_mactype_doc}, |
| | | + {"get_linkname", (PyCFunction)link_get_linkname, METH_NOARGS, |
| | | + get_linkname_doc}, |
| | | + {"get_bcastaddr", (PyCFunction)link_get_bcastaddr, METH_NOARGS, |
| | | + get_bcastaddr_doc}, |
| | | + {"get_physaddr", (PyCFunction)link_get_physaddr, |
| | | + METH_VARARGS|METH_KEYWORDS, get_physaddr_doc}, |
| | | + {"set_physaddr", (PyCFunction)link_set_physaddr, |
| | | + METH_VARARGS|METH_KEYWORDS, set_physaddr_doc}, |
| | | + {"promiscon", (PyCFunction)link_promiscon, METH_VARARGS|METH_KEYWORDS, |
| | | + promiscon_doc}, |
| | | + {"promiscoff", (PyCFunction)link_promiscoff, METH_VARARGS|METH_KEYWORDS, |
| | | + promiscoff_doc}, |
| | | + {"get_timeout", (PyCFunction)link_get_timeout, METH_NOARGS, |
| | | + get_timeout_doc}, |
| | | + {"set_timeout", (PyCFunction)link_set_timeout, |
| | | + METH_VARARGS|METH_KEYWORDS, set_timeout_doc}, |
| | | + {"get_sdu", (PyCFunction)link_get_sdu, METH_NOARGS, get_sdu_doc}, |
| | | + {"get_state", (PyCFunction)link_get_state, METH_NOARGS, |
| | | + get_state_doc}, |
| | | + {"get_qos_select", (PyCFunction)link_get_qos_select, METH_NOARGS, |
| | | + get_qos_select_doc}, |
| | | + {"get_qos_range", (PyCFunction)link_get_qos_range, METH_NOARGS, |
| | | + get_qos_range_doc}, |
| | | + {NULL, NULL} |
| | | +}; |
| | | + |
| | | +static PyTypeObject pylink_type = { |
| | | + PyVarObject_HEAD_INIT(NULL, 0) /* Must fill in type value later */ |
| | | + "dlpi.link", /* tp_name */ |
| | | + sizeof(pylink_t), /* tp_basicsize */ |
| | | + 0, /* tp_itemsize */ |
| | | + (destructor)link_dealloc, /* tp_dealloc */ |
| | | + 0, /* tp_print */ |
| | | + 0, /* tp_getattr */ |
| | | + 0, /* tp_setattr */ |
| | | + 0, /* tp_reserved */ |
| | | + 0, /* tp_repr */ |
| | | + 0, /* tp_as_number */ |
| | | + 0, /* tp_as_sequence */ |
| | | + 0, /* tp_as_mapping */ |
| | | + 0, /* tp_hash */ |
| | | + 0, /* tp_call */ |
| | | + 0, /* tp_str */ |
| | | + 0, /* tp_getattro */ |
| | | + 0, /* tp_setattro */ |
| | | + 0, /* tp_as_buffer */ |
| | | + Py_TPFLAGS_DEFAULT, /* tp_flags */ |
| | | + link_doc, /* tp_doc */ |
| | | + 0, /* tp_traverse */ |
| | | + 0, /* tp_clear */ |
| | | + 0, /* tp_richcompare */ |
| | | + 0, /* tp_weaklistoffset */ |
| | | + 0, /* tp_iter */ |
| | | + 0, /* tp_iternext */ |
| | | + pylink_methods, /* tp_methods */ |
| | | + 0, /* tp_members */ |
| | | + 0, /* tp_getset */ |
| | | + 0, /* tp_base */ |
| | | + 0, /* tp_dict */ |
| | | + 0, /* tp_descr_get */ |
| | | + 0, /* tp_descr_set */ |
| | | + 0, /* tp_dictoffset */ |
| | | + (initproc)link_init, /* tp_init */ |
| | | + 0, /* tp_alloc */ |
| | | + PyType_GenericNew, /* tp_new */ |
| | | + 0, /* tp_free */ |
| | | + 0, /* tp_is_gc */ |
| | | +}; |
| | | + |
| | | +PyDoc_STRVAR(arptype_doc, |
| | | + "arptype(arptype) -> unsigned int\n" |
| | | + "\n" |
| | | + "Converts a DLPI MAC type to an ARP hardware type defined\n" |
| | | + " in <netinet/arp.h>\n" |
| | | + "See dlpi_arptype(3DLPI)\n" |
| | | +); |
| | | +static PyObject * |
| | | +arptype(PyObject *dlpi, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + static char *keywords[] = {"arptype", NULL}; |
| | | + uint_t dlpityp, arptyp; |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &dlpityp)) |
| | | + return (NULL); |
| | | + |
| | | + if ((arptyp = dlpi_arptype(dlpityp)) == 0) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("I", arptyp)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(iftype_doc, |
| | | + "iftype(iftype) -> unsigned int\n" |
| | | + "\n" |
| | | + "Converts a DLPI MAC type to a BSD socket interface type\n" |
| | | + "defined in <net/if_types.h>\n" |
| | | + "See dlpi_iftype(3DLPI)\n" |
| | | +); |
| | | +static PyObject * |
| | | +iftype(PyObject *dlpi, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + static char *keywords[] = {"iftype", NULL}; |
| | | + uint_t dlpityp, iftyp; |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &dlpityp)) |
| | | + return (NULL); |
| | | + |
| | | + if ((iftyp = dlpi_iftype(dlpityp)) == 0) { |
| | | + errno = EINVAL; |
| | | + dlpi_raise_exception(DL_SYSERR); |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + return (Py_BuildValue("I", iftyp)); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(mactype_doc, |
| | | + "mactype(mactype) -> string\n" |
| | | + "\n" |
| | | + "Returns a string that describes the specified mactype.\n" |
| | | + "Valid mac types are defined in <sys/dlpi.h>.\n" |
| | | + "See dlpi_mactype(3DLPI)\n" |
| | | +); |
| | | +static PyObject * |
| | | +mactype(PyObject *dlpi, PyObject *args, PyObject *kwds) |
| | | +{ |
| | | + static char *keywords[] = {"mactype", NULL}; |
| | | + uint_t mactyp; |
| | | + |
| | | + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &mactyp)) |
| | | + return (NULL); |
| | | + |
| | | + return (Py_BuildValue("s", dlpi_mactype(mactyp))); |
| | | +} |
| | | + |
| | | +static boolean_t |
| | | +link_walker(const char *name, void *arg) |
| | | +{ |
| | | + PyObject *linkname; |
| | | + PyObject *list = (PyObject *)arg; |
| | | + |
| | | + if ((list == NULL) || !PyList_Check(list)) |
| | | + return (B_FALSE); |
| | | + |
| | | + linkname = Py_BuildValue("s", name); |
| | | + if (PyList_Append(list, linkname) == -1) |
| | | + return (B_TRUE); |
| | | + |
| | | + Py_DECREF(linkname); |
| | | + return (B_FALSE); |
| | | +} |
| | | + |
| | | +PyDoc_STRVAR(listlink_doc, |
| | | + "listlink() -> list\n" |
| | | + "\n" |
| | | + "Returns a list containing link names of all links on the system.\n" |
| | | +); |
| | | +static PyObject * |
| | | +listlink(PyObject *dlpi) |
| | | +{ |
| | | + PyObject *list; |
| | | + |
| | | + if ((list = PyList_New(0)) == NULL) |
| | | + return (NULL); |
| | | + |
| | | + dlpi_walk(link_walker, list, 0); |
| | | + return (list); |
| | | +} |
| | | + |
| | | +static PyMethodDef dlpi_methods[] = { |
| | | + {"arptype", (PyCFunction)arptype, METH_VARARGS|METH_KEYWORDS, |
| | | + arptype_doc}, |
| | | + {"iftype", (PyCFunction)iftype, METH_VARARGS|METH_KEYWORDS, |
| | | + iftype_doc}, |
| | | + {"mactype", (PyCFunction)mactype, METH_VARARGS|METH_KEYWORDS, |
| | | + mactype_doc}, |
| | | + {"listlink", (PyCFunction)listlink, METH_NOARGS, listlink_doc}, |
| | | + {NULL} |
| | | +}; |
| | | + |
| | | +PyMODINIT_FUNC |
| | | +PyInit_dlpi (void) |
| | | +{ |
| | | + PyObject *mod; |
| | | + |
| | | + if (PyType_Ready(&pylink_type) < 0) |
| | | + return NULL; |
| | | + |
| | | + static struct PyModuleDef moduledef = { |
| | | + PyModuleDef_HEAD_INIT, |
| | | + "dlpi", |
| | | + NULL, |
| | | + -1, |
| | | + dlpi_methods, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + }; |
| | | + |
| | | + mod = PyModule_Create(&moduledef); |
| | | + if (mod == NULL) |
| | | + return NULL; |
| | | + |
| | | + dlpi_err = PyErr_NewException("dlpi.error", NULL, NULL); |
| | | + if (dlpi_err == NULL) |
| | | + return NULL; |
| | | + PyModule_AddObject(mod, "error", dlpi_err); |
| | | + |
| | | + Py_INCREF(&pylink_type); |
| | | + PyModule_AddObject(mod, "link", (PyObject *)&pylink_type); |
| | | + PyModule_AddIntConstant(mod, "PASSIVE", DLPI_PASSIVE); |
| | | + PyModule_AddIntConstant(mod, "RAW", DLPI_RAW); |
| | | + PyModule_AddIntConstant(mod, "NATIVE", DLPI_NATIVE); |
| | | + PyModule_AddIntConstant(mod, "ANY_SAP", DLPI_ANY_SAP); |
| | | + PyModule_AddIntConstant(mod, "DEF_TIMEOUT", DLPI_DEF_TIMEOUT); |
| | | + PyModule_AddIntConstant(mod, "NOTE_LINK_DOWN", DL_NOTE_LINK_DOWN); |
| | | + PyModule_AddIntConstant(mod, "NOTE_LINK_UP", DL_NOTE_LINK_UP); |
| | | + PyModule_AddIntConstant(mod, "NOTE_PHYS_ADDR", DL_NOTE_PHYS_ADDR); |
| | | + PyModule_AddIntConstant(mod, "NOTE_SDU_SIZE", DL_NOTE_SDU_SIZE); |
| | | + PyModule_AddIntConstant(mod, "NOTE_SPEED", DL_NOTE_SPEED); |
| | | + PyModule_AddIntConstant(mod, "NOTE_PROMISC_ON_PHYS", |
| | | + DL_NOTE_PROMISC_ON_PHYS); |
| | | + PyModule_AddIntConstant(mod, "NOTE_PROMISC_OFF_PHYS", |
| | | + DL_NOTE_PROMISC_OFF_PHYS); |
| | | + PyModule_AddIntConstant(mod, "FACT_PHYS_ADDR", DL_FACT_PHYS_ADDR); |
| | | + PyModule_AddIntConstant(mod, "CURR_PHYS_ADDR", DL_CURR_PHYS_ADDR); |
| | | + PyModule_AddIntConstant(mod, "PROMISC_PHYS", DL_PROMISC_PHYS); |
| | | + PyModule_AddIntConstant(mod, "PROMISC_SAP", DL_PROMISC_SAP); |
| | | + PyModule_AddIntConstant(mod, "PROMISC_MULTI", DL_PROMISC_MULTI); |
| | | + PyModule_AddIntConstant(mod, "UNKNOWN", DL_UNKNOWN); |
| | | + PyModule_AddIntConstant(mod, "UNBOUND", DL_UNBOUND); |
| | | + PyModule_AddIntConstant(mod, "IDLE", DL_IDLE); |
| | | + PyModule_AddIntConstant(mod, "SYSERR", DL_SYSERR); |
| | | + |
| | | + return mod; |
| | | +} |
| | | --- Python-3.4.0/setup.py.~4~ 2014-03-19 10:45:51.118227834 -0700 |
| | | +++ Python-3.4.0/setup.py 2014-03-19 10:45:51.146201564 -0700 |
| | | @@ -1474,6 +1474,12 @@ |
| | | exts.append( Extension('ucred', ['ucred.c'], |
| | | libraries = ['tsol']) ) |
| | | |
| | | + # dlpi module (Solaris) |
| | | + dlpi_inc = find_file('libdlpi.h', [], inc_dirs) |
| | | + if dlpi_inc is not None: |
| | | + exts.append( Extension('dlpi', ['dlpimodule.c'], |
| | | + libraries = ['dlpi']) ) |
| | | + |
| | | # Thomas Heller's _ctypes module |
| | | self.detect_ctypes(inc_dirs, lib_dirs) |
| | | |
| | | diff --git Python-2.6.4/lib/test/dlpitest.py Python-2.6.4/Lib/test/dlpitest.py |
| | | new file mode 100644 |
| | | --- /dev/null 2011-02-12 03:13:26.000000000 -0600 |
| | | +++ Python-2.6.4/Lib/test/dlpitest.py 2011-01-20 13:52:42.895865414 -0600 |
| | | @@ -0,0 +1,96 @@ |
| | | +#!/usr/bin/python3.4 |
| | | + |
| | | +import dlpi |
| | | +import sys |
| | | +import time |
| | | +import struct |
| | | + |
| | | +#test listlink |
| | | +linklist = dlpi.listlink() |
| | | +print("Found %d links:" % len(linklist)) |
| | | +print(linklist) |
| | | + |
| | | +#pick up the first data link for below testing |
| | | +linkname = linklist[0] |
| | | + |
| | | +#open link |
| | | +print("opening link: " + linkname + "...") |
| | | +testlink = dlpi.link(linkname) |
| | | + |
| | | +#read some info of testlink |
| | | +print("linkname is %s" % testlink.get_linkname()) |
| | | +print("link fd is %d" % testlink.get_fd()) |
| | | +mactype = testlink.get_mactype() |
| | | +print("dlpi mactype is %d" % mactype) |
| | | +print("after convert:") |
| | | +print("\tmactype is %s" % dlpi.mactype(mactype)) |
| | | +print("\tiftype is %d" % dlpi.iftype(mactype)) |
| | | +print("\tarptype is %d" % dlpi.arptype(mactype)) |
| | | +bcastaddr = testlink.get_bcastaddr() |
| | | +print("broadcast addr is: ", end=' ') |
| | | +print(struct.unpack("BBBBBB",bcastaddr)) |
| | | +physaddr = testlink.get_physaddr(dlpi.FACT_PHYS_ADDR) |
| | | +print("factory physical address is: ", end=' ') |
| | | +print(struct.unpack("BBBBBB",physaddr)) |
| | | +print("current timeout value is %d" % testlink.get_timeout()) |
| | | +print("sdu is:", end=' ') |
| | | +print(testlink.get_sdu()) |
| | | +print("qos select is:", end=' ') |
| | | +print(testlink.get_qos_select()) |
| | | +print("qos range is:", end=' ') |
| | | +print(testlink.get_qos_range()) |
| | | + |
| | | +#set some config value of testlink and read them again |
| | | +print("setting current physiacal addr to aa:0:10:13:27:5") |
| | | +testlink.set_physaddr('\xaa\0\x10\x13\x27\5') |
| | | +physaddr = testlink.get_physaddr(dlpi.CURR_PHYS_ADDR) |
| | | +print("current physical addr is: ", end=' ') |
| | | +print(struct.unpack("BBBBBB",physaddr)) |
| | | +print("set timeout value to 6...") |
| | | +testlink.set_timeout(6) |
| | | +print("timeout value is %d" % testlink.get_timeout()) |
| | | + |
| | | +#test enable/disable multicast |
| | | +print("enable/disable multicast address 1:0:5e:0:0:5") |
| | | +testlink.enabmulti('\1\0\x5e\0\0\5') |
| | | +testlink.disabmulti('\1\0\x5e\0\0\5') |
| | | + |
| | | +#test bind |
| | | +print("binding to SAP 0x9000...") |
| | | +testlink.bind(0x9000) |
| | | +print("sap is %x" % testlink.get_sap()) |
| | | +print("state is: %d" % testlink.get_state()) |
| | | + |
| | | +#test send |
| | | +print("sending broadcast loopback packet...") |
| | | +testlink.send(bcastaddr, '\0\1\2\3\4\5') |
| | | + |
| | | +#test notify functionality |
| | | +arg = "notification callback arg" |
| | | +def notify(arg, notes, value): |
| | | + print("NOTE_PROMISC_ON_PHYS notification received with arg: '%s'" % arg) |
| | | +print("enabled notification on NOTE_PROMISC_ON_PHYS") |
| | | +id = testlink.enabnotify(dlpi.NOTE_PROMISC_ON_PHYS, notify, arg) #enable notification |
| | | +testlink.promiscon() #trigger the event (will be seen while receiving pkt below) |
| | | + |
| | | +#test receive |
| | | +print("testing receiving...") |
| | | +try: |
| | | + testlink.recv(0, 0) #should see NOTE_PROMISC_ON_PHYS event here |
| | | +except dlpi.error as err: |
| | | + errnum, errinfo = err |
| | | + if errnum == 10006: |
| | | + pass #timeout error is expected here |
| | | + else: #test fails if reach here |
| | | + print("test failed", end=' ') |
| | | + print(errnum, end=' ') |
| | | + print(err) |
| | | + |
| | | +testlink.promiscoff() |
| | | +testlink.disabnotify(id) #disable notification |
| | | + |
| | | +#test unbind |
| | | +print("unbinding...") |
| | | +testlink.unbind() |
| | | +print("sap is %x" % testlink.get_sap()) |
| | | +print("state is: %d" % testlink.get_state()) |
New file |
| | |
| | | Add missing encoding aliases. It may be contributed upstream at some point, |
| | | but the suitability (or lack thereof) has not yet been determined. |
| | | |
| | | --- Python-3.4.0/Lib/encodings/aliases.py.~1~ 2014-03-16 19:31:29.000000000 -0700 |
| | | +++ Python-3.4.0/Lib/encodings/aliases.py 2014-03-17 13:26:52.837734374 -0700 |
| | | @@ -79,6 +79,7 @@ |
| | | |
| | | # cp1251 codec |
| | | '1251' : 'cp1251', |
| | | + 'ansi_1251' : 'cp1251', |
| | | 'windows_1251' : 'cp1251', |
| | | |
| | | # cp1252 codec |
| | | @@ -233,6 +234,7 @@ |
| | | 'u_jis' : 'euc_jp', |
| | | |
| | | # euc_kr codec |
| | | + '5601' : 'euc_kr', |
| | | 'euckr' : 'euc_kr', |
| | | 'korean' : 'euc_kr', |
| | | 'ksc5601' : 'euc_kr', |
| | | @@ -474,6 +476,7 @@ |
| | | 'shiftjis' : 'shift_jis', |
| | | 'sjis' : 'shift_jis', |
| | | 's_jis' : 'shift_jis', |
| | | + 'pck' : 'shift_jis', |
| | | |
| | | # shift_jis_2004 codec |
| | | 'shiftjis2004' : 'shift_jis_2004', |
| | | @@ -493,6 +496,7 @@ |
| | | 'tis_620_0' : 'tis_620', |
| | | 'tis_620_2529_0' : 'tis_620', |
| | | 'tis_620_2529_1' : 'tis_620', |
| | | + 'tis620.2533' : 'tis_620', |
| | | 'iso_ir_166' : 'tis_620', |
| | | |
| | | # utf_16 codec |
New file |
| | |
| | | This patch provides Python RBAC support. It may be contributed upstream at |
| | | some point, but the suitability (or lack thereof) has not yet been determined. |
| | | |
| | | diff --git Python-2.6.4/Modules/authattr.c Python-2.6.4/Modules/authattr.c |
| | | new file mode 100644 |
| | | --- /dev/null |
| | | +++ Python-2.6.4/Modules/authattr.c |
| | | @@ -0,0 +1,261 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | + |
| | | +/* |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +/* |
| | | + * RBAC Bindings for Python - auth_attr functions |
| | | + */ |
| | | + |
| | | +#include <auth_attr.h> |
| | | +#include "Python.h" |
| | | +#include "pyrbac.h" |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_setauthattr(PyObject* self, PyObject* args) { |
| | | + setauthattr(); |
| | | + return Py_None; |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_endauthattr(PyObject* self, PyObject* args) { |
| | | + endauthattr(); |
| | | + return Py_None; |
| | | +} |
| | | + |
| | | +PyObject* |
| | | +pyrbac_getauthnamattr(PyObject* self, char* authname, int mode) { |
| | | + |
| | | + |
| | | + |
| | | + authattr_t * ret_authattr = (mode == PYRBAC_NAM_MODE) ? getauthnam(authname) : getauthattr(); |
| | | + if (ret_authattr == NULL) |
| | | + return Py_None; |
| | | + |
| | | + PyObject* kv_data = PyDict_New(); |
| | | + if (kv_data == NULL) { |
| | | + free_authattr(ret_authattr); |
| | | + return NULL; |
| | | + } |
| | | + |
| | | + if(ret_authattr->attr != NULL) { |
| | | + int len; |
| | | + for(len = 0; len < ret_authattr->attr->length; len++) { |
| | | + kv_t current = ret_authattr->attr->data[len]; |
| | | + |
| | | + PyObject* set = PyList_New(NULL); |
| | | + char* saveptr; |
| | | + char* item = strtok_r(current.value, ",", &saveptr); |
| | | + PyList_Append(set, PyBytes_FromString(item)); |
| | | + |
| | | + while((item = strtok_r(NULL, ",", &saveptr)) != NULL) { |
| | | + if(PyList_Append(set, PyBytes_FromString(item)) != 0) { |
| | | + Py_XDECREF(set); |
| | | + Py_XDECREF(kv_data); |
| | | + free_authattr(ret_authattr); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + if(PyDict_SetItemString(kv_data, current.key, set)) { |
| | | + free_authattr(ret_authattr); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + } |
| | | + PyObject * retval = Py_BuildValue("{s:s,s:s,s:s,s:s,s:s,s:O}", |
| | | + "name",ret_authattr->name, |
| | | + "res1",ret_authattr->res1, |
| | | + "res2",ret_authattr->res2, |
| | | + "short",ret_authattr->short_desc, |
| | | + "long",ret_authattr->long_desc, |
| | | + "attributes",kv_data); |
| | | + |
| | | + free_authattr(ret_authattr); |
| | | + return retval; |
| | | + |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_getauthattr(PyObject* self, PyObject* args) { |
| | | + return(pyrbac_getauthnamattr(self, NULL, PYRBAC_ATTR_MODE)); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_getauthnam(PyObject* self, PyObject* args) { |
| | | + char* name = NULL; |
| | | + if(!PyArg_ParseTuple(args, "s:getauthnam", &name)) |
| | | + return NULL; |
| | | + return(pyrbac_getauthnamattr(self, name, PYRBAC_NAM_MODE)); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyrbac_chkauthattr(PyObject* self, PyObject* args) { |
| | | + char* authstring = NULL; |
| | | + char* username = NULL; |
| | | + if(!PyArg_ParseTuple(args, "ss:chkauthattr", &authstring, &username)) |
| | | + return NULL; |
| | | + return PyBool_FromLong((long)chkauthattr(authstring, username)); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_authattr_next(PyObject* self, PyObject* args) { |
| | | + PyObject* retval = pyrbac_getauthattr(self, args); |
| | | + if( retval == Py_None ) { |
| | | + setauthattr(); |
| | | + return NULL; |
| | | + } |
| | | + return retval; |
| | | +} |
| | | +static PyObject* |
| | | +pyrbac_authattr__iter__(PyObject* self, PyObject* args) { |
| | | + return self; |
| | | +} |
| | | + |
| | | +typedef struct { |
| | | + PyObject_HEAD |
| | | +} Authattr; |
| | | + |
| | | +static void |
| | | +Authattr_dealloc(Authattr* self) { |
| | | + endauthattr(); |
| | | + Py_TYPE(self)->tp_free((PyObject*) self); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +Authattr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { |
| | | + Authattr *self; |
| | | + self = (Authattr*)type->tp_alloc(type, 0); |
| | | + |
| | | + return ((PyObject *) self); |
| | | +} |
| | | + |
| | | +static int |
| | | +Authattr_init(Authattr* self, PyObject *args, PyObject *kwargs) { |
| | | + setauthattr(); |
| | | + return 0; |
| | | +} |
| | | + |
| | | +static char pyrbac_authattr__doc__[]; |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_authattr__doc__, """provides interfaces to the auth_attr \ |
| | | +database. may be iterated over to return all auth_attr entries\n\n\ |
| | | +Methods provided:\n\ |
| | | +setauthattr\n\ |
| | | +endauthattr\n\ |
| | | +getauthattr\n\ |
| | | +chkauthattr\n\ |
| | | +getauthnam"""); |
| | | + |
| | | +static char pyrbac_setauthattr__doc__[]; |
| | | +static char pyrbac_endauthattr__doc__[]; |
| | | +static char pyrbac_getauthattr__doc__[]; |
| | | +static char pyrbac_chkauthattr__doc__[]; |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_setauthattr__doc__, |
| | | +"\"rewinds\" the auth_attr functions to the first entry in the db. Called \ |
| | | +automatically by the constructor\n\tArguments: None\n\tReturns: None"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_endauthattr__doc__, |
| | | +"closes the auth_attr database, cleans up storage. called automatically by \ |
| | | +the destructor\n\tArguments: None\n\tReturns: None"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_chkauthattr__doc__, "verifies if a user has a given \ |
| | | +authorization.\n\tArguments: 2 Python strings, 'authname' and 'username'\n\ |
| | | +\tReturns: True if the user is authorized, False otherwise"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getauthattr__doc__, |
| | | +"return one entry from the auth_attr database\n\ |
| | | +\tArguments: None\n\ |
| | | +\tReturns: a dict representing the authattr_t struct:\n\ |
| | | +\t\t\"name\": Authorization Name\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"short\": Short Description\n\ |
| | | +\t\t\"long\": Long Description\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \ |
| | | +or a string depending on value"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getauthnam__doc__, |
| | | +"searches the auth_attr database for a given authorization name\n\ |
| | | +\tArguments: a Python string containing the auth name\n\ |
| | | +\tReturns: a dict representing the authattr_t struct:\n\ |
| | | +\t\t\"name\": Authorization Name\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"short\": Short Description\n\ |
| | | +\t\t\"long\": Long Description\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \ |
| | | +or a string depending on value"); |
| | | + |
| | | +static PyMethodDef Authattr_methods[] = { |
| | | + {"setauthattr", pyrbac_setauthattr, METH_NOARGS, pyrbac_setauthattr__doc__}, |
| | | + {"endauthattr", pyrbac_endauthattr, METH_NOARGS, pyrbac_endauthattr__doc__}, |
| | | + {"chkauthattr", pyrbac_chkauthattr, METH_VARARGS, pyrbac_chkauthattr__doc__}, |
| | | + {"getauthattr", pyrbac_getauthattr, METH_NOARGS, pyrbac_getauthattr__doc__}, |
| | | + {"getauthnam", pyrbac_getauthnam, METH_VARARGS, pyrbac_getauthnam__doc__}, |
| | | + {NULL, NULL} |
| | | +}; |
| | | + |
| | | +PyTypeObject AuthattrType = { |
| | | + PyVarObject_HEAD_INIT(NULL, 0) |
| | | + "rbac.authattr", /*tp_name*/ |
| | | + sizeof(Authattr), /*tp_basicsize*/ |
| | | + 0, /*tp_itemsize*/ |
| | | + (destructor)Authattr_dealloc, /*tp_dealloc*/ |
| | | + 0, /*tp_print*/ |
| | | + 0, /*tp_getattr*/ |
| | | + 0, /*tp_setattr*/ |
| | | + 0, /*tp_reserved*/ |
| | | + 0, /*tp_repr*/ |
| | | + 0, /*tp_as_number*/ |
| | | + 0, /*tp_as_sequence*/ |
| | | + 0, /*tp_as_mapping*/ |
| | | + 0, /*tp_hash */ |
| | | + 0, /*tp_call*/ |
| | | + 0, /*tp_str*/ |
| | | + 0, /*tp_getattro*/ |
| | | + 0, /*tp_setattro*/ |
| | | + 0, /*tp_as_buffer*/ |
| | | + Py_TPFLAGS_DEFAULT | |
| | | + Py_TPFLAGS_BASETYPE, /*tp_flags*/ |
| | | + pyrbac_authattr__doc__, /* tp_doc */ |
| | | + 0, /* tp_traverse */ |
| | | + 0, /* tp_clear */ |
| | | + 0, /* tp_richcompare */ |
| | | + 0, /* tp_weaklistoffset */ |
| | | + pyrbac_authattr__iter__, /* tp_iter */ |
| | | + pyrbac_authattr_next, /* tp_iternext */ |
| | | + Authattr_methods, /* tp_methods */ |
| | | + 0, /* tp_members */ |
| | | + 0, /* tp_getset */ |
| | | + 0, /* tp_base */ |
| | | + 0, /* tp_dict */ |
| | | + 0, /* tp_descr_get */ |
| | | + 0, /* tp_descr_set */ |
| | | + 0, /* tp_dictoffset */ |
| | | + (initproc)Authattr_init, /* tp_init */ |
| | | + 0, /* tp_alloc */ |
| | | + Authattr_new, /* tp_new */ |
| | | + 0, /* tp_free */ |
| | | + 0, /* tp_is_gc */ |
| | | +}; |
| | | diff --git Python-2.6.4/Modules/execattr.c Python-2.6.4/Modules/execattr.c |
| | | new file mode 100644 |
| | | --- /dev/null |
| | | +++ Python-2.6.4/Modules/execattr.c |
| | | @@ -0,0 +1,313 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | + |
| | | +/* |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +/* |
| | | + * RBAC Bindings for Python - exec_attr functions |
| | | + */ |
| | | + |
| | | +#include <exec_attr.h> |
| | | +#include "Python.h" |
| | | +#include "pyrbac.h" |
| | | + |
| | | +static PyObject * |
| | | +pyrbac_setexecattr(PyObject* self, PyObject* args) { |
| | | + setexecattr(); |
| | | + return Py_None; |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyrbac_endexecattr(PyObject* self, PyObject* args) { |
| | | + endexecattr(); |
| | | + return Py_None; |
| | | +} |
| | | + |
| | | +PyObject * |
| | | +pyrbac_getexecuserprofattr(PyObject* self, char* userprofname, char* type, char* id, int mode) { |
| | | + |
| | | + PyObject* ep_data = (mode == PYRBAC_ATTR_MODE) ? NULL : PyList_New(0); |
| | | + |
| | | + if (ep_data == NULL && mode != PYRBAC_ATTR_MODE ) |
| | | + return NULL; |
| | | + |
| | | + execattr_t *execprof; |
| | | + if (mode == PYRBAC_USER_MODE) |
| | | + execprof = getexecuser(userprofname, type, id, GET_ALL); |
| | | + else if (mode == PYRBAC_PROF_MODE) |
| | | + execprof = getexecprof(userprofname, type, id, GET_ALL); |
| | | + else if (mode == PYRBAC_ATTR_MODE) |
| | | + execprof = getexecattr(); |
| | | + else |
| | | + return NULL; |
| | | + |
| | | + if (execprof == NULL) |
| | | + return Py_None; |
| | | + |
| | | + execattr_t *execprof_head = execprof; |
| | | + |
| | | + while(execprof != NULL) { |
| | | + |
| | | + PyObject* kv_data = PyDict_New(); |
| | | + |
| | | + if(execprof->attr != NULL) { |
| | | + int len; |
| | | + for(len = 0; len < execprof->attr->length; len++) { |
| | | + kv_t current = execprof->attr->data[len]; |
| | | + |
| | | + PyObject* set = PyList_New(NULL); |
| | | + char* saveptr; |
| | | + char* item = strtok_r(current.value, ",", &saveptr); |
| | | + PyList_Append(set, PyBytes_FromString(item)); |
| | | + |
| | | + while((item = strtok_r(NULL, ",", &saveptr)) != NULL) { |
| | | + if(PyList_Append(set, PyBytes_FromString(item)) != 0) { |
| | | + Py_XDECREF(set); |
| | | + Py_XDECREF(kv_data); |
| | | + free_execattr(execprof_head); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + if(PyDict_SetItemString(kv_data, current.key, set)) { |
| | | + free_execattr(execprof_head); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + } |
| | | + PyObject* entry = Py_BuildValue("{s:s,s:s,s:s,s:s,s:s,s:s,s:O}", |
| | | + "name", execprof->name, |
| | | + "type", execprof->type, |
| | | + "policy", execprof->policy, |
| | | + "res1", execprof->res1, |
| | | + "res2", execprof->res2, |
| | | + "id", execprof->id, |
| | | + "attributes", kv_data); |
| | | + |
| | | + if (entry == NULL) { |
| | | + Py_XDECREF(kv_data); |
| | | + free_execattr(execprof_head); |
| | | + return NULL; |
| | | + } |
| | | + |
| | | + if (mode == PYRBAC_ATTR_MODE) { |
| | | + free_execattr(execprof_head); |
| | | + return(entry); |
| | | + } |
| | | + PyList_Append(ep_data, entry); |
| | | + execprof = execprof->next; |
| | | + } |
| | | + |
| | | + free_execattr(execprof_head); |
| | | + return(ep_data); |
| | | + |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyrbac_getexecuser(PyObject* self, PyObject* args) { |
| | | + char* username = NULL; |
| | | + char* type = NULL; |
| | | + char* id = NULL; |
| | | + |
| | | + if(!PyArg_ParseTuple(args, "sss:getexecuser", &username, &type, &id)) |
| | | + return NULL; |
| | | + |
| | | + return (pyrbac_getexecuserprofattr(self, username, type, id, PYRBAC_USER_MODE)); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyrbac_getexecprof(PyObject* self, PyObject* args) { |
| | | + |
| | | + char* profname = NULL; |
| | | + char* type = NULL; |
| | | + char* id = NULL; |
| | | + |
| | | + if(!PyArg_ParseTuple(args, "sss:getexecprof", &profname, &type, &id)) |
| | | + return NULL; |
| | | + |
| | | + return (pyrbac_getexecuserprofattr(self, profname, type, id, PYRBAC_PROF_MODE)); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_getexecattr(PyObject* self, PyObject* args) { |
| | | + return pyrbac_getexecuserprofattr(self, NULL, NULL, NULL, PYRBAC_ATTR_MODE); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_execattr_next(PyObject* self, PyObject* args) { |
| | | + PyObject* retval = pyrbac_getexecattr(self, args); |
| | | + if( retval == Py_None ) { |
| | | + setexecattr(); |
| | | + return NULL; |
| | | + } |
| | | + return retval; |
| | | +} |
| | | +static PyObject* |
| | | +pyrbac_execattr__iter__(PyObject* self, PyObject* args) { |
| | | + return self; |
| | | +} |
| | | + |
| | | +typedef struct { |
| | | + PyObject_HEAD |
| | | +} Execattr; |
| | | + |
| | | +static void |
| | | +Execattr_dealloc(Execattr* self) { |
| | | + endexecattr(); |
| | | + Py_TYPE(self)->tp_free((PyObject*) self); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +Execattr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { |
| | | + Execattr *self; |
| | | + self = (Execattr*)type->tp_alloc(type, 0); |
| | | + |
| | | + return ((PyObject *) self); |
| | | +} |
| | | + |
| | | +static int |
| | | +Execattr_init(Execattr* self, PyObject *args, PyObject *kwargs) { |
| | | + setexecattr(); |
| | | + return 0; |
| | | +} |
| | | + |
| | | +static char pyrbac_execattr__doc__[]; |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_execattr__doc__, "provides functions for \ |
| | | +interacting with the execution profiles database. May be iterated over to \ |
| | | +enumerate exec_attr(4) entries\n\n\ |
| | | +Methods provided:\n\ |
| | | +setexecattr\n\ |
| | | +endexecattr\n\ |
| | | +getexecattr\n\ |
| | | +getexecprof\n\ |
| | | +getexecuser"); |
| | | + |
| | | + |
| | | +static char pyrbac_getexecuser__doc__[]; |
| | | +static char pyrbac_getexecprof__doc__[]; |
| | | +static char pyrbac_getexecattr__doc__[]; |
| | | +static char pyrbac_setexecattr__doc__[]; |
| | | +static char pyrbac_endexecattr__doc__[]; |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_setexecattr__doc__, |
| | | +"\"rewinds\" the exec_attr functions to the first entry in the db. Called \ |
| | | +automatically by the constructor.\n\ |
| | | +\tArguments: None\ |
| | | +\tReturns: None"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_endexecattr__doc__, |
| | | +"closes the exec_attr database, cleans up storage. called automatically by \ |
| | | +the destructor.\n\ |
| | | +\tArguments: None\ |
| | | +\tReturns: None"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getexecuser__doc__, "corresponds with getexecuser(3SECDB)\ |
| | | +\nTakes: \'username\', \'type\', \'id\'\n\ |
| | | +Return: a single exec_attr entry\n\ |
| | | +\tArguments: None\n\ |
| | | +\tReturns: a dict representation of an execattr_t struct:\n\ |
| | | +\t\t\"name\": Authorization Name\n\ |
| | | +\t\t\"type\": Profile Type\n\ |
| | | +\t\t\"policy\": Policy attributes are relevant in\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"id\": unique identifier\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as\ |
| | | +either a list or a string depending on value"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getexecprof__doc__, "corresponds with getexecprof(3SECDB)\ |
| | | +\nTakes: \'profile name\', \'type\', \'id\'\n\ |
| | | +\tReturns: a dict representation of an execattr_t struct:\n\ |
| | | +\t\t\"name\": Authorization Name\n\ |
| | | +\t\t\"type\": Profile Type\n\ |
| | | +\t\t\"policy\": Policy attributes are relevant in\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"id\": unique identifier\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as\ |
| | | +either a list or a string depending on value"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getexecattr__doc__, "corresponds with getexecattr(3SECDB)\ |
| | | +\nTakes 0 arguments\n\ |
| | | +\tReturns: a dict representation of an execattr_t struct:\n\ |
| | | +\t\t\"name\": Authorization Name\n\ |
| | | +\t\t\"type\": Profile Type\n\ |
| | | +\t\t\"policy\": Policy attributes are relevant in\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"id\": unique identifier\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as\ |
| | | +either a list or a string depending on value"); |
| | | + |
| | | +static PyMethodDef Execattr_methods[] = { |
| | | + {"setexecattr", pyrbac_setexecattr, METH_NOARGS, pyrbac_setexecattr__doc__}, |
| | | + {"endexecattr", pyrbac_endexecattr, METH_NOARGS, pyrbac_endexecattr__doc__}, |
| | | + {"getexecprof", pyrbac_getexecprof, METH_VARARGS, pyrbac_getexecprof__doc__}, |
| | | + {"getexecuser", pyrbac_getexecuser, METH_VARARGS, pyrbac_getexecuser__doc__}, |
| | | + {"getexecattr", pyrbac_getexecattr, METH_NOARGS, pyrbac_getexecattr__doc__}, |
| | | + {NULL, NULL} |
| | | +}; |
| | | + |
| | | +PyTypeObject ExecattrType = { |
| | | + PyVarObject_HEAD_INIT(NULL, 0) |
| | | + "rbac.execattr", /*tp_name*/ |
| | | + sizeof(Execattr), /*tp_basicsize*/ |
| | | + 0, /*tp_itemsize*/ |
| | | + (destructor)Execattr_dealloc, /*tp_dealloc*/ |
| | | + 0, /*tp_print*/ |
| | | + 0, /*tp_getattr*/ |
| | | + 0, /*tp_setattr*/ |
| | | + 0, /*tp_reserved*/ |
| | | + 0, /*tp_repr*/ |
| | | + 0, /*tp_as_number*/ |
| | | + 0, /*tp_as_sequence*/ |
| | | + 0, /*tp_as_mapping*/ |
| | | + 0, /*tp_hash */ |
| | | + 0, /*tp_call*/ |
| | | + 0, /*tp_str*/ |
| | | + 0, /*tp_getattro*/ |
| | | + 0, /*tp_setattro*/ |
| | | + 0, /*tp_as_buffer*/ |
| | | + Py_TPFLAGS_DEFAULT | |
| | | + Py_TPFLAGS_BASETYPE, /*tp_flags*/ |
| | | + pyrbac_execattr__doc__, /* tp_doc */ |
| | | + 0, /* tp_traverse */ |
| | | + 0, /* tp_clear */ |
| | | + 0, /* tp_richcompare */ |
| | | + 0, /* tp_weaklistoffset */ |
| | | + pyrbac_execattr__iter__, /* tp_iter */ |
| | | + pyrbac_execattr_next, /* tp_iternext */ |
| | | + Execattr_methods, /* tp_methods */ |
| | | + 0, /* tp_members */ |
| | | + 0, /* tp_getset */ |
| | | + 0, /* tp_base */ |
| | | + 0, /* tp_dict */ |
| | | + 0, /* tp_descr_get */ |
| | | + 0, /* tp_descr_set */ |
| | | + 0, /* tp_dictoffset */ |
| | | + (initproc)Execattr_init, /* tp_init */ |
| | | + 0, /* tp_alloc */ |
| | | + Execattr_new, /* tp_new */ |
| | | + 0, /* tp_free */ |
| | | + 0, /* tp_is_gc */ |
| | | +}; |
| | | diff --git Python-2.6.4/Modules/privileges.c Python-2.6.4/Modules/privileges.c |
| | | new file mode 100644 |
| | | --- /dev/null |
| | | +++ Python-2.6.4/Modules/privileges.c |
| | | @@ -0,0 +1,243 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | + |
| | | +/* |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +/* |
| | | + * privileges(5) bindings for Python |
| | | + */ |
| | | + |
| | | +#include <priv.h> |
| | | +#include "Python.h" |
| | | + |
| | | +static PyObject * |
| | | +pyprivileges_setppriv( PyObject *self, PyObject *args) { |
| | | + priv_op_t op = -1 ; |
| | | + priv_ptype_t which = NULL; |
| | | + |
| | | + PyObject* set_list = NULL; |
| | | + |
| | | + priv_set_t * set = NULL; |
| | | + |
| | | + if(!PyArg_ParseTuple(args, "iiO:setppriv", &op, &which, &set_list)) |
| | | + return NULL; |
| | | + |
| | | + if((op != PRIV_ON && op != PRIV_OFF && op != PRIV_SET) || |
| | | + (which != PRIV_PERMITTED && which != PRIV_EFFECTIVE && |
| | | + which != PRIV_INHERITABLE && which != PRIV_LIMIT)) |
| | | + return NULL; |
| | | + |
| | | + PyObject* set_string = PyList_GetItem(set_list, 0); |
| | | + int i; |
| | | + for (i = 1; i < PyList_Size(set_list); ++i) { |
| | | + PyBytes_Concat(&set_string, PyBytes_FromString(",")); |
| | | + PyBytes_Concat(&set_string, PyList_GetItem(set_list, i)); |
| | | + } |
| | | + |
| | | + set = priv_str_to_set(PyBytes_AsString(set_string), ",", NULL ); |
| | | + |
| | | + if ( set == NULL ) |
| | | + return NULL; |
| | | + |
| | | + long ret = (long) setppriv(op, which, set); |
| | | + priv_freeset(set); |
| | | + // Python inverts true & false |
| | | + if(ret) |
| | | + Py_RETURN_FALSE; |
| | | + |
| | | + Py_RETURN_TRUE; |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyprivileges_getppriv( PyObject *self, PyObject *args) { |
| | | + |
| | | + char* set_str = NULL; |
| | | + priv_ptype_t which = NULL; |
| | | + priv_set_t * set = priv_allocset(); |
| | | + if (set == NULL) |
| | | + return NULL; |
| | | + |
| | | + if(!PyArg_ParseTuple(args, "i:getppriv", &which)) |
| | | + return NULL; |
| | | + |
| | | + if (which != PRIV_PERMITTED && which != PRIV_EFFECTIVE && |
| | | + which != PRIV_INHERITABLE && which != PRIV_LIMIT) |
| | | + return NULL; |
| | | + |
| | | + if (getppriv(which, set) != 0) |
| | | + return NULL; |
| | | + |
| | | + set_str = priv_set_to_str(set, ',', PRIV_STR_LIT); |
| | | + priv_freeset(set); |
| | | + |
| | | + PyObject* set_list = PyList_New(NULL); |
| | | + char* saveptr; |
| | | + char* item = strtok_r(set_str, ",", &saveptr); |
| | | + PyList_Append(set_list, PyBytes_FromString(item)); |
| | | + |
| | | + while((item = strtok_r(NULL, ",", &saveptr)) != NULL) { |
| | | + if(PyList_Append(set_list, PyBytes_FromString(item)) != 0) { |
| | | + Py_XDECREF(set_list); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + |
| | | + return(set_list); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | +pyprivileges_priv_inverse( PyObject *self, PyObject *args ) { |
| | | + |
| | | + PyObject* set_list_in = NULL; |
| | | + if(!PyArg_ParseTuple(args, "O:priv_inverse", &set_list_in)) |
| | | + return NULL; |
| | | + |
| | | + PyObject* set_string = PyList_GetItem(set_list_in, 0); |
| | | + int i; |
| | | + for (i = 1; i < PyList_Size(set_list_in); ++i) { |
| | | + PyBytes_Concat(set_string, PyBytes_FromString(",")); |
| | | + PyBytes_Concat(set_string, PyList_GetItem(set_list_in, i)); |
| | | + } |
| | | + |
| | | + priv_set_t * set = priv_str_to_set(PyBytes_AsString(set_string), ",", NULL); |
| | | + if (set == NULL) |
| | | + return NULL; |
| | | + priv_inverse(set); |
| | | + char * ret_str = priv_set_to_str(set, ',', PRIV_STR_LIT); |
| | | + priv_freeset(set); |
| | | + |
| | | + PyObject* set_list_out = PyList_New(NULL); |
| | | + char* saveptr; |
| | | + char* item = strtok_r(ret_str, ",", &saveptr); |
| | | + PyList_Append(set_list_out, PyBytes_FromString(item)); |
| | | + |
| | | + while((item = strtok_r(NULL, ",", &saveptr)) != NULL) { |
| | | + if(PyList_Append(set_list_out, PyBytes_FromString(item)) != 0) { |
| | | + Py_XDECREF(set_list_out); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + |
| | | + Py_XDECREF(set_list_in); |
| | | + |
| | | + return(set_list_out); |
| | | +} |
| | | + |
| | | +/* priv_ineffect is a convienient wrapper to priv_get |
| | | + * however priv_set is, in the context of python, not |
| | | + * much of a convienience, so it's omitted |
| | | + */ |
| | | +static PyObject * |
| | | +pyprivileges_priv_ineffect(PyObject* self, PyObject* args) { |
| | | + char* privstring=NULL; |
| | | + if (!PyArg_ParseTuple(args, "s:priv_ineffect", &privstring)) |
| | | + return NULL; |
| | | + return PyBool_FromLong(priv_ineffect(privstring)); |
| | | +} |
| | | + |
| | | + |
| | | +static char pyprivileges__doc__[]; |
| | | +PyDoc_STRVAR(pyprivileges__doc__, |
| | | +"Provides functions for interacting with the Solaris privileges(5) framework\n\ |
| | | +Functions provided:\n\ |
| | | +setppriv\n\ |
| | | +getppriv\n\ |
| | | +priv_ineffect\n\ |
| | | +priv_inverse"); |
| | | + |
| | | +static char pyprivileges_setppriv__doc__[]; |
| | | +static char pyprivileges_getppriv__doc__[]; |
| | | +static char pyprivileges_priv_ineffect__doc__[]; |
| | | +static char pyprivileges_priv_inverse__doc__[]; |
| | | + |
| | | +PyDoc_STRVAR(pyprivileges_setppriv__doc__, |
| | | +"Facilitates setting the permitted/inheritable/limit/effective privileges set\n\ |
| | | +\tArguments:\n\ |
| | | +\t\tone of (PRIV_ON|PRIV_OFF|PRIV_SET)\n\ |
| | | +\t\tone of (PRIV_PERMITTED|PRIV_INHERITABLE|PRIV_LIMIT|PRIV_EFFECTIVE)\n\ |
| | | +\t\tset of privileges: a list of strings\n\ |
| | | +\tReturns: True on success, False on failure\ |
| | | +"); |
| | | + |
| | | +PyDoc_STRVAR(pyprivileges_getppriv__doc__, |
| | | +"Return the process privilege set\n\ |
| | | +\tArguments:\n\ |
| | | +\t\tone of (PRIV_PERMITTED|PRIV_INHERITABLE|PRIV_LIMIT|PRIV_EFFECTIVE)\n\ |
| | | +\tReturns: a Python list of strings"); |
| | | + |
| | | +PyDoc_STRVAR(pyprivileges_priv_ineffect__doc__, |
| | | +"Checks for a privileges presence in the effective set\n\ |
| | | +\tArguments: a String\n\ |
| | | +\tReturns: True if the privilege is in effect, False otherwise"); |
| | | + |
| | | +PyDoc_STRVAR(pyprivileges_priv_inverse__doc__, |
| | | +"The complement of the set of privileges\n\ |
| | | +\tArguments: a list of strings\n\tReturns: a list of strings"); |
| | | + |
| | | +static PyMethodDef module_methods[] = { |
| | | + {"setppriv", pyprivileges_setppriv, METH_VARARGS, pyprivileges_setppriv__doc__}, |
| | | + {"getppriv", pyprivileges_getppriv, METH_VARARGS, pyprivileges_getppriv__doc__}, |
| | | + {"priv_ineffect", pyprivileges_priv_ineffect, METH_VARARGS, pyprivileges_priv_ineffect__doc__}, |
| | | + {"priv_inverse", pyprivileges_priv_inverse, METH_VARARGS, pyprivileges_priv_inverse__doc__}, |
| | | + {NULL, NULL} |
| | | +}; |
| | | + |
| | | + |
| | | +#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */ |
| | | +#define PyMODINIT_FUNC void |
| | | +#endif |
| | | +PyMODINIT_FUNC |
| | | +PyInit_privileges (void) { |
| | | + PyObject* m; |
| | | + |
| | | + static struct PyModuleDef moduledef = { |
| | | + PyModuleDef_HEAD_INIT, |
| | | + "privileges", |
| | | + pyprivileges__doc__, |
| | | + -1, |
| | | + module_methods, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + }; |
| | | + |
| | | + m = PyModule_Create(&moduledef); |
| | | + if ( m == NULL ) |
| | | + return m; |
| | | + |
| | | + PyObject* d = PyModule_GetDict(m); |
| | | + if (d == NULL) |
| | | + return m; |
| | | + |
| | | + PyDict_SetItemString(d, "PRIV_ON", PyLong_FromLong((long)PRIV_ON)); |
| | | + PyDict_SetItemString(d, "PRIV_OFF", PyLong_FromLong((long)PRIV_OFF)); |
| | | + PyDict_SetItemString(d, "PRIV_SET", PyLong_FromLong((long)PRIV_SET)); |
| | | + |
| | | + PyDict_SetItemString(d, "PRIV_PERMITTED", PyLong_FromLong((long)PRIV_PERMITTED)); |
| | | + PyDict_SetItemString(d, "PRIV_INHERITABLE", PyLong_FromLong((long)PRIV_INHERITABLE)); |
| | | + PyDict_SetItemString(d, "PRIV_LIMIT", PyLong_FromLong((long)PRIV_LIMIT)); |
| | | + PyDict_SetItemString(d, "PRIV_EFFECTIVE", PyLong_FromLong((long)PRIV_EFFECTIVE)); |
| | | + |
| | | + return m; |
| | | +} |
| | | diff --git Python-2.6.4/Modules/pyrbac.c Python-2.6.4/Modules/pyrbac.c |
| | | new file mode 100644 |
| | | --- /dev/null |
| | | +++ Python-2.6.4/Modules/pyrbac.c |
| | | @@ -0,0 +1,82 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | + |
| | | +/* |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +/* |
| | | + * RBAC Bindings for Python |
| | | + */ |
| | | + |
| | | +#include <Python.h> |
| | | +#include "pyrbac.h" |
| | | + |
| | | +static PyMethodDef module_methods[] = {NULL}; |
| | | +static char pyrbac__doc__[]; |
| | | + |
| | | +PyDoc_STRVAR(pyrbac__doc__, "provides access to some objects \ |
| | | +for interaction with the Solaris Role-Based Access Control \ |
| | | +framework.\n\nDynamic objects:\n\ |
| | | +userattr -- for interacting with user_attr(4)\n\ |
| | | +authattr -- for interacting with auth_attr(4)\n\ |
| | | +execattr -- for interacting with exec_attr(4)\n"); |
| | | + |
| | | +#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */ |
| | | +#define PyMODINIT_FUNC void |
| | | +#endif |
| | | +PyMODINIT_FUNC |
| | | +PyInit_rbac (void) { |
| | | + PyObject* m; |
| | | + |
| | | + if (PyType_Ready(&AuthattrType) < 0 || |
| | | + PyType_Ready(&ExecattrType) < 0 || |
| | | + PyType_Ready(&UserattrType) < 0 ) |
| | | + return NULL; |
| | | + |
| | | + static struct PyModuleDef moduledef = { |
| | | + PyModuleDef_HEAD_INIT, |
| | | + "rbac", |
| | | + pyrbac__doc__, |
| | | + -1, |
| | | + module_methods, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + NULL, |
| | | + }; |
| | | + |
| | | + m = PyModule_Create(&moduledef); |
| | | + if ( m == NULL ) |
| | | + return NULL; |
| | | + |
| | | + Py_INCREF(&AuthattrType); |
| | | + PyModule_AddObject(m, "authattr", (PyObject*)&AuthattrType); |
| | | + |
| | | + Py_INCREF(&ExecattrType); |
| | | + PyModule_AddObject(m, "execattr", (PyObject*)&ExecattrType); |
| | | + |
| | | + Py_INCREF(&UserattrType); |
| | | + PyModule_AddObject(m, "userattr", (PyObject*)&UserattrType); |
| | | + |
| | | + return m; |
| | | + |
| | | +} |
| | | diff --git Python-2.6.4/Modules/pyrbac.h Python-2.6.4/Modules/pyrbac.h |
| | | new file mode 100644 |
| | | --- /dev/null |
| | | +++ Python-2.6.4/Modules/pyrbac.h |
| | | @@ -0,0 +1,45 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | + |
| | | +/* |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +/* |
| | | + * RBAC bindings for python |
| | | + */ |
| | | +#ifndef PYRBAC_H |
| | | +#define PYRBAC_H |
| | | + |
| | | +#include <secdb.h> |
| | | + |
| | | + |
| | | +#define PYRBAC_USER_MODE 1 |
| | | +#define PYRBAC_PROF_MODE 2 |
| | | +#define PYRBAC_ATTR_MODE 3 |
| | | +#define PYRBAC_NAM_MODE 4 |
| | | +#define PYRBAC_UID_MODE 5 |
| | | + |
| | | +PyTypeObject AuthattrType; |
| | | +PyTypeObject ExecattrType; |
| | | +PyTypeObject UserattrType; |
| | | + |
| | | +#endif |
| | | diff --git Python-2.6.4/Modules/userattr.c Python-2.6.4/Modules/userattr.c |
| | | new file mode 100644 |
| | | --- /dev/null |
| | | +++ Python-2.6.4/Modules/userattr.c |
| | | @@ -0,0 +1,308 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | + |
| | | +/* |
| | | + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +/* |
| | | + * RBAC Bindings for Python - user_attr functions |
| | | + */ |
| | | + |
| | | +#include <stdio.h> |
| | | +#include <user_attr.h> |
| | | +#include "Python.h" |
| | | +#include "pyrbac.h" |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_setuserattr(PyObject* self, PyObject* args) { |
| | | + setuserattr(); |
| | | + return Py_None; |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_enduserattr(PyObject* self, PyObject* args) { |
| | | + enduserattr(); |
| | | + return Py_None; |
| | | +} |
| | | + |
| | | +PyObject* |
| | | +pyrbac_getuseruidnamattr(PyObject* self, void* arg, int mode, char* filename) { |
| | | + |
| | | + userattr_t *ret_userattr; |
| | | + |
| | | + if (mode == PYRBAC_ATTR_MODE) { |
| | | + if (filename != NULL) { |
| | | + FILE* file = fopen(filename, "r"); |
| | | + if (file == NULL) |
| | | + return NULL; |
| | | + ret_userattr = fgetuserattr(file); |
| | | + if (fclose(file)) |
| | | + return NULL; |
| | | + } |
| | | + else |
| | | + ret_userattr = getuserattr(); |
| | | + } |
| | | + else if (mode == PYRBAC_NAM_MODE) |
| | | + ret_userattr = getusernam((char*) arg); |
| | | + else if (mode == PYRBAC_UID_MODE) |
| | | + ret_userattr = getuseruid(*((uid_t*) arg)); |
| | | + |
| | | + if (ret_userattr == NULL) |
| | | + return Py_None; |
| | | + |
| | | + PyObject* entry = PyTuple_New(5); |
| | | + if (entry == NULL) { |
| | | + free_userattr(ret_userattr); |
| | | + return NULL; |
| | | + } |
| | | + |
| | | + PyObject* kv_data = PyDict_New(); |
| | | + |
| | | + if(ret_userattr->attr != NULL) { |
| | | + int len; |
| | | + for(len = 0; len < ret_userattr->attr->length; len++) { |
| | | + kv_t current = ret_userattr->attr->data[len]; |
| | | + |
| | | + PyObject* set = PyList_New(NULL); |
| | | + char* saveptr; |
| | | + char* item = strtok_r(current.value, ",", &saveptr); |
| | | + PyList_Append(set, PyBytes_FromString(item)); |
| | | + |
| | | + while((item = strtok_r(NULL, ",", &saveptr)) != NULL) { |
| | | + if(PyList_Append(set, PyBytes_FromString(item)) != 0) { |
| | | + Py_XDECREF(set); |
| | | + Py_XDECREF(kv_data); |
| | | + free_userattr(ret_userattr); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + if(PyDict_SetItemString(kv_data, current.key, set)) { |
| | | + free_userattr(ret_userattr); |
| | | + return NULL; |
| | | + } |
| | | + } |
| | | + } |
| | | + entry = Py_BuildValue("{s:s,s:s,s:s,s:s,s:O}", |
| | | + "name", ret_userattr->name, |
| | | + "qualifier", ret_userattr->qualifier, |
| | | + "res1", ret_userattr->res1, |
| | | + "res2", ret_userattr->res2, |
| | | + "attributes", kv_data); |
| | | + |
| | | + free_userattr(ret_userattr); |
| | | + |
| | | + return entry; |
| | | +} |
| | | + |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_getuserattr(PyObject* self, PyObject* args) { |
| | | + return(pyrbac_getuseruidnamattr(self, (void*) NULL, PYRBAC_ATTR_MODE, NULL)); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_fgetuserattr(PyObject* self, PyObject* args) { |
| | | + char* filename = NULL; |
| | | + if(!PyArg_ParseTuple(args, "s:fgetuserattr", &filename)) |
| | | + return NULL; |
| | | + return(pyrbac_getuseruidnamattr(self, NULL, PYRBAC_ATTR_MODE, filename)); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_getusernam(PyObject* self, PyObject* args) { |
| | | + char* name = NULL; |
| | | + if(!PyArg_ParseTuple(args, "s:getusernam", &name)) |
| | | + return NULL; |
| | | + return(pyrbac_getuseruidnamattr(self, (void*) name, PYRBAC_NAM_MODE, NULL)); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_getuseruid(PyObject* self, PyObject* args) { |
| | | + uid_t uid; |
| | | + if(!PyArg_ParseTuple(args, "i:getuseruid", &uid)) |
| | | + return NULL; |
| | | + return(pyrbac_getuseruidnamattr(self, (void*) &uid, PYRBAC_UID_MODE, NULL)); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +pyrbac_userattr_next(PyObject* self, PyObject* args) { |
| | | + PyObject* retval = pyrbac_getuserattr(self, args); |
| | | + if( retval == Py_None ) { |
| | | + setuserattr(); |
| | | + return NULL; |
| | | + } |
| | | + return retval; |
| | | +} |
| | | +static PyObject* |
| | | +pyrbac_userattr__iter__(PyObject* self, PyObject* args) { |
| | | + return self; |
| | | +} |
| | | + |
| | | +typedef struct { |
| | | + PyObject_HEAD |
| | | +} Userattr; |
| | | + |
| | | +static void |
| | | +Userattr_dealloc(Userattr* self) { |
| | | + enduserattr(); |
| | | + Py_TYPE(self)->tp_free((PyObject*) self); |
| | | +} |
| | | + |
| | | +static PyObject* |
| | | +Userattr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { |
| | | + Userattr *self; |
| | | + self = (Userattr*)type->tp_alloc(type, 0); |
| | | + |
| | | + return ((PyObject *) self); |
| | | +} |
| | | + |
| | | +static int |
| | | +Userattr_init(Userattr* self, PyObject *args, PyObject *kwargs) { |
| | | + setuserattr(); |
| | | + return 0; |
| | | +} |
| | | + |
| | | +static char pyrbac_userattr__doc__[]; |
| | | +PyDoc_STRVAR(pyrbac_userattr__doc__, "provides functions for \ |
| | | +interacting with the extended user attributes database. May be iterated over \ |
| | | +to enumerate user_attr(4) entries\n\n\ |
| | | +Methods provided:\n\ |
| | | +setuserattr\n\ |
| | | +enduserattr\n\ |
| | | +getuserattr\n\ |
| | | +fgetuserattr\n\ |
| | | +getusernam\n\ |
| | | +getuseruid"); |
| | | + |
| | | +static char pyrbac_setuserattr__doc__[]; |
| | | +static char pyrbac_enduserattr__doc__[]; |
| | | +static char pyrbac_getuserattr__doc__[]; |
| | | +static char pyrbac_getusernam__doc__[]; |
| | | +static char pyrbac_getuseruid__doc__[]; |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_setuserattr__doc__, "\"rewinds\" the user_attr functions \ |
| | | +to the first entry in the db. Called automatically by the constructor.\n\ |
| | | +\tArguments: None\n\ |
| | | +\tReturns: None"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_enduserattr__doc__, "closes the user_attr database, \ |
| | | +cleans up storage. called automatically by the destructor\n\ |
| | | +\tArguments: None\n\ |
| | | +\tReturns: None"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getuserattr__doc__, "Return a single user_attr entry\n \ |
| | | +\tArguments: None\n\ |
| | | +\tReturns: a dict representation of a userattr_t struct:\n\ |
| | | +\t\t\"name\": username\n\ |
| | | +\t\t\"qualifier\": reserved\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \ |
| | | +or a string depending on value" |
| | | +); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_fgetuserattr__doc__, "Return a single user_attr entry \ |
| | | +from a file, bypassing nsswitch.conf\n\ |
| | | +\tArguments: \'filename\'\n\ |
| | | +\tReturns: a dict representation of a userattr_t struct:\n\ |
| | | +\t\t\"name\": username\n\ |
| | | +\t\t\"qualifier\": reserved\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \ |
| | | +or a string depending on value"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getusernam__doc__, "Searches for a user_attr entry with a \ |
| | | +given user name\n\ |
| | | +\tArgument: \'username\'\n\ |
| | | +\tReturns: a dict representation of a userattr_t struct:\n\ |
| | | +\t\t\"name\": username\n\ |
| | | +\t\t\"qualifier\": reserved\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \ |
| | | +or a string depending on value"); |
| | | + |
| | | +PyDoc_STRVAR(pyrbac_getuseruid__doc__, "Searches for a user_attr entry with a \ |
| | | +given uid\n\ |
| | | +\tArgument: uid\n\ |
| | | +\tReturns: a dict representation of a userattr_t struct:\n\ |
| | | +\t\t\"name\": username\n\ |
| | | +\t\t\"qualifier\": reserved\n\ |
| | | +\t\t\"res1\": reserved\n\ |
| | | +\t\t\"res2\": reserved\n\ |
| | | +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \ |
| | | +or a string depending on value"); |
| | | + |
| | | +static PyMethodDef Userattr_methods[] = { |
| | | + {"setuserattr", pyrbac_setuserattr, METH_NOARGS, pyrbac_setuserattr__doc__}, |
| | | + {"enduserattr", pyrbac_enduserattr, METH_NOARGS, pyrbac_enduserattr__doc__}, |
| | | + {"getuserattr", pyrbac_getuserattr, METH_NOARGS, pyrbac_getuserattr__doc__}, |
| | | + {"fgetuserattr", pyrbac_fgetuserattr, METH_VARARGS, pyrbac_fgetuserattr__doc__}, |
| | | + {"getusernam", pyrbac_getusernam, METH_VARARGS, pyrbac_getusernam__doc__}, |
| | | + {"getuseruid", pyrbac_getuseruid, METH_VARARGS, pyrbac_getuseruid__doc__}, |
| | | + {NULL, NULL} |
| | | +}; |
| | | + |
| | | +PyTypeObject UserattrType = { |
| | | + PyVarObject_HEAD_INIT(NULL, 0) |
| | | + "rbac.userattr", /*tp_name*/ |
| | | + sizeof(Userattr), /*tp_basicsize*/ |
| | | + 0, /*tp_itemsize*/ |
| | | + (destructor)Userattr_dealloc, /*tp_dealloc*/ |
| | | + 0, /*tp_print*/ |
| | | + 0, /*tp_getattr*/ |
| | | + 0, /*tp_setattr*/ |
| | | + 0, /*tp_reserved*/ |
| | | + 0, /*tp_repr*/ |
| | | + 0, /*tp_as_number*/ |
| | | + 0, /*tp_as_sequence*/ |
| | | + 0, /*tp_as_mapping*/ |
| | | + 0, /*tp_hash */ |
| | | + 0, /*tp_call*/ |
| | | + 0, /*tp_str*/ |
| | | + 0, /*tp_getattro*/ |
| | | + 0, /*tp_setattro*/ |
| | | + 0, /*tp_as_buffer*/ |
| | | + Py_TPFLAGS_DEFAULT | |
| | | + Py_TPFLAGS_BASETYPE, /*tp_flags*/ |
| | | + pyrbac_userattr__doc__, /* tp_doc */ |
| | | + 0, /* tp_traverse */ |
| | | + 0, /* tp_clear */ |
| | | + 0, /* tp_richcompare */ |
| | | + 0, /* tp_weaklistoffset */ |
| | | + pyrbac_userattr__iter__, /* tp_iter */ |
| | | + pyrbac_userattr_next, /* tp_iternext */ |
| | | + Userattr_methods, /* tp_methods */ |
| | | + 0, /* tp_members */ |
| | | + 0, /* tp_getset */ |
| | | + 0, /* tp_base */ |
| | | + 0, /* tp_dict */ |
| | | + 0, /* tp_descr_get */ |
| | | + 0, /* tp_descr_set */ |
| | | + 0, /* tp_dictoffset */ |
| | | + (initproc)Userattr_init, /* tp_init */ |
| | | + 0, /* tp_alloc */ |
| | | + Userattr_new, /* tp_new */ |
| | | + 0, /* tp_free */ |
| | | + 0, /* tp_is_gc */ |
| | | +}; |
| | | --- Python-3.4.0/setup.py.~5~ 2014-03-19 10:47:07.143319629 -0700 |
| | | +++ Python-3.4.0/setup.py 2014-03-19 10:47:07.193485865 -0700 |
| | | @@ -1480,6 +1480,22 @@ |
| | | exts.append( Extension('dlpi', ['dlpimodule.c'], |
| | | libraries = ['dlpi']) ) |
| | | |
| | | + # privileges module (Solaris) |
| | | + priv_inc = find_file('priv.h', [], inc_dirs) |
| | | + if priv_inc is not None: |
| | | + exts.append( Extension('privileges', ['privileges.c'])) |
| | | + |
| | | + # rbac module (Solaris) |
| | | + secdb_inc = find_file('secdb.h', [], inc_dirs) |
| | | + aa_inc = find_file('auth_attr.h', [], inc_dirs) |
| | | + ea_inc = find_file('exec_attr.h', [], inc_dirs) |
| | | + ua_inc = find_file('user_attr.h', [], inc_dirs) |
| | | + if secdb_inc is not None and aa_inc is not None and \ |
| | | + ea_inc is not None and ua_inc is not None: |
| | | + exts.append( Extension('rbac', ['pyrbac.c', 'authattr.c', \ |
| | | + 'execattr.c', 'userattr.c'], |
| | | + libraries = ['nsl', 'socket', 'secdb']) ) |
| | | + |
| | | # Thomas Heller's _ctypes module |
| | | self.detect_ctypes(inc_dirs, lib_dirs) |
| | | |
| | | --- /dev/null 2011-02-12 03:13:57.000000000 -0600 |
| | | +++ Python-3.4.0/Lib/test/privrbactest.py 2011-01-20 13:52:42.862305331 -0600 |
| | | @@ -0,0 +1,289 @@ |
| | | +#!/usr/bin/python3.4 |
| | | +# |
| | | +# CDDL HEADER START |
| | | +# |
| | | +# The contents of this file are subject to the terms of the |
| | | +# Common Development and Distribution License (the "License"). |
| | | +# You may not use this file except in compliance with the License. |
| | | +# |
| | | +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | +# or http://www.opensolaris.org/os/licensing. |
| | | +# See the License for the specific language governing permissions |
| | | +# and limitations under the License. |
| | | +# |
| | | +# When distributing Covered Code, include this CDDL HEADER in each |
| | | +# file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | +# If applicable, add the following below this CDDL HEADER, with the |
| | | +# fields enclosed by brackets "[]" replaced with your own identifying |
| | | +# information: Portions Copyright [yyyy] [name of copyright owner] |
| | | +# |
| | | +# CDDL HEADER END |
| | | +# |
| | | + |
| | | +# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | + |
| | | +import privileges |
| | | +import rbac |
| | | +import os |
| | | +import sys |
| | | +import tempfile |
| | | + |
| | | +# privileges tests |
| | | + |
| | | +def test_setppriv(): |
| | | + amchild = os.fork() |
| | | + if amchild == 0: |
| | | + if privileges.setppriv(privileges.PRIV_OFF, privileges.PRIV_EFFECTIVE, |
| | | + ['proc_fork']): |
| | | + try: |
| | | + os.fork() |
| | | + sys.exit(1) |
| | | + except OSError as e: |
| | | + sys.exit(0) |
| | | + |
| | | + child = os.wait() |
| | | + if child[1] is not 0: |
| | | + print("setppriv. Bad exit status from pid %i\n" % child[0]) |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_getppriv(): |
| | | + if 'proc_fork' in privileges.getppriv(privileges.PRIV_LIMIT): |
| | | + return True |
| | | + print("getppriv or PRIV_PROC_FORK not in PRIV_LIMIT.\n") |
| | | + return False |
| | | + |
| | | +def test_priv_ineffect(): |
| | | + if privileges.priv_ineffect('proc_fork'): |
| | | + return True |
| | | + print("priv_ineffect or PRIV_PROC_FORK not in effect\n") |
| | | + return False |
| | | + |
| | | +# authattr tests |
| | | + |
| | | +def test_chkauthattr(): |
| | | + try: |
| | | + a = rbac.authattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate authattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.chkauthattr('solaris.*', 'root') |
| | | + except Exception as e: |
| | | + print("chkauthattr failed: %s\n" % e) |
| | | + return False |
| | | + if not res: |
| | | + print("chkauthattr failed or \'root\' lacks \'solaris.*\'\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_getauthattr(): |
| | | + try: |
| | | + a = rbac.authattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate authattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getauthattr() |
| | | + except Exception as e: |
| | | + print("getauthattr failed: %s\n" % e) |
| | | + return False |
| | | + if not 'name' in list(res.keys()): |
| | | + print("getauthattr failed\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_getauthnam(): |
| | | + try: |
| | | + a = rbac.authattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate authattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getauthnam('solaris.') |
| | | + except Exception as e: |
| | | + print("getauthnam failed: %s\n" % e) |
| | | + return False |
| | | + if not res: |
| | | + print("getauthnam failed or \'solaris.\' not in auth_attr(4)\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_authattr_iter(): |
| | | + try: |
| | | + a = rbac.authattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate authattr object: %s\n" % e) |
| | | + return False |
| | | + res = next(a) |
| | | + if not 'name' in list(res.keys()) or type(a) != type(a.__iter__()): |
| | | + print("authattr object is not an iterable\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +# execattr tests |
| | | + |
| | | +def test_getexecattr(): |
| | | + try: |
| | | + a = rbac.execattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate execattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getexecattr() |
| | | + except Exception as e: |
| | | + print("getexecattr failed: %s\n" % e) |
| | | + return False |
| | | + if not 'name' in list(res.keys()): |
| | | + print("getexecattr failed\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_getexecuser(): |
| | | + try: |
| | | + a = rbac.execattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate execattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getexecuser("root", "act", "*;*;*;*;*") |
| | | + except Exception as e: |
| | | + print("getexecuser failed: %s\n" % e) |
| | | + return False |
| | | + if not res: |
| | | + print("getexecuser failed or \'root\' not assigned to \'act\', " \ |
| | | + "\'*;*;*;*;*\' \n") |
| | | + return False |
| | | + return True |
| | | + |
| | | + |
| | | +def test_getexecprof(): |
| | | + try: |
| | | + a = rbac.execattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate execattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getexecprof("All", "cmd", "*") |
| | | + except Exception as e: |
| | | + print("getexecprof failed: %s\n" % e) |
| | | + return False |
| | | + if not res: |
| | | + print("getexecprof failed or \'All\' not granted \'cmd\' : \'*\'\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_execattr_iter(): |
| | | + try: |
| | | + a = rbac.execattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate execattr object: %s\n" % e) |
| | | + return False |
| | | + res = next(a) |
| | | + if not 'name' in list(res.keys()) or type(a) != type(a.__iter__()): |
| | | + print("execattr object is not an iterable\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +# userattr tests |
| | | + |
| | | +def test_getuserattr(): |
| | | + try: |
| | | + a = rbac.userattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate userattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getuserattr() |
| | | + except Exception as e: |
| | | + print("getuserattr failed: %s\n" % e) |
| | | + return False |
| | | + if not 'name' in list(res.keys()): |
| | | + print("getuserattr failed\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_fgetuserattr(): |
| | | + temp = tempfile.NamedTemporaryFile() |
| | | + temp.write("user::::profiles=Software Installation;roles=foo;"\ |
| | | + "auths=solaris.foo.bar") |
| | | + temp.seek(0) |
| | | + try: |
| | | + a = rbac.userattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate userattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.fgetuserattr(temp.name) |
| | | + temp.close() |
| | | + except Exception as e: |
| | | + print("fgetuserattr failed: %s\n" % e) |
| | | + temp.close() |
| | | + return False |
| | | + if not 'name' in list(res.keys()): |
| | | + print("fgetuserattr failed\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_getuseruid(): |
| | | + try: |
| | | + a = rbac.userattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate userattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getuseruid(0) |
| | | + except Exception as e: |
| | | + print("getusernam failed: %s\n" % e) |
| | | + return False |
| | | + if not 'name' in res: |
| | | + print("getusernam failed or no uid 0\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_getusernam(): |
| | | + try: |
| | | + a = rbac.userattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate userattr object: %s\n" % e) |
| | | + return False |
| | | + try: |
| | | + res = a.getusernam('root') |
| | | + except Exception as e: |
| | | + print("getusernam failed: %s\n" % e) |
| | | + return False |
| | | + if not 'name' in res: |
| | | + print("getusernam failed or no \'root\' user\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +def test_userattr_iter(): |
| | | + try: |
| | | + a = rbac.userattr() |
| | | + except Exception as e: |
| | | + print("Could not instantiate userattr object: %s\n" % e) |
| | | + return False |
| | | + res = next(a) |
| | | + if not 'name' in list(res.keys()) or type(a) != type(a.__iter__()): |
| | | + print("userattr object is not an iterable\n") |
| | | + return False |
| | | + return True |
| | | + |
| | | +if not test_setppriv() or not test_getppriv() or not test_priv_ineffect(): |
| | | + print("*** Failures detected in privileges module\n") |
| | | + sys.exit(1) |
| | | + |
| | | +if not test_getauthattr() or not test_chkauthattr() or not test_getauthnam() \ |
| | | + or not test_authattr_iter: |
| | | + print("*** Failures detected in rbac.authattr\n") |
| | | + sys.exit(1) |
| | | + |
| | | +if not test_getexecattr() or not test_getexecuser() or not test_getexecprof() \ |
| | | + or not test_execattr_iter(): |
| | | + print("*** Failures detected in rbac.execattr\n") |
| | | + sys.exit(1) |
| | | + |
| | | +if not test_getuserattr() or not test_fgetuserattr() or not test_getusernam()\ |
| | | + or not test_getuseruid() or not test_userattr_iter(): |
| | | + print("*** Failures detected in rbac.userattr\n") |
| | | + sys.exit(1) |
New file |
| | |
| | | This patch uses fdwalk(3c) to close file descriptors; as that function is not |
| | | widely implemented, this is unsuitable for upstream. |
| | | |
| | | --- Python-3.4.0/Modules/posixmodule.c.~1~ 2014-03-16 19:31:31.000000000 -0700 |
| | | +++ Python-3.4.0/Modules/posixmodule.c 2014-03-17 13:31:33.433740698 -0700 |
| | | @@ -7789,16 +7789,34 @@ |
| | | "closerange(fd_low, fd_high)\n\n\ |
| | | Closes all file descriptors in [fd_low, fd_high), ignoring errors."); |
| | | |
| | | +static int |
| | | +close_func(void *lohi, int fd) |
| | | +{ |
| | | + int lo = ((int *)lohi)[0]; |
| | | + int hi = ((int *)lohi)[1]; |
| | | + |
| | | + if (fd >= hi) |
| | | + return (1); |
| | | + else if (fd >= lo) |
| | | + close(fd); |
| | | + |
| | | + return (0); |
| | | +} |
| | | + |
| | | static PyObject * |
| | | posix_closerange(PyObject *self, PyObject *args) |
| | | { |
| | | int fd_from, fd_to, i; |
| | | + int lohi[2]; |
| | | + |
| | | if (!PyArg_ParseTuple(args, "ii:closerange", &fd_from, &fd_to)) |
| | | return NULL; |
| | | Py_BEGIN_ALLOW_THREADS |
| | | - for (i = fd_from; i < fd_to; i++) |
| | | - if (_PyVerify_fd(i)) |
| | | - close(i); |
| | | + |
| | | + lohi[0] = fd_from; |
| | | + lohi[1] = fd_to; |
| | | + fdwalk(close_func, lohi); |
| | | + |
| | | Py_END_ALLOW_THREADS |
| | | Py_RETURN_NONE; |
| | | } |
New file |
| | |
| | | This patch adds Python debugger support. It may be contributed upstream at |
| | | some point, but the suitability (or lack thereof) has not yet been determined. |
| | | |
| | | --- Python-3.4.0/Makefile.pre.in.~3~ 2014-03-19 10:48:24.881429192 -0700 |
| | | +++ Python-3.4.0/Makefile.pre.in 2014-03-19 10:48:25.069002130 -0700 |
| | | @@ -466,7 +466,7 @@ |
| | | |
| | | # Default target |
| | | all: build_all |
| | | -build_all: $(BUILDPYTHON) oldsharedmods sharedmods gdbhooks Modules/_testembed python-config |
| | | +build_all: $(BUILDPYTHON) oldsharedmods sharedmods gdbhooks Modules/_testembed python-config build-py_db |
| | | |
| | | # Compile a binary with gcc profile guided optimization. |
| | | profile-opt: |
| | | @@ -658,6 +658,19 @@ |
| | | @mv config.c Modules |
| | | @echo "The Makefile was updated, you may need to re-run make." |
| | | |
| | | +SHLIB_FLAGS = -shared -fpic |
| | | + |
| | | +libpython3.4_db.so.1.0: $(srcdir)/py_db/libpython34_db.c |
| | | + $(CC) -o $@ $(CFLAGS) $(PY_CPPFLAGS) $(CPPFLAGS) $(SHLIB_FLAGS) $< |
| | | + |
| | | +check_offset: $(srcdir)/py_db/check_offsets.c |
| | | + $(CC) -o $@ $(CFLAGS) $(PY_CPPFLAGS) $(CPPFLAGS) $< |
| | | + |
| | | +build-py_db: libpython3.4_db.so.1.0 check_offset |
| | | + |
| | | +install-py_db: libpython3.4_db.so.1.0 check_offset |
| | | + $(INSTALL_SHARED) libpython3.4_db.so.1.0 $(DESTDIR)$(LIBDIR) |
| | | + $(INSTALL_PROGRAM) check_offset $(DESTDIR)$(BINDIR) |
| | | |
| | | Modules/Setup: $(srcdir)/Modules/Setup.dist |
| | | @if test -f Modules/Setup; then \ |
| | | @@ -1027,7 +1040,7 @@ |
| | | $(TESTRUNNER) $(QUICKTESTOPTS) |
| | | |
| | | |
| | | -install: @FRAMEWORKINSTALLFIRST@ commoninstall bininstall maninstall @FRAMEWORKINSTALLLAST@ |
| | | +install: @FRAMEWORKINSTALLFIRST@ commoninstall bininstall maninstall install-py_db @FRAMEWORKINSTALLLAST@ |
| | | if test "x$(ENSUREPIP)" != "xno" ; then \ |
| | | case $(ENSUREPIP) in \ |
| | | upgrade) ensurepip="--upgrade" ;; \ |
| | | --- /dev/null |
| | | +++ Python-3.4.0/py_db/check_offsets.c |
| | | @@ -0,0 +1,87 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | +/* |
| | | + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +#include <stdio.h> |
| | | + |
| | | +#include <Python.h> |
| | | +#include <frameobject.h> |
| | | + |
| | | +#include "libpython34_db_32.h" |
| | | + |
| | | +#if 0 |
| | | +#define offsetof(s, m) ((size_t)(&(((s *)0)->m))) |
| | | +#endif |
| | | + |
| | | +int |
| | | +main(void) |
| | | +{ |
| | | +/* |
| | | + * PyCodeObject co_name |
| | | + * PyCodeObject co_filename |
| | | + * PyCodeObject co_lnotab |
| | | + * PyFrameObject f_back |
| | | + * PyFrameObject f_code |
| | | + * PyFrameObject f_lasti |
| | | + * PyInterpreterState next |
| | | + * PyInterpreterState tstate_head |
| | | + * PyBytesObject ob_sval |
| | | + * PyBytesObject ob_size |
| | | + * PyThreadState frame |
| | | + * PyThreadState next |
| | | + */ |
| | | + |
| | | + printf("struct member: native 32\n"); |
| | | + printf("PyCodeObject co_name: %d %d\n", offsetof(PyCodeObject, co_name), |
| | | + offsetof(PyCodeObject32, co_name)); |
| | | + printf("PyCodeObject co_filename: %d %d\n", offsetof(PyCodeObject, |
| | | + co_filename), offsetof(PyCodeObject32, co_filename)); |
| | | + printf("PyCodeObject co_lnotab: %d %d\n", offsetof(PyCodeObject, |
| | | + co_lnotab), offsetof(PyCodeObject32, co_lnotab)); |
| | | + printf("PyFrameObject f_back: %d %d\n", offsetof(PyFrameObject, f_back), |
| | | + offsetof(PyFrameObject32, f_back)); |
| | | + printf("PyFrameObject f_code: %d %d\n", offsetof(PyFrameObject, f_code), |
| | | + offsetof(PyFrameObject32, f_code)); |
| | | + printf("PyFrameObject f_lasti: %d %d\n", offsetof(PyFrameObject, |
| | | + f_lasti), offsetof(PyFrameObject32, f_lasti)); |
| | | + printf("PyInterpreterState next: %d %d\n", offsetof(PyInterpreterState, |
| | | + next), offsetof(PyInterpreterState32, next)); |
| | | + printf("PyInterpreterState tstate_head: %d %d\n", |
| | | + offsetof(PyInterpreterState, tstate_head), |
| | | + offsetof(PyInterpreterState32, tstate_head)); |
| | | + printf("PyBytesObject ob_sval: %d %d\n", offsetof(PyBytesObject, |
| | | + ob_sval), offsetof(PyBytesObject32, ob_sval)); |
| | | + printf("PyBytesObject ob_size: %d %d\n", offsetof(PyBytesObject, |
| | | + ob_base.ob_size), offsetof(PyBytesObject32, ob_size)); |
| | | + printf("PyThreadState frame: %d %d\n", offsetof(PyThreadState, frame), |
| | | + offsetof(PyThreadState32, frame)); |
| | | + printf("PyThreadState next: %d %d\n", offsetof(PyThreadState, next), |
| | | + offsetof(PyThreadState32, next)); |
| | | + |
| | | + printf("\nObject sizes\n"); |
| | | + printf("PyObject: %d %d\n", sizeof (PyObject), sizeof (PyObject32)); |
| | | + printf("PyVarObject: %d %d\n", sizeof (PyVarObject), |
| | | + sizeof (PyVarObject32)); |
| | | + |
| | | + return (0); |
| | | +} |
| | | --- /dev/null |
| | | +++ Python-3.4.0/py_db/libpython34_db.c |
| | | @@ -0,0 +1,654 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | +/* |
| | | + * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +#include <stdio.h> |
| | | +#include <stdlib.h> |
| | | +#include <string.h> |
| | | +#include <errno.h> |
| | | +#include <gelf.h> |
| | | + |
| | | +#include <Python.h> |
| | | +#include <frameobject.h> |
| | | + |
| | | +#include "libpython34_db.h" |
| | | +#if defined(_LP64) |
| | | +#include "libpython34_db_32.h" |
| | | +#endif /* _LP64 */ |
| | | + |
| | | +/* |
| | | + * Because MDB always runs the debugger in the same datamodel as the target, |
| | | + * only functions that are used by the procfs part of this interface (or shared |
| | | + * between the two) are written as 64->32 aware. |
| | | + */ |
| | | +typedef struct pydb_arch_ops { |
| | | + ssize_t (*strobj_readdata)(pydb_agent_t *, uintptr_t, unsigned char *, |
| | | + size_t); |
| | | + int (*frameinfo)(pydb_agent_t *, uintptr_t, char *, |
| | | + size_t, char *, size_t, int *); |
| | | +} pydb_arch_ops_t; |
| | | + |
| | | +struct pydb_agent { |
| | | + struct ps_prochandle *pdb_ph; |
| | | + int pdb_vers; |
| | | + int pdb_is_64bit; |
| | | + int pdb_datamodel; |
| | | + const pydb_arch_ops_t *pdb_ops; |
| | | +}; |
| | | + |
| | | +typedef uintptr_t (*pdi_next_cb_t)(pydb_iter_t *); |
| | | + |
| | | +struct pydb_iter { |
| | | + struct ps_prochandle *pdi_ph; |
| | | + uintptr_t pdi_current; |
| | | + pdi_next_cb_t pdi_nextf; |
| | | +}; |
| | | + |
| | | +#define LIBPYTHON "libpython3.4.so" |
| | | + |
| | | +#define MIN(x, y) (((x) < (y)) ? (x) : (y)) |
| | | + |
| | | +/* Generic interface to helper functions */ |
| | | +static ssize_t pydb_strobj_readdata(pydb_agent_t *py, uintptr_t addr, |
| | | + unsigned char *buf, size_t buf_len); |
| | | +static int pydb_getlno(pydb_agent_t *py, uintptr_t lnotab_addr, int firstline, |
| | | + int lastinst); |
| | | +static int pydb_frameinfo(pydb_agent_t *py, uintptr_t addr, char *funcnm, |
| | | + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno); |
| | | + |
| | | +/* datamodel specific implementation of helper functions */ |
| | | +static ssize_t pydb_strobj_readdata_native(pydb_agent_t *py, uintptr_t addr, |
| | | + unsigned char *buf, size_t buf_len); |
| | | +static int pydb_frameinfo_native(pydb_agent_t *py, uintptr_t addr, char *funcnm, |
| | | + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno); |
| | | + |
| | | +#if defined (_LP64) |
| | | +static ssize_t pydb_strobj_readdata_32(pydb_agent_t *py, uintptr_t addr, |
| | | + unsigned char *buf, size_t buf_len); |
| | | +static int pydb_frameinfo_32(pydb_agent_t *py, uintptr_t addr, char *funcnm, |
| | | + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno); |
| | | +#endif /* _LP64 */ |
| | | + |
| | | +static ssize_t pydb_strobj_readstr(pydb_agent_t *py, uintptr_t addr, char *buf, |
| | | + size_t len); |
| | | + |
| | | +/* Iterator function next routines. Plugable, configured by iterator init */ |
| | | +static uintptr_t pydb_frame_iter_next(pydb_iter_t *iter); |
| | | +static uintptr_t pydb_interp_iter_next(pydb_iter_t *iter); |
| | | +static uintptr_t pydb_thread_iter_next(pydb_iter_t *iter); |
| | | + |
| | | +static const char *strbasename(const char *s); |
| | | + |
| | | +static const pydb_arch_ops_t arch_ops_native = { |
| | | + .frameinfo = pydb_frameinfo_native, |
| | | + .strobj_readdata = pydb_strobj_readdata_native, |
| | | +}; |
| | | + |
| | | +#if defined (_LP64) |
| | | +static const pydb_arch_ops_t arch_ops_32 = { |
| | | + .frameinfo = pydb_frameinfo_32, |
| | | + .strobj_readdata = pydb_strobj_readdata_32, |
| | | +}; |
| | | +#endif /* _LP64 */ |
| | | + |
| | | +static const char * |
| | | +strbasename(const char *s) |
| | | +{ |
| | | + const char *p = strrchr(s, '/'); |
| | | + |
| | | + if (p == NULL) |
| | | + return (s); |
| | | + |
| | | + return (++p); |
| | | +} |
| | | + |
| | | +/* Agent creation / destruction routines */ |
| | | + |
| | | +pydb_agent_t * |
| | | +pydb_agent_create(struct ps_prochandle *P, int vers) |
| | | +{ |
| | | + pydb_agent_t *py; |
| | | + int datamodel; |
| | | + |
| | | + if (vers != PYDB_VERSION) { |
| | | + errno = ENOTSUP; |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + if (ps_pdmodel(P, &datamodel) != PS_OK) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + py = (pydb_agent_t *)malloc(sizeof (pydb_agent_t)); |
| | | + if (py == NULL) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + py->pdb_ph = P; |
| | | + py->pdb_vers = vers; |
| | | + py->pdb_datamodel = datamodel; |
| | | + py->pdb_is_64bit = 0; |
| | | + py->pdb_ops = &arch_ops_native; |
| | | + |
| | | +#if defined (_LP64) |
| | | + py->pdb_is_64bit = (datamodel == PR_MODEL_LP64); |
| | | + if (!py->pdb_is_64bit) { |
| | | + py->pdb_ops = &arch_ops_32; |
| | | + } |
| | | +#endif /* _LP64 */ |
| | | + |
| | | + return (py); |
| | | +} |
| | | + |
| | | +void |
| | | +pydb_agent_destroy(pydb_agent_t *py) |
| | | +{ |
| | | + if (py == NULL) { |
| | | + return; |
| | | + } |
| | | + |
| | | + free(py); |
| | | +} |
| | | + |
| | | +/* Helper functions */ |
| | | +static int |
| | | +pydb_getlno(pydb_agent_t *py, uintptr_t lnotab_addr, int firstline, |
| | | + int lastinst) |
| | | +{ |
| | | + unsigned char lnotab[4096]; |
| | | + ssize_t lnotab_len; |
| | | + int addr, line; |
| | | + int i; |
| | | + |
| | | + lnotab_len = pydb_strobj_readdata(py, lnotab_addr, lnotab, |
| | | + sizeof (lnotab)); |
| | | + if (lnotab_len < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + /* |
| | | + * Python's line number algorithm is arcane. See here for details: |
| | | + * http://svn.python.org/projects/python/trunk/Objects/lnotab_notes.txt |
| | | + */ |
| | | + |
| | | + line = firstline; |
| | | + for (addr = i = 0; i < lnotab_len; i += 2) { |
| | | + if (addr + lnotab[i] > lastinst) { |
| | | + break; |
| | | + } |
| | | + addr += lnotab[i]; |
| | | + line += lnotab[i + 1]; |
| | | + } |
| | | + |
| | | + return (line); |
| | | +} |
| | | + |
| | | +static ssize_t |
| | | +pydb_strobj_readdata(pydb_agent_t *py, uintptr_t addr, unsigned char *buf, |
| | | + size_t buf_len) |
| | | +{ |
| | | + return (py->pdb_ops->strobj_readdata(py, addr, buf, buf_len)); |
| | | +} |
| | | + |
| | | +static ssize_t |
| | | +pydb_strobj_readdata_native(pydb_agent_t *py, uintptr_t addr, |
| | | + unsigned char *buf, size_t buf_len) |
| | | +{ |
| | | + PyBytesObject sobj; |
| | | + ssize_t obj_sz; |
| | | + ssize_t read_sz; |
| | | + psaddr_t straddr; |
| | | + |
| | | + /* |
| | | + * PyBytesObject are variable size. The size of the PyBytesObject |
| | | + * struct is fixed, and known at compile time; however, the size of the |
| | | + * associated buffer is variable. The char[1] element at the end of the |
| | | + * structure contains the string, and the ob_size of the PyBytesObject |
| | | + * indicates how much extra space was allocated to contain the string |
| | | + * buffer at the object's tail. Read in the fixed size portion of the |
| | | + * object first, and then read the contents of the data buffer into the |
| | | + * buffer passed by the caller. |
| | | + */ |
| | | + |
| | | + if (ps_pread(py->pdb_ph, addr, &sobj, sizeof (PyBytesObject)) |
| | | + != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + obj_sz = (ssize_t)PyString_GET_SIZE(&sobj); |
| | | + |
| | | + read_sz = MIN(obj_sz, (ssize_t)buf_len); |
| | | + straddr = (psaddr_t)(addr + offsetof(PyBytesObject, ob_sval)); |
| | | + |
| | | + if (ps_pread(py->pdb_ph, straddr, buf, (size_t)read_sz) != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + return (read_sz); |
| | | +} |
| | | + |
| | | +#if defined(_LP64) |
| | | +static ssize_t |
| | | +pydb_strobj_readdata_32(pydb_agent_t *py, uintptr_t addr, |
| | | + unsigned char *buf, size_t buf_len) |
| | | +{ |
| | | + PyBytesObject32 sobj; |
| | | + ssize_t obj_sz; |
| | | + ssize_t read_sz; |
| | | + psaddr_t straddr; |
| | | + |
| | | + /* |
| | | + * PyBytesObject are variable size. The size of the PyBytesObject |
| | | + * struct is fixed, and known at compile time; however, the size of the |
| | | + * associated buffer is variable. The char[1] element at the end of the |
| | | + * structure contains the string, and the ob_size of the PyBytesObject |
| | | + * indicates how much extra space was allocated to contain the string |
| | | + * buffer at the object's tail. Read in the fixed size portion of the |
| | | + * object first, and then read the contents of the data buffer into the |
| | | + * buffer passed by the caller. |
| | | + */ |
| | | + |
| | | + if (ps_pread(py->pdb_ph, addr, &sobj, sizeof (PyBytesObject32)) |
| | | + != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + obj_sz = (ssize_t)PyString_GET_SIZE32(&sobj); |
| | | + |
| | | + read_sz = MIN(obj_sz, (ssize_t)buf_len); |
| | | + straddr = (psaddr_t)(addr + offsetof(PyBytesObject32, ob_sval)); |
| | | + |
| | | + if (ps_pread(py->pdb_ph, straddr, buf, (size_t)read_sz) != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + return (read_sz); |
| | | +} |
| | | +#endif /* _LP64 */ |
| | | + |
| | | +/* |
| | | + * Most Python PyBytesObject contain strings, as one would expect. However, |
| | | + * due to some sleazy hackery in parts of the Python code, some string objects |
| | | + * are used as buffers for binary data. In the general case, |
| | | + * pydb_strobj_readstr() should be used to read strings out of string objects. |
| | | + * It wraps pydb_strobj_readdata(), which should be used by callers only when |
| | | + * trying to retrieve binary data. (This routine does some string cleanup). |
| | | + */ |
| | | +static ssize_t |
| | | +pydb_strobj_readstr(pydb_agent_t *py, uintptr_t addr, char *buf, |
| | | + size_t buf_len) |
| | | +{ |
| | | + ssize_t read_sz; |
| | | + |
| | | + read_sz = pydb_strobj_readdata(py, addr, (unsigned char *)buf, buf_len); |
| | | + |
| | | + if (read_sz >= 0) { |
| | | + if (read_sz >= buf_len) { |
| | | + read_sz = buf_len - 1; |
| | | + } |
| | | + |
| | | + buf[read_sz] = '\0'; |
| | | + } |
| | | + |
| | | + return (read_sz); |
| | | +} |
| | | + |
| | | + |
| | | +static int |
| | | +pydb_frameinfo(pydb_agent_t *py, uintptr_t addr, char *funcnm, |
| | | + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno) |
| | | +{ |
| | | + return (py->pdb_ops->frameinfo(py, addr, funcnm, funcnm_sz, |
| | | + filenm, filenm_sz, lineno)); |
| | | +} |
| | | + |
| | | +static int |
| | | +pydb_frameinfo_native(pydb_agent_t *py, uintptr_t addr, char *funcnm, |
| | | + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno) |
| | | +{ |
| | | + PyFrameObject fo; |
| | | + PyCodeObject co; |
| | | + ssize_t rc; |
| | | + |
| | | + if (ps_pread(py->pdb_ph, addr, &fo, sizeof (PyFrameObject)) |
| | | + != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + if (ps_pread(py->pdb_ph, (uintptr_t)fo.f_code, &co, |
| | | + sizeof (PyCodeObject)) != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + rc = pydb_strobj_readstr(py, (uintptr_t)co.co_name, funcnm, funcnm_sz); |
| | | + if (rc < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + rc = pydb_strobj_readstr(py, (uintptr_t)co.co_filename, filenm, |
| | | + filenm_sz); |
| | | + if (rc < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + *lineno = pydb_getlno(py, (uintptr_t)co.co_lnotab, co.co_firstlineno, |
| | | + fo.f_lasti); |
| | | + if (*lineno < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + return (0); |
| | | +} |
| | | + |
| | | +#if defined (_LP64) |
| | | +static int |
| | | +pydb_frameinfo_32(pydb_agent_t *py, uintptr_t addr, char *funcnm, |
| | | + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno) |
| | | +{ |
| | | + PyFrameObject32 fo; |
| | | + PyCodeObject32 co; |
| | | + ssize_t rc; |
| | | + |
| | | + if (ps_pread(py->pdb_ph, addr, &fo, sizeof (PyFrameObject32)) |
| | | + != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + if (ps_pread(py->pdb_ph, (uintptr_t)fo.f_code, &co, |
| | | + sizeof (PyCodeObject32)) != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + rc = pydb_strobj_readstr(py, (uintptr_t)co.co_name, funcnm, funcnm_sz); |
| | | + if (rc < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + rc = pydb_strobj_readstr(py, (uintptr_t)co.co_filename, filenm, |
| | | + filenm_sz); |
| | | + if (rc < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + *lineno = pydb_getlno(py, (uintptr_t)co.co_lnotab, co.co_firstlineno, |
| | | + fo.f_lasti); |
| | | + if (*lineno < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + return (0); |
| | | +} |
| | | + |
| | | +#endif /* _LP64 */ |
| | | + |
| | | +/* Functions that are part of the library's interface */ |
| | | + |
| | | +/* |
| | | + * Given the address of a PyFrameObject, and a buffer of a known size, |
| | | + * fill the buffer with a description of the frame. |
| | | + */ |
| | | +int |
| | | +pydb_get_frameinfo(pydb_agent_t *py, uintptr_t frame_addr, char *fbuf, |
| | | + size_t bufsz, int verbose) |
| | | +{ |
| | | + char funcname[1024]; |
| | | + char filename[1024]; |
| | | + char *fn; |
| | | + int lineno; |
| | | + int length = (py->pdb_is_64bit ? 16 : 8); |
| | | + int rc; |
| | | + |
| | | + rc = pydb_frameinfo(py, frame_addr, funcname, sizeof (funcname), |
| | | + filename, sizeof (filename), &lineno); |
| | | + if (rc < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + if (!verbose) { |
| | | + fn = (char *)strbasename(filename); |
| | | + } else { |
| | | + fn = filename; |
| | | + } |
| | | + |
| | | + (void) snprintf(fbuf, bufsz, "%0.*lx %s:%d %s()\n", length, |
| | | + frame_addr, fn, lineno, funcname); |
| | | + |
| | | + return (0); |
| | | +} |
| | | + |
| | | +/* |
| | | + * Return a description about a PyFrameObject, if the object is |
| | | + * actually a PyFrameObject. In this case, the pc argument is checked |
| | | + * to make sure that it came from a function that takes a PyFrameObject |
| | | + * as its first (argv[0]) argument. |
| | | + */ |
| | | +int |
| | | +pydb_pc_frameinfo(pydb_agent_t *py, uintptr_t pc, uintptr_t frame_addr, |
| | | + char *fbuf, size_t bufsz) |
| | | +{ |
| | | + char funcname[1024]; |
| | | + char filename[1024]; |
| | | + int lineno; |
| | | + int rc; |
| | | + ps_sym_t psym; |
| | | + |
| | | + /* |
| | | + * If PC doesn't match PyEval_EvalFrameEx in either libpython |
| | | + * or the executable, don't decode it. |
| | | + */ |
| | | + if (ps_pglobal_sym(py->pdb_ph, LIBPYTHON, "PyEval_EvalFrameEx", &psym) |
| | | + != PS_OK) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + /* If symbol found, ensure that PC falls within PyEval_EvalFrameEx. */ |
| | | + if (pc < psym.st_value || pc > psym.st_value + psym.st_size) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + rc = pydb_frameinfo(py, frame_addr, funcname, sizeof (funcname), |
| | | + filename, sizeof (filename), &lineno); |
| | | + if (rc < 0) { |
| | | + return (-1); |
| | | + } |
| | | + |
| | | + (void) snprintf(fbuf, bufsz, "[ %s:%d (%s) ]\n", filename, lineno, |
| | | + funcname); |
| | | + |
| | | + return (0); |
| | | +} |
| | | + |
| | | +/* |
| | | + * Walks the list of PyInterpreterState objects. If caller doesn't |
| | | + * supply address of list, this method will look it up. |
| | | + */ |
| | | +pydb_iter_t * |
| | | +pydb_interp_iter_init(pydb_agent_t *py, uintptr_t addr) |
| | | +{ |
| | | + pydb_iter_t *itr; |
| | | + uintptr_t i_addr; |
| | | + int rc; |
| | | + |
| | | + if (addr == 0) { |
| | | + rc = ps_pglobal_lookup(py->pdb_ph, LIBPYTHON, "interp_head", |
| | | + (psaddr_t *)&addr); |
| | | + if (rc != PS_OK) { |
| | | + return (NULL); |
| | | + } |
| | | + } |
| | | + |
| | | + if (ps_pread(py->pdb_ph, (uintptr_t)addr, &i_addr, sizeof (uintptr_t)) |
| | | + != PS_OK) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + itr = malloc(sizeof (pydb_iter_t)); |
| | | + if (itr == NULL) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + itr->pdi_ph = py->pdb_ph; |
| | | + itr->pdi_current = i_addr; |
| | | + itr->pdi_nextf = pydb_interp_iter_next; |
| | | + |
| | | + return (itr); |
| | | +} |
| | | + |
| | | +static uintptr_t |
| | | +pydb_interp_iter_next(pydb_iter_t *iter) |
| | | +{ |
| | | + PyInterpreterState st; |
| | | + uintptr_t cur; |
| | | + |
| | | + cur = iter->pdi_current; |
| | | + |
| | | + if (cur == 0) { |
| | | + return (cur); |
| | | + } |
| | | + |
| | | + if (ps_pread(iter->pdi_ph, cur, &st, sizeof (PyInterpreterState)) |
| | | + != PS_OK) { |
| | | + iter->pdi_current = 0; |
| | | + return (0); |
| | | + } |
| | | + |
| | | + iter->pdi_current = (uintptr_t)st.next; |
| | | + |
| | | + return (cur); |
| | | +} |
| | | + |
| | | +/* |
| | | + * Walk a list of Python PyFrameObjects. The addr argument must be |
| | | + * the address of a valid PyThreadState object. |
| | | + */ |
| | | +pydb_iter_t * |
| | | +pydb_frame_iter_init(pydb_agent_t *py, uintptr_t addr) |
| | | +{ |
| | | + pydb_iter_t *itr; |
| | | + PyThreadState ts; |
| | | + |
| | | + if (ps_pread(py->pdb_ph, (uintptr_t)addr, &ts, sizeof (PyThreadState)) |
| | | + != PS_OK) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + itr = malloc(sizeof (pydb_iter_t)); |
| | | + if (itr == NULL) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + itr->pdi_ph = py->pdb_ph; |
| | | + itr->pdi_current = (uintptr_t)ts.frame; |
| | | + itr->pdi_nextf = pydb_frame_iter_next; |
| | | + |
| | | + return (itr); |
| | | +} |
| | | + |
| | | +static uintptr_t |
| | | +pydb_frame_iter_next(pydb_iter_t *iter) |
| | | +{ |
| | | + PyFrameObject fo; |
| | | + uintptr_t cur; |
| | | + |
| | | + cur = iter->pdi_current; |
| | | + |
| | | + if (cur == 0) { |
| | | + return (cur); |
| | | + } |
| | | + |
| | | + if (ps_pread(iter->pdi_ph, cur, &fo, sizeof (PyFrameObject)) |
| | | + != PS_OK) { |
| | | + iter->pdi_current = 0; |
| | | + return (0); |
| | | + } |
| | | + |
| | | + iter->pdi_current = (uintptr_t)fo.f_back; |
| | | + |
| | | + return (cur); |
| | | +} |
| | | + |
| | | +/* |
| | | + * Walk a list of Python PyThreadState objects. The addr argument must be |
| | | + * the address of a valid PyInterpreterState object. |
| | | + */ |
| | | +pydb_iter_t * |
| | | +pydb_thread_iter_init(pydb_agent_t *py, uintptr_t addr) |
| | | +{ |
| | | + pydb_iter_t *itr; |
| | | + PyInterpreterState is; |
| | | + |
| | | + if (ps_pread(py->pdb_ph, (uintptr_t)addr, &is, |
| | | + sizeof (PyInterpreterState)) != PS_OK) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + itr = malloc(sizeof (pydb_iter_t)); |
| | | + if (itr == NULL) { |
| | | + return (NULL); |
| | | + } |
| | | + |
| | | + itr->pdi_ph = py->pdb_ph; |
| | | + itr->pdi_current = (uintptr_t)is.tstate_head; |
| | | + itr->pdi_nextf = pydb_thread_iter_next; |
| | | + |
| | | + return (itr); |
| | | +} |
| | | + |
| | | +static uintptr_t |
| | | +pydb_thread_iter_next(pydb_iter_t *iter) |
| | | +{ |
| | | + PyThreadState ts; |
| | | + uintptr_t cur; |
| | | + |
| | | + cur = iter->pdi_current; |
| | | + |
| | | + if (cur == 0) { |
| | | + return (cur); |
| | | + } |
| | | + |
| | | + if (ps_pread(iter->pdi_ph, cur, &ts, sizeof (PyThreadState)) != PS_OK) { |
| | | + iter->pdi_current = 0; |
| | | + return (0); |
| | | + } |
| | | + |
| | | + iter->pdi_current = (uintptr_t)ts.next; |
| | | + |
| | | + return (cur); |
| | | +} |
| | | + |
| | | + |
| | | +uintptr_t |
| | | +pydb_iter_next(pydb_iter_t *iter) |
| | | +{ |
| | | + return (iter->pdi_nextf(iter)); |
| | | +} |
| | | + |
| | | +void |
| | | +pydb_iter_fini(pydb_iter_t *iter) |
| | | +{ |
| | | + if (iter == NULL) { |
| | | + return; |
| | | + } |
| | | + |
| | | + free(iter); |
| | | +} |
| | | --- /dev/null |
| | | +++ Python-3.4.0/py_db/libpython34_db.h |
| | | @@ -0,0 +1,73 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | +/* |
| | | + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +#ifndef _LIBPYTHON34_DB_H |
| | | +#define _LIBPYTHON34_DB_H |
| | | + |
| | | +#include <proc_service.h> |
| | | + |
| | | +#ifdef __cplusplus |
| | | +extern "C" { |
| | | +#endif |
| | | + |
| | | +/* Agent is opaque to library's consumers. */ |
| | | +typedef struct pydb_agent pydb_agent_t; |
| | | + |
| | | +/* |
| | | + * Library's debug version is 1. Changes to interface should increase this |
| | | + * number. |
| | | + */ |
| | | +#define PYDB_VERSION 1 |
| | | + |
| | | +/* Agent creation/destruction routines */ |
| | | +extern pydb_agent_t *pydb_agent_create(struct ps_prochandle *P, int vers); |
| | | +extern void pydb_agent_destroy(pydb_agent_t *py); |
| | | + |
| | | +/* Used by callers that know they are looking at a PyFrameObject */ |
| | | +extern int pydb_get_frameinfo(pydb_agent_t *py, uintptr_t frame_addr, |
| | | + char *fbuf, size_t bufsz, int verbose); |
| | | + |
| | | +/* |
| | | + * Used by callers that don't know if they're looking at PyFrameObject. |
| | | + * Checks PC for traceable functions. |
| | | + */ |
| | | +extern int pydb_pc_frameinfo(pydb_agent_t *py, uintptr_t pc, |
| | | + uintptr_t frame_addr, char *fbuf, size_t bufsz); |
| | | + |
| | | +/* Iterator functions */ |
| | | +typedef struct pydb_iter pydb_iter_t; |
| | | + |
| | | +extern pydb_iter_t *pydb_frame_iter_init(pydb_agent_t *py, uintptr_t addr); |
| | | +extern pydb_iter_t *pydb_interp_iter_init(pydb_agent_t *py, |
| | | + uintptr_t addr); |
| | | +extern pydb_iter_t *pydb_thread_iter_init(pydb_agent_t *py, |
| | | + uintptr_t addr); |
| | | +extern void pydb_iter_fini(pydb_iter_t *iter); |
| | | +extern uintptr_t pydb_iter_next(pydb_iter_t *iter); |
| | | + |
| | | +#ifdef __cplusplus |
| | | +} |
| | | +#endif |
| | | + |
| | | +#endif /* _LIBPYTHON34_DB_H */ |
| | | --- /dev/null |
| | | +++ Python-3.4.0/py_db/libpython34_db_32.h |
| | | @@ -0,0 +1,121 @@ |
| | | +/* |
| | | + * CDDL HEADER START |
| | | + * |
| | | + * The contents of this file are subject to the terms of the |
| | | + * Common Development and Distribution License (the "License"). |
| | | + * You may not use this file except in compliance with the License. |
| | | + * |
| | | + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | + * or http://www.opensolaris.org/os/licensing. |
| | | + * See the License for the specific language governing permissions |
| | | + * and limitations under the License. |
| | | + * |
| | | + * When distributing Covered Code, include this CDDL HEADER in each |
| | | + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | + * If applicable, add the following below this CDDL HEADER, with the |
| | | + * fields enclosed by brackets "[]" replaced with your own identifying |
| | | + * information: Portions Copyright [yyyy] [name of copyright owner] |
| | | + * |
| | | + * CDDL HEADER END |
| | | + */ |
| | | +/* |
| | | + * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. |
| | | + */ |
| | | + |
| | | +#ifndef _LIBPYTHON34_DB_32_H |
| | | +#define _LIBPYTHON34_DB_32_H |
| | | + |
| | | +#ifdef __cplusplus |
| | | +extern "C" { |
| | | +#endif |
| | | + |
| | | +#include <sys/types.h> |
| | | + |
| | | +/* |
| | | + * Define 32-bit Python data structures for use by the 64-bit debugger. This |
| | | + * is so that a 64-bit debugger may properly examine a 32-bit process. |
| | | + * |
| | | + * In many cases, the debug library is only concerned with a few fields in the |
| | | + * Python structure. In that case, the other ancillary fields are elided. |
| | | + */ |
| | | + |
| | | +typedef uint32_t uintptr32_t; |
| | | +typedef int32_t Py_ssize32_t; |
| | | + |
| | | +typedef struct _is32 { |
| | | + uintptr32_t next; |
| | | + uintptr32_t tstate_head; |
| | | +} PyInterpreterState32; |
| | | + |
| | | +typedef struct _ts32 { |
| | | + uintptr32_t next; |
| | | + uintptr32_t interp; |
| | | + uintptr32_t frame; |
| | | +} PyThreadState32; |
| | | + |
| | | +#define PyObject_HEAD32 \ |
| | | + Py_ssize32_t ob_refcnt; \ |
| | | + uintptr32_t ob_type; |
| | | + |
| | | +#define PyObject_VAR_HEAD32 \ |
| | | + PyObject_HEAD32 \ |
| | | + Py_ssize32_t ob_size; |
| | | + |
| | | +typedef struct { |
| | | + PyObject_HEAD32 |
| | | +} PyObject32; |
| | | + |
| | | +typedef struct { |
| | | + PyObject_VAR_HEAD32 |
| | | +} PyVarObject32; |
| | | + |
| | | +typedef struct { |
| | | + PyObject_VAR_HEAD32 |
| | | + int32_t ob_shash; |
| | | + int ob_sstate; |
| | | + char ob_sval[1]; |
| | | +} PyBytesObject32; |
| | | + |
| | | +#define Py_SIZE32(ob) (((PyVarObject32*)(ob))->ob_size) |
| | | +#define PyString_GET_SIZE32(op) Py_SIZE32(op) |
| | | +#define PyString_AS_STRING32(op) (((PyBytesObject32 *)(op))->ob_sval) |
| | | + |
| | | +typedef struct { |
| | | + PyObject_VAR_HEAD32 |
| | | + uintptr32_t f_back; |
| | | + uintptr32_t f_code; |
| | | + uintptr32_t f_builtins; |
| | | + uintptr32_t f_globals; |
| | | + uintptr32_t f_locals; |
| | | + uintptr32_t f_valuestack; |
| | | + uintptr32_t f_stacktop; |
| | | + uintptr32_t f_trace; |
| | | + uintptr32_t f_exc_typpe, f_exc_value, f_exc_traceback; |
| | | + uintptr32_t f_tstate; |
| | | + int f_lasti; |
| | | + int f_lineno; |
| | | +} PyFrameObject32; |
| | | + |
| | | +typedef struct { |
| | | + PyObject_HEAD32 |
| | | + int co_argcount; |
| | | + int co_nlocals; |
| | | + int co_stacksize; |
| | | + int co_flags; |
| | | + uintptr32_t co_code; |
| | | + uintptr32_t co_consts; |
| | | + uintptr32_t co_names; |
| | | + uintptr32_t co_varnames; |
| | | + uintptr32_t co_freevars; |
| | | + uintptr32_t co_cellvars; |
| | | + uintptr32_t co_filename; |
| | | + uintptr32_t co_name; |
| | | + int co_firstlineno; |
| | | + uintptr32_t co_lnotab; |
| | | +} PyCodeObject32; |
| | | + |
| | | +#ifdef __cplusplus |
| | | +} |
| | | +#endif |
| | | + |
| | | +#endif /* _LIBPYTHON34_DB_32_H */ |
| | | --- /dev/null |
| | | +++ Python-3.4.0/py_db/mapfile-vers |
| | | @@ -0,0 +1,39 @@ |
| | | +# |
| | | +# CDDL HEADER START |
| | | +# |
| | | +# The contents of this file are subject to the terms of the |
| | | +# Common Development and Distribution License (the "License"). |
| | | +# You may not use this file except in compliance with the License. |
| | | +# |
| | | +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | +# or http://www.opensolaris.org/os/licensing. |
| | | +# See the License for the specific language governing permissions |
| | | +# and limitations under the License. |
| | | +# |
| | | +# When distributing Covered Code, include this CDDL HEADER in each |
| | | +# file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | +# If applicable, add the following below this CDDL HEADER, with the |
| | | +# fields enclosed by brackets "[]" replaced with your own identifying |
| | | +# information: Portions Copyright [yyyy] [name of copyright owner] |
| | | +# |
| | | +# CDDL HEADER END |
| | | +# |
| | | + |
| | | +# |
| | | +# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. |
| | | +# |
| | | + |
| | | +SUNWprivate_1.1 { |
| | | + global: |
| | | + pydb_agent_create; |
| | | + pydb_agent_destroy; |
| | | + pydb_frame_iter_init; |
| | | + pydb_get_frameinfo; |
| | | + pydb_pc_frameinfo; |
| | | + pydb_interp_iter_init; |
| | | + pydb_thread_iter_init; |
| | | + pydb_iter_fini; |
| | | + pydb_iter_next; |
| | | + local: |
| | | + *; |
| | | +}; |
New file |
| | |
| | | This patch adds wget_wch support to the curses module. It may be contributed |
| | | upstream at some point, but the suitability (or lack thereof) has not yet |
| | | been determined. |
| | | |
| | | --- Python-3.4.0/Modules/_cursesmodule.c.~1~ 2014-03-16 19:31:31.000000000 -0700 |
| | | +++ Python-3.4.0/Modules/_cursesmodule.c 2014-03-17 13:44:21.194828659 -0700 |
| | | @@ -1187,6 +1187,37 @@ |
| | | } |
| | | |
| | | static PyObject * |
| | | +PyCursesWindow_Get_WCh(PyCursesWindowObject *self, PyObject *args) |
| | | +{ |
| | | + int x, y; |
| | | + int ct; |
| | | + wint_t rtn; |
| | | + |
| | | + switch (PyTuple_Size(args)) { |
| | | + case 0: |
| | | + Py_BEGIN_ALLOW_THREADS |
| | | + ct = wget_wch(self->win,&rtn); |
| | | + Py_END_ALLOW_THREADS |
| | | + break; |
| | | + case 2: |
| | | + if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x)) |
| | | + return NULL; |
| | | + Py_BEGIN_ALLOW_THREADS |
| | | + ct = mvwget_wch(self->win,y,x,&rtn); |
| | | + Py_END_ALLOW_THREADS |
| | | + break; |
| | | + default: |
| | | + PyErr_SetString(PyExc_TypeError, "get_wch requires 0 or 2 arguments"); |
| | | + return NULL; |
| | | + } |
| | | + if (ct == ERR) { |
| | | + PyErr_SetString(PyCursesError, "get_wch failed"); |
| | | + return NULL; |
| | | + } |
| | | + return PyLong_FromLong((long)rtn); |
| | | +} |
| | | + |
| | | +static PyObject * |
| | | PyCursesWindow_GetKey(PyCursesWindowObject *self, PyObject *args) |
| | | { |
| | | int x, y; |
| | | @@ -2059,6 +2090,7 @@ |
| | | {"getbegyx", (PyCFunction)PyCursesWindow_getbegyx, METH_NOARGS}, |
| | | {"getbkgd", (PyCFunction)PyCursesWindow_GetBkgd, METH_NOARGS}, |
| | | {"getch", (PyCFunction)PyCursesWindow_GetCh, METH_VARARGS}, |
| | | + {"get_wch", (PyCFunction)PyCursesWindow_Get_WCh, METH_VARARGS}, |
| | | {"getkey", (PyCFunction)PyCursesWindow_GetKey, METH_VARARGS}, |
| | | #ifdef HAVE_NCURSESW |
| | | {"get_wch", (PyCFunction)PyCursesWindow_Get_WCh, METH_VARARGS}, |
New file |
| | |
| | | This patch is needed to make Python understand it can build the OSS plugin. |
| | | Some OSS ioctls are not supported on Solaris, so they are ifdef'd out. As |
| | | the patch is Solaris-specific, it is not suitable for upstream. |
| | | |
| | | --- Python-3.4.0/setup.py.~6~ 2014-03-19 10:50:15.496976758 -0700 |
| | | +++ Python-3.4.0/setup.py 2014-03-19 10:50:15.609798728 -0700 |
| | | @@ -1551,7 +1551,7 @@ |
| | | # End multiprocessing |
| | | |
| | | # Platform-specific libraries |
| | | - if host_platform.startswith(('linux', 'freebsd', 'gnukfreebsd')): |
| | | + if host_platform.startswith(('sunos5', 'linux', 'freebsd', 'gnukfreebsd')): |
| | | exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) ) |
| | | else: |
| | | missing.append('ossaudiodev') |
| | | --- Python-3.4.0/Modules/ossaudiodev.c.~1~ 2014-03-16 19:31:31.000000000 -0700 |
| | | +++ Python-3.4.0/Modules/ossaudiodev.c 2014-03-17 13:48:16.395254733 -0700 |
| | | @@ -1211,6 +1211,7 @@ |
| | | _EXPORT_INT(m, SOUND_MIXER_MONITOR); |
| | | #endif |
| | | |
| | | +#ifndef __sun |
| | | /* Expose all the ioctl numbers for masochists who like to do this |
| | | stuff directly. */ |
| | | _EXPORT_INT(m, SNDCTL_COPR_HALT); |
| | | @@ -1223,6 +1224,7 @@ |
| | | _EXPORT_INT(m, SNDCTL_COPR_SENDMSG); |
| | | _EXPORT_INT(m, SNDCTL_COPR_WCODE); |
| | | _EXPORT_INT(m, SNDCTL_COPR_WDATA); |
| | | +#endif |
| | | #ifdef SNDCTL_DSP_BIND_CHANNEL |
| | | _EXPORT_INT(m, SNDCTL_DSP_BIND_CHANNEL); |
| | | #endif |
| | | @@ -1244,8 +1246,12 @@ |
| | | _EXPORT_INT(m, SNDCTL_DSP_GETSPDIF); |
| | | #endif |
| | | _EXPORT_INT(m, SNDCTL_DSP_GETTRIGGER); |
| | | +#ifdef SNDCTL_DSP_MAPINBUF |
| | | _EXPORT_INT(m, SNDCTL_DSP_MAPINBUF); |
| | | +#endif |
| | | +#ifdef SNDCTL_DSP_MAPOUTBUF |
| | | _EXPORT_INT(m, SNDCTL_DSP_MAPOUTBUF); |
| | | +#endif |
| | | _EXPORT_INT(m, SNDCTL_DSP_NONBLOCK); |
| | | _EXPORT_INT(m, SNDCTL_DSP_POST); |
| | | #ifdef SNDCTL_DSP_PROFILE |
| | | @@ -1265,6 +1271,7 @@ |
| | | _EXPORT_INT(m, SNDCTL_DSP_STEREO); |
| | | _EXPORT_INT(m, SNDCTL_DSP_SUBDIVIDE); |
| | | _EXPORT_INT(m, SNDCTL_DSP_SYNC); |
| | | +#ifndef __sun |
| | | _EXPORT_INT(m, SNDCTL_FM_4OP_ENABLE); |
| | | _EXPORT_INT(m, SNDCTL_FM_LOAD_INSTR); |
| | | _EXPORT_INT(m, SNDCTL_MIDI_INFO); |
| | | @@ -1306,5 +1313,6 @@ |
| | | _EXPORT_INT(m, SNDCTL_TMR_STOP); |
| | | _EXPORT_INT(m, SNDCTL_TMR_TEMPO); |
| | | _EXPORT_INT(m, SNDCTL_TMR_TIMEBASE); |
| | | +#endif |
| | | return m; |
| | | } |
New file |
| | |
| | | On Solaris pyconfig.h is delivered in the normal python header directory. |
| | | As this is Solaris-specific, it is not suitable for upstream. |
| | | |
| | | --- Python-3.4.0/Lib/distutils/sysconfig.py.~1~ 2014-03-16 19:31:29.000000000 -0700 |
| | | +++ Python-3.4.0/Lib/distutils/sysconfig.py 2014-03-17 13:50:16.261084406 -0700 |
| | | @@ -242,7 +242,7 @@ |
| | | else: |
| | | inc_dir = _sys_home or project_base |
| | | else: |
| | | - inc_dir = get_python_inc(plat_specific=1) |
| | | + inc_dir = get_python_inc(plat_specific=0) |
| | | if get_python_version() < '2.2': |
| | | config_h = 'config.h' |
| | | else: |
New file |
| | |
| | | This patch is a Solaris-specific hack; it will not be submitted upstream. |
| | | |
| | | --- Python-3.4.0/Lib/distutils/sysconfig.py.~2~ 2014-04-30 09:23:26.632873134 -0700 |
| | | +++ Python-3.4.0/Lib/distutils/sysconfig.py 2014-04-30 10:49:42.395635789 -0700 |
| | | @@ -221,6 +221,22 @@ |
| | | else: |
| | | archiver = ar + ' ' + ar_flags |
| | | |
| | | + # Force PIC compilation. Determine if GNU compiler or otherwise |
| | | + # and set the PIC flag(s) accordingly. Defaults to Studio compiler. |
| | | + if re.search('-.PIC', cflags) == None: |
| | | + try: |
| | | + out = os.popen(cc + ' --version 2>/dev/null', 'r') |
| | | + out_string = out.read() |
| | | + out.close() |
| | | + result = re.search(' (\d+\.\d+(\.\d+)*)', out_string) |
| | | + kpic_flags = "-fPIC -DPIC" if result else "-KPIC -DPIC" |
| | | + except ImportError: |
| | | + # The only time the above should fail is during boot-strapping |
| | | + # when time (os imports subprocess which imports time) is not |
| | | + # yet available. Assume Studio compiler for that case. |
| | | + kpic_flags = "-KPIC -DPIC" |
| | | + cflags += ' ' + kpic_flags |
| | | + |
| | | cc_cmd = cc + ' ' + cflags |
| | | compiler.set_executables( |
| | | preprocessor=cpp, |
New file |
| | |
| | | # |
| | | # CDDL HEADER START |
| | | # |
| | | # The contents of this file are subject to the terms of the |
| | | # Common Development and Distribution License (the "License"). |
| | | # You may not use this file except in compliance with the License. |
| | | # |
| | | # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | # or http://www.opensolaris.org/os/licensing. |
| | | # See the License for the specific language governing permissions |
| | | # and limitations under the License. |
| | | # |
| | | # When distributing Covered Code, include this CDDL HEADER in each |
| | | # file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | # If applicable, add the following below this CDDL HEADER, with the |
| | | # fields enclosed by brackets "[]" replaced with your own identifying |
| | | # information: Portions Copyright [yyyy] [name of copyright owner] |
| | | # |
| | | # CDDL HEADER END |
| | | # |
| | | # Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. |
| | | # |
| | | |
| | | # bootstrap: pkgdepend doesn't like python 3.4 yet; |
| | | # remove this block once it is installed on build machine |
| | | # also look for other "XXX bootstrap" comments |
| | | <transform file path=.+\.py$ -> \ |
| | | default pkg.depend.bypass-generate .* > |
| | | <transform file path=.+\.pyc$ -> \ |
| | | default pkg.depend.bypass-generate .* > |
| | | <transform file path=usr/bin.*$ -> \ |
| | | default pkg.depend.bypass-generate .* > |
| | | |
| | | <transform file path=usr.*/man/.+ -> default mangler.man.stability uncommitted> |
| | | <transform file path=.*/(idle_)?tests?/.* -> default facet.optional.test true> |
| | | set name=pkg.fmri \ |
| | | value=pkg:/runtime/python-34@$(IPS_COMPONENT_VERSION),$(BUILD_VERSION) |
| | | set name=pkg.summary value="The Python interpreter, libraries and utilities" |
| | | set name=com.oracle.info.description value="Python 3.4" |
| | | set name=com.oracle.info.tpno value=17691 |
| | | set name=info.classification \ |
| | | value=org.opensolaris.category.2008:Development/Python |
| | | set name=info.source-url value=$(COMPONENT_ARCHIVE_URL) |
| | | set name=info.upstream-url value=$(COMPONENT_PROJECT_URL) |
| | | set name=org.opensolaris.arc-caseid value=PSARC/2005/555 value=PSARC/2008/514 \ |
| | | value=PSARC/2009/529 value=PSARC/2013/235 value=PSARC/2014/151 |
| | | set name=org.opensolaris.consolidation value=$(CONSOLIDATION) |
| | | # |
| | | link path=usr/bin/$(MACH64)/2to3 target=2to3-3.4 mediator=python \ |
| | | mediator-version=3.4 |
| | | file path=usr/bin/$(MACH64)/2to3-3.4 |
| | | link path=usr/bin/$(MACH64)/idle3 target=idle3.4 mediator=python \ |
| | | mediator-version=3.4 |
| | | file path=usr/bin/$(MACH64)/idle3.4 |
| | | link path=usr/bin/$(MACH64)/pydoc3 target=pydoc3.4 mediator=python \ |
| | | mediator-version=3.4 |
| | | file path=usr/bin/$(MACH64)/pydoc3.4 |
| | | link path=usr/bin/$(MACH64)/python3-config target=python3.4-config \ |
| | | mediator=python mediator-version=3.4 |
| | | file path=usr/bin/$(MACH64)/python3.4 |
| | | file path=usr/bin/$(MACH64)/python3.4-config |
| | | link path=usr/bin/$(MACH64)/pyvenv target=pyvenv-3.4 mediator=python \ |
| | | mediator-version=3.4 |
| | | file path=usr/bin/$(MACH64)/pyvenv-3.4 |
| | | link path=usr/bin/2to3 target=2to3-3.4 mediator=python mediator-version=3.4 |
| | | link path=usr/bin/2to3-3.4 target=$(MACH64)/2to3-3.4 |
| | | link path=usr/bin/idle3 target=idle3.4 mediator=python mediator-version=3.4 |
| | | link path=usr/bin/idle3.4 target=$(MACH64)/idle3.4 |
| | | link path=usr/bin/pydoc3 target=pydoc3.4 mediator=python mediator-version=3.4 |
| | | link path=usr/bin/pydoc3.4 target=$(MACH64)/pydoc3.4 |
| | | link path=usr/bin/python3-config target=python3.4-config mediator=python \ |
| | | mediator-version=3.4 |
| | | link path=usr/bin/python3.4 target=$(MACH64)/python3.4 |
| | | link path=usr/bin/python3.4-config target=$(MACH64)/python3.4-config |
| | | link path=usr/bin/pyvenv target=pyvenv-3.4 mediator=python mediator-version=3.4 |
| | | link path=usr/bin/pyvenv-3.4 target=$(MACH64)/pyvenv-3.4 |
| | | file path=usr/include/python3.4/Python-ast.h |
| | | file path=usr/include/python3.4/Python.h |
| | | file path=usr/include/python3.4/abstract.h |
| | | file path=usr/include/python3.4/accu.h |
| | | file path=usr/include/python3.4/asdl.h |
| | | file path=usr/include/python3.4/ast.h |
| | | file path=usr/include/python3.4/bitset.h |
| | | file path=usr/include/python3.4/bltinmodule.h |
| | | file path=usr/include/python3.4/boolobject.h |
| | | file path=usr/include/python3.4/bytearrayobject.h |
| | | file path=usr/include/python3.4/bytes_methods.h |
| | | file path=usr/include/python3.4/bytesobject.h |
| | | file path=usr/include/python3.4/cellobject.h |
| | | file path=usr/include/python3.4/ceval.h |
| | | file path=usr/include/python3.4/classobject.h |
| | | file path=usr/include/python3.4/code.h |
| | | file path=usr/include/python3.4/codecs.h |
| | | file path=usr/include/python3.4/compile.h |
| | | file path=usr/include/python3.4/complexobject.h |
| | | file path=usr/include/python3.4/datetime.h |
| | | file path=usr/include/python3.4/descrobject.h |
| | | file path=usr/include/python3.4/dictobject.h |
| | | file path=usr/include/python3.4/dtoa.h |
| | | file path=usr/include/python3.4/dynamic_annotations.h |
| | | file path=usr/include/python3.4/enumobject.h |
| | | file path=usr/include/python3.4/errcode.h |
| | | file path=usr/include/python3.4/eval.h |
| | | file path=usr/include/python3.4/fileobject.h |
| | | file path=usr/include/python3.4/fileutils.h |
| | | file path=usr/include/python3.4/floatobject.h |
| | | file path=usr/include/python3.4/frameobject.h |
| | | file path=usr/include/python3.4/funcobject.h |
| | | file path=usr/include/python3.4/genobject.h |
| | | file path=usr/include/python3.4/graminit.h |
| | | file path=usr/include/python3.4/grammar.h |
| | | file path=usr/include/python3.4/import.h |
| | | file path=usr/include/python3.4/intrcheck.h |
| | | file path=usr/include/python3.4/iterobject.h |
| | | file path=usr/include/python3.4/listobject.h |
| | | file path=usr/include/python3.4/longintrepr.h |
| | | file path=usr/include/python3.4/longobject.h |
| | | file path=usr/include/python3.4/marshal.h |
| | | file path=usr/include/python3.4/memoryobject.h |
| | | file path=usr/include/python3.4/metagrammar.h |
| | | file path=usr/include/python3.4/methodobject.h |
| | | file path=usr/include/python3.4/modsupport.h |
| | | file path=usr/include/python3.4/moduleobject.h |
| | | file path=usr/include/python3.4/namespaceobject.h |
| | | file path=usr/include/python3.4/node.h |
| | | file path=usr/include/python3.4/object.h |
| | | file path=usr/include/python3.4/objimpl.h |
| | | file path=usr/include/python3.4/opcode.h |
| | | file path=usr/include/python3.4/osdefs.h |
| | | file path=usr/include/python3.4/parsetok.h |
| | | file path=usr/include/python3.4/patchlevel.h |
| | | file path=usr/include/python3.4/pgen.h |
| | | file path=usr/include/python3.4/pgenheaders.h |
| | | file path=usr/include/python3.4/py_curses.h |
| | | file path=usr/include/python3.4/pyarena.h |
| | | file path=usr/include/python3.4/pyatomic.h |
| | | file path=usr/include/python3.4/pycapsule.h |
| | | file path=usr/include/python3.4/pyconfig.h |
| | | file path=usr/include/python3.4/pyctype.h |
| | | file path=usr/include/python3.4/pydebug.h |
| | | file path=usr/include/python3.4/pyerrors.h |
| | | file path=usr/include/python3.4/pyexpat.h |
| | | file path=usr/include/python3.4/pyfpe.h |
| | | file path=usr/include/python3.4/pygetopt.h |
| | | file path=usr/include/python3.4/pyhash.h |
| | | file path=usr/include/python3.4/pymacconfig.h |
| | | file path=usr/include/python3.4/pymacro.h |
| | | file path=usr/include/python3.4/pymath.h |
| | | file path=usr/include/python3.4/pymem.h |
| | | file path=usr/include/python3.4/pyport.h |
| | | file path=usr/include/python3.4/pystate.h |
| | | file path=usr/include/python3.4/pystrcmp.h |
| | | file path=usr/include/python3.4/pystrtod.h |
| | | file path=usr/include/python3.4/pythonrun.h |
| | | file path=usr/include/python3.4/pythread.h |
| | | file path=usr/include/python3.4/pytime.h |
| | | file path=usr/include/python3.4/rangeobject.h |
| | | file path=usr/include/python3.4/setobject.h |
| | | file path=usr/include/python3.4/sliceobject.h |
| | | file path=usr/include/python3.4/structmember.h |
| | | file path=usr/include/python3.4/structseq.h |
| | | file path=usr/include/python3.4/symtable.h |
| | | file path=usr/include/python3.4/sysmodule.h |
| | | file path=usr/include/python3.4/token.h |
| | | file path=usr/include/python3.4/traceback.h |
| | | file path=usr/include/python3.4/tupleobject.h |
| | | file path=usr/include/python3.4/typeslots.h |
| | | file path=usr/include/python3.4/ucnhash.h |
| | | file path=usr/include/python3.4/unicodeobject.h |
| | | file path=usr/include/python3.4/warnings.h |
| | | file path=usr/include/python3.4/weakrefobject.h |
| | | link path=usr/lib/$(MACH64)/libpython3.4.so target=libpython3.4.so.1.0 |
| | | file path=usr/lib/$(MACH64)/libpython3.4.so.1.0 |
| | | link path=usr/lib/$(MACH64)/libpython3.4_db.so target=libpython3.4_db.so.1.0 |
| | | file path=usr/lib/$(MACH64)/libpython3.4_db.so.1.0 |
| | | file path=usr/lib/$(MACH64)/libpython3.so |
| | | file path=usr/lib/$(MACH64)/pkgconfig/python-3.4.pc |
| | | link path=usr/lib/$(MACH64)/pkgconfig/python3.pc target=python-3.4.pc \ |
| | | mediator=python mediator-version=3.4 |
| | | link path=usr/lib/pkgconfig/python-3.4.pc \ |
| | | target=../$(MACH64)/pkgconfig/python-3.4.pc |
| | | link path=usr/lib/pkgconfig/python3.pc target=python-3.4.pc mediator=python \ |
| | | mediator-version=3.4 |
| | | file path=usr/lib/python3.4/LICENSE.txt |
| | | file path=usr/lib/python3.4/__future__.py |
| | | file path=usr/lib/python3.4/__phello__.foo.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/_bootlocale.py |
| | | file path=usr/lib/python3.4/_collections_abc.py |
| | | file path=usr/lib/python3.4/_compat_pickle.py |
| | | file path=usr/lib/python3.4/_dummy_thread.py |
| | | file path=usr/lib/python3.4/_markupbase.py |
| | | file path=usr/lib/python3.4/_osx_support.py |
| | | file path=usr/lib/python3.4/_pyio.py |
| | | file path=usr/lib/python3.4/_sitebuiltins.py |
| | | file path=usr/lib/python3.4/_strptime.py |
| | | file path=usr/lib/python3.4/_threading_local.py |
| | | file path=usr/lib/python3.4/_weakrefset.py |
| | | file path=usr/lib/python3.4/abc.py |
| | | file path=usr/lib/python3.4/aifc.py |
| | | file path=usr/lib/python3.4/antigravity.py |
| | | file path=usr/lib/python3.4/argparse.py |
| | | file path=usr/lib/python3.4/ast.py |
| | | file path=usr/lib/python3.4/asynchat.py |
| | | file path=usr/lib/python3.4/asyncio/__init__.py |
| | | file path=usr/lib/python3.4/asyncio/base_events.py |
| | | file path=usr/lib/python3.4/asyncio/base_subprocess.py |
| | | file path=usr/lib/python3.4/asyncio/constants.py |
| | | file path=usr/lib/python3.4/asyncio/events.py |
| | | file path=usr/lib/python3.4/asyncio/futures.py |
| | | file path=usr/lib/python3.4/asyncio/locks.py |
| | | file path=usr/lib/python3.4/asyncio/log.py |
| | | file path=usr/lib/python3.4/asyncio/proactor_events.py |
| | | file path=usr/lib/python3.4/asyncio/protocols.py |
| | | file path=usr/lib/python3.4/asyncio/queues.py |
| | | file path=usr/lib/python3.4/asyncio/selector_events.py |
| | | file path=usr/lib/python3.4/asyncio/streams.py |
| | | file path=usr/lib/python3.4/asyncio/subprocess.py |
| | | file path=usr/lib/python3.4/asyncio/tasks.py |
| | | file path=usr/lib/python3.4/asyncio/test_utils.py |
| | | file path=usr/lib/python3.4/asyncio/transports.py |
| | | file path=usr/lib/python3.4/asyncio/unix_events.py |
| | | file path=usr/lib/python3.4/asyncio/windows_events.py |
| | | file path=usr/lib/python3.4/asyncio/windows_utils.py |
| | | file path=usr/lib/python3.4/asyncore.py |
| | | file path=usr/lib/python3.4/base64.py |
| | | file path=usr/lib/python3.4/bdb.py |
| | | file path=usr/lib/python3.4/binhex.py |
| | | file path=usr/lib/python3.4/bisect.py |
| | | file path=usr/lib/python3.4/bz2.py |
| | | file path=usr/lib/python3.4/cProfile.py pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/calendar.py |
| | | file path=usr/lib/python3.4/cgi.py |
| | | file path=usr/lib/python3.4/cgitb.py |
| | | file path=usr/lib/python3.4/chunk.py |
| | | file path=usr/lib/python3.4/cmd.py |
| | | file path=usr/lib/python3.4/code.py |
| | | file path=usr/lib/python3.4/codecs.py |
| | | file path=usr/lib/python3.4/codeop.py |
| | | file path=usr/lib/python3.4/collections/__init__.py |
| | | file path=usr/lib/python3.4/collections/__main__.py |
| | | file path=usr/lib/python3.4/collections/abc.py |
| | | file path=usr/lib/python3.4/colorsys.py |
| | | file path=usr/lib/python3.4/compileall.py |
| | | file path=usr/lib/python3.4/concurrent/__init__.py |
| | | file path=usr/lib/python3.4/concurrent/futures/__init__.py |
| | | file path=usr/lib/python3.4/concurrent/futures/_base.py |
| | | file path=usr/lib/python3.4/concurrent/futures/process.py |
| | | file path=usr/lib/python3.4/concurrent/futures/thread.py |
| | | file usr/lib/python3.4/config-3.4/python.o \ |
| | | path=usr/lib/python3.4/config-3.4/64/python.o |
| | | file path=usr/lib/python3.4/config-3.4/Makefile |
| | | file path=usr/lib/python3.4/config-3.4/Setup |
| | | file path=usr/lib/python3.4/config-3.4/Setup.config |
| | | file path=usr/lib/python3.4/config-3.4/Setup.local |
| | | file path=usr/lib/python3.4/config-3.4/config.c |
| | | file path=usr/lib/python3.4/config-3.4/config.c.in |
| | | file path=usr/lib/python3.4/config-3.4/install-sh |
| | | file path=usr/lib/python3.4/config-3.4/libpython3.4.a |
| | | file path=usr/lib/python3.4/config-3.4/makesetup |
| | | file path=usr/lib/python3.4/configparser.py |
| | | file path=usr/lib/python3.4/contextlib.py |
| | | file path=usr/lib/python3.4/copy.py |
| | | file path=usr/lib/python3.4/copyreg.py |
| | | file path=usr/lib/python3.4/crypt.py |
| | | file path=usr/lib/python3.4/csv.py |
| | | file path=usr/lib/python3.4/ctypes/__init__.py |
| | | file path=usr/lib/python3.4/ctypes/_endian.py |
| | | file path=usr/lib/python3.4/ctypes/macholib/README.ctypes |
| | | file path=usr/lib/python3.4/ctypes/macholib/__init__.py |
| | | file path=usr/lib/python3.4/ctypes/macholib/dyld.py |
| | | file path=usr/lib/python3.4/ctypes/macholib/dylib.py |
| | | file path=usr/lib/python3.4/ctypes/macholib/fetch_macholib |
| | | file path=usr/lib/python3.4/ctypes/macholib/fetch_macholib.bat |
| | | file path=usr/lib/python3.4/ctypes/macholib/framework.py |
| | | # |
| | | file path=usr/lib/python3.4/ctypes/test/__init__.py |
| | | file path=usr/lib/python3.4/ctypes/test/runtests.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_anon.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_array_in_pointer.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_arrays.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_as_parameter.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_bitfields.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_buffers.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_bytes.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_byteswap.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_callbacks.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_cast.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_cfuncs.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_checkretval.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_delattr.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_errcheck.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_errno.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_find.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_frombuffer.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_funcptr.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_functions.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_incomplete.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_init.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_integers.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_internals.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_keeprefs.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_libc.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_loading.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_macholib.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_memfunctions.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_numbers.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_objects.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_parameters.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_pep3118.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_pickling.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_pointers.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_prototypes.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_python_api.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_random_things.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_refcounts.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_repr.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_returnfuncptrs.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_simplesubclasses.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_sizes.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_slicing.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_stringptr.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_strings.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_struct_fields.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_structures.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_unaligned_structures.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_unicode.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_values.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_varsize_struct.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_win32.py |
| | | file path=usr/lib/python3.4/ctypes/test/test_wintypes.py |
| | | file path=usr/lib/python3.4/ctypes/util.py |
| | | file path=usr/lib/python3.4/ctypes/wintypes.py |
| | | file path=usr/lib/python3.4/curses/__init__.py |
| | | file path=usr/lib/python3.4/curses/ascii.py |
| | | file path=usr/lib/python3.4/curses/has_key.py |
| | | file path=usr/lib/python3.4/curses/panel.py |
| | | file path=usr/lib/python3.4/curses/textpad.py |
| | | file path=usr/lib/python3.4/datetime.py |
| | | file path=usr/lib/python3.4/dbm/__init__.py |
| | | file path=usr/lib/python3.4/dbm/dumb.py |
| | | file path=usr/lib/python3.4/dbm/gnu.py |
| | | file path=usr/lib/python3.4/dbm/ndbm.py |
| | | file path=usr/lib/python3.4/decimal.py |
| | | file path=usr/lib/python3.4/difflib.py |
| | | file path=usr/lib/python3.4/dis.py |
| | | file path=usr/lib/python3.4/distutils/README |
| | | file path=usr/lib/python3.4/distutils/__init__.py |
| | | file path=usr/lib/python3.4/distutils/archive_util.py |
| | | file path=usr/lib/python3.4/distutils/bcppcompiler.py |
| | | file path=usr/lib/python3.4/distutils/ccompiler.py |
| | | file path=usr/lib/python3.4/distutils/cmd.py |
| | | file path=usr/lib/python3.4/distutils/command/__init__.py |
| | | file path=usr/lib/python3.4/distutils/command/bdist.py |
| | | file path=usr/lib/python3.4/distutils/command/bdist_dumb.py |
| | | file path=usr/lib/python3.4/distutils/command/bdist_msi.py |
| | | file path=usr/lib/python3.4/distutils/command/bdist_rpm.py |
| | | file path=usr/lib/python3.4/distutils/command/bdist_wininst.py |
| | | file path=usr/lib/python3.4/distutils/command/build.py |
| | | file path=usr/lib/python3.4/distutils/command/build_clib.py |
| | | file path=usr/lib/python3.4/distutils/command/build_ext.py |
| | | file path=usr/lib/python3.4/distutils/command/build_py.py |
| | | file path=usr/lib/python3.4/distutils/command/build_scripts.py |
| | | file path=usr/lib/python3.4/distutils/command/check.py |
| | | file path=usr/lib/python3.4/distutils/command/clean.py |
| | | file path=usr/lib/python3.4/distutils/command/command_template |
| | | file path=usr/lib/python3.4/distutils/command/config.py |
| | | file path=usr/lib/python3.4/distutils/command/install.py |
| | | file path=usr/lib/python3.4/distutils/command/install_data.py |
| | | file path=usr/lib/python3.4/distutils/command/install_egg_info.py |
| | | file path=usr/lib/python3.4/distutils/command/install_headers.py |
| | | file path=usr/lib/python3.4/distutils/command/install_lib.py |
| | | file path=usr/lib/python3.4/distutils/command/install_scripts.py |
| | | file path=usr/lib/python3.4/distutils/command/register.py |
| | | file path=usr/lib/python3.4/distutils/command/sdist.py |
| | | file path=usr/lib/python3.4/distutils/command/upload.py |
| | | file path=usr/lib/python3.4/distutils/command/wininst-10.0-amd64.exe |
| | | file path=usr/lib/python3.4/distutils/command/wininst-10.0.exe |
| | | file path=usr/lib/python3.4/distutils/command/wininst-6.0.exe |
| | | file path=usr/lib/python3.4/distutils/command/wininst-7.1.exe |
| | | file path=usr/lib/python3.4/distutils/command/wininst-8.0.exe |
| | | file path=usr/lib/python3.4/distutils/command/wininst-9.0-amd64.exe |
| | | file path=usr/lib/python3.4/distutils/command/wininst-9.0.exe |
| | | file path=usr/lib/python3.4/distutils/config.py |
| | | file path=usr/lib/python3.4/distutils/core.py |
| | | file path=usr/lib/python3.4/distutils/cygwinccompiler.py |
| | | file path=usr/lib/python3.4/distutils/debug.py |
| | | file path=usr/lib/python3.4/distutils/dep_util.py |
| | | file path=usr/lib/python3.4/distutils/dir_util.py |
| | | file path=usr/lib/python3.4/distutils/dist.py |
| | | file path=usr/lib/python3.4/distutils/errors.py |
| | | file path=usr/lib/python3.4/distutils/extension.py |
| | | file path=usr/lib/python3.4/distutils/fancy_getopt.py |
| | | file path=usr/lib/python3.4/distutils/file_util.py |
| | | file path=usr/lib/python3.4/distutils/filelist.py |
| | | file path=usr/lib/python3.4/distutils/log.py |
| | | file path=usr/lib/python3.4/distutils/msvc9compiler.py |
| | | file path=usr/lib/python3.4/distutils/msvccompiler.py |
| | | file path=usr/lib/python3.4/distutils/spawn.py |
| | | file path=usr/lib/python3.4/distutils/sysconfig.py |
| | | file path=usr/lib/python3.4/distutils/tests/Setup.sample |
| | | file path=usr/lib/python3.4/distutils/tests/__init__.py |
| | | file path=usr/lib/python3.4/distutils/tests/support.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_archive_util.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_bdist.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_bdist_dumb.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_bdist_msi.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_bdist_rpm.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_bdist_wininst.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_build.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_build_clib.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_build_ext.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_build_py.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_build_scripts.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_check.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_clean.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_cmd.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_config.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_config_cmd.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_core.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_cygwinccompiler.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_dep_util.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_dir_util.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_dist.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_extension.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_file_util.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_filelist.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_install.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_install_data.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_install_headers.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_install_lib.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_install_scripts.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_log.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_msvc9compiler.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_register.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_sdist.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_spawn.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_sysconfig.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_text_file.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_unixccompiler.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_upload.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_util.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_version.py |
| | | file path=usr/lib/python3.4/distutils/tests/test_versionpredicate.py |
| | | file path=usr/lib/python3.4/distutils/tests/xxmodule.c |
| | | file path=usr/lib/python3.4/distutils/text_file.py |
| | | file path=usr/lib/python3.4/distutils/unixccompiler.py |
| | | file path=usr/lib/python3.4/distutils/util.py |
| | | file path=usr/lib/python3.4/distutils/version.py |
| | | file path=usr/lib/python3.4/distutils/versionpredicate.py |
| | | file path=usr/lib/python3.4/doctest.py |
| | | file path=usr/lib/python3.4/dummy_threading.py |
| | | file path=usr/lib/python3.4/email/__init__.py |
| | | file path=usr/lib/python3.4/email/_encoded_words.py |
| | | file path=usr/lib/python3.4/email/_header_value_parser.py |
| | | file path=usr/lib/python3.4/email/_parseaddr.py |
| | | file path=usr/lib/python3.4/email/_policybase.py |
| | | file path=usr/lib/python3.4/email/architecture.rst |
| | | file path=usr/lib/python3.4/email/base64mime.py |
| | | file path=usr/lib/python3.4/email/charset.py |
| | | file path=usr/lib/python3.4/email/contentmanager.py |
| | | file path=usr/lib/python3.4/email/encoders.py |
| | | file path=usr/lib/python3.4/email/errors.py |
| | | file path=usr/lib/python3.4/email/feedparser.py |
| | | file path=usr/lib/python3.4/email/generator.py |
| | | file path=usr/lib/python3.4/email/header.py |
| | | file path=usr/lib/python3.4/email/headerregistry.py |
| | | file path=usr/lib/python3.4/email/iterators.py |
| | | file path=usr/lib/python3.4/email/message.py |
| | | file path=usr/lib/python3.4/email/mime/__init__.py |
| | | file path=usr/lib/python3.4/email/mime/application.py |
| | | file path=usr/lib/python3.4/email/mime/audio.py |
| | | file path=usr/lib/python3.4/email/mime/base.py |
| | | file path=usr/lib/python3.4/email/mime/image.py |
| | | file path=usr/lib/python3.4/email/mime/message.py |
| | | file path=usr/lib/python3.4/email/mime/multipart.py |
| | | file path=usr/lib/python3.4/email/mime/nonmultipart.py |
| | | file path=usr/lib/python3.4/email/mime/text.py |
| | | file path=usr/lib/python3.4/email/parser.py |
| | | file path=usr/lib/python3.4/email/policy.py |
| | | file path=usr/lib/python3.4/email/quoprimime.py |
| | | file path=usr/lib/python3.4/email/utils.py |
| | | file path=usr/lib/python3.4/encodings/__init__.py |
| | | file path=usr/lib/python3.4/encodings/aliases.py |
| | | file path=usr/lib/python3.4/encodings/ascii.py |
| | | file path=usr/lib/python3.4/encodings/base64_codec.py |
| | | file path=usr/lib/python3.4/encodings/big5.py |
| | | file path=usr/lib/python3.4/encodings/big5hkscs.py |
| | | file path=usr/lib/python3.4/encodings/bz2_codec.py |
| | | file path=usr/lib/python3.4/encodings/charmap.py |
| | | file path=usr/lib/python3.4/encodings/cp037.py |
| | | file path=usr/lib/python3.4/encodings/cp1006.py |
| | | file path=usr/lib/python3.4/encodings/cp1026.py |
| | | file path=usr/lib/python3.4/encodings/cp1125.py |
| | | file path=usr/lib/python3.4/encodings/cp1140.py |
| | | file path=usr/lib/python3.4/encodings/cp1250.py |
| | | file path=usr/lib/python3.4/encodings/cp1251.py |
| | | file path=usr/lib/python3.4/encodings/cp1252.py |
| | | file path=usr/lib/python3.4/encodings/cp1253.py |
| | | file path=usr/lib/python3.4/encodings/cp1254.py |
| | | file path=usr/lib/python3.4/encodings/cp1255.py |
| | | file path=usr/lib/python3.4/encodings/cp1256.py |
| | | file path=usr/lib/python3.4/encodings/cp1257.py |
| | | file path=usr/lib/python3.4/encodings/cp1258.py |
| | | file path=usr/lib/python3.4/encodings/cp273.py |
| | | file path=usr/lib/python3.4/encodings/cp424.py |
| | | file path=usr/lib/python3.4/encodings/cp437.py |
| | | file path=usr/lib/python3.4/encodings/cp500.py |
| | | file path=usr/lib/python3.4/encodings/cp65001.py |
| | | file path=usr/lib/python3.4/encodings/cp720.py |
| | | file path=usr/lib/python3.4/encodings/cp737.py |
| | | file path=usr/lib/python3.4/encodings/cp775.py |
| | | file path=usr/lib/python3.4/encodings/cp850.py |
| | | file path=usr/lib/python3.4/encodings/cp852.py |
| | | file path=usr/lib/python3.4/encodings/cp855.py |
| | | file path=usr/lib/python3.4/encodings/cp856.py |
| | | file path=usr/lib/python3.4/encodings/cp857.py |
| | | file path=usr/lib/python3.4/encodings/cp858.py |
| | | file path=usr/lib/python3.4/encodings/cp860.py |
| | | file path=usr/lib/python3.4/encodings/cp861.py |
| | | file path=usr/lib/python3.4/encodings/cp862.py |
| | | file path=usr/lib/python3.4/encodings/cp863.py |
| | | file path=usr/lib/python3.4/encodings/cp864.py |
| | | file path=usr/lib/python3.4/encodings/cp865.py |
| | | file path=usr/lib/python3.4/encodings/cp866.py |
| | | file path=usr/lib/python3.4/encodings/cp869.py |
| | | file path=usr/lib/python3.4/encodings/cp874.py |
| | | file path=usr/lib/python3.4/encodings/cp875.py |
| | | file path=usr/lib/python3.4/encodings/cp932.py |
| | | file path=usr/lib/python3.4/encodings/cp949.py |
| | | file path=usr/lib/python3.4/encodings/cp950.py |
| | | file path=usr/lib/python3.4/encodings/euc_jis_2004.py |
| | | file path=usr/lib/python3.4/encodings/euc_jisx0213.py |
| | | file path=usr/lib/python3.4/encodings/euc_jp.py |
| | | file path=usr/lib/python3.4/encodings/euc_kr.py |
| | | file path=usr/lib/python3.4/encodings/gb18030.py |
| | | file path=usr/lib/python3.4/encodings/gb2312.py |
| | | file path=usr/lib/python3.4/encodings/gbk.py |
| | | file path=usr/lib/python3.4/encodings/hex_codec.py |
| | | file path=usr/lib/python3.4/encodings/hp_roman8.py |
| | | file path=usr/lib/python3.4/encodings/hz.py |
| | | file path=usr/lib/python3.4/encodings/idna.py |
| | | file path=usr/lib/python3.4/encodings/iso2022_jp.py |
| | | file path=usr/lib/python3.4/encodings/iso2022_jp_1.py |
| | | file path=usr/lib/python3.4/encodings/iso2022_jp_2.py |
| | | file path=usr/lib/python3.4/encodings/iso2022_jp_2004.py |
| | | file path=usr/lib/python3.4/encodings/iso2022_jp_3.py |
| | | file path=usr/lib/python3.4/encodings/iso2022_jp_ext.py |
| | | file path=usr/lib/python3.4/encodings/iso2022_kr.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_1.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_10.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_11.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_13.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_14.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_15.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_16.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_2.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_3.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_4.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_5.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_6.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_7.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_8.py |
| | | file path=usr/lib/python3.4/encodings/iso8859_9.py |
| | | file path=usr/lib/python3.4/encodings/johab.py |
| | | file path=usr/lib/python3.4/encodings/koi8_r.py |
| | | file path=usr/lib/python3.4/encodings/koi8_u.py |
| | | file path=usr/lib/python3.4/encodings/latin_1.py |
| | | file path=usr/lib/python3.4/encodings/mac_arabic.py |
| | | file path=usr/lib/python3.4/encodings/mac_centeuro.py |
| | | file path=usr/lib/python3.4/encodings/mac_croatian.py |
| | | file path=usr/lib/python3.4/encodings/mac_cyrillic.py |
| | | file path=usr/lib/python3.4/encodings/mac_farsi.py |
| | | file path=usr/lib/python3.4/encodings/mac_greek.py |
| | | file path=usr/lib/python3.4/encodings/mac_iceland.py |
| | | file path=usr/lib/python3.4/encodings/mac_latin2.py |
| | | file path=usr/lib/python3.4/encodings/mac_roman.py |
| | | file path=usr/lib/python3.4/encodings/mac_romanian.py |
| | | file path=usr/lib/python3.4/encodings/mac_turkish.py |
| | | file path=usr/lib/python3.4/encodings/mbcs.py |
| | | file path=usr/lib/python3.4/encodings/palmos.py |
| | | file path=usr/lib/python3.4/encodings/ptcp154.py |
| | | file path=usr/lib/python3.4/encodings/punycode.py |
| | | file path=usr/lib/python3.4/encodings/quopri_codec.py |
| | | file path=usr/lib/python3.4/encodings/raw_unicode_escape.py |
| | | file path=usr/lib/python3.4/encodings/rot_13.py |
| | | file path=usr/lib/python3.4/encodings/shift_jis.py |
| | | file path=usr/lib/python3.4/encodings/shift_jis_2004.py |
| | | file path=usr/lib/python3.4/encodings/shift_jisx0213.py |
| | | file path=usr/lib/python3.4/encodings/tis_620.py |
| | | file path=usr/lib/python3.4/encodings/undefined.py |
| | | file path=usr/lib/python3.4/encodings/unicode_escape.py |
| | | file path=usr/lib/python3.4/encodings/unicode_internal.py |
| | | file path=usr/lib/python3.4/encodings/utf_16.py |
| | | file path=usr/lib/python3.4/encodings/utf_16_be.py |
| | | file path=usr/lib/python3.4/encodings/utf_16_le.py |
| | | file path=usr/lib/python3.4/encodings/utf_32.py |
| | | file path=usr/lib/python3.4/encodings/utf_32_be.py |
| | | file path=usr/lib/python3.4/encodings/utf_32_le.py |
| | | file path=usr/lib/python3.4/encodings/utf_7.py |
| | | file path=usr/lib/python3.4/encodings/utf_8.py |
| | | file path=usr/lib/python3.4/encodings/utf_8_sig.py |
| | | file path=usr/lib/python3.4/encodings/uu_codec.py |
| | | file path=usr/lib/python3.4/encodings/zlib_codec.py |
| | | file path=usr/lib/python3.4/enum.py |
| | | file path=usr/lib/python3.4/filecmp.py |
| | | file path=usr/lib/python3.4/fileinput.py |
| | | file path=usr/lib/python3.4/fnmatch.py |
| | | file path=usr/lib/python3.4/formatter.py |
| | | file path=usr/lib/python3.4/fractions.py |
| | | file path=usr/lib/python3.4/ftplib.py |
| | | file path=usr/lib/python3.4/functools.py |
| | | file path=usr/lib/python3.4/genericpath.py |
| | | file path=usr/lib/python3.4/getopt.py |
| | | file path=usr/lib/python3.4/getpass.py |
| | | file path=usr/lib/python3.4/gettext.py |
| | | file path=usr/lib/python3.4/glob.py |
| | | file path=usr/lib/python3.4/gzip.py |
| | | file path=usr/lib/python3.4/hashlib.py |
| | | file path=usr/lib/python3.4/heapq.py |
| | | file path=usr/lib/python3.4/hmac.py |
| | | file path=usr/lib/python3.4/html/__init__.py |
| | | file path=usr/lib/python3.4/html/entities.py |
| | | file path=usr/lib/python3.4/html/parser.py |
| | | file path=usr/lib/python3.4/http/__init__.py |
| | | file path=usr/lib/python3.4/http/client.py |
| | | file path=usr/lib/python3.4/http/cookiejar.py |
| | | file path=usr/lib/python3.4/http/cookies.py |
| | | file path=usr/lib/python3.4/http/server.py |
| | | file path=usr/lib/python3.4/idlelib/AutoComplete.py |
| | | file path=usr/lib/python3.4/idlelib/AutoCompleteWindow.py |
| | | file path=usr/lib/python3.4/idlelib/AutoExpand.py |
| | | file path=usr/lib/python3.4/idlelib/Bindings.py |
| | | file path=usr/lib/python3.4/idlelib/CREDITS.txt |
| | | file path=usr/lib/python3.4/idlelib/CallTipWindow.py |
| | | file path=usr/lib/python3.4/idlelib/CallTips.py |
| | | file path=usr/lib/python3.4/idlelib/ChangeLog |
| | | file path=usr/lib/python3.4/idlelib/ClassBrowser.py |
| | | file path=usr/lib/python3.4/idlelib/CodeContext.py |
| | | file path=usr/lib/python3.4/idlelib/ColorDelegator.py |
| | | file path=usr/lib/python3.4/idlelib/Debugger.py |
| | | file path=usr/lib/python3.4/idlelib/Delegator.py |
| | | file path=usr/lib/python3.4/idlelib/EditorWindow.py |
| | | file path=usr/lib/python3.4/idlelib/FileList.py |
| | | file path=usr/lib/python3.4/idlelib/FormatParagraph.py |
| | | file path=usr/lib/python3.4/idlelib/GrepDialog.py |
| | | file path=usr/lib/python3.4/idlelib/HISTORY.txt |
| | | file path=usr/lib/python3.4/idlelib/HyperParser.py |
| | | file path=usr/lib/python3.4/idlelib/IOBinding.py |
| | | file path=usr/lib/python3.4/idlelib/Icons/folder.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle.icns |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle.ico |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle_16.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle_16.png |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle_32.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle_32.png |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle_48.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/idle_48.png |
| | | file path=usr/lib/python3.4/idlelib/Icons/minusnode.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/openfolder.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/plusnode.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/python.gif |
| | | file path=usr/lib/python3.4/idlelib/Icons/tk.gif |
| | | file path=usr/lib/python3.4/idlelib/IdleHistory.py |
| | | file path=usr/lib/python3.4/idlelib/MultiCall.py |
| | | file path=usr/lib/python3.4/idlelib/MultiStatusBar.py |
| | | file path=usr/lib/python3.4/idlelib/NEWS.txt |
| | | file path=usr/lib/python3.4/idlelib/ObjectBrowser.py |
| | | file path=usr/lib/python3.4/idlelib/OutputWindow.py |
| | | file path=usr/lib/python3.4/idlelib/ParenMatch.py |
| | | file path=usr/lib/python3.4/idlelib/PathBrowser.py |
| | | file path=usr/lib/python3.4/idlelib/Percolator.py |
| | | file path=usr/lib/python3.4/idlelib/PyParse.py |
| | | file path=usr/lib/python3.4/idlelib/PyShell.py |
| | | file path=usr/lib/python3.4/idlelib/README.txt |
| | | file path=usr/lib/python3.4/idlelib/RemoteDebugger.py |
| | | file path=usr/lib/python3.4/idlelib/RemoteObjectBrowser.py |
| | | file path=usr/lib/python3.4/idlelib/ReplaceDialog.py |
| | | file path=usr/lib/python3.4/idlelib/RstripExtension.py |
| | | file path=usr/lib/python3.4/idlelib/ScriptBinding.py |
| | | file path=usr/lib/python3.4/idlelib/ScrolledList.py |
| | | file path=usr/lib/python3.4/idlelib/SearchDialog.py |
| | | file path=usr/lib/python3.4/idlelib/SearchDialogBase.py |
| | | file path=usr/lib/python3.4/idlelib/SearchEngine.py |
| | | file path=usr/lib/python3.4/idlelib/StackViewer.py |
| | | file path=usr/lib/python3.4/idlelib/TODO.txt |
| | | file path=usr/lib/python3.4/idlelib/ToolTip.py |
| | | file path=usr/lib/python3.4/idlelib/TreeWidget.py |
| | | file path=usr/lib/python3.4/idlelib/UndoDelegator.py |
| | | file path=usr/lib/python3.4/idlelib/WidgetRedirector.py |
| | | file path=usr/lib/python3.4/idlelib/WindowList.py |
| | | file path=usr/lib/python3.4/idlelib/ZoomHeight.py |
| | | file path=usr/lib/python3.4/idlelib/__init__.py |
| | | file path=usr/lib/python3.4/idlelib/__main__.py |
| | | file path=usr/lib/python3.4/idlelib/aboutDialog.py |
| | | file path=usr/lib/python3.4/idlelib/config-extensions.def |
| | | file path=usr/lib/python3.4/idlelib/config-highlight.def |
| | | file path=usr/lib/python3.4/idlelib/config-keys.def |
| | | file path=usr/lib/python3.4/idlelib/config-main.def |
| | | file path=usr/lib/python3.4/idlelib/configDialog.py |
| | | file path=usr/lib/python3.4/idlelib/configHandler.py |
| | | file path=usr/lib/python3.4/idlelib/configHelpSourceEdit.py |
| | | file path=usr/lib/python3.4/idlelib/configSectionNameDialog.py |
| | | file path=usr/lib/python3.4/idlelib/dynOptionMenuWidget.py |
| | | file path=usr/lib/python3.4/idlelib/extend.txt |
| | | file path=usr/lib/python3.4/idlelib/help.txt |
| | | file path=usr/lib/python3.4/idlelib/idle.bat |
| | | file path=usr/lib/python3.4/idlelib/idle.py |
| | | file path=usr/lib/python3.4/idlelib/idle.pyw |
| | | file path=usr/lib/python3.4/idlelib/idle_test/README.txt |
| | | file path=usr/lib/python3.4/idlelib/idle_test/__init__.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/mock_idle.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/mock_tk.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_calltips.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_config_name.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_delegator.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_formatparagraph.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_grep.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_idlehistory.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_pathbrowser.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_rstrip.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_searchengine.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_text.py |
| | | file path=usr/lib/python3.4/idlelib/idle_test/test_warning.py |
| | | file path=usr/lib/python3.4/idlelib/idlever.py |
| | | file path=usr/lib/python3.4/idlelib/keybindingDialog.py |
| | | file path=usr/lib/python3.4/idlelib/macosxSupport.py |
| | | file path=usr/lib/python3.4/idlelib/rpc.py |
| | | file path=usr/lib/python3.4/idlelib/run.py |
| | | file path=usr/lib/python3.4/idlelib/tabbedpages.py |
| | | file path=usr/lib/python3.4/idlelib/testcode.py |
| | | file path=usr/lib/python3.4/idlelib/textView.py |
| | | file path=usr/lib/python3.4/imaplib.py |
| | | file path=usr/lib/python3.4/imghdr.py |
| | | file path=usr/lib/python3.4/imp.py |
| | | file path=usr/lib/python3.4/importlib/__init__.py |
| | | file path=usr/lib/python3.4/importlib/_bootstrap.py |
| | | file path=usr/lib/python3.4/importlib/abc.py |
| | | file path=usr/lib/python3.4/importlib/machinery.py |
| | | file path=usr/lib/python3.4/importlib/util.py |
| | | file path=usr/lib/python3.4/inspect.py |
| | | file path=usr/lib/python3.4/io.py |
| | | file path=usr/lib/python3.4/ipaddress.py |
| | | file path=usr/lib/python3.4/json/__init__.py |
| | | file path=usr/lib/python3.4/json/decoder.py |
| | | file path=usr/lib/python3.4/json/encoder.py |
| | | file path=usr/lib/python3.4/json/scanner.py |
| | | file path=usr/lib/python3.4/json/tool.py |
| | | file path=usr/lib/python3.4/keyword.py |
| | | file path=usr/lib/python3.4/lib-dynload/64/_bisect.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_bz2.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_codecs_cn.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_codecs_hk.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_codecs_iso2022.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_codecs_jp.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_codecs_kr.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_codecs_tw.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_crypt.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_csv.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_ctypes.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_ctypes_test.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_curses.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_curses_panel.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_datetime.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_dbm.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_decimal.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_elementtree.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_gdbm.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_hashlib.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_heapq.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_json.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_lsprof.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_lzma.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_md5.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_multibytecodec.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_multiprocessing.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_opcode.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_pickle.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_posixsubprocess.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_random.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_sha1.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_sha256.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_sha512.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_socket.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_sqlite3.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_ssl.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_struct.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_sysconfigdata.py |
| | | file path=usr/lib/python3.4/lib-dynload/64/_testbuffer.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_testcapi.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/_testimportmultiple.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/array.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/audioop.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/binascii.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/cmath.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/dlpi.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/fcntl.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/grp.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/math.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/mmap.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/nis.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/ossaudiodev.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/parser.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/privileges.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/pyexpat.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/rbac.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/readline.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/resource.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/select.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/spwd.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/syslog.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/termios.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/time.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/ucred.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/unicodedata.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/xxlimited.so |
| | | file path=usr/lib/python3.4/lib-dynload/64/zlib.so |
| | | file path=usr/lib/python3.4/lib2to3/Grammar$(COMPONENT_VERSION).final.0.pickle |
| | | file path=usr/lib/python3.4/lib2to3/Grammar.txt |
| | | file path=usr/lib/python3.4/lib2to3/PatternGrammar$(COMPONENT_VERSION).final.0.pickle |
| | | file path=usr/lib/python3.4/lib2to3/PatternGrammar.txt |
| | | file path=usr/lib/python3.4/lib2to3/__init__.py |
| | | file path=usr/lib/python3.4/lib2to3/__main__.py |
| | | file path=usr/lib/python3.4/lib2to3/btm_matcher.py |
| | | file path=usr/lib/python3.4/lib2to3/btm_utils.py |
| | | file path=usr/lib/python3.4/lib2to3/fixer_base.py |
| | | file path=usr/lib/python3.4/lib2to3/fixer_util.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/__init__.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_apply.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_asserts.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_basestring.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_buffer.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_callable.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_dict.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_except.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_exec.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_execfile.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_exitfunc.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_filter.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_funcattrs.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_future.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_getcwdu.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_has_key.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_idioms.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_import.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_imports.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_imports2.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_input.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_intern.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_isinstance.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_itertools.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_itertools_imports.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_long.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_map.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_metaclass.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_methodattrs.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_ne.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_next.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_nonzero.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_numliterals.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_operator.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_paren.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_print.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_raise.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_raw_input.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_reduce.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_reload.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_renames.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_repr.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_set_literal.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_standarderror.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_sys_exc.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_throw.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_tuple_params.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_types.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_unicode.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_urllib.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_ws_comma.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_xrange.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_xreadlines.py |
| | | file path=usr/lib/python3.4/lib2to3/fixes/fix_zip.py |
| | | file path=usr/lib/python3.4/lib2to3/main.py |
| | | file path=usr/lib/python3.4/lib2to3/patcomp.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/__init__.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/conv.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/driver.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/grammar.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/literals.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/parse.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/pgen.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/token.py |
| | | file path=usr/lib/python3.4/lib2to3/pgen2/tokenize.py |
| | | file path=usr/lib/python3.4/lib2to3/pygram.py |
| | | file path=usr/lib/python3.4/lib2to3/pytree.py |
| | | file path=usr/lib/python3.4/lib2to3/refactor.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/__init__.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/README |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/bom.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/crlf.py pkg.tmp.autopyc=false |
| | | # |
| | | # The {different,false}_encoding.py files needs bypass-generate because they |
| | | # contains an intentional SyntaxError with a invalid string that cannot be |
| | | # parsed. |
| | | # |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/different_encoding.py \ |
| | | pkg.depend.bypass-generate=.* pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/false_encoding.py \ |
| | | pkg.depend.bypass-generate=.* pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/bad_order.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/myfixes/__init__.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/myfixes/fix_explicit.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/myfixes/fix_first.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/myfixes/fix_last.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/myfixes/fix_parrot.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/myfixes/fix_preorder.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/no_fixer_cls.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/fixers/parrot_example.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/infinite_recursion.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/py2_test_grammar.py \ |
| | | pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/lib2to3/tests/data/py3_test_grammar.py \ |
| | | pkg.tmp.autopyc=false |
| | | # |
| | | # bypass-generate needed due to issue with __main__. |
| | | # |
| | | file path=usr/lib/python3.4/lib2to3/tests/pytree_idempotency.py \ |
| | | pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/lib2to3/tests/support.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/test_all_fixers.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/test_fixers.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/test_main.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/test_parser.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/test_pytree.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/test_refactor.py |
| | | file path=usr/lib/python3.4/lib2to3/tests/test_util.py |
| | | file path=usr/lib/python3.4/linecache.py |
| | | file path=usr/lib/python3.4/locale.py |
| | | file path=usr/lib/python3.4/logging/__init__.py |
| | | file path=usr/lib/python3.4/logging/config.py |
| | | file path=usr/lib/python3.4/logging/handlers.py |
| | | file path=usr/lib/python3.4/lzma.py |
| | | file path=usr/lib/python3.4/macpath.py |
| | | file path=usr/lib/python3.4/macurl2path.py |
| | | file path=usr/lib/python3.4/mailbox.py |
| | | file path=usr/lib/python3.4/mailcap.py |
| | | file path=usr/lib/python3.4/mimetypes.py |
| | | file path=usr/lib/python3.4/modulefinder.py |
| | | file path=usr/lib/python3.4/multiprocessing/__init__.py |
| | | file path=usr/lib/python3.4/multiprocessing/connection.py |
| | | file path=usr/lib/python3.4/multiprocessing/context.py |
| | | file path=usr/lib/python3.4/multiprocessing/dummy/__init__.py |
| | | file path=usr/lib/python3.4/multiprocessing/dummy/connection.py |
| | | file path=usr/lib/python3.4/multiprocessing/forkserver.py |
| | | file path=usr/lib/python3.4/multiprocessing/heap.py |
| | | file path=usr/lib/python3.4/multiprocessing/managers.py |
| | | file path=usr/lib/python3.4/multiprocessing/pool.py |
| | | file path=usr/lib/python3.4/multiprocessing/popen_fork.py |
| | | file path=usr/lib/python3.4/multiprocessing/popen_forkserver.py |
| | | file path=usr/lib/python3.4/multiprocessing/popen_spawn_posix.py |
| | | file path=usr/lib/python3.4/multiprocessing/popen_spawn_win32.py |
| | | file path=usr/lib/python3.4/multiprocessing/process.py |
| | | file path=usr/lib/python3.4/multiprocessing/queues.py |
| | | file path=usr/lib/python3.4/multiprocessing/reduction.py |
| | | file path=usr/lib/python3.4/multiprocessing/resource_sharer.py |
| | | file path=usr/lib/python3.4/multiprocessing/semaphore_tracker.py |
| | | file path=usr/lib/python3.4/multiprocessing/sharedctypes.py |
| | | file path=usr/lib/python3.4/multiprocessing/spawn.py |
| | | file path=usr/lib/python3.4/multiprocessing/synchronize.py |
| | | file path=usr/lib/python3.4/multiprocessing/util.py |
| | | file path=usr/lib/python3.4/netrc.py |
| | | file path=usr/lib/python3.4/nntplib.py |
| | | file path=usr/lib/python3.4/ntpath.py |
| | | file path=usr/lib/python3.4/nturl2path.py |
| | | file path=usr/lib/python3.4/numbers.py |
| | | file path=usr/lib/python3.4/opcode.py |
| | | file path=usr/lib/python3.4/operator.py |
| | | file path=usr/lib/python3.4/optparse.py |
| | | file path=usr/lib/python3.4/os.py |
| | | file path=usr/lib/python3.4/pathlib.py |
| | | file path=usr/lib/python3.4/pdb.py pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/pickle.py |
| | | file path=usr/lib/python3.4/pickletools.py |
| | | file path=usr/lib/python3.4/pipes.py |
| | | file path=usr/lib/python3.4/pkgutil.py |
| | | file path=usr/lib/python3.4/plat-sunos5/CDIO.py |
| | | file path=usr/lib/python3.4/plat-sunos5/DLFCN.py |
| | | file path=usr/lib/python3.4/plat-sunos5/IN.py |
| | | file path=usr/lib/python3.4/plat-sunos5/STROPTS.py |
| | | file path=usr/lib/python3.4/plat-sunos5/TYPES.py |
| | | file path=usr/lib/python3.4/plat-sunos5/regen |
| | | # XXX bootstrap |
| | | #file path=usr/lib/python3.4/platform.py \ |
| | | # pkg.depend.bypass-generate=.*/MacOS.* \ |
| | | # pkg.depend.bypass-generate=.*/_gestalt.* \ |
| | | # pkg.depend.bypass-generate=.*/java/__init__.py \ |
| | | # pkg.depend.bypass-generate=.*/lang.* \ |
| | | # pkg.depend.bypass-generate=.*/vms_lib.* \ |
| | | # pkg.depend.bypass-generate=.*/win32api.* \ |
| | | # pkg.depend.bypass-generate=.*/win32con.* \ |
| | | # pkg.depend.bypass-generate=.*/winreg.* |
| | | file path=usr/lib/python3.4/platform.py pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/plistlib.py |
| | | file path=usr/lib/python3.4/poplib.py |
| | | file path=usr/lib/python3.4/posixpath.py |
| | | file path=usr/lib/python3.4/pprint.py |
| | | file path=usr/lib/python3.4/profile.py pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/pstats.py |
| | | file path=usr/lib/python3.4/pty.py |
| | | file path=usr/lib/python3.4/py_compile.py |
| | | file path=usr/lib/python3.4/pyclbr.py |
| | | file path=usr/lib/python3.4/pydoc.py |
| | | file path=usr/lib/python3.4/pydoc_data/__init__.py |
| | | file path=usr/lib/python3.4/pydoc_data/_pydoc.css |
| | | file path=usr/lib/python3.4/pydoc_data/topics.py |
| | | file path=usr/lib/python3.4/queue.py |
| | | file path=usr/lib/python3.4/quopri.py |
| | | file path=usr/lib/python3.4/random.py |
| | | file path=usr/lib/python3.4/re.py |
| | | file path=usr/lib/python3.4/reprlib.py |
| | | file path=usr/lib/python3.4/rlcompleter.py |
| | | file path=usr/lib/python3.4/runpy.py |
| | | file path=usr/lib/python3.4/sched.py |
| | | file path=usr/lib/python3.4/selectors.py |
| | | file path=usr/lib/python3.4/shelve.py |
| | | file path=usr/lib/python3.4/shlex.py |
| | | file path=usr/lib/python3.4/shutil.py |
| | | file path=usr/lib/python3.4/site-packages/README |
| | | file path=usr/lib/python3.4/site-packages/vendor-packages.pth |
| | | file path=usr/lib/python3.4/site.py |
| | | file path=usr/lib/python3.4/smtpd.py pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/smtplib.py |
| | | file path=usr/lib/python3.4/sndhdr.py |
| | | file path=usr/lib/python3.4/socket.py |
| | | file path=usr/lib/python3.4/socketserver.py |
| | | file path=usr/lib/python3.4/sqlite3/__init__.py |
| | | file path=usr/lib/python3.4/sqlite3/dbapi2.py |
| | | file path=usr/lib/python3.4/sqlite3/dump.py |
| | | file path=usr/lib/python3.4/sqlite3/test/__init__.py |
| | | file path=usr/lib/python3.4/sqlite3/test/dbapi.py |
| | | file path=usr/lib/python3.4/sqlite3/test/dump.py |
| | | file path=usr/lib/python3.4/sqlite3/test/factory.py |
| | | file path=usr/lib/python3.4/sqlite3/test/hooks.py |
| | | file path=usr/lib/python3.4/sqlite3/test/regression.py |
| | | file path=usr/lib/python3.4/sqlite3/test/transactions.py |
| | | file path=usr/lib/python3.4/sqlite3/test/types.py |
| | | file path=usr/lib/python3.4/sqlite3/test/userfunctions.py |
| | | file path=usr/lib/python3.4/sre_compile.py |
| | | file path=usr/lib/python3.4/sre_constants.py |
| | | file path=usr/lib/python3.4/sre_parse.py |
| | | file path=usr/lib/python3.4/ssl.py |
| | | file path=usr/lib/python3.4/stat.py |
| | | file path=usr/lib/python3.4/statistics.py |
| | | file path=usr/lib/python3.4/string.py |
| | | file path=usr/lib/python3.4/stringprep.py |
| | | file path=usr/lib/python3.4/struct.py |
| | | file path=usr/lib/python3.4/subprocess.py |
| | | file path=usr/lib/python3.4/sunau.py |
| | | file path=usr/lib/python3.4/symbol.py |
| | | file path=usr/lib/python3.4/symtable.py |
| | | file path=usr/lib/python3.4/sysconfig.py |
| | | file path=usr/lib/python3.4/tabnanny.py |
| | | file path=usr/lib/python3.4/tarfile.py |
| | | file path=usr/lib/python3.4/telnetlib.py |
| | | file path=usr/lib/python3.4/tempfile.py |
| | | file path=usr/lib/python3.4/test/185test.db |
| | | file path=usr/lib/python3.4/test/Sine-1000Hz-300ms.aif |
| | | file path=usr/lib/python3.4/test/__init__.py |
| | | file path=usr/lib/python3.4/test/__main__.py |
| | | file path=usr/lib/python3.4/test/_test_multiprocessing.py |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-alaw.aifc |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm16.aiff |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm16.au |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm16.wav |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm24.aiff |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm24.au |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm24.wav |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm32.aiff |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm32.au |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm32.wav |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm8.aiff |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm8.au |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-pcm8.wav |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-ulaw.aifc |
| | | file path=usr/lib/python3.4/test/audiodata/pluck-ulaw.au |
| | | file path=usr/lib/python3.4/test/audiotest.au |
| | | file path=usr/lib/python3.4/test/audiotests.py |
| | | file path=usr/lib/python3.4/test/autotest.py |
| | | file path=usr/lib/python3.4/test/bad_coding.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/bad_coding2.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badcert.pem |
| | | file path=usr/lib/python3.4/test/badkey.pem |
| | | file path=usr/lib/python3.4/test/badsyntax_3131.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future10.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future3.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future4.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future5.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future6.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future7.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future8.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_future9.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/badsyntax_pep3120.py pkg.tmp.autopyc=false |
| | | file path=usr/lib/python3.4/test/buffer_tests.py |
| | | file path=usr/lib/python3.4/test/bytecode_helper.py |
| | | file path=usr/lib/python3.4/test/capath/4e1295a3.0 |
| | | file path=usr/lib/python3.4/test/capath/5ed36f99.0 |
| | | file path=usr/lib/python3.4/test/capath/6e88d7b8.0 |
| | | file path=usr/lib/python3.4/test/capath/99d0fa06.0 |
| | | file path=usr/lib/python3.4/test/cfgparser.1 |
| | | file path=usr/lib/python3.4/test/cfgparser.2 |
| | | file path=usr/lib/python3.4/test/cfgparser.3 |
| | | file path=usr/lib/python3.4/test/check_soundcard.vbs |
| | | file path=usr/lib/python3.4/test/cjkencodings/big5-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/big5.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/big5hkscs-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/big5hkscs.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/cp949-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/cp949.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/euc_jisx0213-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/euc_jisx0213.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/euc_jp-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/euc_jp.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/euc_kr-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/euc_kr.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/gb18030-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/gb18030.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/gb2312-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/gb2312.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/gbk-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/gbk.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/hz-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/hz.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/iso2022_jp-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/iso2022_jp.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/iso2022_kr-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/iso2022_kr.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/johab-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/johab.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/shift_jis-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/shift_jis.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/shift_jisx0213-utf8.txt |
| | | file path=usr/lib/python3.4/test/cjkencodings/shift_jisx0213.txt |
| | | file path=usr/lib/python3.4/test/cmath_testcases.txt |
| | | file path=usr/lib/python3.4/test/curses_tests.py |
| | | file path=usr/lib/python3.4/test/data/README |
| | | file path=usr/lib/python3.4/test/datetimetester.py |
| | | file path=usr/lib/python3.4/test/decimaltestdata/abs.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/add.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/and.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/base.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/clamp.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/class.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/compare.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/comparetotal.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/comparetotmag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/copy.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/copyabs.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/copynegate.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/copysign.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddAbs.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddAdd.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddAnd.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddBase.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCanonical.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddClass.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCompare.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCompareSig.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCompareTotal.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCompareTotalMag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCopy.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCopyAbs.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCopyNegate.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddCopySign.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddDivide.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddDivideInt.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddEncode.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddFMA.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddInvert.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddLogB.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddMax.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddMaxMag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddMin.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddMinMag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddMinus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddMultiply.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddNextMinus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddNextPlus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddNextToward.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddOr.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddPlus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddQuantize.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddReduce.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddRemainder.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddRemainderNear.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddRotate.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddSameQuantum.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddScaleB.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddShift.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddSubtract.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddToIntegral.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ddXor.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/decDouble.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/decQuad.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/decSingle.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/divide.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/divideint.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqAbs.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqAdd.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqAnd.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqBase.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCanonical.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqClass.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCompare.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCompareSig.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCompareTotal.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCompareTotalMag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCopy.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCopyAbs.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCopyNegate.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqCopySign.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqDivide.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqDivideInt.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqEncode.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqFMA.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqInvert.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqLogB.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqMax.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqMaxMag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqMin.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqMinMag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqMinus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqMultiply.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqNextMinus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqNextPlus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqNextToward.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqOr.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqPlus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqQuantize.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqReduce.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqRemainder.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqRemainderNear.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqRotate.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqSameQuantum.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqScaleB.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqShift.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqSubtract.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqToIntegral.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dqXor.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dsBase.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/dsEncode.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/exp.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/extra.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/fma.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/inexact.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/invert.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/ln.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/log10.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/logb.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/max.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/maxmag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/min.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/minmag.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/minus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/multiply.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/nextminus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/nextplus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/nexttoward.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/or.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/plus.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/power.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/powersqrt.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/quantize.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/randomBound32.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/randoms.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/reduce.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/remainder.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/remainderNear.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/rescale.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/rotate.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/rounding.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/samequantum.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/scaleb.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/shift.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/squareroot.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/subtract.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/testall.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/tointegral.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/tointegralx.decTest |
| | | file path=usr/lib/python3.4/test/decimaltestdata/xor.decTest |
| | | file path=usr/lib/python3.4/test/dh512.pem |
| | | file path=usr/lib/python3.4/test/dis_module.py |
| | | file path=usr/lib/python3.4/test/dlpitest.py |
| | | file path=usr/lib/python3.4/test/doctest_aliases.py |
| | | file path=usr/lib/python3.4/test/double_const.py |
| | | file path=usr/lib/python3.4/test/dtrace_sample.py |
| | | file path=usr/lib/python3.4/test/empty.vbs |
| | | file path=usr/lib/python3.4/test/encoded_modules/__init__.py |
| | | file path=usr/lib/python3.4/test/encoded_modules/module_iso_8859_1.py |
| | | file path=usr/lib/python3.4/test/encoded_modules/module_koi8_r.py |
| | | file path=usr/lib/python3.4/test/exception_hierarchy.txt |
| | | file path=usr/lib/python3.4/test/final_a.py |
| | | file path=usr/lib/python3.4/test/final_b.py |
| | | file path=usr/lib/python3.4/test/floating_points.txt |
| | | file path=usr/lib/python3.4/test/fork_wait.py |
| | | file path=usr/lib/python3.4/test/formatfloat_testcases.txt |
| | | file path=usr/lib/python3.4/test/future_test1.py |
| | | file path=usr/lib/python3.4/test/future_test2.py |
| | | file path=usr/lib/python3.4/test/gdb_sample.py |
| | | file path=usr/lib/python3.4/test/https_svn_python_org_root.pem |
| | | file path=usr/lib/python3.4/test/ieee754.txt |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.bmp |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.gif |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.jpg |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.pbm |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.pgm |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.png |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.ppm |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.ras |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.sgi |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.tiff |
| | | file path=usr/lib/python3.4/test/imghdrdata/python.xbm |
| | | file path=usr/lib/python3.4/test/inspect_fodder.py |
| | | file path=usr/lib/python3.4/test/inspect_fodder2.py |
| | | file path=usr/lib/python3.4/test/keycert.passwd.pem |
| | | file path=usr/lib/python3.4/test/keycert.pem |
| | | file path=usr/lib/python3.4/test/keycert2.pem |
| | | file path=usr/lib/python3.4/test/keycert3.pem |
| | | file path=usr/lib/python3.4/test/keycert4.pem |
| | | file path=usr/lib/python3.4/test/list_tests.py |
| | | file path=usr/lib/python3.4/test/lock_tests.py |
| | | file path=usr/lib/python3.4/test/mailcap.txt |
| | | file path=usr/lib/python3.4/test/make_ssl_certs.py |
| | | file path=usr/lib/python3.4/test/mapping_tests.py |
| | | file path=usr/lib/python3.4/test/math_testcases.txt |
| | | file path=usr/lib/python3.4/test/memory_watchdog.py |
| | | file path=usr/lib/python3.4/test/mime.types |
| | | file path=usr/lib/python3.4/test/mock_socket.py |
| | | file path=usr/lib/python3.4/test/mp_fork_bomb.py |
| | | file path=usr/lib/python3.4/test/multibytecodec_support.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/both_portions/foo/one.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/both_portions/foo/two.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/missing_directory.zip |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/module_and_namespace_package/a_test.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/module_and_namespace_package/a_test/empty |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/nested_portion1.zip |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/not_a_namespace_pkg/foo/__init__.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/not_a_namespace_pkg/foo/one.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/portion1/foo/one.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/portion2/foo/two.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/project1/parent/child/one.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/project2/parent/child/two.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/project3/parent/child/three.py |
| | | file path=usr/lib/python3.4/test/namespace_pkgs/top_level_portion1.zip |
| | | file path=usr/lib/python3.4/test/nokia.pem |
| | | file path=usr/lib/python3.4/test/nullbytecert.pem |
| | | file path=usr/lib/python3.4/test/nullcert.pem |
| | | file path=usr/lib/python3.4/test/outstanding_bugs.py |
| | | file path=usr/lib/python3.4/test/pickletester.py |
| | | file path=usr/lib/python3.4/test/privrbactest.py |
| | | file path=usr/lib/python3.4/test/profilee.py |
| | | file path=usr/lib/python3.4/test/pstats.pck |
| | | file path=usr/lib/python3.4/test/pycacert.pem |
| | | file path=usr/lib/python3.4/test/pycakey.pem |
| | | file path=usr/lib/python3.4/test/pyclbr_input.py |
| | | file path=usr/lib/python3.4/test/pydoc_mod.py |
| | | file path=usr/lib/python3.4/test/pydocfodder.py |
| | | file path=usr/lib/python3.4/test/pystone.py |
| | | file path=usr/lib/python3.4/test/randv2_32.pck |
| | | file path=usr/lib/python3.4/test/randv2_64.pck |
| | | file path=usr/lib/python3.4/test/randv3.pck |
| | | file path=usr/lib/python3.4/test/re_tests.py |
| | | # XXX bootstrap |
| | | # file path=usr/lib/python3.4/test/regrtest.py \ |
| | | # pkg.depend.bypass-generate=.*/msvcrt.* |
| | | file path=usr/lib/python3.4/test/regrtest.py pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/test/relimport.py |
| | | file path=usr/lib/python3.4/test/reperf.py |
| | | file path=usr/lib/python3.4/test/revocation.crl |
| | | file path=usr/lib/python3.4/test/sample_doctest.py |
| | | file path=usr/lib/python3.4/test/sample_doctest_no_docstrings.py |
| | | file path=usr/lib/python3.4/test/sample_doctest_no_doctests.py |
| | | file path=usr/lib/python3.4/test/script_helper.py |
| | | file path=usr/lib/python3.4/test/seq_tests.py |
| | | file path=usr/lib/python3.4/test/sgml_input.html |
| | | file path=usr/lib/python3.4/test/sha256.pem |
| | | file path=usr/lib/python3.4/test/sndhdrdata/README |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.8svx |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.aifc |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.aiff |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.au |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.hcom |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.sndt |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.voc |
| | | file path=usr/lib/python3.4/test/sndhdrdata/sndhdr.wav |
| | | file path=usr/lib/python3.4/test/sortperf.py |
| | | file path=usr/lib/python3.4/test/ssl_cert.pem |
| | | file path=usr/lib/python3.4/test/ssl_key.passwd.pem |
| | | file path=usr/lib/python3.4/test/ssl_key.pem |
| | | file path=usr/lib/python3.4/test/ssl_servers.py |
| | | file path=usr/lib/python3.4/test/ssltests.py |
| | | file path=usr/lib/python3.4/test/string_tests.py |
| | | file path=usr/lib/python3.4/test/subprocessdata/fd_status.py |
| | | file path=usr/lib/python3.4/test/subprocessdata/input_reader.py |
| | | file path=usr/lib/python3.4/test/subprocessdata/qcat.py |
| | | file path=usr/lib/python3.4/test/subprocessdata/qgrep.py |
| | | file path=usr/lib/python3.4/test/subprocessdata/sigchild_ignore.py |
| | | file path=usr/lib/python3.4/test/support/__init__.py |
| | | file path=usr/lib/python3.4/test/test___all__.py |
| | | file path=usr/lib/python3.4/test/test___future__.py |
| | | file path=usr/lib/python3.4/test/test__locale.py |
| | | file path=usr/lib/python3.4/test/test__opcode.py |
| | | file path=usr/lib/python3.4/test/test__osx_support.py |
| | | file path=usr/lib/python3.4/test/test_abc.py |
| | | file path=usr/lib/python3.4/test/test_abstract_numbers.py |
| | | file path=usr/lib/python3.4/test/test_aifc.py |
| | | file path=usr/lib/python3.4/test/test_argparse.py |
| | | file path=usr/lib/python3.4/test/test_array.py |
| | | file path=usr/lib/python3.4/test/test_ast.py |
| | | file path=usr/lib/python3.4/test/test_asynchat.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/__init__.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/__main__.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/echo.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/echo2.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/echo3.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/keycert3.pem |
| | | file path=usr/lib/python3.4/test/test_asyncio/pycacert.pem |
| | | file path=usr/lib/python3.4/test/test_asyncio/ssl_cert.pem |
| | | file path=usr/lib/python3.4/test/test_asyncio/ssl_key.pem |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_base_events.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_events.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_futures.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_locks.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_proactor_events.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_queues.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_selector_events.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_streams.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_subprocess.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_tasks.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_transports.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_unix_events.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_windows_events.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/test_windows_utils.py |
| | | file path=usr/lib/python3.4/test/test_asyncio/tests.txt |
| | | file path=usr/lib/python3.4/test/test_asyncore.py |
| | | file path=usr/lib/python3.4/test/test_atexit.py |
| | | file path=usr/lib/python3.4/test/test_audioop.py |
| | | file path=usr/lib/python3.4/test/test_augassign.py |
| | | file path=usr/lib/python3.4/test/test_base64.py |
| | | file path=usr/lib/python3.4/test/test_bigaddrspace.py |
| | | file path=usr/lib/python3.4/test/test_bigmem.py |
| | | file path=usr/lib/python3.4/test/test_binascii.py |
| | | file path=usr/lib/python3.4/test/test_binhex.py |
| | | file path=usr/lib/python3.4/test/test_binop.py |
| | | file path=usr/lib/python3.4/test/test_bisect.py |
| | | file path=usr/lib/python3.4/test/test_bool.py |
| | | file path=usr/lib/python3.4/test/test_buffer.py |
| | | file path=usr/lib/python3.4/test/test_bufio.py |
| | | file path=usr/lib/python3.4/test/test_builtin.py |
| | | file path=usr/lib/python3.4/test/test_bytes.py |
| | | file path=usr/lib/python3.4/test/test_bz2.py |
| | | file path=usr/lib/python3.4/test/test_calendar.py |
| | | file path=usr/lib/python3.4/test/test_call.py |
| | | file path=usr/lib/python3.4/test/test_capi.py |
| | | file path=usr/lib/python3.4/test/test_cgi.py |
| | | file path=usr/lib/python3.4/test/test_cgitb.py |
| | | file path=usr/lib/python3.4/test/test_charmapcodec.py |
| | | file path=usr/lib/python3.4/test/test_class.py |
| | | file path=usr/lib/python3.4/test/test_cmath.py |
| | | file path=usr/lib/python3.4/test/test_cmd.py |
| | | file path=usr/lib/python3.4/test/test_cmd_line.py |
| | | file path=usr/lib/python3.4/test/test_cmd_line_script.py |
| | | file path=usr/lib/python3.4/test/test_code.py |
| | | file path=usr/lib/python3.4/test/test_code_module.py |
| | | file path=usr/lib/python3.4/test/test_codeccallbacks.py |
| | | file path=usr/lib/python3.4/test/test_codecencodings_cn.py |
| | | file path=usr/lib/python3.4/test/test_codecencodings_hk.py |
| | | file path=usr/lib/python3.4/test/test_codecencodings_iso2022.py |
| | | file path=usr/lib/python3.4/test/test_codecencodings_jp.py |
| | | file path=usr/lib/python3.4/test/test_codecencodings_kr.py |
| | | file path=usr/lib/python3.4/test/test_codecencodings_tw.py |
| | | file path=usr/lib/python3.4/test/test_codecmaps_cn.py |
| | | file path=usr/lib/python3.4/test/test_codecmaps_hk.py |
| | | file path=usr/lib/python3.4/test/test_codecmaps_jp.py |
| | | file path=usr/lib/python3.4/test/test_codecmaps_kr.py |
| | | file path=usr/lib/python3.4/test/test_codecmaps_tw.py |
| | | file path=usr/lib/python3.4/test/test_codecs.py |
| | | file path=usr/lib/python3.4/test/test_codeop.py |
| | | file path=usr/lib/python3.4/test/test_collections.py |
| | | file path=usr/lib/python3.4/test/test_colorsys.py |
| | | file path=usr/lib/python3.4/test/test_compare.py |
| | | file path=usr/lib/python3.4/test/test_compile.py |
| | | file path=usr/lib/python3.4/test/test_compileall.py |
| | | file path=usr/lib/python3.4/test/test_complex.py |
| | | file path=usr/lib/python3.4/test/test_concurrent_futures.py |
| | | file path=usr/lib/python3.4/test/test_configparser.py |
| | | file path=usr/lib/python3.4/test/test_contains.py |
| | | file path=usr/lib/python3.4/test/test_contextlib.py |
| | | file path=usr/lib/python3.4/test/test_copy.py |
| | | file path=usr/lib/python3.4/test/test_copyreg.py |
| | | file path=usr/lib/python3.4/test/test_cprofile.py |
| | | file path=usr/lib/python3.4/test/test_crashers.py |
| | | file path=usr/lib/python3.4/test/test_crypt.py |
| | | file path=usr/lib/python3.4/test/test_csv.py |
| | | file path=usr/lib/python3.4/test/test_ctypes.py |
| | | file path=usr/lib/python3.4/test/test_curses.py |
| | | file path=usr/lib/python3.4/test/test_datetime.py |
| | | file path=usr/lib/python3.4/test/test_dbm.py |
| | | file path=usr/lib/python3.4/test/test_dbm_dumb.py |
| | | file path=usr/lib/python3.4/test/test_dbm_gnu.py |
| | | file path=usr/lib/python3.4/test/test_dbm_ndbm.py |
| | | file path=usr/lib/python3.4/test/test_decimal.py |
| | | file path=usr/lib/python3.4/test/test_decorators.py |
| | | file path=usr/lib/python3.4/test/test_defaultdict.py |
| | | file path=usr/lib/python3.4/test/test_deque.py |
| | | file path=usr/lib/python3.4/test/test_descr.py |
| | | file path=usr/lib/python3.4/test/test_descrtut.py |
| | | file path=usr/lib/python3.4/test/test_devpoll.py |
| | | file path=usr/lib/python3.4/test/test_dict.py |
| | | file path=usr/lib/python3.4/test/test_dictcomps.py |
| | | file path=usr/lib/python3.4/test/test_dictviews.py |
| | | file path=usr/lib/python3.4/test/test_difflib.py |
| | | file path=usr/lib/python3.4/test/test_difflib_expect.html |
| | | file path=usr/lib/python3.4/test/test_dis.py |
| | | file path=usr/lib/python3.4/test/test_distutils.py |
| | | file path=usr/lib/python3.4/test/test_doctest.py |
| | | file path=usr/lib/python3.4/test/test_doctest.txt |
| | | file path=usr/lib/python3.4/test/test_doctest2.py |
| | | file path=usr/lib/python3.4/test/test_doctest2.txt |
| | | file path=usr/lib/python3.4/test/test_doctest3.txt |
| | | file path=usr/lib/python3.4/test/test_doctest4.txt |
| | | file path=usr/lib/python3.4/test/test_docxmlrpc.py |
| | | file path=usr/lib/python3.4/test/test_dtrace.py |
| | | file path=usr/lib/python3.4/test/test_dummy_thread.py |
| | | file path=usr/lib/python3.4/test/test_dummy_threading.py |
| | | file path=usr/lib/python3.4/test/test_dynamic.py |
| | | file path=usr/lib/python3.4/test/test_dynamicclassattribute.py |
| | | file path=usr/lib/python3.4/test/test_email/__init__.py |
| | | file path=usr/lib/python3.4/test/test_email/__main__.py |
| | | file path=usr/lib/python3.4/test/test_email/data/PyBanner048.gif |
| | | file path=usr/lib/python3.4/test/test_email/data/audiotest.au |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_01.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_02.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_03.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_04.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_05.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_06.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_07.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_08.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_09.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_10.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_11.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_12.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_12a.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_13.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_14.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_15.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_16.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_17.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_18.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_19.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_20.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_21.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_22.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_23.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_24.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_25.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_26.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_27.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_28.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_29.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_30.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_31.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_32.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_33.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_34.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_35.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_36.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_37.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_38.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_39.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_40.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_41.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_42.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_43.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_44.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_45.txt |
| | | file path=usr/lib/python3.4/test/test_email/data/msg_46.txt |
| | | file path=usr/lib/python3.4/test/test_email/test__encoded_words.py |
| | | file path=usr/lib/python3.4/test/test_email/test__header_value_parser.py |
| | | file path=usr/lib/python3.4/test/test_email/test_asian_codecs.py |
| | | file path=usr/lib/python3.4/test/test_email/test_contentmanager.py |
| | | file path=usr/lib/python3.4/test/test_email/test_defect_handling.py |
| | | file path=usr/lib/python3.4/test/test_email/test_email.py |
| | | file path=usr/lib/python3.4/test/test_email/test_generator.py |
| | | file path=usr/lib/python3.4/test/test_email/test_headerregistry.py |
| | | file path=usr/lib/python3.4/test/test_email/test_inversion.py |
| | | file path=usr/lib/python3.4/test/test_email/test_message.py |
| | | file path=usr/lib/python3.4/test/test_email/test_parser.py |
| | | file path=usr/lib/python3.4/test/test_email/test_pickleable.py |
| | | file path=usr/lib/python3.4/test/test_email/test_policy.py |
| | | file path=usr/lib/python3.4/test/test_email/test_utils.py |
| | | file path=usr/lib/python3.4/test/test_email/torture_test.py |
| | | file path=usr/lib/python3.4/test/test_enum.py |
| | | file path=usr/lib/python3.4/test/test_enumerate.py |
| | | file path=usr/lib/python3.4/test/test_eof.py |
| | | file path=usr/lib/python3.4/test/test_epoll.py |
| | | file path=usr/lib/python3.4/test/test_errno.py |
| | | file path=usr/lib/python3.4/test/test_exception_variations.py |
| | | file path=usr/lib/python3.4/test/test_exceptions.py |
| | | file path=usr/lib/python3.4/test/test_extcall.py |
| | | file path=usr/lib/python3.4/test/test_faulthandler.py |
| | | file path=usr/lib/python3.4/test/test_fcntl.py |
| | | file path=usr/lib/python3.4/test/test_file.py |
| | | file path=usr/lib/python3.4/test/test_file_eintr.py |
| | | file path=usr/lib/python3.4/test/test_filecmp.py |
| | | file path=usr/lib/python3.4/test/test_fileinput.py |
| | | file path=usr/lib/python3.4/test/test_fileio.py |
| | | file path=usr/lib/python3.4/test/test_finalization.py |
| | | file path=usr/lib/python3.4/test/test_float.py |
| | | file path=usr/lib/python3.4/test/test_flufl.py |
| | | file path=usr/lib/python3.4/test/test_fnmatch.py |
| | | file path=usr/lib/python3.4/test/test_fork1.py |
| | | file path=usr/lib/python3.4/test/test_format.py |
| | | file path=usr/lib/python3.4/test/test_fractions.py |
| | | file path=usr/lib/python3.4/test/test_frame.py |
| | | file path=usr/lib/python3.4/test/test_ftplib.py |
| | | file path=usr/lib/python3.4/test/test_funcattrs.py |
| | | file path=usr/lib/python3.4/test/test_functools.py |
| | | file path=usr/lib/python3.4/test/test_future.py |
| | | file path=usr/lib/python3.4/test/test_future3.py |
| | | file path=usr/lib/python3.4/test/test_future4.py |
| | | file path=usr/lib/python3.4/test/test_future5.py |
| | | file path=usr/lib/python3.4/test/test_gc.py |
| | | file path=usr/lib/python3.4/test/test_gdb.py |
| | | file path=usr/lib/python3.4/test/test_generators.py |
| | | file path=usr/lib/python3.4/test/test_genericpath.py |
| | | file path=usr/lib/python3.4/test/test_genexps.py |
| | | file path=usr/lib/python3.4/test/test_getargs2.py |
| | | file path=usr/lib/python3.4/test/test_getopt.py |
| | | file path=usr/lib/python3.4/test/test_getpass.py |
| | | file path=usr/lib/python3.4/test/test_gettext.py |
| | | file path=usr/lib/python3.4/test/test_glob.py |
| | | file path=usr/lib/python3.4/test/test_global.py |
| | | file path=usr/lib/python3.4/test/test_grammar.py |
| | | file path=usr/lib/python3.4/test/test_grp.py |
| | | file path=usr/lib/python3.4/test/test_gzip.py |
| | | file path=usr/lib/python3.4/test/test_hash.py |
| | | file path=usr/lib/python3.4/test/test_hashlib.py |
| | | file path=usr/lib/python3.4/test/test_heapq.py |
| | | file path=usr/lib/python3.4/test/test_hmac.py |
| | | file path=usr/lib/python3.4/test/test_html.py |
| | | file path=usr/lib/python3.4/test/test_htmlparser.py |
| | | file path=usr/lib/python3.4/test/test_http_cookiejar.py |
| | | file path=usr/lib/python3.4/test/test_http_cookies.py |
| | | file path=usr/lib/python3.4/test/test_httplib.py |
| | | file path=usr/lib/python3.4/test/test_httpservers.py |
| | | file path=usr/lib/python3.4/test/test_idle.py |
| | | file path=usr/lib/python3.4/test/test_imaplib.py |
| | | file path=usr/lib/python3.4/test/test_imghdr.py |
| | | file path=usr/lib/python3.4/test/test_imp.py |
| | | file path=usr/lib/python3.4/test/test_import.py |
| | | file path=usr/lib/python3.4/test/test_importlib/__init__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/__main__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/abc.py |
| | | file path=usr/lib/python3.4/test/test_importlib/builtin/__init__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/builtin/test_finder.py |
| | | file path=usr/lib/python3.4/test/test_importlib/builtin/test_loader.py |
| | | file path=usr/lib/python3.4/test/test_importlib/builtin/util.py |
| | | file path=usr/lib/python3.4/test/test_importlib/extension/__init__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/extension/test_case_sensitivity.py |
| | | file path=usr/lib/python3.4/test/test_importlib/extension/test_finder.py |
| | | file path=usr/lib/python3.4/test/test_importlib/extension/test_loader.py |
| | | file path=usr/lib/python3.4/test/test_importlib/extension/test_path_hook.py |
| | | file path=usr/lib/python3.4/test/test_importlib/extension/util.py |
| | | file path=usr/lib/python3.4/test/test_importlib/frozen/__init__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/frozen/test_finder.py |
| | | file path=usr/lib/python3.4/test/test_importlib/frozen/test_loader.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/__init__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test___loader__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test___package__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test_api.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test_caching.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test_fromlist.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test_meta_path.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test_packages.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test_path.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/test_relative_imports.py |
| | | file path=usr/lib/python3.4/test/test_importlib/import_/util.py |
| | | file path=usr/lib/python3.4/test/test_importlib/regrtest.py |
| | | file path=usr/lib/python3.4/test/test_importlib/source/__init__.py |
| | | file path=usr/lib/python3.4/test/test_importlib/source/test_case_sensitivity.py |
| | | file path=usr/lib/python3.4/test/test_importlib/source/test_file_loader.py |
| | | file path=usr/lib/python3.4/test/test_importlib/source/test_finder.py |
| | | file path=usr/lib/python3.4/test/test_importlib/source/test_path_hook.py |
| | | file path=usr/lib/python3.4/test/test_importlib/source/test_source_encoding.py |
| | | file path=usr/lib/python3.4/test/test_importlib/source/util.py |
| | | file path=usr/lib/python3.4/test/test_importlib/test_abc.py |
| | | file path=usr/lib/python3.4/test/test_importlib/test_api.py |
| | | file path=usr/lib/python3.4/test/test_importlib/test_locks.py |
| | | file path=usr/lib/python3.4/test/test_importlib/test_spec.py |
| | | file path=usr/lib/python3.4/test/test_importlib/test_util.py |
| | | file path=usr/lib/python3.4/test/test_importlib/test_windows.py |
| | | file path=usr/lib/python3.4/test/test_importlib/util.py |
| | | file path=usr/lib/python3.4/test/test_index.py |
| | | file path=usr/lib/python3.4/test/test_inspect.py |
| | | file path=usr/lib/python3.4/test/test_int.py |
| | | file path=usr/lib/python3.4/test/test_int_literal.py |
| | | file path=usr/lib/python3.4/test/test_io.py |
| | | file path=usr/lib/python3.4/test/test_ioctl.py |
| | | file path=usr/lib/python3.4/test/test_ipaddress.py |
| | | file path=usr/lib/python3.4/test/test_isinstance.py |
| | | file path=usr/lib/python3.4/test/test_iter.py |
| | | file path=usr/lib/python3.4/test/test_iterlen.py |
| | | file path=usr/lib/python3.4/test/test_itertools.py |
| | | file path=usr/lib/python3.4/test/test_json/__init__.py |
| | | file path=usr/lib/python3.4/test/test_json/__main__.py |
| | | file path=usr/lib/python3.4/test/test_json/test_decode.py |
| | | file path=usr/lib/python3.4/test/test_json/test_default.py |
| | | file path=usr/lib/python3.4/test/test_json/test_dump.py |
| | | file path=usr/lib/python3.4/test/test_json/test_encode_basestring_ascii.py |
| | | file path=usr/lib/python3.4/test/test_json/test_enum.py |
| | | file path=usr/lib/python3.4/test/test_json/test_fail.py |
| | | file path=usr/lib/python3.4/test/test_json/test_float.py |
| | | file path=usr/lib/python3.4/test/test_json/test_indent.py |
| | | file path=usr/lib/python3.4/test/test_json/test_pass1.py |
| | | file path=usr/lib/python3.4/test/test_json/test_pass2.py |
| | | file path=usr/lib/python3.4/test/test_json/test_pass3.py |
| | | file path=usr/lib/python3.4/test/test_json/test_recursion.py |
| | | file path=usr/lib/python3.4/test/test_json/test_scanstring.py |
| | | file path=usr/lib/python3.4/test/test_json/test_separators.py |
| | | file path=usr/lib/python3.4/test/test_json/test_speedups.py |
| | | file path=usr/lib/python3.4/test/test_json/test_tool.py |
| | | file path=usr/lib/python3.4/test/test_json/test_unicode.py |
| | | file path=usr/lib/python3.4/test/test_keyword.py |
| | | file path=usr/lib/python3.4/test/test_keywordonlyarg.py |
| | | file path=usr/lib/python3.4/test/test_kqueue.py |
| | | file path=usr/lib/python3.4/test/test_largefile.py |
| | | file path=usr/lib/python3.4/test/test_lib2to3.py |
| | | file path=usr/lib/python3.4/test/test_linecache.py |
| | | file path=usr/lib/python3.4/test/test_list.py |
| | | file path=usr/lib/python3.4/test/test_listcomps.py |
| | | file path=usr/lib/python3.4/test/test_locale.py |
| | | file path=usr/lib/python3.4/test/test_logging.py \ |
| | | pkg.depend.bypass-generate=.*/win32evtlog.* |
| | | file path=usr/lib/python3.4/test/test_long.py |
| | | file path=usr/lib/python3.4/test/test_longexp.py |
| | | file path=usr/lib/python3.4/test/test_lzma.py |
| | | file path=usr/lib/python3.4/test/test_macpath.py |
| | | file path=usr/lib/python3.4/test/test_macurl2path.py |
| | | file path=usr/lib/python3.4/test/test_mailbox.py |
| | | file path=usr/lib/python3.4/test/test_mailcap.py |
| | | file path=usr/lib/python3.4/test/test_marshal.py |
| | | file path=usr/lib/python3.4/test/test_math.py |
| | | file path=usr/lib/python3.4/test/test_memoryio.py |
| | | file path=usr/lib/python3.4/test/test_memoryview.py |
| | | file path=usr/lib/python3.4/test/test_metaclass.py |
| | | file path=usr/lib/python3.4/test/test_mimetypes.py |
| | | file path=usr/lib/python3.4/test/test_minidom.py |
| | | file path=usr/lib/python3.4/test/test_mmap.py |
| | | file path=usr/lib/python3.4/test/test_module.py |
| | | file path=usr/lib/python3.4/test/test_modulefinder.py |
| | | file path=usr/lib/python3.4/test/test_msilib.py |
| | | file path=usr/lib/python3.4/test/test_multibytecodec.py |
| | | file path=usr/lib/python3.4/test/test_multiprocessing_fork.py |
| | | file path=usr/lib/python3.4/test/test_multiprocessing_forkserver.py |
| | | file path=usr/lib/python3.4/test/test_multiprocessing_main_handling.py |
| | | file path=usr/lib/python3.4/test/test_multiprocessing_spawn.py |
| | | file path=usr/lib/python3.4/test/test_namespace_pkgs.py |
| | | file path=usr/lib/python3.4/test/test_netrc.py |
| | | file path=usr/lib/python3.4/test/test_nis.py |
| | | file path=usr/lib/python3.4/test/test_nntplib.py |
| | | file path=usr/lib/python3.4/test/test_normalization.py |
| | | file path=usr/lib/python3.4/test/test_ntpath.py |
| | | file path=usr/lib/python3.4/test/test_numeric_tower.py |
| | | file path=usr/lib/python3.4/test/test_opcodes.py |
| | | file path=usr/lib/python3.4/test/test_openpty.py |
| | | file path=usr/lib/python3.4/test/test_operator.py |
| | | file path=usr/lib/python3.4/test/test_optparse.py |
| | | file path=usr/lib/python3.4/test/test_os.py |
| | | file path=usr/lib/python3.4/test/test_ossaudiodev.py |
| | | file path=usr/lib/python3.4/test/test_osx_env.py |
| | | file path=usr/lib/python3.4/test/test_parser.py |
| | | file path=usr/lib/python3.4/test/test_pathlib.py |
| | | file path=usr/lib/python3.4/test/test_pdb.py |
| | | file path=usr/lib/python3.4/test/test_peepholer.py |
| | | file path=usr/lib/python3.4/test/test_pep247.py |
| | | file path=usr/lib/python3.4/test/test_pep277.py |
| | | file path=usr/lib/python3.4/test/test_pep292.py |
| | | file path=usr/lib/python3.4/test/test_pep3120.py |
| | | file path=usr/lib/python3.4/test/test_pep3131.py |
| | | file path=usr/lib/python3.4/test/test_pep3151.py |
| | | file path=usr/lib/python3.4/test/test_pep352.py |
| | | file path=usr/lib/python3.4/test/test_pep380.py |
| | | file path=usr/lib/python3.4/test/test_pickle.py |
| | | file path=usr/lib/python3.4/test/test_pickletools.py |
| | | file path=usr/lib/python3.4/test/test_pipes.py |
| | | file path=usr/lib/python3.4/test/test_pkg.py |
| | | file path=usr/lib/python3.4/test/test_pkgimport.py |
| | | file path=usr/lib/python3.4/test/test_pkgutil.py |
| | | file path=usr/lib/python3.4/test/test_platform.py |
| | | file path=usr/lib/python3.4/test/test_plistlib.py |
| | | file path=usr/lib/python3.4/test/test_poll.py |
| | | file path=usr/lib/python3.4/test/test_popen.py |
| | | file path=usr/lib/python3.4/test/test_poplib.py |
| | | file path=usr/lib/python3.4/test/test_posix.py |
| | | file path=usr/lib/python3.4/test/test_posixpath.py |
| | | file path=usr/lib/python3.4/test/test_pow.py |
| | | file path=usr/lib/python3.4/test/test_pprint.py |
| | | file path=usr/lib/python3.4/test/test_print.py |
| | | file path=usr/lib/python3.4/test/test_profile.py |
| | | file path=usr/lib/python3.4/test/test_property.py |
| | | file path=usr/lib/python3.4/test/test_pstats.py |
| | | file path=usr/lib/python3.4/test/test_pty.py |
| | | file path=usr/lib/python3.4/test/test_pulldom.py |
| | | file path=usr/lib/python3.4/test/test_pwd.py |
| | | file path=usr/lib/python3.4/test/test_py_compile.py |
| | | file path=usr/lib/python3.4/test/test_pyclbr.py |
| | | file path=usr/lib/python3.4/test/test_pydoc.py |
| | | file path=usr/lib/python3.4/test/test_pyexpat.py |
| | | file path=usr/lib/python3.4/test/test_queue.py |
| | | file path=usr/lib/python3.4/test/test_quopri.py |
| | | file path=usr/lib/python3.4/test/test_raise.py |
| | | file path=usr/lib/python3.4/test/test_random.py |
| | | file path=usr/lib/python3.4/test/test_range.py |
| | | file path=usr/lib/python3.4/test/test_re.py |
| | | file path=usr/lib/python3.4/test/test_readline.py |
| | | file path=usr/lib/python3.4/test/test_regrtest.py |
| | | file path=usr/lib/python3.4/test/test_reprlib.py |
| | | file path=usr/lib/python3.4/test/test_resource.py |
| | | file path=usr/lib/python3.4/test/test_richcmp.py |
| | | file path=usr/lib/python3.4/test/test_rlcompleter.py |
| | | file path=usr/lib/python3.4/test/test_robotparser.py |
| | | file path=usr/lib/python3.4/test/test_runpy.py |
| | | file path=usr/lib/python3.4/test/test_sax.py |
| | | file path=usr/lib/python3.4/test/test_sched.py |
| | | file path=usr/lib/python3.4/test/test_scope.py |
| | | file path=usr/lib/python3.4/test/test_select.py |
| | | file path=usr/lib/python3.4/test/test_selectors.py |
| | | file path=usr/lib/python3.4/test/test_set.py |
| | | file path=usr/lib/python3.4/test/test_setcomps.py |
| | | file path=usr/lib/python3.4/test/test_shelve.py |
| | | file path=usr/lib/python3.4/test/test_shlex.py |
| | | file path=usr/lib/python3.4/test/test_shutil.py |
| | | file path=usr/lib/python3.4/test/test_signal.py |
| | | file path=usr/lib/python3.4/test/test_site.py |
| | | file path=usr/lib/python3.4/test/test_slice.py |
| | | file path=usr/lib/python3.4/test/test_smtpd.py |
| | | file path=usr/lib/python3.4/test/test_smtplib.py |
| | | file path=usr/lib/python3.4/test/test_smtpnet.py |
| | | file path=usr/lib/python3.4/test/test_sndhdr.py |
| | | file path=usr/lib/python3.4/test/test_socket.py |
| | | file path=usr/lib/python3.4/test/test_socketserver.py |
| | | file path=usr/lib/python3.4/test/test_sort.py |
| | | file path=usr/lib/python3.4/test/test_source_encoding.py |
| | | file path=usr/lib/python3.4/test/test_sqlite.py |
| | | file path=usr/lib/python3.4/test/test_ssl.py |
| | | file path=usr/lib/python3.4/test/test_startfile.py |
| | | file path=usr/lib/python3.4/test/test_stat.py |
| | | file path=usr/lib/python3.4/test/test_statistics.py |
| | | file path=usr/lib/python3.4/test/test_strftime.py |
| | | file path=usr/lib/python3.4/test/test_string.py |
| | | file path=usr/lib/python3.4/test/test_stringprep.py |
| | | file path=usr/lib/python3.4/test/test_strlit.py |
| | | file path=usr/lib/python3.4/test/test_strptime.py |
| | | file path=usr/lib/python3.4/test/test_strtod.py |
| | | file path=usr/lib/python3.4/test/test_struct.py |
| | | file path=usr/lib/python3.4/test/test_structmembers.py |
| | | file path=usr/lib/python3.4/test/test_structseq.py |
| | | file path=usr/lib/python3.4/test/test_subprocess.py |
| | | file path=usr/lib/python3.4/test/test_sunau.py |
| | | file path=usr/lib/python3.4/test/test_sundry.py |
| | | file path=usr/lib/python3.4/test/test_super.py |
| | | file path=usr/lib/python3.4/test/test_support.py |
| | | file path=usr/lib/python3.4/test/test_symtable.py |
| | | file path=usr/lib/python3.4/test/test_syntax.py |
| | | file path=usr/lib/python3.4/test/test_sys.py |
| | | file path=usr/lib/python3.4/test/test_sys_setprofile.py |
| | | file path=usr/lib/python3.4/test/test_sys_settrace.py |
| | | file path=usr/lib/python3.4/test/test_sysconfig.py |
| | | file path=usr/lib/python3.4/test/test_syslog.py |
| | | file path=usr/lib/python3.4/test/test_tarfile.py |
| | | file path=usr/lib/python3.4/test/test_tcl.py |
| | | file path=usr/lib/python3.4/test/test_telnetlib.py |
| | | file path=usr/lib/python3.4/test/test_tempfile.py |
| | | file path=usr/lib/python3.4/test/test_textwrap.py |
| | | file path=usr/lib/python3.4/test/test_thread.py |
| | | file path=usr/lib/python3.4/test/test_threaded_import.py |
| | | file path=usr/lib/python3.4/test/test_threadedtempfile.py |
| | | file path=usr/lib/python3.4/test/test_threading.py |
| | | file path=usr/lib/python3.4/test/test_threading_local.py |
| | | file path=usr/lib/python3.4/test/test_threadsignals.py |
| | | file path=usr/lib/python3.4/test/test_time.py |
| | | file path=usr/lib/python3.4/test/test_timeit.py |
| | | file path=usr/lib/python3.4/test/test_timeout.py |
| | | file path=usr/lib/python3.4/test/test_tk.py |
| | | file path=usr/lib/python3.4/test/test_tokenize.py |
| | | file path=usr/lib/python3.4/test/test_tools.py |
| | | file path=usr/lib/python3.4/test/test_trace.py |
| | | file path=usr/lib/python3.4/test/test_traceback.py |
| | | file path=usr/lib/python3.4/test/test_tracemalloc.py |
| | | file path=usr/lib/python3.4/test/test_ttk_guionly.py |
| | | file path=usr/lib/python3.4/test/test_ttk_textonly.py |
| | | file path=usr/lib/python3.4/test/test_tuple.py |
| | | file path=usr/lib/python3.4/test/test_typechecks.py |
| | | file path=usr/lib/python3.4/test/test_types.py |
| | | file path=usr/lib/python3.4/test/test_ucn.py |
| | | file path=usr/lib/python3.4/test/test_unary.py |
| | | file path=usr/lib/python3.4/test/test_unicode.py |
| | | file path=usr/lib/python3.4/test/test_unicode_file.py |
| | | file path=usr/lib/python3.4/test/test_unicodedata.py |
| | | file path=usr/lib/python3.4/test/test_unittest.py |
| | | file path=usr/lib/python3.4/test/test_univnewlines.py |
| | | file path=usr/lib/python3.4/test/test_unpack.py |
| | | file path=usr/lib/python3.4/test/test_unpack_ex.py |
| | | file path=usr/lib/python3.4/test/test_urllib.py |
| | | file path=usr/lib/python3.4/test/test_urllib2.py |
| | | file path=usr/lib/python3.4/test/test_urllib2_localnet.py |
| | | file path=usr/lib/python3.4/test/test_urllib2net.py |
| | | file path=usr/lib/python3.4/test/test_urllib_response.py |
| | | file path=usr/lib/python3.4/test/test_urllibnet.py |
| | | file path=usr/lib/python3.4/test/test_urlparse.py |
| | | file path=usr/lib/python3.4/test/test_userdict.py |
| | | file path=usr/lib/python3.4/test/test_userlist.py |
| | | file path=usr/lib/python3.4/test/test_userstring.py |
| | | file path=usr/lib/python3.4/test/test_uu.py |
| | | file path=usr/lib/python3.4/test/test_uuid.py |
| | | file path=usr/lib/python3.4/test/test_venv.py |
| | | file path=usr/lib/python3.4/test/test_wait3.py |
| | | file path=usr/lib/python3.4/test/test_wait4.py |
| | | file path=usr/lib/python3.4/test/test_warnings.py |
| | | file path=usr/lib/python3.4/test/test_wave.py |
| | | file path=usr/lib/python3.4/test/test_weakref.py |
| | | file path=usr/lib/python3.4/test/test_weakset.py |
| | | file path=usr/lib/python3.4/test/test_webbrowser.py |
| | | file path=usr/lib/python3.4/test/test_winreg.py |
| | | file path=usr/lib/python3.4/test/test_winsound.py |
| | | file path=usr/lib/python3.4/test/test_with.py |
| | | file path=usr/lib/python3.4/test/test_wsgiref.py |
| | | file path=usr/lib/python3.4/test/test_xdrlib.py |
| | | file path=usr/lib/python3.4/test/test_xml_dom_minicompat.py |
| | | file path=usr/lib/python3.4/test/test_xml_etree.py |
| | | file path=usr/lib/python3.4/test/test_xml_etree_c.py |
| | | file path=usr/lib/python3.4/test/test_xmlrpc.py |
| | | file path=usr/lib/python3.4/test/test_xmlrpc_net.py |
| | | file path=usr/lib/python3.4/test/test_zipfile.py |
| | | file path=usr/lib/python3.4/test/test_zipfile64.py |
| | | file path=usr/lib/python3.4/test/test_zipimport.py |
| | | file path=usr/lib/python3.4/test/test_zipimport_support.py |
| | | file path=usr/lib/python3.4/test/test_zlib.py |
| | | file path=usr/lib/python3.4/test/testcodec.py |
| | | file path=usr/lib/python3.4/test/testtar.tar |
| | | file path=usr/lib/python3.4/test/tf_inherit_check.py |
| | | file path=usr/lib/python3.4/test/threaded_import_hangers.py |
| | | file path=usr/lib/python3.4/test/time_hashlib.py |
| | | file path=usr/lib/python3.4/test/tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt |
| | | file path=usr/lib/python3.4/test/tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt |
| | | file path=usr/lib/python3.4/test/tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt |
| | | file path=usr/lib/python3.4/test/tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt |
| | | file path=usr/lib/python3.4/test/tokenize_tests.txt |
| | | file path=usr/lib/python3.4/test/tracedmodules/__init__.py |
| | | file path=usr/lib/python3.4/test/tracedmodules/testmod.py |
| | | file path=usr/lib/python3.4/test/ucredtest.py |
| | | file path=usr/lib/python3.4/test/warning_tests.py |
| | | file path=usr/lib/python3.4/test/win_console_handler.py |
| | | file path=usr/lib/python3.4/test/xmltestdata/simple-ns.xml |
| | | file path=usr/lib/python3.4/test/xmltestdata/simple.xml |
| | | file path=usr/lib/python3.4/test/xmltestdata/test.xml |
| | | file path=usr/lib/python3.4/test/xmltestdata/test.xml.out |
| | | file path=usr/lib/python3.4/test/xmltests.py |
| | | file path=usr/lib/python3.4/test/zip_cp437_header.zip |
| | | file path=usr/lib/python3.4/test/zipdir.zip |
| | | file path=usr/lib/python3.4/textwrap.py |
| | | file path=usr/lib/python3.4/this.py |
| | | file path=usr/lib/python3.4/threading.py |
| | | file path=usr/lib/python3.4/timeit.py |
| | | file path=usr/lib/python3.4/tkinter/test/README |
| | | file path=usr/lib/python3.4/tkinter/test/__init__.py |
| | | file path=usr/lib/python3.4/tkinter/test/runtktests.py |
| | | file path=usr/lib/python3.4/tkinter/test/support.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_tkinter/__init__.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_tkinter/test_font.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_tkinter/test_loadtk.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_tkinter/test_misc.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_tkinter/test_text.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_tkinter/test_variables.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_tkinter/test_widgets.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_ttk/__init__.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_ttk/test_extensions.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_ttk/test_functions.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_ttk/test_style.py |
| | | file path=usr/lib/python3.4/tkinter/test/test_ttk/test_widgets.py |
| | | file path=usr/lib/python3.4/tkinter/test/widget_tests.py |
| | | file path=usr/lib/python3.4/token.py |
| | | file path=usr/lib/python3.4/tokenize.py |
| | | file path=usr/lib/python3.4/trace.py pkg.depend.bypass-generate=.* |
| | | file path=usr/lib/python3.4/traceback.py |
| | | file path=usr/lib/python3.4/tracemalloc.py |
| | | file path=usr/lib/python3.4/tty.py |
| | | file path=usr/lib/python3.4/turtle.py |
| | | file path=usr/lib/python3.4/turtledemo/__init__.py |
| | | file path=usr/lib/python3.4/turtledemo/__main__.py |
| | | file path=usr/lib/python3.4/turtledemo/about_turtle.txt |
| | | file path=usr/lib/python3.4/turtledemo/about_turtledemo.txt |
| | | file path=usr/lib/python3.4/turtledemo/bytedesign.py |
| | | file path=usr/lib/python3.4/turtledemo/chaos.py |
| | | file path=usr/lib/python3.4/turtledemo/clock.py |
| | | file path=usr/lib/python3.4/turtledemo/colormixer.py |
| | | file path=usr/lib/python3.4/turtledemo/demohelp.txt |
| | | file path=usr/lib/python3.4/turtledemo/forest.py |
| | | file path=usr/lib/python3.4/turtledemo/fractalcurves.py |
| | | file path=usr/lib/python3.4/turtledemo/lindenmayer.py |
| | | file path=usr/lib/python3.4/turtledemo/minimal_hanoi.py |
| | | file path=usr/lib/python3.4/turtledemo/nim.py |
| | | file path=usr/lib/python3.4/turtledemo/paint.py |
| | | file path=usr/lib/python3.4/turtledemo/peace.py |
| | | file path=usr/lib/python3.4/turtledemo/penrose.py |
| | | file path=usr/lib/python3.4/turtledemo/planet_and_moon.py |
| | | file path=usr/lib/python3.4/turtledemo/round_dance.py |
| | | file path=usr/lib/python3.4/turtledemo/tree.py |
| | | file path=usr/lib/python3.4/turtledemo/turtle.cfg |
| | | file path=usr/lib/python3.4/turtledemo/two_canvases.py |
| | | file path=usr/lib/python3.4/turtledemo/wikipedia.py |
| | | file path=usr/lib/python3.4/turtledemo/yinyang.py |
| | | file path=usr/lib/python3.4/types.py |
| | | file path=usr/lib/python3.4/unittest/__init__.py |
| | | file path=usr/lib/python3.4/unittest/__main__.py |
| | | file path=usr/lib/python3.4/unittest/case.py |
| | | file path=usr/lib/python3.4/unittest/loader.py |
| | | file path=usr/lib/python3.4/unittest/main.py |
| | | file path=usr/lib/python3.4/unittest/mock.py |
| | | file path=usr/lib/python3.4/unittest/result.py |
| | | file path=usr/lib/python3.4/unittest/runner.py |
| | | file path=usr/lib/python3.4/unittest/signals.py |
| | | file path=usr/lib/python3.4/unittest/suite.py |
| | | file path=usr/lib/python3.4/unittest/test/__init__.py |
| | | file path=usr/lib/python3.4/unittest/test/__main__.py |
| | | file path=usr/lib/python3.4/unittest/test/_test_warnings.py |
| | | file path=usr/lib/python3.4/unittest/test/dummy.py |
| | | file path=usr/lib/python3.4/unittest/test/support.py |
| | | file path=usr/lib/python3.4/unittest/test/test_assertions.py |
| | | file path=usr/lib/python3.4/unittest/test/test_break.py |
| | | file path=usr/lib/python3.4/unittest/test/test_case.py |
| | | file path=usr/lib/python3.4/unittest/test/test_discovery.py |
| | | file path=usr/lib/python3.4/unittest/test/test_functiontestcase.py |
| | | file path=usr/lib/python3.4/unittest/test/test_loader.py |
| | | file path=usr/lib/python3.4/unittest/test/test_program.py |
| | | file path=usr/lib/python3.4/unittest/test/test_result.py |
| | | file path=usr/lib/python3.4/unittest/test/test_runner.py |
| | | file path=usr/lib/python3.4/unittest/test/test_setups.py |
| | | file path=usr/lib/python3.4/unittest/test/test_skipping.py |
| | | file path=usr/lib/python3.4/unittest/test/test_suite.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/__init__.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/__main__.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/support.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/testcallable.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/testhelpers.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/testmagicmethods.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/testmock.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/testpatch.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/testsentinel.py |
| | | file path=usr/lib/python3.4/unittest/test/testmock/testwith.py |
| | | file path=usr/lib/python3.4/unittest/util.py |
| | | file path=usr/lib/python3.4/urllib/__init__.py |
| | | file path=usr/lib/python3.4/urllib/error.py |
| | | file path=usr/lib/python3.4/urllib/parse.py |
| | | file path=usr/lib/python3.4/urllib/request.py |
| | | file path=usr/lib/python3.4/urllib/response.py |
| | | file path=usr/lib/python3.4/urllib/robotparser.py |
| | | file path=usr/lib/python3.4/uu.py |
| | | file path=usr/lib/python3.4/uuid.py |
| | | file path=usr/lib/python3.4/venv/__init__.py |
| | | file path=usr/lib/python3.4/venv/__main__.py |
| | | file path=usr/lib/python3.4/venv/scripts/posix/activate |
| | | file path=usr/lib/python3.4/warnings.py |
| | | file path=usr/lib/python3.4/wave.py |
| | | file path=usr/lib/python3.4/weakref.py |
| | | file path=usr/lib/python3.4/webbrowser.py |
| | | file path=usr/lib/python3.4/wsgiref/__init__.py |
| | | file path=usr/lib/python3.4/wsgiref/handlers.py |
| | | file path=usr/lib/python3.4/wsgiref/headers.py |
| | | file path=usr/lib/python3.4/wsgiref/simple_server.py |
| | | file path=usr/lib/python3.4/wsgiref/util.py |
| | | file path=usr/lib/python3.4/wsgiref/validate.py |
| | | file path=usr/lib/python3.4/xdrlib.py |
| | | file path=usr/lib/python3.4/xml/__init__.py |
| | | file path=usr/lib/python3.4/xml/dom/NodeFilter.py |
| | | file path=usr/lib/python3.4/xml/dom/__init__.py |
| | | file path=usr/lib/python3.4/xml/dom/domreg.py |
| | | file path=usr/lib/python3.4/xml/dom/expatbuilder.py |
| | | file path=usr/lib/python3.4/xml/dom/minicompat.py |
| | | file path=usr/lib/python3.4/xml/dom/minidom.py |
| | | file path=usr/lib/python3.4/xml/dom/pulldom.py |
| | | file path=usr/lib/python3.4/xml/dom/xmlbuilder.py |
| | | file path=usr/lib/python3.4/xml/etree/ElementInclude.py |
| | | file path=usr/lib/python3.4/xml/etree/ElementPath.py |
| | | file path=usr/lib/python3.4/xml/etree/ElementTree.py |
| | | file path=usr/lib/python3.4/xml/etree/__init__.py |
| | | file path=usr/lib/python3.4/xml/etree/cElementTree.py |
| | | file path=usr/lib/python3.4/xml/parsers/__init__.py |
| | | file path=usr/lib/python3.4/xml/parsers/expat.py |
| | | file path=usr/lib/python3.4/xml/sax/__init__.py |
| | | file path=usr/lib/python3.4/xml/sax/_exceptions.py |
| | | file path=usr/lib/python3.4/xml/sax/expatreader.py |
| | | file path=usr/lib/python3.4/xml/sax/handler.py |
| | | file path=usr/lib/python3.4/xml/sax/saxutils.py |
| | | file path=usr/lib/python3.4/xml/sax/xmlreader.py |
| | | file path=usr/lib/python3.4/xmlrpc/__init__.py |
| | | file path=usr/lib/python3.4/xmlrpc/client.py |
| | | file path=usr/lib/python3.4/xmlrpc/server.py |
| | | file path=usr/lib/python3.4/zipfile.py |
| | | link path=usr/share/man/man1/python3.1 target=python3.4.1 mediator=python \ |
| | | mediator-version=3.4 |
| | | file path=usr/share/man/man1/python3.4.1 |
| | | # |
| | | license python34.license license=PSFv2 |
New file |
| | |
| | | Terms and conditions for accessing or otherwise using Python |
| | | ============================================================ |
| | | |
| | | |
| | | .. centered:: PSF LICENSE AGREEMENT FOR PYTHON |release| |
| | | |
| | | #. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and |
| | | the Individual or Organization ("Licensee") accessing and otherwise using Python |
| | | |release| software in source or binary form and its associated documentation. |
| | | |
| | | #. Subject to the terms and conditions of this License Agreement, PSF hereby |
| | | grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, |
| | | analyze, test, perform and/or display publicly, prepare derivative works, |
| | | distribute, and otherwise use Python |release| alone or in any derivative |
| | | version, provided, however, that PSF's License Agreement and PSF's notice of |
| | | copyright, i.e., "Copyright © 2001-2010 Python Software Foundation; All Rights |
| | | Reserved" are retained in Python |release| alone or in any derivative version |
| | | prepared by Licensee. |
| | | |
| | | #. In the event Licensee prepares a derivative work that is based on or |
| | | incorporates Python |release| or any part thereof, and wants to make the |
| | | derivative work available to others as provided herein, then Licensee hereby |
| | | agrees to include in any such work a brief summary of the changes made to Python |
| | | |release|. |
| | | |
| | | #. PSF is making Python |release| available to Licensee on an "AS IS" basis. |
| | | PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF |
| | | EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR |
| | | WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE |
| | | USE OF PYTHON |release| WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. |
| | | |
| | | #. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON |release| |
| | | FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF |
| | | MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON |release|, OR ANY DERIVATIVE |
| | | THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. |
| | | |
| | | #. This License Agreement will automatically terminate upon a material breach of |
| | | its terms and conditions. |
| | | |
| | | #. Nothing in this License Agreement shall be deemed to create any relationship |
| | | of agency, partnership, or joint venture between PSF and Licensee. This License |
| | | Agreement does not grant permission to use PSF trademarks or trade name in a |
| | | trademark sense to endorse or promote products or services of Licensee, or any |
| | | third party. |
| | | |
| | | #. By copying, installing or otherwise using Python |release|, Licensee agrees |
| | | to be bound by the terms and conditions of this License Agreement. |
| | | |
| | | |
| | | Licenses and Acknowledgements for Incorporated Software |
| | | ======================================================= |
| | | |
| | | This section is an incomplete, but growing list of licenses and acknowledgements |
| | | for third-party software incorporated in the Python distribution. |
| | | |
| | | |
| | | Mersenne Twister |
| | | ---------------- |
| | | |
| | | The :mod:`_random` module includes code based on a download from |
| | | http://www.math.keio.ac.jp/ matumoto/MT2002/emt19937ar.html. The following are |
| | | the verbatim comments from the original code:: |
| | | |
| | | A C-program for MT19937, with initialization improved 2002/1/26. |
| | | Coded by Takuji Nishimura and Makoto Matsumoto. |
| | | |
| | | Before using, initialize the state by using init_genrand(seed) |
| | | or init_by_array(init_key, key_length). |
| | | |
| | | Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura, |
| | | All rights reserved. |
| | | |
| | | Redistribution and use in source and binary forms, with or without |
| | | modification, are permitted provided that the following conditions |
| | | are met: |
| | | |
| | | 1. Redistributions of source code must retain the above copyright |
| | | notice, this list of conditions and the following disclaimer. |
| | | |
| | | 2. 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. |
| | | |
| | | 3. The names of its contributors may not 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. |
| | | |
| | | |
| | | Any feedback is very welcome. |
| | | http://www.math.keio.ac.jp/matumoto/emt.html |
| | | email: matumoto@math.keio.ac.jp |
| | | |
| | | |
| | | Sockets |
| | | ------- |
| | | |
| | | The :mod:`socket` module uses the functions, :func:`getaddrinfo`, and |
| | | :func:`getnameinfo`, which are coded in separate source files from the WIDE |
| | | Project, http://www.wide.ad.jp/. :: |
| | | |
| | | Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. |
| | | All rights reserved. |
| | | |
| | | Redistribution and use in source and binary forms, with or without |
| | | modification, are permitted provided that the following conditions |
| | | are met: |
| | | 1. Redistributions of source code must retain the above copyright |
| | | notice, this list of conditions and the following disclaimer. |
| | | 2. 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. |
| | | 3. Neither the name of the project 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 PROJECT AND CONTRIBUTORS ``AS IS'' AND |
| | | GAI_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 PROJECT OR CONTRIBUTORS BE LIABLE |
| | | FOR GAI_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 GAI_ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| | | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN GAI_ANY WAY |
| | | OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| | | SUCH DAMAGE. |
| | | |
| | | |
| | | Floating point exception control |
| | | -------------------------------- |
| | | |
| | | The source for the :mod:`fpectl` module includes the following notice:: |
| | | |
| | | --------------------------------------------------------------------- |
| | | / Copyright (c) 1996. \ |
| | | | The Regents of the University of California. | |
| | | | All rights reserved. | |
| | | | | |
| | | | Permission to use, copy, modify, and distribute this software for | |
| | | | any purpose without fee is hereby granted, provided that this en- | |
| | | | tire notice is included in all copies of any software which is or | |
| | | | includes a copy or modification of this software and in all | |
| | | | copies of the supporting documentation for such software. | |
| | | | | |
| | | | This work was produced at the University of California, Lawrence | |
| | | | Livermore National Laboratory under contract no. W-7405-ENG-48 | |
| | | | between the U.S. Department of Energy and The Regents of the | |
| | | | University of California for the operation of UC LLNL. | |
| | | | | |
| | | | DISCLAIMER | |
| | | | | |
| | | | This software was prepared as an account of work sponsored by an | |
| | | | agency of the United States Government. Neither the United States | |
| | | | Government nor the University of California nor any of their em- | |
| | | | ployees, makes any warranty, express or implied, or assumes any | |
| | | | liability or responsibility for the accuracy, completeness, or | |
| | | | usefulness of any information, apparatus, product, or process | |
| | | | disclosed, or represents that its use would not infringe | |
| | | | privately-owned rights. Reference herein to any specific commer- | |
| | | | cial products, process, or service by trade name, trademark, | |
| | | | manufacturer, or otherwise, does not necessarily constitute or | |
| | | | imply its endorsement, recommendation, or favoring by the United | |
| | | | States Government or the University of California. The views and | |
| | | | opinions of authors expressed herein do not necessarily state or | |
| | | | reflect those of the United States Government or the University | |
| | | | of California, and shall not be used for advertising or product | |
| | | \ endorsement purposes. / |
| | | --------------------------------------------------------------------- |
| | | |
| | | |
| | | MD5 message digest algorithm |
| | | ---------------------------- |
| | | |
| | | The source code for the :mod:`md5` module contains the following notice:: |
| | | |
| | | Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. |
| | | |
| | | This software is provided 'as-is', without any express or implied |
| | | warranty. In no event will the authors be held liable for any damages |
| | | arising from the use of this software. |
| | | |
| | | Permission is granted to anyone to use this software for any purpose, |
| | | including commercial applications, and to alter it and redistribute it |
| | | freely, subject to the following restrictions: |
| | | |
| | | 1. The origin of this software must not be misrepresented; you must not |
| | | claim that you wrote the original software. If you use this software |
| | | in a product, an acknowledgment in the product documentation would be |
| | | appreciated but is not required. |
| | | 2. Altered source versions must be plainly marked as such, and must not be |
| | | misrepresented as being the original software. |
| | | 3. This notice may not be removed or altered from any source distribution. |
| | | |
| | | L. Peter Deutsch |
| | | ghost@aladdin.com |
| | | |
| | | Independent implementation of MD5 (RFC 1321). |
| | | |
| | | This code implements the MD5 Algorithm defined in RFC 1321, whose |
| | | text is available at |
| | | http://www.ietf.org/rfc/rfc1321.txt |
| | | The code is derived from the text of the RFC, including the test suite |
| | | (section A.5) but excluding the rest of Appendix A. It does not include |
| | | any code or documentation that is identified in the RFC as being |
| | | copyrighted. |
| | | |
| | | The original and principal author of md5.h is L. Peter Deutsch |
| | | <ghost@aladdin.com>. Other authors are noted in the change history |
| | | that follows (in reverse chronological order): |
| | | |
| | | 2002-04-13 lpd Removed support for non-ANSI compilers; removed |
| | | references to Ghostscript; clarified derivation from RFC 1321; |
| | | now handles byte order either statically or dynamically. |
| | | 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. |
| | | 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5); |
| | | added conditionalization for C++ compilation from Martin |
| | | Purschke <purschke@bnl.gov>. |
| | | 1999-05-03 lpd Original version. |
| | | |
| | | |
| | | Asynchronous socket services |
| | | ---------------------------- |
| | | |
| | | The :mod:`asynchat` and :mod:`asyncore` modules contain the following notice:: |
| | | |
| | | Copyright 1996 by Sam Rushing |
| | | |
| | | All Rights Reserved |
| | | |
| | | Permission to use, copy, modify, and distribute this software and |
| | | its documentation for any purpose and without fee is hereby |
| | | granted, provided that the above copyright notice appear in all |
| | | copies and that both that copyright notice and this permission |
| | | notice appear in supporting documentation, and that the name of Sam |
| | | Rushing not be used in advertising or publicity pertaining to |
| | | distribution of the software without specific, written prior |
| | | permission. |
| | | |
| | | SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
| | | INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN |
| | | NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
| | | CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS |
| | | OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, |
| | | NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| | | CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| | | |
| | | |
| | | Cookie management |
| | | ----------------- |
| | | |
| | | The :mod:`Cookie` module contains the following notice:: |
| | | |
| | | Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu> |
| | | |
| | | All Rights Reserved |
| | | |
| | | Permission to use, copy, modify, and distribute this software |
| | | and its documentation for any purpose and without fee is hereby |
| | | granted, provided that the above copyright notice appear in all |
| | | copies and that both that copyright notice and this permission |
| | | notice appear in supporting documentation, and that the name of |
| | | Timothy O'Malley not be used in advertising or publicity |
| | | pertaining to distribution of the software without specific, written |
| | | prior permission. |
| | | |
| | | Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS |
| | | SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
| | | AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR |
| | | ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| | | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
| | | WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS |
| | | ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| | | PERFORMANCE OF THIS SOFTWARE. |
| | | |
| | | |
| | | Execution tracing |
| | | ----------------- |
| | | |
| | | The :mod:`trace` module contains the following notice:: |
| | | |
| | | portions copyright 2001, Autonomous Zones Industries, Inc., all rights... |
| | | err... reserved and offered to the public under the terms of the |
| | | Python 2.2 license. |
| | | Author: Zooko O'Whielacronx |
| | | http://zooko.com/ |
| | | mailto:zooko@zooko.com |
| | | |
| | | Copyright 2000, Mojam Media, Inc., all rights reserved. |
| | | Author: Skip Montanaro |
| | | |
| | | Copyright 1999, Bioreason, Inc., all rights reserved. |
| | | Author: Andrew Dalke |
| | | |
| | | Copyright 1995-1997, Automatrix, Inc., all rights reserved. |
| | | Author: Skip Montanaro |
| | | |
| | | Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved. |
| | | |
| | | |
| | | Permission to use, copy, modify, and distribute this Python software and |
| | | its associated documentation for any purpose without fee is hereby |
| | | granted, provided that the above copyright notice appears in all copies, |
| | | and that both that copyright notice and this permission notice appear in |
| | | supporting documentation, and that the name of neither Automatrix, |
| | | Bioreason or Mojam Media be used in advertising or publicity pertaining to |
| | | distribution of the software without specific, written prior permission. |
| | | |
| | | |
| | | UUencode and UUdecode functions |
| | | ------------------------------- |
| | | |
| | | The :mod:`uu` module contains the following notice:: |
| | | |
| | | Copyright 1994 by Lance Ellinghouse |
| | | Cathedral City, California Republic, United States of America. |
| | | All Rights Reserved |
| | | Permission to use, copy, modify, and distribute this software and its |
| | | documentation for any purpose and without fee is hereby granted, |
| | | provided that the above copyright notice appear in all copies and that |
| | | both that copyright notice and this permission notice appear in |
| | | supporting documentation, and that the name of Lance Ellinghouse |
| | | not be used in advertising or publicity pertaining to distribution |
| | | of the software without specific, written prior permission. |
| | | LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO |
| | | THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| | | FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE |
| | | FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| | | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| | | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| | | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| | | |
| | | Modified by Jack Jansen, CWI, July 1995: |
| | | - Use binascii module to do the actual line-by-line conversion |
| | | between ascii and binary. This results in a 1000-fold speedup. The C |
| | | version is still 5 times faster, though. |
| | | - Arguments more compliant with Python standard |
| | | |
| | | |
| | | XML Remote Procedure Calls |
| | | -------------------------- |
| | | |
| | | The :mod:`xmlrpclib` module contains the following notice:: |
| | | |
| | | The XML-RPC client interface is |
| | | |
| | | Copyright (c) 1999-2002 by Secret Labs AB |
| | | Copyright (c) 1999-2002 by Fredrik Lundh |
| | | |
| | | By obtaining, using, and/or copying this software and/or its |
| | | associated documentation, you agree that you have read, understood, |
| | | and will comply with the following terms and conditions: |
| | | |
| | | Permission to use, copy, modify, and distribute this software and |
| | | its associated documentation for any purpose and without fee is |
| | | hereby granted, provided that the above copyright notice appears in |
| | | all copies, and that both that copyright notice and this permission |
| | | notice appear in supporting documentation, and that the name of |
| | | Secret Labs AB or the author not be used in advertising or publicity |
| | | pertaining to distribution of the software without specific, written |
| | | prior permission. |
| | | |
| | | SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD |
| | | TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- |
| | | ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR |
| | | BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY |
| | | DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
| | | WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS |
| | | ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE |
| | | OF THIS SOFTWARE. |
| | | |
| | | |
| | | test_epoll |
| | | ---------- |
| | | |
| | | The :mod:`test_epoll` contains the following notice:: |
| | | |
| | | Copyright (c) 2001-2006 Twisted Matrix Laboratories. |
| | | |
| | | Permission is hereby granted, free of charge, to any person obtaining |
| | | a copy of this software and associated documentation files (the |
| | | "Software"), to deal in the Software without restriction, including |
| | | without limitation the rights to use, copy, modify, merge, publish, |
| | | distribute, sublicense, and/or sell copies of the Software, and to |
| | | permit persons to whom the Software is furnished to do so, subject to |
| | | the following conditions: |
| | | |
| | | The above copyright notice and this permission notice shall be |
| | | included in all copies or substantial portions of the Software. |
| | | |
| | | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| | | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| | | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| | | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
| | | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
| | | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| | | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| | | |
| | | Select kqueue |
| | | ------------- |
| | | |
| | | The :mod:`select` and contains the following notice for the kqueue interface:: |
| | | |
| | | Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes |
| | | All rights reserved. |
| | | |
| | | Redistribution and use in source and binary forms, with or without |
| | | modification, are permitted provided that the following conditions |
| | | are met: |
| | | 1. Redistributions of source code must retain the above copyright |
| | | notice, this list of conditions and the following disclaimer. |
| | | 2. 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. |
| | | |
| | | THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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. |
New file |
| | |
| | | compress/bzip2 |
| | | compress/xz |
| | | database/sqlite-3 |
| | | library/database/gdbm |
| | | library/expat |
| | | library/libffi |
| | | library/ncurses |
| | | library/readline |
| | | library/security/openssl |
| | | library/zlib |
| | | runtime/tcl-8 |
| | | runtime/tk-8 |
| | | system/library |
| | | system/library/math |
| | | system/linker |
| | | x11/library/libx11 |
New file |
| | |
| | | # |
| | | # CDDL HEADER START |
| | | # |
| | | # The contents of this file are subject to the terms of the |
| | | # Common Development and Distribution License (the "License"). |
| | | # You may not use this file except in compliance with the License. |
| | | # |
| | | # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| | | # or http://www.opensolaris.org/os/licensing. |
| | | # See the License for the specific language governing permissions |
| | | # and limitations under the License. |
| | | # |
| | | # When distributing Covered Code, include this CDDL HEADER in each |
| | | # file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| | | # If applicable, add the following below this CDDL HEADER, with the |
| | | # fields enclosed by brackets "[]" replaced with your own identifying |
| | | # information: Portions Copyright [yyyy] [name of copyright owner] |
| | | # |
| | | # CDDL HEADER END |
| | | # |
| | | # Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. |
| | | # |
| | | |
| | | # bootstrap: pkgdepend doesn't like python 3.4 yet; |
| | | # remove this block once it is installed on build machine |
| | | <transform file path=.+\.py$ -> \ |
| | | default pkg.depend.bypass-generate .* > |
| | | <transform file path=.+\.pyc$ -> \ |
| | | default pkg.depend.bypass-generate .* > |
| | | <transform file path=usr/bin.*$ -> \ |
| | | default pkg.depend.bypass-generate .* > |
| | | # |
| | | set name=pkg.fmri \ |
| | | value=pkg:/library/python/tkinter-34@$(IPS_COMPONENT_VERSION),$(BUILD_VERSION) |
| | | set name=pkg.summary value="Python 3.4 bindings to tcl/tk" |
| | | set name=com.oracle.info.description value="Python 3.4 bindings for Tcl/Tk" |
| | | set name=com.oracle.info.tpno value=9104 |
| | | set name=info.classification \ |
| | | value=org.opensolaris.category.2008:Development/Python |
| | | set name=info.source-url value=$(COMPONENT_ARCHIVE_URL) |
| | | set name=info.upstream-url value=$(COMPONENT_PROJECT_URL) |
| | | set name=org.opensolaris.arc-caseid value=PSARC/2005/555 value=PSARC/2008/514 \ |
| | | value=PSARC/2009/529 value=PSARC/2013/235 value=PSARC/2014/151 |
| | | set name=org.opensolaris.consolidation value=$(CONSOLIDATION) |
| | | # |
| | | file path=usr/lib/python3.4/lib-dynload/64/_tkinter.so |
| | | file path=usr/lib/python3.4/tkinter/__init__.py |
| | | file path=usr/lib/python3.4/tkinter/__main__.py |
| | | file path=usr/lib/python3.4/tkinter/_fix.py |
| | | file path=usr/lib/python3.4/tkinter/colorchooser.py |
| | | file path=usr/lib/python3.4/tkinter/commondialog.py |
| | | file path=usr/lib/python3.4/tkinter/constants.py |
| | | file path=usr/lib/python3.4/tkinter/dialog.py |
| | | file path=usr/lib/python3.4/tkinter/dnd.py |
| | | file path=usr/lib/python3.4/tkinter/filedialog.py |
| | | file path=usr/lib/python3.4/tkinter/font.py |
| | | file path=usr/lib/python3.4/tkinter/messagebox.py |
| | | file path=usr/lib/python3.4/tkinter/scrolledtext.py |
| | | file path=usr/lib/python3.4/tkinter/simpledialog.py |
| | | file path=usr/lib/python3.4/tkinter/tix.py |
| | | file path=usr/lib/python3.4/tkinter/ttk.py |
| | | # |
| | | license python34.license license=PSFv2 |
| | |
| | | # |
| | | # CDDL HEADER END |
| | | # |
| | | # Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. |
| | | # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved. |
| | | # |
| | | |
| | | # Don't bother specifying each .pyc file. Allow individual actions to |
| | | # override this by setting pkg.tmp.autopyc to false. |
| | | <transform file path=.*\.py$ -> default pkg.tmp.autopyc true> |
| | | <transform file pkg.tmp.autopyc=true -> emit file path=%(path)c> |
| | | <transform file hardlink pkg.tmp.autopyc=true path=usr/lib/python2\.(.*)\.py$ -> default pkg.tmp.pyversion 2.X> |
| | | <transform file hardlink pkg.tmp.autopyc=true path=usr/lib/python3\.(.*)/.*\.py$ -> default pkg.tmp.pyversion 3.%<1>> |
| | | |
| | | <transform file pkg.tmp.pyversion=2\.X -> emit file path=%(path)c> |
| | | <transform hardlink pkg.tmp.pyversion=2\.X -> emit hardlink path=%(path)c target=%(target)c> |
| | | |
| | | <transform file pkg.tmp.pyversion=3\.([0-9])(.*) path=.*/(.*)\.py$ -> emit file path=/usr/lib/python3.%<1>%<2>/__pycache__/%<3>.cpython-3%<1>.pyc> |
| | | <transform hardlink pkg.tmp.pyversion=3\.(.*) -> emit hardlink path=%(path)c target=%(target)c> |
| | | |
| | | <transform file pkg.tmp.autopyc=.* -> delete pkg.tmp.autopyc .*> |
| | | <transform hardlink path=.*\.py$ -> emit hardlink path=%(path)c target=%(target)c> |
| | | <transform pkg.tmp.pyversion=.* -> delete pkg.tmp.pyversion .*> |