2008-12-21 01:38:30 +03:00
/*
Unix SMB / CIFS implementation .
Copyright ( C ) Jelmer Vernooij < jelmer @ samba . org > 2007
2009-08-17 13:46:23 +04:00
Copyright ( C ) Matthias Dieter Wallnöfer 2009
2008-12-21 01:38:30 +03:00
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/>.
*/
2009-10-23 09:23:01 +04:00
# include <Python.h>
2008-12-21 01:38:30 +03:00
# include "includes.h"
# include "param/param.h"
# include "version.h"
# include "libcli/util/pyerrors.h"
2008-12-22 06:38:57 +03:00
# include "param/pyparam.h"
2010-02-17 14:19:57 +03:00
# include "lib/socket/netif.h"
# include "lib/socket/netif_proto.h"
2010-08-25 06:33:38 +04:00
# include "lib/talloc/pytalloc.h"
2008-12-21 02:24:54 +03:00
2008-12-21 01:38:30 +03:00
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 ;
}
2010-02-24 16:44:22 +03:00
static PyObject * py_generate_random_password ( PyObject * self , PyObject * args )
{
int min , max ;
PyObject * ret ;
char * retstr ;
if ( ! PyArg_ParseTuple ( args , " ii " , & min , & max ) )
return NULL ;
retstr = generate_random_password ( NULL , min , max ) ;
if ( retstr = = NULL ) {
return NULL ;
}
ret = PyString_FromString ( retstr ) ;
talloc_free ( retstr ) ;
return ret ;
}
2008-12-21 01:38:30 +03:00
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 ) ;
2010-04-15 00:18:14 +04:00
return PyLong_FromLongLong ( ( uint64_t ) nt ) ;
}
static PyObject * py_nttime2unix ( PyObject * self , PyObject * args )
{
time_t t ;
NTTIME nt ;
if ( ! PyArg_ParseTuple ( args , " K " , & nt ) )
return NULL ;
t = nt_time_to_unix ( nt ) ;
return PyInt_FromLong ( ( uint64_t ) t ) ;
}
static PyObject * py_nttime2string ( PyObject * self , PyObject * args )
{
PyObject * ret ;
2010-05-04 19:21:30 +04:00
NTTIME nt ;
2010-04-15 00:18:14 +04:00
TALLOC_CTX * tmp_ctx ;
const char * string ;
if ( ! PyArg_ParseTuple ( args , " K " , & nt ) )
return NULL ;
2010-05-04 19:21:30 +04:00
2010-04-15 00:18:14 +04:00
tmp_ctx = talloc_new ( NULL ) ;
string = nt_time_string ( tmp_ctx , nt ) ;
ret = PyString_FromString ( string ) ;
talloc_free ( tmp_ctx ) ;
2010-05-04 19:21:30 +04:00
2010-04-15 00:18:14 +04:00
return ret ;
2008-12-21 01:38:30 +03:00
}
2009-09-03 07:03:31 +04:00
static PyObject * py_set_debug_level ( PyObject * self , PyObject * args )
{
unsigned level ;
if ( ! PyArg_ParseTuple ( args , " I " , & level ) )
return NULL ;
( DEBUGLEVEL ) = level ;
Py_RETURN_NONE ;
}
2010-02-17 14:19:57 +03:00
/*
return the list of interface IPs we have configured
takes an loadparm context , returns a list of IPs in string form
2010-02-25 08:29:47 +03:00
Does not return addresses on 127.0 .0 .0 / 8
2010-02-17 14:19:57 +03:00
*/
static PyObject * py_interface_ips ( PyObject * self , PyObject * args )
{
PyObject * pylist ;
int count ;
TALLOC_CTX * tmp_ctx ;
PyObject * py_lp_ctx ;
struct loadparm_context * lp_ctx ;
struct interface * ifaces ;
2010-02-25 08:29:47 +03:00
int i , ifcount ;
2010-03-09 15:34:10 +03:00
int all_interfaces ;
2010-02-17 14:19:57 +03:00
2010-03-09 15:34:10 +03:00
if ( ! PyArg_ParseTuple ( args , " Oi " , & py_lp_ctx , & all_interfaces ) )
2010-02-17 14:19:57 +03:00
return NULL ;
2010-03-02 00:23:45 +03:00
tmp_ctx = talloc_new ( NULL ) ;
2010-09-23 02:35:36 +04:00
lp_ctx = lpcfg_from_py_object ( tmp_ctx , py_lp_ctx ) ;
2010-02-17 14:19:57 +03:00
if ( lp_ctx = = NULL ) {
2010-03-02 00:23:45 +03:00
talloc_free ( tmp_ctx ) ;
2010-02-17 14:19:57 +03:00
return NULL ;
}
2010-07-16 08:32:42 +04:00
load_interfaces ( tmp_ctx , lpcfg_interfaces ( lp_ctx ) , & ifaces ) ;
2010-02-17 14:19:57 +03:00
count = iface_count ( ifaces ) ;
2010-02-25 08:29:47 +03:00
/* first count how many are not loopback addresses */
for ( ifcount = i = 0 ; i < count ; i + + ) {
const char * ip = iface_n_ip ( ifaces , i ) ;
2010-03-09 15:34:10 +03:00
if ( ! ( ! all_interfaces & & iface_same_net ( ip , " 127.0.0.1 " , " 255.0.0.0 " ) ) ) {
2010-02-25 08:29:47 +03:00
ifcount + + ;
}
}
pylist = PyList_New ( ifcount ) ;
for ( ifcount = i = 0 ; i < count ; i + + ) {
const char * ip = iface_n_ip ( ifaces , i ) ;
2010-03-09 15:34:10 +03:00
if ( ! ( ! all_interfaces & & iface_same_net ( ip , " 127.0.0.1 " , " 255.0.0.0 " ) ) ) {
2010-02-25 08:29:47 +03:00
PyList_SetItem ( pylist , ifcount , PyString_FromString ( ip ) ) ;
ifcount + + ;
}
2010-02-17 14:19:57 +03:00
}
talloc_free ( tmp_ctx ) ;
return pylist ;
}
2010-08-25 09:21:08 +04:00
/* print a talloc tree report for a talloc python object */
2010-08-25 06:33:38 +04:00
static PyObject * py_talloc_report_full ( PyObject * self , PyObject * args )
{
PyObject * py_obj ;
PyTypeObject * type ;
if ( ! PyArg_ParseTuple ( args , " O " , & py_obj ) )
return NULL ;
if ( py_obj = = Py_None ) {
talloc_report_full ( NULL , stdout ) ;
} else {
type = ( PyTypeObject * ) PyObject_Type ( py_obj ) ;
talloc_report_full ( py_talloc_get_mem_ctx ( py_obj ) , stdout ) ;
}
return Py_None ;
}
2010-08-25 09:21:08 +04:00
/* enable null tracking */
2010-08-25 06:33:38 +04:00
static PyObject * py_talloc_enable_null_tracking ( PyObject * self , PyObject * args )
{
talloc_enable_null_tracking ( ) ;
return Py_None ;
}
2010-08-25 09:21:08 +04:00
/* return the number of talloc blocks */
static PyObject * py_talloc_total_blocks ( PyObject * self , PyObject * args )
{
PyObject * py_obj ;
PyTypeObject * type ;
if ( ! PyArg_ParseTuple ( args , " O " , & py_obj ) )
return NULL ;
if ( py_obj = = Py_None ) {
return PyLong_FromLong ( talloc_total_blocks ( NULL ) ) ;
}
type = ( PyTypeObject * ) PyObject_Type ( py_obj ) ;
return PyLong_FromLong ( talloc_total_blocks ( py_talloc_get_mem_ctx ( py_obj ) ) ) ;
}
2010-02-17 14:19:57 +03:00
2008-12-21 01:38:30 +03:00
static PyMethodDef py_misc_methods [ ] = {
{ " generate_random_str " , ( PyCFunction ) py_generate_random_str , METH_VARARGS ,
2010-02-24 16:44:22 +03:00
" generate_random_str(len) -> string \n "
" Generate random string with specified length. " } ,
2010-06-19 19:19:48 +04:00
{ " generate_random_password " , ( PyCFunction ) py_generate_random_password ,
METH_VARARGS , " generate_random_password(min, max) -> string \n "
2010-02-24 16:44:22 +03:00
" Generate random password with a length >= min and <= max. " } ,
2008-12-21 01:38:30 +03:00
{ " unix2nttime " , ( PyCFunction ) py_unix2nttime , METH_VARARGS ,
" unix2nttime(timestamp) -> nttime " } ,
2010-04-15 00:18:14 +04:00
{ " nttime2unix " , ( PyCFunction ) py_nttime2unix , METH_VARARGS ,
" nttime2unix(nttime) -> timestamp " } ,
{ " nttime2string " , ( PyCFunction ) py_nttime2string , METH_VARARGS ,
" nttime2string(nttime) -> string " } ,
2009-09-03 07:03:31 +04:00
{ " set_debug_level " , ( PyCFunction ) py_set_debug_level , METH_VARARGS ,
" set debug level " } ,
2010-02-17 14:19:57 +03:00
{ " interface_ips " , ( PyCFunction ) py_interface_ips , METH_VARARGS ,
" get interface IP address list " } ,
2010-08-25 06:33:38 +04:00
{ " talloc_report_full " , ( PyCFunction ) py_talloc_report_full , METH_VARARGS ,
" show a talloc tree for an object " } ,
{ " talloc_enable_null_tracking " , ( PyCFunction ) py_talloc_enable_null_tracking , METH_VARARGS ,
" enable tracking of the NULL object " } ,
2010-08-25 09:21:08 +04:00
{ " talloc_total_blocks " , ( PyCFunction ) py_talloc_total_blocks , METH_VARARGS ,
" return talloc block count " } ,
2008-12-21 01:38:30 +03:00
{ NULL }
} ;
2010-04-08 22:34:40 +04:00
void init_glue ( void )
2008-12-21 01:38:30 +03:00
{
PyObject * m ;
2010-04-02 11:21:14 +04:00
debug_setup_talloc_log ( ) ;
2010-04-08 22:34:40 +04:00
m = Py_InitModule3 ( " _glue " , py_misc_methods ,
2008-12-21 01:38:30 +03:00
" Python bindings for miscellaneous Samba functions. " ) ;
if ( m = = NULL )
return ;
2010-06-19 19:19:48 +04:00
PyModule_AddObject ( m , " version " ,
PyString_FromString ( SAMBA_VERSION_STRING ) ) ;
2009-07-14 02:15:50 +04:00
2009-10-23 10:12:48 +04:00
/* one of the most annoying things about python scripts is
that they don ' t die when you hit control - C . This fixes that
sillyness . As we do all database operations using
2010-06-19 19:19:48 +04:00
transactions , this is also safe .
2009-10-23 10:12:48 +04:00
*/
signal ( SIGINT , SIG_DFL ) ;
2008-12-21 01:38:30 +03:00
}