sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-08-03 04:22:09 +03:00
Code Activity

Use plain C implementation for misc Python module rather than SWIG.

Browse Source
This commit is contained in:
Jelmer Vernooij
2008-12-20 23:38:30 +01:00
parent 0d585a67ed
commit 13fa639a29
9 changed files with 293 additions and 4238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source4/lib/ldb/pyldb.h
View File

@ -3,8 +3,6 @@
Swig interface to ldb.
Copyright (C) 2005,2006 Tim Potter <tpot@samba.org>
Copyright (C) 2006 Simo Sorce <idra@samba.org>
Copyright (C) 2007-2008 Jelmer Vernooij <jelmer@samba.org>
** NOTE! The following LGPL license applies to the ldb
@ -32,6 +30,7 @@
#include <pytalloc.h>
#include <ldb.h>
#include <ldb_private.h>
#include <ldb_errors.h>
typedef py_talloc_Object PyLdbObject;
PyAPI_DATA(PyTypeObject) PyLdb;
@ -70,6 +69,7 @@ PyAPI_DATA(PyTypeObject) PyLdbTree;
PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *);
#define PyLdbTree_AsTree(pyobj) py_talloc_get_type(pyobj, struct ldb_parse_tree)
void PyErr_SetLdbError(int ret, struct ldb_context *ldb_ctx);
#define PyErr_LDB_ERROR_IS_ERR_RAISE(ret,ldb) \
if (ret != LDB_SUCCESS) { \
PyErr_SetLdbError(ret, ldb); \

3
source4/param/param.i
View File

@ -354,3 +354,6 @@ struct loadparm_context *py_default_loadparm_context(TALLOC_CTX *mem_ctx)
}
%}
char *private_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
const char *name);

1
source4/param/param.py
View File

@ -262,5 +262,6 @@ param_section.next_parameter = new_instancemethod(_param.param_section_next_para
param_section_swigregister = _param.param_section_swigregister
param_section_swigregister(param_section)
private_path = _param.private_path

45
source4/param/param_wrap.c
View File

@ -4153,6 +4153,50 @@ SWIGINTERN PyObject *param_section_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb
return SWIG_Python_InitShadowInstance(args);
}
SWIGINTERN PyObject *_wrap_private_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
struct loadparm_context *arg2 = (struct loadparm_context *) 0 ;
char *arg3 = (char *) 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "lp_ctx",(char *) "name", NULL
};
char *result = 0 ;
arg2 = loadparm_init(NULL);
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:private_path",kwnames,&obj0,&obj1)) SWIG_fail;
if (obj0) {
res2 = SWIG_ConvertPtr(obj0, &argp2,SWIGTYPE_p_loadparm_context, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "private_path" "', argument " "2"" of type '" "struct loadparm_context *""'");
}
arg2 = (struct loadparm_context *)(argp2);
}
if (obj1) {
res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "private_path" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
}
result = (char *)private_path(arg1,arg2,(char const *)arg3);
resultobj = SWIG_FromCharPtr((const char *)result);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ (char *)"new_LoadParm", (PyCFunction)_wrap_new_LoadParm, METH_NOARGS, NULL},
{ (char *)"LoadParm_default_service", (PyCFunction) _wrap_LoadParm_default_service, METH_VARARGS | METH_KEYWORDS, NULL},
@ -4230,6 +4274,7 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"delete_param_section", (PyCFunction)_wrap_delete_param_section, METH_O, NULL},
{ (char *)"param_section_swigregister", param_section_swigregister, METH_VARARGS, NULL},
{ (char *)"param_section_swiginit", param_section_swiginit, METH_VARARGS, NULL},
{ (char *)"private_path", (PyCFunction) _wrap_private_path, METH_VARARGS | METH_KEYWORDS, NULL},
{ NULL, NULL, 0, NULL }
};

10
source4/scripting/python/config.mk
View File

@ -16,19 +16,17 @@ PRIVATE_DEPENDENCIES = LIBNDR
python_uuid_OBJ_FILES = $(pyscriptsrcdir)/uuidmodule.o
[PYTHON::python_misc]
LIBRARY_REALNAME = samba/_misc.$(SHLIBEXT)
PRIVATE_DEPENDENCIES = LIBNDR LIBLDB SAMDB CREDENTIALS
LIBRARY_REALNAME = samba/misc.$(SHLIBEXT)
PRIVATE_DEPENDENCIES = LIBNDR LIBLDB SAMDB CREDENTIALS swig_ldb
python_misc_OBJ_FILES = $(pyscriptsrcdir)/misc_wrap.o
python_misc_OBJ_FILES = $(pyscriptsrcdir)/pymisc.o
$(python_misc_OBJ_FILES): CFLAGS+=$(CFLAG_NO_UNUSED_MACROS) $(CFLAG_NO_CAST_QUAL)
$(python_misc_OBJ_FILES): CFLAGS+=$(CFLAG_NO_CAST_QUAL) -I$(ldbsrcdir)
_PY_FILES = $(shell find $(pyscriptsrcdir)/samba ../lib/subunit/python -name "*.py")
$(eval $(foreach pyfile, $(_PY_FILES),$(call python_py_module_template,$(patsubst $(pyscriptsrcdir)/%,%,$(pyfile)),$(pyfile))))
$(eval $(call python_py_module_template,samba/misc.py,$(pyscriptsrcdir)/misc.py))
EPYDOC_OPTIONS = --no-private --url http://www.samba.org/ --no-sourcecode
epydoc:: pythonmods

121
source4/scripting/python/misc.i
View File

@ -1,121 +0,0 @@
/*
Unix SMB/CIFS implementation.
Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
%module(docstring="Python bindings for miscellaneous Samba functions.",package="samba.misc") misc
%{
#include "includes.h"
#include "ldb.h"
#include "param/param.h"
#include "auth/credentials/credentials.h"
#include "dsdb/samdb/samdb.h"
#include "lib/ldb-samba/ldif_handlers.h"
#include "librpc/ndr/libndr.h"
#include "version.h"
%}
%import "stdint.i"
%include "exception.i"
%import "../../../lib/talloc/talloc.i"
%import "../../lib/ldb/ldb.i"
%import "../../auth/credentials/credentials.i"
%import "../../param/param.i"
%import "../../libcli/security/security.i"
%include "../../libcli/util/errors.i"
%feature("docstring") generate_random_str "S.random_password(len) -> string\n" \
"Generate random password with specified length.";
%rename(random_password) generate_random_str;
char *generate_random_str(TALLOC_CTX *mem_ctx, size_t len);
%feature("docstring") ldb_set_credentials "S.set_credentials(credentials)\n"
"Set credentials to use when connecting.";
%feature("docstring") ldb_set_session_info "S.set_session_info(session_info)\n"
"Set session info to use when connecting.";
%feature("docstring") ldb_set_loadparm "S.set_loadparm(session_info)\n"
"Set loadparm context to use when connecting.";
%inline %{
void ldb_set_credentials(struct ldb_context *ldb, struct cli_credentials *creds)
{
ldb_set_opaque(ldb, "credentials", creds);
}
void ldb_set_session_info(struct ldb_context *ldb, struct auth_session_info *session_info)
{
ldb_set_opaque(ldb, "sessionInfo", session_info);
}
void ldb_set_loadparm(struct ldb_context *ldb, struct loadparm_context *lp_ctx)
{
ldb_set_opaque(ldb, "loadparm", lp_ctx);
}
%}
%feature("docstring") samdb_set_domain_sid "S.set_domain_sid(sid)\n"
"Set SID of domain to use.";
bool samdb_set_domain_sid(struct ldb_context *ldb,
const struct dom_sid *dom_sid_in);
WERROR dsdb_attach_schema_from_ldif_file(struct ldb_context *ldb, const char *pf, const char *df);
%feature("docstring") version "version()\n"
"Obtain the Samba version.";
%inline {
const char *version(void)
{
return SAMBA_VERSION_STRING;
}
}
int dsdb_set_global_schema(struct ldb_context *ldb);
%feature("docstring") ldb_register_samba_handlers "register_samba_handlers()\n"
"Register Samba-specific LDB modules and schemas.";
int ldb_register_samba_handlers(struct ldb_context *ldb);
%inline %{
bool dsdb_set_ntds_invocation_id(struct ldb_context *ldb, const char *guid)
{
struct GUID invocation_id_in;
if (NT_STATUS_IS_ERR(GUID_from_string(guid, &invocation_id_in))) {
return false;
}
return samdb_set_ntds_invocation_id(ldb, &invocation_id_in);
}
%}
char *private_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
const char *name);
typedef unsigned long time_t;
/*
convert from unix time to NT time
*/
%inline %{
uint64_t unix2nttime(time_t t)
{
NTTIME nt;
unix_to_nt_time(&nt, t);
return (uint64_t)nt;
}
%}

123
source4/scripting/python/misc.py
View File

@ -1,123 +0,0 @@
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
"""
Python bindings for miscellaneous Samba functions.
"""
import _misc
import new
new_instancemethod = new.instancemethod
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
if (name == "thisown"): return self.this.own(value)
if (name == "this"):
if type(value).__name__ == 'PySwigObject':
self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name,None)
if method: return method(self,value)
if (not static) or hasattr(self,name):
self.__dict__[name] = value
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self,class_type,name,value):
return _swig_setattr_nondynamic(self,class_type,name,value,0)
def _swig_getattr(self,class_type,name):
if (name == "thisown"): return self.this.own()
method = class_type.__swig_getmethods__.get(name,None)
if method: return method(self)
raise AttributeError,name
def _swig_repr(self):
try: strthis = "proxy of " + self.this.__repr__()
except: strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
import types
try:
_object = types.ObjectType
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0
del types
def _swig_setattr_nondynamic_method(set):
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
import ldb
import credentials
import param
import security
def random_password(*args, **kwargs):
"""
S.random_password(len) -> string
Generate random password with specified length.
"""
return _misc.random_password(*args, **kwargs)
def ldb_set_credentials(*args, **kwargs):
"""
S.set_credentials(credentials)
Set credentials to use when connecting.
"""
return _misc.ldb_set_credentials(*args, **kwargs)
def ldb_set_session_info(*args, **kwargs):
"""
S.set_session_info(session_info)
Set session info to use when connecting.
"""
return _misc.ldb_set_session_info(*args, **kwargs)
def ldb_set_loadparm(*args, **kwargs):
"""
S.set_loadparm(session_info)
Set loadparm context to use when connecting.
"""
return _misc.ldb_set_loadparm(*args, **kwargs)
def samdb_set_domain_sid(*args, **kwargs):
"""
S.set_domain_sid(sid)
Set SID of domain to use.
"""
return _misc.samdb_set_domain_sid(*args, **kwargs)
dsdb_attach_schema_from_ldif_file = _misc.dsdb_attach_schema_from_ldif_file
def version(*args):
"""
version()
Obtain the Samba version.
"""
return _misc.version(*args)
dsdb_set_global_schema = _misc.dsdb_set_global_schema
def ldb_register_samba_handlers(*args, **kwargs):
"""
register_samba_handlers()
Register Samba-specific LDB modules and schemas.
"""
return _misc.ldb_register_samba_handlers(*args, **kwargs)
dsdb_set_ntds_invocation_id = _misc.dsdb_set_ntds_invocation_id
private_path = _misc.private_path
unix2nttime = _misc.unix2nttime

3986
source4/scripting/python/misc_wrap.c
View File

File diff suppressed because it is too large Load Diff

238
source4/scripting/python/pymisc.c Normal file
View File

@ -0,0 +1,238 @@
/*
Unix SMB/CIFS implementation.
Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "ldb.h"
#include "param/param.h"
#include "auth/credentials/credentials.h"
#include "dsdb/samdb/samdb.h"
#include "lib/ldb-samba/ldif_handlers.h"
#include "librpc/ndr/libndr.h"
#include "version.h"
#include <Python.h>
#include "pyldb.h"
#include "libcli/util/pyerrors.h"
static PyObject *py_generate_random_str(PyObject *self, PyObject *args)
{
int len;
PyObject *ret;
char *retstr;
if (!PyArg_ParseTuple(args, "i", &len))
return NULL;
retstr = generate_random_str(NULL, len);
ret = PyString_FromString(retstr);
talloc_free(retstr);
return ret;
}
static PyObject *py_unix2nttime(PyObject *self, PyObject *args)
{
time_t t;
NTTIME nt;
if (!PyArg_ParseTuple(args, "I", &t))
return NULL;
unix_to_nt_time(&nt, t);
return PyInt_FromLong((uint64_t)nt);
}
static PyObject *py_ldb_set_credentials(PyObject *self, PyObject *args)
{
PyObject *py_creds, *py_ldb;
struct cli_credentials *creds;
struct ldb_context *ldb;
if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_creds))
return NULL;
/* FIXME: Magic py_creds -> creds */
/* FIXME: Magic py_ldb -> ldb */
ldb_set_opaque(ldb, "credentials", creds);
return Py_None;
}
static PyObject *py_ldb_set_loadparm(PyObject *self, PyObject *args)
{
PyObject *py_lp_ctx, *py_ldb;
struct loadparm_context *lp_ctx;
struct ldb_context *ldb;
if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_lp_ctx))
return NULL;
/* FIXME: Magic py_lp_ctx -> lp_ctx */
/* FIXME: Magic py_ldb -> ldb */
ldb_set_opaque(ldb, "loadparm", lp_ctx);
return Py_None;
}
static PyObject *py_ldb_set_session_info(PyObject *self, PyObject *args)
{
PyObject *py_session_info, *py_ldb;
struct auth_session_info *info;
struct ldb_context *ldb;
if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_session_info))
return NULL;
/* FIXME: Magic py_session_info -> info */
/* FIXME: Magic py_ldb -> ldb */
ldb_set_opaque(ldb, "sessionInfo", info);
return Py_None;
}
static PyObject *py_samdb_set_domain_sid(PyLdbObject *self, PyObject *args)
{
PyObject *py_ldb, *py_sid;
struct ldb_context *ldb;
struct dom_sid *sid;
bool ret;
if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_sid))
return NULL;
/* FIXME: Magic py_ldb -> ldb */
/* FIXME: Magic py_sid -> sid */
ret = samdb_set_domain_sid(ldb, sid);
if (!ret) {
PyErr_SetString(PyExc_RuntimeError, "set_domain_sid failed");
return NULL;
}
return Py_None;
}
static PyObject *py_ldb_register_samba_handlers(PyObject *self, PyObject *args)
{
PyObject *py_ldb;
struct ldb_context *ldb;
int ret;
if (!PyArg_ParseTuple(args, "O", &py_ldb))
return NULL;
/* FIXME: Magic py_ldb -> ldb */
ret = ldb_register_samba_handlers(ldb);
PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb);
return Py_None;
}
static PyObject *py_dsdb_set_ntds_invocation_id(PyObject *self, PyObject *args)
{
PyObject *py_ldb, *py_guid;
bool ret;
struct GUID *guid;
struct ldb_context *ldb;
if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_guid))
return NULL;
/* FIXME: Magic py_ldb -> ldb */
/* FIXME: Magic py_guid -> guid */
ret = samdb_set_ntds_invocation_id(ldb, guid);
if (!ret) {
PyErr_SetString(PyExc_RuntimeError, "set_ntds_invocation_id failed");
return NULL;
}
return Py_None;
}
static PyObject *py_dsdb_set_global_schema(PyObject *self, PyObject *args)
{
PyObject *py_ldb;
struct ldb_context *ldb;
int ret;
if (!PyArg_ParseTuple(args, "O", &py_ldb))
return NULL;
/* FIXME: Magic py_ldb -> ldb */
ret = dsdb_set_global_schema(ldb);
PyErr_LDB_ERROR_IS_ERR_RAISE(ret, ldb);
return Py_None;
}
static PyObject *py_dsdb_attach_schema_from_ldif_file(PyObject *self, PyObject *args)
{
WERROR result;
char *pf, *df;
PyObject *py_ldb;
struct ldb_context *ldb;
if (!PyArg_ParseTuple(args, "Oss", &py_ldb, &pf, &df))
return NULL;
/* FIXME: Magic py_ldb -> ldb */
result = dsdb_attach_schema_from_ldif_file(ldb, pf, df);
PyErr_WERROR_IS_ERR_RAISE(result);
return Py_None;
}
static PyMethodDef py_misc_methods[] = {
{ "generate_random_str", (PyCFunction)py_generate_random_str, METH_VARARGS,
"random_password(len) -> string\n"
"Generate random password with specified length." },
{ "unix2nttime", (PyCFunction)py_unix2nttime, METH_VARARGS,
"unix2nttime(timestamp) -> nttime" },
{ "ldb_set_credentials", (PyCFunction)py_ldb_set_credentials, METH_VARARGS,
"ldb_set_credentials(ldb, credentials) -> None\n"
"Set credentials to use when connecting." },
{ "ldb_set_session_info", (PyCFunction)py_ldb_set_session_info, METH_VARARGS,
"ldb_set_session_info(ldb, session_info)\n"
"Set session info to use when connecting." },
{ "ldb_set_loadparm", (PyCFunction)py_ldb_set_loadparm, METH_VARARGS,
"ldb_set_loadparm(ldb, session_info)\n"
"Set loadparm context to use when connecting." },
{ "samdb_set_domain_sid", (PyCFunction)py_samdb_set_domain_sid, METH_VARARGS,
"samdb_set_domain_sid(samdb, sid)\n"
"Set SID of domain to use." },
{ "ldb_register_samba_handlers", (PyCFunction)py_ldb_register_samba_handlers, METH_VARARGS,
"ldb_register_samba_handlers(ldb)\n"
"Register Samba-specific LDB modules and schemas." },
{ "dsdb_set_ntds_invocation_id", (PyCFunction)py_dsdb_set_ntds_invocation_id, METH_VARARGS,
NULL },
{ "dsdb_set_global_schema", (PyCFunction)py_dsdb_set_global_schema, METH_VARARGS,
NULL },
{ "dsdb_attach_schema_from_ldif_file", (PyCFunction)py_dsdb_attach_schema_from_ldif_file, METH_VARARGS,
NULL },
{ NULL }
};
void initmisc(void)
{
PyObject *m;
m = Py_InitModule3("misc", py_misc_methods,
"Python bindings for miscellaneous Samba functions.");
if (m == NULL)
return;
PyModule_AddObject(m, "version", PyString_FromString(SAMBA_VERSION_STRING));
}